Strong Password Checker

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

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

✓ Brute Force Analysis

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

Check length requirements, character type requirements, and repeating character issues independently, then combine the operations needed.

Greedy Optimization

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

Handle different length cases with optimal strategies: for short passwords maximize insertion benefits, for long passwords optimize deletions, for medium length passwords use replacements efficiently.

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 min(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 deleteSaved[3] = {0, 0, 0};
        int i = 0;
        
        while (i < n) {
            if (i + 2 < n && password[i] == password[i+1] && password[i+1] == password[i+2]) {
                int length = 0;
                char startChar = password[i];
                while (i < n && password[i] == startChar) {
                    length++;
                    i++;
                }
                repeating += length / 3;
                deleteSaved[length % 3]++;
            } else {
                i++;
            }
        }
        
        int savedReplacements = min(deleteSaved[0], deleteCount) + 
                              min(deleteSaved[1], deleteCount) + 
                              min(deleteSaved[2], deleteCount / 2);
        
        return deleteCount + max(missingTypes, repeating - savedReplacements);
    } else {
        int repeating = 0;
        int i = 0;
        while (i < n) {
            if (i + 2 < n && password[i] == password[i+1] && password[i+1] == password[i+2]) {
                int length = 0;
                char startChar = password[i];
                while (i < n && password[i] == startChar) {
                    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