Height Checker

Height Checker - Problem

A school is trying to take an annual photo of all the students. The students are asked to stand in a single file line in non-decreasing order by height.

Let this ordering be represented by the integer array expected where expected[i] is the expected height of the i^th student in line.

You are given an integer array heights representing the current order that the students are standing in. Each heights[i] is the height of the i^th student in line (0-indexed).

Return the number of indices where heights[i] != expected[i].

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Expected order is [1,1,1,2,3,4]. Positions 2, 3, and 5 have wrong heights (4≠1, 2≠2, 3≠4), so 3 students need to move.

Example 2 — Already Sorted

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

› Output: 5

💡 Note: Expected order is [1,2,3,4,5]. All positions except none match, so all 5 students are in wrong positions.

Example 3 — Perfect Order

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

› Output: 0

💡 Note: Already in non-decreasing order. No students need to move.

Constraints

1 ≤ heights.length ≤ 100
1 ≤ heights[i] ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 20 Apple 15

The key insight is that we need to compare the current arrangement with the sorted arrangement to count misplaced students. The optimal approach uses counting sort since heights are limited to range 1-100. Time: O(n), Space: O(1) extra.

Common Approaches

✓ Counting Sort Approach

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

Since student heights are limited to range 1-100, we can use counting sort to efficiently create the expected sorted order, then compare with the original array.

Sort and Compare

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

Create a copy of the heights array, sort it to get the expected order, then count how many positions differ between the original and sorted arrays.

Counting Sort Approach — Algorithm Steps

Step 1: Count frequency of each height
Step 2: Generate expected sorted array using counts
Step 3: Compare original with expected positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Heights

Count frequency of each height value

Build Expected

Construct sorted array from counts

Compare

Find positions that differ

Code -

solution.c — C

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

int solution(int* heights, int size) {
    // Count frequencies
    int count[101] = {0};
    for (int i = 0; i < size; i++) {
        count[heights[i]]++;
    }
    
    // Generate expected sorted array
    int* expected = (int*)malloc(size * sizeof(int));
    int idx = 0;
    for (int height = 1; height <= 100; height++) {
        for (int i = 0; i < count[height]; i++) {
            expected[idx++] = height;
        }
    }
    
    // Count differences
    int diffCount = 0;
    for (int i = 0; i < size; i++) {
        if (heights[i] != expected[i]) {
            diffCount++;
        }
    }
    
    free(expected);
    return diffCount;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

One pass to count frequencies O(n), one pass to generate expected array O(n), where k=100 is the height range

⚡ Linearithmic

Space Complexity

O(k + n)

Counting array of size k=100 plus expected array of size n

⚡ Linearithmic Space

78.0K Views

Medium Frequency

~8 min Avg. Time

892 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

Counting Sort Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler