Floor and Ceil in Sorted Array in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA C#

int floor = -1;
for (int i = 0; i < arr.Length; i++) {
    if (arr[i] <= target) {
        floor = arr[i];
    } else {
        break;
    }
}
return [1];

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

Afloor

Btarget

Ci

Darr

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the target instead of the floor value.

Returning the index variable instead of the floor value.

The variable 'floor' stores the greatest element less than or equal to the target, so we return 'floor'.

2fill in blank

medium

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

DSA C#

int ceil = -1;
for (int i = 0; i < arr.Length; i++) {
    if (arr[i] >= target) {
        ceil = arr[i];
        break;
    }
}
return [1];

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

Atarget

Barr

Cceil

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the target instead of the ceil value.

Returning the index variable instead of the ceil value.

The variable 'ceil' stores the smallest element greater than or equal to the target, so we return 'ceil'.

3fill in blank

hard

Fix the error in the binary search to find floor in a sorted array.

DSA C#

int low = 0, high = arr.Length - 1;
int floor = -1;
while (low <= high) {
    int mid = low + (high - low) / 2;
    if (arr[mid] [1] target) {
        floor = arr[mid];
        low = mid + 1;
    } else {
        high = mid - 1;
    }
}
return floor;

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

A<=

B>=

C<

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>=' instead of '<=' causing wrong floor calculation.

Using '<' or '>' which misses equal elements.

To find the floor, we move right when arr[mid] is less than or equal to target, so the condition is arr[mid] <= target.

4fill in blank

hard

Fill both blanks to complete the binary search for ceil in a sorted array.

DSA C#

int low = 0, high = arr.Length - 1;
int ceil = -1;
while (low <= high) {
    int mid = low + (high - low) / 2;
    if (arr[mid] [1] target) {
        ceil = arr[mid];
        [2] = mid - 1;
    } else {
        low = mid + 1;
    }
}
return ceil;

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

A>=

B<=

Chigh

Dlow

Attempts:

3 left

💡 Hint

Common Mistakes

Moving low instead of high when arr[mid] >= target.

Using wrong comparison operator causing incorrect ceil.

For ceil, if arr[mid] >= target, update ceil and move high to mid - 1 to find smaller ceil candidates.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each number to its floor and ceil in a sorted array.

DSA C#

var result = new Dictionary<int, (int floor, int ceil)>();
foreach (var num in nums) {
    int floor = -1, ceil = -1;
    int low = 0, high = arr.Length - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] [1] num) {
            floor = arr[mid];
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    low = 0; high = arr.Length - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] [2] num) {
            ceil = arr[mid];
            [3] = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    result[num] = (floor, ceil);
}

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

A<=

B>=

Chigh

Dlow

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up floor and ceil conditions.

Moving wrong pointers in binary search loops.

For floor, use '<=' and move low up; for ceil, use '>=' and move high down.

Practice

1. What does the floor of a number mean in a sorted array context?

easy

A. The average of all elements less than the number

B. The smallest element greater than or equal to the number

C. The smallest element strictly less than the number

D. The greatest element less 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 that number.

2. Step 2: Compare options with definition

   The greatest element less than or equal to the number matches the definition exactly. Options A, B, and D do not match the floor concept.

3. Final Answer:

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

4. Quick Check:

   Floor = greatest ≤ number [OK]

Hint: Floor is always ≤ the target number [OK]

Common Mistakes:

• Confusing floor with ceil
• Thinking floor is strictly less than the number
• Mixing floor with average or median

2. Which of the following C# method signatures correctly represents a function to find the floor in a sorted integer array (with array as first parameter)?

easy

A. void FindFloor(int[] arr, int target)

B. int FindFloor(int[] arr, int target)

C. int FindFloor(int target, int[] arr)

D. int FindFloor(List<int> arr, string target)

Solution

1. Step 1: Check method return type and parameters

   The function should return an integer (the floor value) and accept an integer array and an integer target.

2. Step 2: Validate each option

   int FindFloor(int[] arr, int target) matches the correct signature: returns int, takes int[] and int. void FindFloor(int[] arr, int target) returns void, so no result. int FindFloor(int target, int[] arr) swaps parameters order (less common but possible). int FindFloor(List<int> arr, string target) uses wrong types (List<int> and string target).

3. Final Answer:

   int FindFloor(int[] arr, int target) -> Option B

4. Quick Check:

   Return int, params (int[], int) [OK]

Hint: Floor function returns int and takes int array, int target [OK]

Common Mistakes:

• Using void return type
• Swapping parameter order incorrectly
• Using wrong parameter types

3. What is the output of the following C# code?

int[] arr = {1, 3, 5, 7, 9};
int target = 6;
int floor = -1;
int left = 0, right = arr.Length - 1;
while (left <= right) {
  int mid = left + (right - left) / 2;
  if (arr[mid] == target) {
    floor = arr[mid];
    break;
  } else if (arr[mid] < target) {
    floor = arr[mid];
    left = mid + 1;
  } else {
    right = mid - 1;
  }
}
Console.WriteLine(floor);

medium

A. 5

B. 7

C. 6

D. -1

Solution

1. Step 1: Trace binary search for floor of 6

   Initial array: [1,3,5,7,9]. Target=6. Start left=0, right=4, floor=-1.
   mid=2 (arr[2]=5) < 6, floor=5, left=3.
   mid=3 (arr[3]=7) > 6, right=2.
   Loop ends as left > right.

2. Step 2: Final floor value

   Floor is 5, the greatest element ≤ 6.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Floor(6) in [1,3,5,7,9] = 5 [OK]

Hint: Floor is last smaller or equal element found in binary search [OK]

Common Mistakes:

• Returning 7 instead of 5
• Confusing floor with ceil
• Not updating floor inside loop

4. The following code is intended to find the ceil of a target in a sorted array but has a bug. What is the bug?

int Ceil(int[] arr, int target) {
  int left = 0, right = arr.Length - 1;
  int ceil = -1;
  while (left <= right) {
    int mid = left + (right - left) / 2;
    if (arr[mid] == target) {
      return arr[mid];
    } else if (arr[mid] > target) {
      ceil = arr[mid];
      right = mid + 1;
    } else {
      left = mid + 1;
    }
  }
  return ceil;
}

medium

A. The function should return -1 if no ceil found

B. left should be updated to mid - 1, not mid + 1

C. right should be updated to mid - 1, not mid + 1

D. ceil should be initialized to 0, not -1

Solution

1. Step 1: Analyze right pointer update in binary search

   When arr[mid] > target, we want to search left half, so right should move to mid - 1, not mid + 1.

2. Step 2: Identify impact of wrong update

   Using right = mid + 1 moves right pointer incorrectly, causing infinite loop or wrong result.

3. Final Answer:

   right should be updated to mid - 1, not mid + 1 -> Option C

4. Quick Check:

   Correct binary search halves pointers [OK]

Hint: When arr[mid] > target, move right to mid - 1 [OK]

Common Mistakes:

• Updating right pointer incorrectly
• Confusing ceil with floor logic
• Not returning correct default value

5. Given a sorted array arr = {2, 4, 6, 8, 10} and a target 5, write a C# method to return both floor and ceil values as a tuple. What should the method return?

medium

A. (4, 6)

B. (2, 4)

C. (5, 5)

D. (-1, -1)

Solution

1. Step 1: Identify floor and ceil for target 5 in array

   Array: [2,4,6,8,10]. Floor is greatest ≤ 5, which is 4. Ceil is smallest ≥ 5, which is 6.

2. Step 2: Confirm tuple return

   The method should return (floor, ceil) = (4, 6).

3. Final Answer:

   (4, 6) -> Option A

4. Quick Check:

   Floor=4, Ceil=6 for target 5 [OK]

Hint: Floor ≤ target, Ceil ≥ target; pick closest values [OK]

Common Mistakes:

• Returning target itself when not in array
• Swapping floor and ceil values
• Returning -1 when values exist