Search in a Sorted Array of Unknown Size - Practice Coding Problems

Search in a Sorted Array of Unknown Size - Problem

Imagine you're given access to a mystery sorted array through a special interface, but here's the catch - you don't know how big it is!

You have an ArrayReader interface that lets you peek at elements using ArrayReader.get(i):

Returns the value at index i if it's within bounds
Returns 2³¹ - 1 (2147483647) if you've gone beyond the array's end

Your mission: Find the index where a target value is hiding in this mysterious sorted array, or return -1 if it doesn't exist.

The challenge? You must solve this in O(log n) time complexity - no linear scanning allowed!

Example: If the hidden array is [1, 3, 5, 7, 9] and target is 5, you should return 2.

Input & Output

example_1.py — Basic Search

$ Input: secret = [1, 3, 5, 7, 9], target = 5

› Output: 2

💡 Note: The target value 5 is located at index 2 in the sorted array. Our algorithm first finds the boundary by checking positions exponentially, then performs binary search.

example_2.py — Target Not Found

$ Input: secret = [1, 3, 5, 7, 9], target = 6

› Output: -1

💡 Note: The target value 6 does not exist in the array. Since the array is sorted and 6 would be between 5 and 7, we can determine it's missing during the binary search phase.

example_3.py — Single Element Array

$ Input: secret = [1], target = 1

› Output: 0

💡 Note: Edge case with a single element array. The target 1 is found immediately at index 0. The boundary detection stops at position 1, and binary search finds it at index 0.

Constraints

1 ≤ secret.length ≤ 10⁴
-10⁴ ≤ secret[i], target ≤ 10⁴
secret is sorted in strictly increasing order
You must write an algorithm with O(log n) runtime complexity

Visualization

Tap to expand

Understanding the Visualization

Exponential Exploration

Use your flashlight to check positions 1, 2, 4, 8, 16... doubling each time until you hit the dark area (boundary)

Establish Search Zone

Now you know the shelf ends somewhere between the last lit position and the dark area - this becomes your search range

Binary Search

Within this range, use binary search - check the middle, then eliminate half the remaining area based on what you find

Locate Target

Continue halving the search space until you find your target book or determine it doesn't exist

Key Takeaway

🎯 Key Insight: By exponentially finding the boundary and then binary searching, we achieve O(log n) complexity even with an unknown array size!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a two-phase approach: first find the array boundary by exponentially checking positions 1, 2, 4, 8..., then perform binary search within the identified bounds. This achieves the required O(log n) time complexity while handling the unknown array size constraint elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search from Start	O(n)	O(1)	Check each position sequentially until finding target or boundary
Find Boundary + Binary Search (Optimal)	O(log n)	O(1)	Exponentially find array boundary, then binary search within bounds

Linear Search from Start — Algorithm Steps

Start from index 0
Check ArrayReader.get(i) for each position
If value equals target, return index
If value equals 2³¹ - 1, we've hit the boundary - return -1
If value > target (since sorted), return -1
Continue to next index

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin checking from the first position

Check each position

Compare value with target, continue if smaller

Find target or boundary

Stop when target found or boundary hit

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

// ArrayReader interface simulation
typedef struct {
    int* arr;
    int size;
} ArrayReader;

int get(ArrayReader* reader, int index) {
    if (index >= reader->size) {
        return INT_MAX;
    }
    return reader->arr[index];
}

int search(ArrayReader* reader, int target) {
    int index = 0;
    
    while (1) {
        int value = get(reader, index);
        if (value == INT_MAX) {
            return -1;
        }
        if (value == target) {
            return index;
        }
        if (value > target) {
            return -1;
        }
        index++;
    }
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, we might need to check every element in the array

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

52.3K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Linear Search from Start — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler