Strong Password Checker - Practice Coding Problems

Strong Password Checker - Problem

A password is considered strong if all of the following conditions are met:

It has at least 6 characters and at most 20 characters.
It contains at least one lowercase letter, at least one uppercase letter, and at least one digit.
It does not contain three repeating characters in a row (i.e., "Baaabb0" is weak, but "Baaba0" is strong).

Given a string password, return the minimum number of steps required to make the password strong. If the password is already strong, return 0.

In one step, you can:

Insert one character to password
Delete one character from password
Replace one character of password with another character

Input & Output

Example 1 — Short Password

$ Input: password = "a"

› Output: 5

💡 Note: Password is too short (1 < 6) and missing uppercase and digit. Need max(6-1, 3) = 5 insertions: "a" → "Aa1bcd"

Example 2 — Repeating Characters

$ Input: password = "aaa111"

› Output: 2

💡 Note: Length is 6 (good), has lowercase and digits, missing uppercase. Has "aaa" and "111" repeating. Need max(1 missing type, 2 replacements) = 2 steps.

Example 3 — Already Strong

$ Input: password = "Aa1bcde"

› Output: 0

💡 Note: Length 7 is valid, has all character types, no repeating sequences. Already strong.

Constraints

1 ≤ password.length ≤ 50
password consists of letters, digits, dot '.' or exclamation mark '!'

Visualization

Tap to expand

Understanding the Visualization

Input Analysis

Check length, character types, and repeating sequences

Strategy Selection

Choose optimal operation type based on length

Minimize Operations

Combine fixes to reduce total steps

Key Takeaway

🎯 Key Insight: Different password lengths require different optimization strategies to minimize total operations

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is to handle different password lengths with optimal strategies: short passwords benefit from insertions that fix multiple issues, medium passwords use targeted replacements, and long passwords optimize deletions to minimize remaining fixes. Best approach is Greedy Optimization with Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Analysis	O(n)	O(1)	Analyze each condition separately and sum up required operations
Greedy Optimization	O(n)	O(1)	Strategically combine operations to minimize total steps

Brute Force Analysis — Algorithm Steps

Step 1: Count missing character types
Step 2: Handle length violations
Step 3: Fix repeating characters
Step 4: Sum all operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Length

Too short needs insertions, too long needs deletions

Check Types

Count missing lowercase, uppercase, digits

Count Repeats

Find sequences of 3+ same characters

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(char* password) {
    int n = strlen(password);
    bool hasLower = false, hasUpper = false, hasDigit = false;
    
    for (int i = 0; i < n; i++) {
        char c = password[i];
        if (c >= 'a' && c <= 'z') hasLower = true;
        else if (c >= 'A' && c <= 'Z') hasUpper = true;
        else if (c >= '0' && c <= '9') hasDigit = true;
    }
    
    int missingTypes = (!hasLower ? 1 : 0) + (!hasUpper ? 1 : 0) + (!hasDigit ? 1 : 0);
    
    if (n < 6) {
        return max(6 - n, missingTypes);
    } else if (n > 20) {
        int deleteCount = n - 20;
        int repeating = 0;
        int i = 2;
        while (i < n) {
            if (password[i] == password[i-1] && password[i-1] == password[i-2]) {
                int length = 2;
                while (i < n && password[i] == password[i-1]) {
                    length++;
                    i++;
                }
                repeating += length / 3;
            } else {
                i++;
            }
        }
        return deleteCount + max(missingTypes, repeating);
    } else {
        int repeating = 0;
        int i = 2;
        while (i < n) {
            if (password[i] == password[i-1] && password[i-1] == password[i-2]) {
                int length = 2;
                while (i < n && password[i] == password[i-1]) {
                    length++;
                    i++;
                }
                repeating += length / 3;
            } else {
                i++;
            }
        }
        return max(missingTypes, repeating);
    }
}

int main() {
    char password[1001];
    fgets(password, sizeof(password), stdin);
    password[strcspn(password, "\n")] = 0;
    int result = solution(password);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string to check all conditions

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

89.2K Views

Medium Frequency

~35 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 Analysis — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler