Number of Changing Keys - Practice Coding Problems

Number of Changing Keys - Problem

String Easy

Imagine you're typing on a keyboard and want to track how many times you switch between different keys. You are given a 0-indexed string s that represents the sequence of characters a user typed.

A key change occurs when the user presses a different physical key than the one they just pressed. For example:

"ab" has 1 key change (from 'a' to 'b')
"bBBb" has 0 key changes (all are the same 'b' key, just with different cases)
"aAbBcC" has 2 key changes ('a'→'b', 'b'→'c')

Important: Case doesn't matter! Typing 'a' then 'A' is not considered a key change since it's the same physical key (just with Shift or Caps Lock). Return the total number of times the user had to change keys.

Input & Output

example_1.py — Basic Case

$ Input: s = "aAbBcC"

› Output: 2

💡 Note: The key changes are: 'a'→'b' (indices 1→2) and 'b'→'c' (indices 3→4). Note that 'a'→'A' and 'b'→'B' and 'c'→'C' are not key changes since they're the same physical keys.

example_2.py — No Changes

$ Input: s = "AaAaAa"

› Output: 0

💡 Note: All characters represent the same physical key 'a', just with different cases. No key changes occur.

example_3.py — All Different

$ Input: s = "abc"

› Output: 2

💡 Note: Every adjacent pair represents different keys: 'a'→'b' and 'b'→'c', giving us 2 key changes total.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only English letters (uppercase and lowercase)
Case insensitive: 'a' and 'A' represent the same key

Visualization

Tap to expand

Understanding the Visualization

Start typing

Begin with the first character - no change yet since there's no previous key

Compare with previous

For each new character, compare it with the previous one (ignoring case)

Count the changes

If the physical keys are different, increment our counter

Continue until end

Repeat this process for every character in the string

Key Takeaway

🎯 Key Insight: We only need to compare adjacent characters in a single pass, making this an O(n) time, O(1) space solution.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 25

The optimal solution uses a single pass through the string, comparing each character with its predecessor using case-insensitive comparison. This achieves O(n) time complexity with O(1) space, making it the most efficient approach for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Comparison (Optimal)	O(n)	O(1)	Compare each character with its immediate predecessor in one pass
Brute Force (Nested Comparison)	O(n²)	O(1)	Compare every character with every previous character to find key changes

Single Pass Comparison (Optimal) — Algorithm Steps

Start from the second character (index 1)
Compare current character with the previous character (case-insensitive)
If they represent different keys, increment the counter
Continue until the end of the string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start from second character, set counter to 0

Compare adjacent

Compare current with previous character (case-insensitive)

Count changes

Increment counter when keys differ, continue to next

Code -

solution.c — C

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

int countKeyChanges(char* s) {
    int len = strlen(s);
    if (len <= 1) {
        return 0;
    }
    
    int changes = 0;
    for (int i = 1; i < len; i++) {
        // Compare current character with previous (case insensitive)
        if (tolower(s[i]) != tolower(s[i-1])) {
            changes++;
        }
    }
    
    return changes;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    int len = strlen(s);
    if (s[0] == '"' && s[len-1] == '"') {
        memmove(s, s+1, len-2);
        s[len-2] = '\0';
    }
    printf("%d\n", countKeyChanges(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, checking each character once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

23.6K Views

Medium Frequency

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

Single Pass Comparison (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler