Find Lucky Integer in an Array - Practice Coding Problems

Find Lucky Integer in an Array - Problem

Find Lucky Integer in an Array

Given an array of integers arr, a lucky integer is an integer that has a frequency in the array equal to its value.

For example, if the number 3 appears exactly 3 times in the array, then 3 is a lucky integer.

Goal: Return the largest lucky integer in the array. If there is no lucky integer, return -1.

Example: In array [2, 2, 3, 4], the number 2 appears 2 times, so it's lucky! The number 3 appears 1 time (not 3 times), so it's not lucky.

This is a classic frequency counting problem that tests your ability to efficiently track and compare element occurrences.

Input & Output

example_1.py — Basic Case

$ Input: arr = [2, 2, 3, 4]

› Output: 2

💡 Note: The number 2 appears exactly 2 times in the array, making it a lucky integer. Numbers 3 and 4 each appear only 1 time, so they are not lucky. Therefore, 2 is the largest (and only) lucky integer.

example_2.py — Multiple Lucky Integers

$ Input: arr = [1, 2, 2, 3, 3, 3]

› Output: 3

💡 Note: Number 1 appears 1 time (lucky), number 2 appears 2 times (lucky), and number 3 appears 3 times (lucky). Among all lucky integers [1, 2, 3], the largest is 3.

example_3.py — No Lucky Integers

$ Input: arr = [2, 2, 2, 3, 3]

› Output: -1

💡 Note: Number 2 appears 3 times (not equal to 2), and number 3 appears 2 times (not equal to 3). Since no number's frequency equals its value, return -1.

Constraints

1 ≤ arr.length ≤ 500
1 ≤ arr[i] ≤ 500
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Count Guests

Create a registry counting how many people have each invitation number

Find Lucky Groups

Check which invitation numbers match their group sizes exactly

Pick Highest

Among all lucky groups, select the one with the highest invitation number

Key Takeaway

🎯 Key Insight: Hash tables are perfect for frequency counting problems. The two-pass approach (count then search) is clean and efficient, turning an O(n²) brute force into an elegant O(n) solution!

Asked in

a Amazon 25 G Google 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses a hash table to count element frequencies in O(n) time. First pass builds the frequency map, second pass finds the largest lucky integer where frequency equals value. This is much more efficient than the O(n²) brute force approach and handles all edge cases elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(k)	Build frequency map first, then find the largest lucky integer
Brute Force (Nested Loops)	O(n²)	O(1)	For each unique number, count its frequency by scanning the entire array

Two-Pass Hash Table — Algorithm Steps

First pass: Build a hash map counting frequency of each element
Second pass: Iterate through the hash map
For each element-frequency pair, check if frequency equals the element value
Keep track of the maximum lucky integer found
Return the maximum lucky integer or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Frequency Map

Count each element's occurrences

Search Lucky Integers

Check each entry where count equals value

Track Maximum

Keep the largest lucky integer found

Code -

solution.c — C

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

int findLucky(int* arr, int arrSize) {
    // Using array as hash map (assuming values <= 1000)
    int freq[1001] = {0};
    
    // First pass: count frequencies
    for (int i = 0; i < arrSize; i++) {
        freq[arr[i]]++;
    }
    
    // Second pass: find largest lucky integer
    int maxLucky = -1;
    for (int i = 1; i <= 1000; i++) {
        if (freq[i] == i) {
            maxLucky = i;
        }
    }
    
    return maxLucky;
}

int main() {
    int arr[1000];
    int size = 0;
    char c;
    int num = 0;
    
    scanf("%c", &c); // Read '['
    while (scanf("%d%c", &num, &c) == 2) {
        arr[size++] = num;
        if (c == ']') break;
    }
    
    printf("%d\n", findLucky(arr, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

First pass O(n) to build frequency map, second pass O(k) where k is unique elements

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k unique elements where k ≤ n

✓ Linear Space

42.3K Views

Medium 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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler