Count Occurrences - Problem

Given an array of integers, count how many times each unique element appears in the array.

Return the result as a formatted string where each line contains: element: count

The elements should be displayed in the order they first appear in the original array.

Input & Output

Example 1 — Basic Array with Duplicates

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

› Output: 3: 2 1: 2 2: 1

💡 Note: Element 3 appears 2 times, element 1 appears 2 times, element 2 appears 1 time. Order matches first appearance.

Example 2 — All Unique Elements

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

› Output: 5: 1 4: 1 3: 1 2: 1 1: 1

💡 Note: Each element appears exactly once, so all counts are 1. Output preserves original order.

Example 3 — Single Element Repeated

$ Input: nums = [7, 7, 7]

› Output: 7: 3

💡 Note: Only one unique element (7) appears 3 times total.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 20 G Google 15

The key insight is using a hash map to count frequencies in one pass, then preserving the original order by iterating through the array again. The optimal approach uses frequency counting with Time: O(n), Space: O(k) where k is the number of unique elements.

Common Approaches

✓ Brute Force - Count Each Element Separately

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

For every element in the array, iterate through the entire array to count how many times it appears. Skip elements we've already processed to avoid duplicates in the output.

Hash Map - Single Pass Frequency Count

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

Iterate through the array once, using a hash map to keep track of frequency counts for each element. Then iterate through the array again to build the result string in order of first appearance.

Brute Force - Count Each Element Separately — Algorithm Steps

For each position i in the array
Check if nums[i] was already processed (appears earlier)
If not processed, count occurrences of nums[i] in entire array
Add 'element: count' to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Take nums[0] = 3, scan entire array

Count occurrences

Find all positions where 3 appears: positions 0, 3

Record result

Add '3: 2' to output, mark 3 as processed

Code -

solution.c — C

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

char* solution(int* nums, int numsSize) {
    char* result = malloc(10000);
    result[0] = '\0';
    bool* processed = calloc(numsSize, sizeof(bool));
    
    for (int i = 0; i < numsSize; i++) {
        if (!processed[i]) {
            int count = 0;
            for (int j = 0; j < numsSize; j++) {
                if (nums[j] == nums[i]) {
                    count++;
                    if (j > i) processed[j] = true;
                }
            }
            
            char line[100];
            sprintf(line, "%d: %d", nums[i], count);
            
            if (strlen(result) > 0) {
                strcat(result, "\n");
            }
            strcat(result, line);
            processed[i] = true;
        }
    }
    
    free(processed);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[1000];
    int count = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token && count < 1000) {
            nums[count++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    char* result = solution(nums, count);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we scan the entire array to count occurrences

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

23.0K Views

Medium Frequency

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

Count Occurrences - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Count Each Element Separately — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler