Height Checker - Practice Coding Problems

Height Checker - Problem

School Photo Height Arrangement Problem

It's picture day at school! 📸 The students need to line up in non-decreasing order by height for the perfect annual photo. However, some students are currently standing in the wrong positions.

You are given two scenarios:
• heights[] - The current arrangement of students by height
• expected[] - The correct arrangement (sorted in non-decreasing order)

Your task is to determine how many students are standing in the wrong position. In other words, count the number of indices where heights[i] != expected[i].

Goal: Return the minimum number of students that need to move to achieve the correct height arrangement.

Input & Output

example_1.py — Basic Case

$ Input: heights = [1,1,4,2,1,3]

› Output: 3

💡 Note: Expected sorted order: [1,1,1,2,3,4]. Students at positions 2, 4, and 5 are in wrong positions (4→1, 1→3, 3→4), but the optimal answer considers that position 2 should have 1 instead of 4, position 3 should have 2 (correct), position 4 should have 3 instead of 1, and position 5 should have 4 instead of 3. Total mismatches: 3.

example_2.py — Already Sorted

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

› Output: 5

💡 Note: Expected sorted order: [1,2,3,4,5]. Every single position has the wrong student: position 0 has 5→1, position 1 has 1→2, position 2 has 2→3, position 3 has 3→4, position 4 has 4→5. All 5 students are in wrong positions.

example_3.py — No Changes Needed

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

› Output: 0

💡 Note: The array is already sorted in non-decreasing order. Expected order: [1,2,3,4,5]. Every student is in the correct position, so 0 students need to move.

Constraints

1 ≤ heights.length ≤ 100
1 ≤ heights[i] ≤ 100
All heights are positive integers
Array represents student heights in centimeters or similar unit

Visualization

Tap to expand

Understanding the Visualization

Current Line-Up

Students are currently standing: [1,1,4,2,1,3] - some are clearly out of place

Expected Order

For the photo, they should be: [1,1,1,2,3,4] - shortest to tallest

Count Mismatches

Compare position by position: 4 students need to move to correct positions

Key Takeaway

🎯 Key Insight: Compare each position in the current arrangement with what should be there in the sorted order - count the mismatches!

Asked in

G Google 35 a Amazon 28 Apple 22 ⊞ Microsoft 18

The optimal solution uses a sorting approach with O(n log n) time complexity. Create a sorted copy of the heights array and compare it position-by-position with the original. For problems with constrained height ranges, counting sort can achieve O(n) time complexity by using frequency counting instead of comparison-based sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Compare Each Position)	O(n²)	O(1)	For each position, count how many smaller elements should come before it
Sorting + Comparison	O(n log n)	O(n)	Sort array first, then compare with original to count differences
Counting Sort Approach (Optimal)	O(n)	O(k)	Use counting sort technique for optimal O(n) solution with height constraints

Brute Force (Compare Each Position) — Algorithm Steps

For each position i, count elements that should come before it
Compare with actual elements that come before it
If counts don't match, this position is wrong
Count total wrong positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position 0

Count elements smaller than heights[0] to see if it belongs at position 0

Check Position 1

Count elements smaller than heights[1] to see if it belongs at position 1

Continue for All

Repeat for all positions, comparing expected vs actual placement

Code -

solution.c — C

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

int heightChecker(int* heights, int n) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        // Count how many students should be before position i
        int smallerCount = 0;
        for (int j = 0; j < n; j++) {
            if (heights[j] < heights[i] || (heights[j] == heights[i] && j < i)) {
                smallerCount++;
            }
        }
        
        // If this student is not in correct position
        if (smallerCount != i) {
            count++;
        }
    }
    
    return count;
}

int main() {
    int heights[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // skip '['
    while (scanf("%d%c", &heights[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", heightChecker(heights, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we check all n elements to determine correct placement

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

42.4K Views

Medium Frequency

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

Brute Force (Compare Each Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler