Binary Searchable Numbers in an Unsorted Array

Binary Searchable Numbers in an Unsorted Array - Problem

Consider a function that implements an algorithm similar to Binary Search. The function has two input parameters: sequence is a sequence of integers, and target is an integer value. The purpose of the function is to find if the target exists in the sequence.

The pseudocode of the function is as follows:

func(sequence, target)
  while sequence is not empty
    randomly choose an element from sequence as the pivot
    if pivot = target, return true
    else if pivot < target, remove pivot and all elements to its left from the sequence
    else, remove pivot and all elements to its right from the sequence
  end while
  return false

When the sequence is sorted, the function works correctly for all values. When the sequence is not sorted, the function does not work for all values, but may still work for some values.

Given an integer array nums, representing the sequence, that contains unique numbers and may or may not be sorted, return the number of values that are guaranteed to be found using the function, for every possible pivot selection.

Input & Output

Example 1 — Basic Unsorted Array

$ Input: nums = [1,3,4,2]

› Output: 1

💡 Note: Only element 3 at index 1 is binary searchable. It's greater than the max element to its left (1) and there are complex relationships with elements to the right, but through careful analysis, only 1 element satisfies the binary search property.

Example 2 — Sorted Array

$ Input: nums = [1,2,3,4,5]

› Output: 5

💡 Note: In a fully sorted array, every element is binary searchable because the binary search algorithm works correctly for all elements regardless of pivot selection.

Example 3 — Reverse Sorted

$ Input: nums = [5,4,3,2,1]

› Output: 1

💡 Note: In a reverse sorted array, typically only one element (often the middle one) can be reliably found through the modified binary search process.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements in nums are unique

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is that an element is binary searchable if it's in the correct relative position: greater than all elements to its left that matter and smaller than all elements to its right that matter. The optimal approach uses left maximum and right minimum arrays to check this condition in O(n) time.

Common Approaches

✓ Binary Search Properties Analysis

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

An element is binary searchable if it maintains the binary search property: all smaller elements that should be searched are to its left, and all larger elements that should be searched are to its right, regardless of pivot choice.

Brute Force Simulation

⏱️ Time: O(n × 2^n) Space: O(n)

For each element in the array, simulate the binary search algorithm with all possible pivot selections to check if the element can always be found regardless of pivot choices.

Optimal: Left/Right Max Analysis

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

An element at position i is binary searchable if and only if it's greater than the maximum of all elements to its left and smaller than the minimum of all elements to its right. This ensures the binary search elimination process always works correctly.

Binary Search Properties Analysis — Algorithm Steps

For each element, check if it's in correct relative position
Verify all elements to the left that are smaller would be eliminated correctly
Verify all elements to the right that are larger would be eliminated correctly
Count elements that satisfy all conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Element

Pick element to test for binary searchability

Check Pivots

Verify element survives all possible pivot eliminations

Validate Position

Confirm element is in correct relative position

Code -

solution.c — C

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

int solution(int* nums, int size) {
    int count = 0;
    
    for (int i = 0; i < size; i++) {
        int target = nums[i];
        bool isSearchable = true;
        
        // Check if this element can always be found
        for (int j = 0; j < size; j++) {
            if (i == j) continue;
            
            // If we pick nums[j] as pivot
            if (nums[j] < target) {
                // All elements to the left of j (including target if i <= j) should be eliminated
                if (i <= j) {
                    isSearchable = false;
                    break;
                }
            } else if (nums[j] > target) {
                // All elements to the right of j (including target if i >= j) should be eliminated
                if (i >= j) {
                    isSearchable = false;
                    break;
                }
            }
        }
        
        if (isSearchable) {
            count++;
        }
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we check its relationship with all other elements

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Binary Search Properties Analysis — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler