Floor and Ceil in Sorted Array in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find the floor value in a sorted array.

DSA Rust

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

Drag options to blanks, or click blank then click option'

A-1

B0

C1

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using low = mid instead of low = mid + 1 causes infinite loops.

Using negative increments for low pointer.

When the middle element is less than the target, we move the low pointer to mid + 1 to search the right half.

2fill in blank

medium

Complete the code to find the ceil value in a sorted array.

DSA Rust

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

Drag options to blanks, or click blank then click option'

A0

B2

C-1

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using high = mid instead of high = mid - 1 causes infinite loops.

Using positive increments for high pointer.

When the middle element is greater than the target, we move the high pointer to mid - 1 to search the left half.

3fill in blank

hard

Fix the error in the binary search loop condition to avoid infinite loops.

DSA Rust

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

Drag options to blanks, or click blank then click option'

A<

B<=

C>=

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using < causes missing the last element in search.

Using > or >= causes logic errors.

The loop should continue while low is less than or equal to high to cover all elements.

4fill in blank

hard

Fill both blanks to create a function that returns floor and ceil as a tuple.

DSA Rust

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

Drag options to blanks, or click blank then click option'

A1

B0

C-1

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or negative values causes infinite loops.

Using 2 causes skipping elements.

Increment low by 1 and decrement high by 1 to move pointers correctly and avoid infinite loops.

5fill in blank

hard

Fill both blanks to create a function that returns floor and ceil using binary search with proper conditions.

DSA Rust

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

// Usage example:
// let arr = [1, 3, 5, 7, 9];
// let (floor_val, ceil_val) = floor_ceil_search(&arr, 6);
// println!("Floor: {:?}, Ceil: {:?}", floor_val, ceil_val);

Drag options to blanks, or click blank then click option'

A1

B0

C-1

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or negative values causes infinite loops.

Using 2 causes skipping elements.

Increment low by 1 and decrement high by 1 to move pointers correctly and avoid infinite loops.

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