Element Appearing More Than 25% In Sorted Array

Element Appearing More Than 25% In Sorted Array - Problem

Array Easy

You're given an integer array that's already sorted in non-decreasing order. Your mission is to find the special element that appears more than 25% of the time in the array.

The problem guarantees that exactly one integer meets this criteria. For example, in an array of 4 elements, you need to find the element that appears at least 2 times (since 25% of 4 is 1, so "more than 25%" means at least 2 occurrences).

Key Points:

Array is sorted in non-decreasing order
There's always exactly one element that appears more than 25% of the time
Return that dominant element

Input & Output

example_1.py — Basic Case

$ Input: [1,2,2,6,6,6,6,7,10]

› Output: 6

💡 Note: The array has 9 elements. 25% of 9 is 2.25, so we need an element appearing more than 2.25 times (at least 3 times). Element 6 appears 4 times, which is more than 25% of the array.

example_2.py — All Same Elements

$ Input: [1,1]

› Output: 1

💡 Note: The array has 2 elements. 25% of 2 is 0.5, so we need an element appearing more than 0.5 times (at least 1 time). Element 1 appears 2 times, which is 100% > 25%.

example_3.py — Larger Array

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

› Output: 3

💡 Note: The array has 9 elements. We need an element appearing more than 2.25 times. Element 3 appears 5 times, which clearly exceeds 25% of the array size.

Constraints

1 ≤ arr.length ≤ 10⁴
-10⁶ ≤ arr[i] ≤ 10⁶
arr is sorted in non-decreasing order
Exactly one integer appears more than 25% of the time

Visualization

Tap to expand

Understanding the Visualization

Understand the threshold

Calculate 25% of array length to determine minimum occurrences needed

Identify key positions

The dominant element must appear at positions n/4, n/2, or 3n/4 in sorted array

Check candidates

Count occurrences of elements at these strategic positions

Return the winner

The element exceeding the threshold is our answer

Key Takeaway

🎯 Key Insight: In a sorted array, any element appearing more than 25% of the time must occupy at least one of the strategic positions n/4, n/2, or 3n/4, making the solution extremely efficient!

Asked in

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

The optimal solution leverages the sorted array property with a key mathematical insight: any element appearing more than 25% of the time must be present at position n/4, n/2, or 3n/4. Check these three candidates and count their occurrences to find the answer in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count All Elements)	O(n)	O(1)	Count frequency of each element and return the one exceeding 25%
Binary Search Optimization	O(log n)	O(1)	Check candidate positions at n/4, n/2, 3n/4 and use binary search to count occurrences
One-Pass Optimized (Best)	O(n)	O(1)	Single pass checking every n/4 positions due to sorted array property

Brute Force (Count All Elements) — Algorithm Steps

Iterate through each element in the array
Count consecutive occurrences of each element
Check if count exceeds 25% threshold (n/4)
Return the element that meets the criteria

Visualization

Tap to expand

Step-by-Step Walkthrough

Start counting

Begin with first element and count consecutive occurrences

Check threshold

Compare count with 25% threshold

Move to next

If not found, move to next unique element

Code -

solution.c — C

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

int findSpecialInteger(int* arr, int n) {
    int threshold = n / 4;
    
    int i = 0;
    while (i < n) {
        int current = arr[i];
        int count = 1;
        
        // Count consecutive occurrences
        while (i + 1 < n && arr[i + 1] == current) {
            count++;
            i++;
        }
        
        if (count > threshold) {
            return current;
        }
        
        i++;
    }
    
    return arr[0]; // Should never reach here
}

int main() {
    int arr[] = {1, 2, 2, 6, 6, 6, 6, 7, 10};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    printf("%d\n", findSpecialInteger(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the array once, counting elements

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Brute Force (Count All Elements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler