Search in a Sorted Array of Unknown Size

Search in a Sorted Array of Unknown Size - Problem

This is an interactive problem. You have a sorted array of unique elements with an unknown size. You cannot directly access the array, but you can use the ArrayReader interface.

The ArrayReader.get(i) method:

Returns the value at index i (0-indexed) if i is within bounds
Returns 2³¹ - 1 if i is out of bounds

Given an integer target, return the index where the target exists in the hidden array, or -1 if it doesn't exist.

Constraint: Your algorithm must run in O(log n) time complexity.

Input & Output

Example 1 — Target Found

$ Input: secret = [-1,0,2,3,4], target = 2

› Output: 2

💡 Note: Target 2 is found at index 2. First we find bounds by checking indices 1→2→4, then binary search between indices 2 and 4.

Example 2 — Target Not Found

$ Input: secret = [-1,0,3,5,9,12], target = 2

› Output: -1

💡 Note: Target 2 is not in the array. We search through the bounds but don't find the target value.

Example 3 — Target at Beginning

$ Input: secret = [-1,0,3,5,9,12], target = -1

› Output: 0

💡 Note: Target -1 is found at index 0, the very first position in the array.

Constraints

1 ≤ secret.length ≤ 10⁴
-10⁴ ≤ secret[i], target ≤ 10⁴
secret is sorted in ascending order
secret consists of unique elements

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 12 M Microsoft 8

The key insight is to first find the array bounds using exponential search (doubling indices: 1→2→4→8), then apply binary search within those bounds. This achieves the required O(log n) time complexity. The optimal approach uses two phases: boundary discovery and binary search. Time: O(log n), Space: O(1)

Common Approaches

✓ Find Bounds + Binary Search

⏱️ Time: O(log n) Space: O(1)

Since we don't know the array size, first find the right boundary by doubling the index until we hit out-of-bounds. Then use binary search between the found bounds.

Linear Search

⏱️ Time: O(n) Space: O(1)

Start from index 0 and check each position one by one using ArrayReader.get(). Stop when we find the target or encounter the out-of-bounds value (2³¹ - 1).

Find Bounds + Binary Search — Algorithm Steps

Find right boundary by exponentially increasing index (1, 2, 4, 8, ...)
Once out-of-bounds is hit, we know target is between previous index and current
Apply standard binary search within these bounds
Return index if found, -1 otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Bounds

Exponentially increase index: 1→2→4→8 until out of bounds

Binary Search

Apply binary search within discovered bounds

Result

Return target index or -1

Code -

solution.c — C

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

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 solution(ArrayReader* reader, int target) {
    // Phase 1: Find bounds by exponential search
    int left = 0, right = 1;
    while (get(reader, right) < target) {
        left = right;
        right *= 2;
    }
    
    // Phase 2: Binary search within bounds
    while (left <= right) {
        int mid = left + (right - left) / 2;
        int val = get(reader, mid);
        
        if (val == target) {
            return mid;
        } else if (val > target || val == INT_MAX) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int target;
    scanf("%d", &target);
    
    ArrayReader reader = {arr, size};
    int result = solution(&reader, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Finding bounds takes O(log n) steps, binary search takes O(log n) steps

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for left, right, and mid pointers

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Find Bounds + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler