Binary Searchable Numbers in an Unsorted Array

Binary Searchable Numbers in an Unsorted Array - Problem

Binary Searchable Numbers in an Unsorted Array

Imagine you have a modified binary search algorithm that works on unsorted arrays by randomly selecting pivots instead of always choosing the middle element. While this algorithm doesn't guarantee to find all values in an unsorted array, some values are guaranteed to be found regardless of which pivots are randomly selected.

Given an integer array nums with unique numbers (which may or may not be sorted), your task is to determine how many values are guaranteed to be found using this modified binary search, no matter which pivots are randomly chosen during the search process.

The Algorithm:

Start with the entire array
Randomly pick any element as pivot
If pivot equals target, return true
If pivot < target, remove pivot and all elements to its left
If pivot > target, remove pivot and all elements to its right
Repeat until array is empty or target is found

A number is binary searchable if it will always be found regardless of the random pivot selections made during the search.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: Elements 1, 3, 4, and 5 are binary searchable. Element 2 is not because 3 > 2 but appears to the left of 2, violating the local sorted property.

example_2.py — Fully Sorted Array

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

› Output: 5

💡 Note: All elements are binary searchable because the array is already sorted, so every element maintains the local sorted property.

example_3.py — Reverse Sorted

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

› Output: 1

💡 Note: Only element 5 is binary searchable because it's the only element where all elements to its right are smaller (and there are no elements to its left).

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

A binary searchable element must have all smaller elements to its left and all larger elements to its right

Check Each Element

For each position, verify the local sorted property holds

Count Valid Elements

Elements that satisfy the property are guaranteed to be found by the modified binary search

Key Takeaway

🎯 Key Insight: An element is binary searchable if it maintains the sorted property locally - all elements to its left must be smaller, and all elements to its right must be larger. This guarantees the modified binary search will always find it regardless of pivot selection.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we check all elements to its left and right in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10³
-10⁴ ≤ nums[i] ≤ 10⁴
All elements in nums are unique

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution uses the local sorted property insight: a number is binary searchable if and only if all elements to its left are smaller and all elements to its right are larger. This can be checked in O(n²) time with constant space, or optimized to O(n) time using preprocessing to track maximum left and minimum right values.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Approach (Local Sorted Property)	O(n²)	O(1)	Check if each element maintains sorted order with respect to its position
Brute Force (Simulate All Scenarios)	O(n * 2^n)	O(n)	For each element, simulate all possible random pivot selections to verify if it's always found

Optimized Approach (Local Sorted Property) — Algorithm Steps

For each element at index i in the original array
Check if all elements to the left (indices 0 to i-1) are smaller
Check if all elements to the right (indices i+1 to n-1) are larger
If both conditions are satisfied, the element is binary searchable
Count and return the total number of such elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Element

Choose current element to check

Check Left Side

Verify all left elements are smaller

Check Right Side

Verify all right elements are larger

Count Valid

If both conditions hold, increment counter

Code -

solution.c — C

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

int binarySearchableNumbers(int* nums, int size) {
    int count = 0;
    
    for (int i = 0; i < size; i++) {
        bool isBinarySearchable = true;
        
        // Check if all elements to the left are smaller
        for (int j = 0; j < i; j++) {
            if (nums[j] >= nums[i]) {
                isBinarySearchable = false;
                break;
            }
        }
        
        // Check if all elements to the right are larger
        if (isBinarySearchable) {
            for (int j = i + 1; j < size; j++) {
                if (nums[j] <= nums[i]) {
                    isBinarySearchable = false;
                    break;
                }
            }
        }
        
        if (isBinarySearchable) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL && size < 100) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", binarySearchableNumbers(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we check all elements to its left and right in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10³
-10⁴ ≤ nums[i] ≤ 10⁴
All elements in nums are unique

21.1K Views

Medium Frequency

~25 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

Binary Searchable Numbers in an Unsorted Array

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Approach (Local Sorted Property) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler