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

Practice - 5 Tasks

1fill in blank

easy

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

DSA Go

func floorIndex(arr []int, target int) int {
    low, high := 0, len(arr)-1
    result := -1
    for low <= high {
        mid := low + (high - low) / 2
        if arr[mid] <= [1] {
            result = mid
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return result
}

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

Ahigh

Barr[mid]

Ctarget

Dlow

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing arr[mid] with low or high instead of target.

Using '<' instead of '<=' which misses exact matches.

We compare arr[mid] with the target to find the floor value index.

2fill in blank

medium

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

DSA Go

func ceilIndex(arr []int, target int) int {
    low, high := 0, len(arr)-1
    result := -1
    for low <= high {
        mid := low + (high - low) / 2
        if arr[mid] >= [1] {
            result = mid
            high = mid - 1
        } else {
            low = mid + 1
        }
    }
    return result
}

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

Aarr[mid]

Btarget

Clow

Dhigh

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing arr[mid] with low or high instead of target.

Using '>' instead of '>=' which misses exact matches.

We compare arr[mid] with the target to find the ceil value index.

3fill in blank

hard

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

DSA Go

func findFloor(arr []int, target int) int {
    low, high := 0, len(arr)-1
    result := -1
    for [1] {
        mid := low + (high - low) / 2
        if arr[mid] <= target {
            result = mid
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return result
}

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

Alow == high

Blow < high

Clow >= high

Dlow <= high

Attempts:

3 left

💡 Hint

Common Mistakes

Using low < high causes missing the last element check.

Using low == high causes the loop to run only once.

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 complete the function that returns floor and ceil indices for a target.

DSA Go

func floorAndCeil(arr []int, target int) (int, int) {
    floor := -1
    ceil := -1
    low, high := 0, len(arr)-1
    for low <= high {
        mid := low + (high - low) / 2
        if arr[mid] == target {
            return mid, mid
        } else if arr[mid] < [1] {
            floor = mid
            low = mid + 1
        } else {
            ceil = mid
            high = [2]
        }
    }
    return floor, ceil
}

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

Atarget

Bmid + 1

Cmid - 1

Darr[mid]

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong comparison variable instead of target.

Updating high incorrectly causing infinite loops.

Compare arr[mid] with target; update high to mid - 1 when arr[mid] > target.

5fill in blank

hard

Fill all three blanks to create a function that returns floor and ceil values (not indices) or -1 if not found.

DSA Go

func floorAndCeilValues(arr []int, target int) (int, int) {
    floor := -1
    ceil := -1
    low, high := 0, len(arr)-1
    for low <= high {
        mid := low + (high - low) / 2
        if arr[mid] == [1] {
            return arr[mid], arr[mid]
        } else if arr[mid] < target {
            floor = arr[mid]
            low = [2]
        } else {
            ceil = arr[mid]
            high = [3]
        }
    }
    return floor, ceil
}

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

Atarget

Bmid + 1

Cmid - 1

Dtarget + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Returning indices instead of values.

Incorrectly updating low or high causing infinite loops.

Compare arr[mid] with target; update low to mid + 1 if arr[mid] < target; update high to mid - 1 if arr[mid] > target.

Practice

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

easy

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

B. The smallest element greater than the number

C. The average of all elements less than the number

D. The smallest element less than the number

Solution

1. Step 1: Understand the floor definition

   The floor of a number in a sorted array is the greatest element 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 this definition exactly, while others describe different concepts.

3. Final Answer:

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

4. Quick Check:

   Floor = greatest ≤ number [OK]

Hint: Floor is always ≤ number, pick greatest such element [OK]

Common Mistakes:

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

2. Which Go code snippet correctly declares a function to find the floor in a sorted array?

easy

A. func floor(arr int[], x int) int { /* code */ }

B. func floor(arr []int, x int) int { /* code */ }

C. function floor(arr []int, x int) int { /* code */ }

D. func floor(arr []int, x int) void { /* code */ }

Solution

1. Step 1: Check Go function syntax

   In Go, functions are declared with func, parameter types follow names, and return type is after parameters.

2. Step 2: Validate each option

   func floor(arr []int, x int) int { /* code */ } uses correct Go syntax: func floor(arr []int, x int) int. func floor(arr int[], x int) int { /* code */ } uses incorrect array syntax, C uses wrong keyword, D has wrong return type.

3. Final Answer:

   func floor(arr []int, x int) int { /* code */ } -> Option B

4. Quick Check:

   Go func syntax = func floor(arr []int, x int) int { /* code */ } [OK]

Hint: Go arrays use []type, func keyword, return type after params [OK]

Common Mistakes:

• Using 'function' keyword instead of 'func'
• Incorrect array type syntax
• Wrong return type declaration

3. What is the output of the following Go code snippet?

arr := []int{1, 3, 5, 7, 9}
x := 6
floor := -1
for _, val := range arr {
    if val <= x {
        floor = val
    } else {
        break
    }
}
fmt.Println(floor)

medium

A. 5

B. 6

C. 7

D. -1

Solution

1. Step 1: Trace the loop over array elements

   The loop checks each element: 1 ≤ 6 (floor=1), 3 ≤ 6 (floor=3), 5 ≤ 6 (floor=5), 7 ≤ 6? No, break loop.

2. Step 2: Determine final floor value

   Last floor assigned is 5, so printed output is 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Floor of 6 in arr = 5 [OK]

Hint: Floor is last element ≤ x before break [OK]

Common Mistakes:

• Assuming floor equals x if not present
• Not breaking loop early
• Confusing floor with ceil

4. Identify the bug in this Go code to find the ceil of x in a sorted array arr:

func ceil(arr []int, x int) int {
    ceil := -1
    for _, val := range arr {
        if val >= x {
            ceil = val
        }
    }
    return ceil
}

medium

A. It uses wrong comparison operator

B. It initializes ceil with -1 incorrectly

C. It returns ceil before loop ends

D. It does not break after finding first valid ceil

Solution

1. Step 1: Analyze loop behavior for ceil

   The loop updates ceil whenever val ≥ x, but does not stop after first valid ceil, so it ends with the last such value, which may not be the smallest ceil.

2. Step 2: Identify correct fix

   To find the smallest ceil, the loop should break immediately after first val ≥ x is found.

3. Final Answer:

   It does not break after finding first valid ceil -> Option D

4. Quick Check:

   Ceil needs first ≥ x, break loop [OK]

Hint: Break loop on first val ≥ x for correct ceil [OK]

Common Mistakes:

• Not breaking loop early
• Confusing ceil with floor logic
• Incorrect initialization of ceil

5. Given a sorted array arr := []int{2, 4, 6, 8, 10} and a number x = 5, write a Go function that returns both floor and ceil of x. What is the correct output of floor and ceil?

hard

A. Floor: -1, Ceil: -1

B. Floor: 6, Ceil: 4

C. Floor: 4, Ceil: 6

D. Floor: 5, Ceil: 5

Solution

1. Step 1: Find floor of 5 in arr

   Floor is greatest element ≤ 5. Elements ≤ 5 are 2 and 4, greatest is 4.

2. Step 2: Find ceil of 5 in arr

   Ceil is smallest element ≥ 5. Elements ≥ 5 are 6, 8, 10, smallest is 6.

3. Final Answer:

   Floor: 4, Ceil: 6 -> Option C

4. Quick Check:

   Floor ≤ x ≤ Ceil = 4 ≤ 5 ≤ 6 [OK]

Hint: Floor ≤ x ≤ Ceil in sorted array [OK]

Common Mistakes:

• Swapping floor and ceil values
• Assuming floor or ceil equals x if not present
• Returning -1 when valid floor or ceil exists