Counting Elements - Practice Coding Problems

Counting Elements - Problem

🔢 Counting Elements

You are given an integer array arr and need to find how many elements x exist such that x + 1 is also present in the array.

The key insight is that we're looking for consecutive integer pairs where both numbers exist in the array. If an element appears multiple times, each occurrence should be counted separately.

Example: In array [1, 2, 3], we have:

1 → 1+1=2 exists ✓
2 → 2+1=3 exists ✓
3 → 3+1=4 doesn't exist ✗

So the answer is 2.

Goal: Return the count of elements that have their immediate successor in the array.

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 3]

› Output: 2

💡 Note: Elements 1 and 2 have their successors (2 and 3) in the array. Element 3 doesn't have 4, so count is 2.

example_2.py — With Duplicates

$ Input: [1, 1, 3, 3, 5, 5, 7, 7]

› Output: 0

💡 Note: None of the elements have their immediate successor. No element x has x+1 in the array, so count is 0.

example_3.py — Mixed Duplicates

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

› Output: 3

💡 Note: Element 0→1 exists ✓, element 1→2 exists ✓, element 2→3 exists ✓. Other elements don't have successors. Count = 3.

Constraints

0 ≤ arr.length ≤ 1000
0 ≤ arr[i] ≤ 1000
Array elements can be duplicated
Empty array should return 0

Visualization

Tap to expand

Understanding the Visualization

Create Quick Lookup

Build a hash set (like a phone book) of all people in the group for instant lookups

Check Each Person

For each person with ID x, quickly check if person with ID x+1 exists in our phone book

Count the Connections

Every time we find someone whose next friend exists, increment our counter

Key Takeaway

🎯 Key Insight: Hash sets transform expensive O(n²) searches into O(1) lookups, making the solution linear time!

Asked in

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

The optimal approach uses a hash set for O(1) lookups. First, build a set of all elements, then iterate through the array counting elements whose successor (x+1) exists in the set. This achieves O(n) time complexity with O(n) space, much better than the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each element, search the entire array to find x + 1
Two-Pass Hash Set (Optimal)	O(n)	O(n)	Build hash set first, then count elements with x+1 in set

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each element x in the array
For each x, iterate through the entire array again
Check if any element equals x + 1
If found, increment the counter
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Take the first element and search entire array for x+1

Linear search

Go through each element one by one looking for the target

Repeat for each element

Do the same exhaustive search for every element in the array

Code -

solution.c — C

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

int countElements(int* arr, int arrSize) {
    int count = 0;
    for (int i = 0; i < arrSize; i++) {
        int x = arr[i];
        // Search for x + 1 in the entire array
        for (int j = 0; j < arrSize; j++) {
            if (arr[j] == x + 1) {
                count++;
                break; // Found x+1, no need to continue
            }
        }
    }
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int size = 0;
    
    char* token = strtok(line + 1, ",]"); // Skip opening bracket
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", countElements(arr, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan through n elements again to find x+1

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a counter variable, no additional data structures

✓ Linear Space

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

🔢 Counting Elements

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler