Floor and Ceil in Sorted Array in DSA Rust - Build from Scratch

Floor and Ceil in Sorted Array

📖 Scenario: You are working with a sorted list of house numbers on a street. You want to find the closest house numbers that are just smaller or equal (floor) and just greater or equal (ceil) to a visitor's requested house number.

🎯 Goal: Build a Rust program that finds the floor and ceil values for a given number in a sorted array of integers.

📋 What You'll Learn

Create a sorted array called houses with the exact values: [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]

Create a variable called target and set it to 20

Write a function called find_floor_ceil that takes a slice of integers and a target integer, and returns a tuple with the floor and ceil values as Option<i32>

Print the floor and ceil values returned by find_floor_ceil in the format: Floor: X, Ceil: Y

💡 Why This Matters

🌍 Real World

Finding floor and ceil values is useful in many real-world tasks like searching for closest available options, price ranges, or scheduling times.

💼 Career

Understanding floor and ceil concepts and implementing them efficiently is important for software engineers working with sorted data, search algorithms, and optimization problems.

1

Create the sorted array of house numbers

Create a sorted array called houses with these exact values: [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]

DSA Rust

# Create the sorted array houses with the given values
# Your code here

Hint

Use let houses = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]; to create the array.

2

Set the target house number

Create a variable called target and set it to 20

DSA Rust

fn main() {
    let houses = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91];
    // Create the target variable with value 20
    // Your code here
}

Hint

Use let target = 20; to create the target variable.

3

Write the function to find floor and ceil

Write a function called find_floor_ceil that takes a slice of integers called arr and an integer target, and returns a tuple (Option<i32>, Option<i32>) representing the floor and ceil values. Use a for loop with variable num to iterate over arr. The floor is the greatest number less than or equal to target, and the ceil is the smallest number greater than or equal to target. Return None if floor or ceil does not exist.

DSA Rust

fn main() {
    let houses = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91];
    let target = 20;

    // Write the find_floor_ceil function below
    // Your code here
}

Hint

Use a for loop to check each number. Update floor if number is less than or equal to target. Set ceil when you find the first number greater than or equal to target.

4

Print the floor and ceil values

Call the function find_floor_ceil with houses and target, then print the floor and ceil values in the format: Floor: X, Ceil: Y. If floor or ceil is None, print None for that value.

DSA Rust

fn find_floor_ceil(arr: &[i32], target: i32) -> (Option, Option) {
    let mut floor: Option = None;
    let mut ceil: Option = None;
    for &num in arr {
        if num = target && ceil.is_none() {
            ceil = Some(num);
            break;
        }
    }
    (floor, ceil)
}

fn main() {
    let houses = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91];
    let target = 20;

    // Call find_floor_ceil and print the result
    // Your code here
}

Hint

Use let (floor, ceil) = find_floor_ceil(&houses, target); and then println!("Floor: {:?}, Ceil: {:?}", floor, ceil);.

Practice

1. What is the floor of a number in a sorted array?

easy

A. The smallest element less than the number

B. The smallest element greater than the number

C. The greatest element less than or equal to the number

D. The greatest element greater than or equal to the number

Solution

1. Step 1: Understand floor definition in sorted array

   The floor of a number is the greatest element in the array that is less than or equal to the given number.

2. Step 2: Compare options with definition

   The greatest element less than or equal to the number matches the definition exactly, others describe ceil or incorrect concepts.

3. Final Answer:

   The greatest element less than or equal to the number -> Option C

4. Quick Check:

   Floor = greatest ≤ number [OK]

Hint: Floor is largest ≤ target in sorted array [OK]

Common Mistakes:

• Confusing floor with ceil
• Thinking floor is smallest element
• Ignoring equality in floor definition

2. Which Rust code snippet correctly declares a sorted array of integers?

easy

A. let arr = [1, 3, 5, 7, 9];

B. let arr = (1, 3, 5, 7, 9);

C. let arr = {1, 3, 5, 7, 9};

D. let arr = <1, 3, 5, 7, 9>;

Solution

1. Step 1: Recall Rust array syntax

   Rust arrays use square brackets [] with comma-separated values.

2. Step 2: Check each option

   let arr = [1, 3, 5, 7, 9]; uses correct syntax. let arr = (1, 3, 5, 7, 9); uses tuple syntax with parentheses, let arr = {1, 3, 5, 7, 9}; uses braces resembling sets or blocks, let arr = <1, 3, 5, 7, 9>; uses angle brackets which are invalid.

3. Final Answer:

   let arr = [1, 3, 5, 7, 9]; -> Option A

4. Quick Check:

   Rust arrays use [] [OK]

Hint: Use square brackets [] for arrays in Rust [OK]

Common Mistakes:

• Using parentheses () for arrays
• Using braces {} which are for blocks
• Using angle brackets <> which are invalid here

3. Given the sorted array arr = [2, 4, 6, 8, 10], what is the floor and ceil of 7?

medium

A. Floor = 6, Ceil = 8

B. Floor = 4, Ceil = 6

C. Floor = 8, Ceil = 10

D. Floor = 7, Ceil = 7

Solution

1. Step 1: Find floor of 7 in array

   Floor is greatest element ≤ 7. Elements ≤ 7 are 2,4,6. Greatest is 6.

2. Step 2: Find ceil of 7 in array

   Ceil is smallest element ≥ 7. Elements ≥ 7 are 8,10. Smallest is 8.

3. Final Answer:

   Floor = 6, Ceil = 8 -> Option A

4. Quick Check:

   Floor ≤ 7 = 6, Ceil ≥ 7 = 8 [OK]

Hint: Floor ≤ target, Ceil ≥ target in sorted array [OK]

Common Mistakes:

• Choosing floor or ceil outside array bounds
• Confusing floor and ceil values
• Assuming floor or ceil equals the target always

4. Consider this Rust function to find floor in a sorted array:

fn find_floor(arr: &[i32], target: i32) -> Option<i32> {
    let mut low = 0;
    let mut high = arr.len() - 1;
    let mut floor = None;
    while low <= high {
        let mid = (low + high) / 2;
        if arr[mid] == target {
            return Some(arr[mid]);
        } else if arr[mid] < target {
            floor = Some(arr[mid]);
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    floor
}

What is the bug in this code?

medium

A. Incorrect update of low and high pointers

B. Using arr.len() - 1 without checking if array is empty

C. Returning Some(arr[mid]) instead of index

D. Not handling the case when target is smaller than all elements

Solution

1. Step 1: Analyze initialization of high pointer

   Using arr.len() - 1 causes panic if array is empty because len() is 0 and subtracting 1 underflows.

2. Step 2: Check other parts of code

   Other logic for binary search and floor update is correct. The main bug is unsafe initialization.

3. Final Answer:

   Using arr.len() - 1 without checking if array is empty -> Option B

4. Quick Check:

   Empty array causes panic at arr.len() - 1 [OK]

Hint: Check empty array before subtracting 1 from length [OK]

Common Mistakes:

• Ignoring empty array edge case
• Assuming array always has elements
• Confusing return value with index

5. You have a sorted array arr = [1, 3, 5, 7, 9]. You want to find the floor and ceil for multiple targets: [0, 4, 10]. Which Rust code snippet correctly returns a vector of tuples with floor and ceil for each target? Assume floor or ceil is None if not found.

hard

A. ```rust
fn floor_ceil(arr: &[i32], targets: &[i32]) -> Vec<(Option<i32>, Option<i32>)> {
targets.iter().map(|&t| {
let floor = arr.iter().filter(|&&x| x <= t).min().copied();
let ceil = arr.iter().filter(|&&x| x >= t).max().copied();
(floor, ceil)
}).collect()
}
```

B. ```rust
fn floor_ceil(arr: &[i32], targets: &[i32]) -> Vec<(Option<i32>, Option<i32>)> {
targets.iter().map(|&t| {
let floor = arr.iter().filter(|&&x| x < t).max().copied();
let ceil = arr.iter().filter(|&&x| x > t).min().copied();
(floor, ceil)
}).collect()
}
```

C. ```rust
fn floor_ceil(arr: &[i32], targets: &[i32]) -> Vec<(Option<i32>, Option<i32>)> {
targets.iter().map(|&t| {
let floor = arr.iter().find(|&&x| x <= t).copied();
let ceil = arr.iter().find(|&&x| x >= t).copied();
(floor, ceil)
}).collect()
}
```

D. ```rust
fn floor_ceil(arr: &[i32], targets: &[i32]) -> Vec<(Option<i32>, Option<i32>)> {
targets.iter().map(|&t| {
let floor = arr.iter().filter(|&&x| x <= t).max().copied();
let ceil = arr.iter().filter(|&&x| x >= t).min().copied();
(floor, ceil)
}).collect()
}
```

Solution

1. Step 1: Understand floor and ceil conditions

   Floor is max element ≤ target, ceil is min element ≥ target.

2. Step 2: Analyze each code snippet

   ```rust fn floor_ceil(arr: &[i32], targets: &[i32]) -> Vec<(Option<i32>, Option<i32>)> { targets.iter().map(|&t| { let floor = arr.iter().filter(|&&x| x <= t).max().copied(); let ceil = arr.iter().filter(|&&x| x >= t).min().copied(); (floor, ceil) }).collect() } ``` uses filter with ≤ and ≥, then max and min respectively, which matches floor and ceil definitions. ```rust fn floor_ceil(arr: &[i32], targets: &[i32]) -> Vec<(Option<i32>, Option<i32>)> { targets.iter().map(|&t| { let floor = arr.iter().filter(|&&x| x < t).max().copied(); let ceil = arr.iter().filter(|&&x| x > t).min().copied(); (floor, ceil) }).collect() } ``` uses < and > which exclude equality. ```rust fn floor_ceil(arr: &[i32], targets: &[i32]) -> Vec<(Option<i32>, Option<i32>)> { targets.iter().map(|&t| { let floor = arr.iter().find(|&&x| x <= t).copied(); let ceil = arr.iter().find(|&&x| x >= t).copied(); (floor, ceil) }).collect() } ``` uses find which returns first match, not max or min. ```rust fn floor_ceil(arr: &[i32], targets: &[i32]) -> Vec<(Option<i32>, Option<i32>)> { targets.iter().map(|&t| { let floor = arr.iter().filter(|&&x| x <= t).min().copied(); let ceil = arr.iter().filter(|&&x| x >= t).max().copied(); (floor, ceil) }).collect() } ``` reverses min and max causing wrong results.

3. Final Answer:

   filter(|&&x| x <= t).max() for floor, filter(|&&x| x >= t).min() for ceil -> Option D

4. Quick Check:

   Floor = max ≤ target, Ceil = min ≥ target [OK]

Hint: Floor uses max ≤ target, ceil uses min ≥ target filters [OK]

Common Mistakes:

• Using strict < or > instead of ≤ or ≥
• Using find instead of max/min for floor/ceil
• Swapping min and max in floor/ceil logic