Strong Password Checker - Practice Coding Problems

Strong Password Checker - Problem

Imagine you're a security consultant tasked with strengthening weak passwords. Your job is to determine the minimum number of changes needed to transform any password into a fortress-level secure one!

A password achieves "strong" status when it satisfies ALL these criteria:

Length: Between 6-20 characters (inclusive)
Character diversity: At least one lowercase letter, one uppercase letter, and one digit
No repetition: No three consecutive identical characters (e.g., "aaa" is forbidden, but "aab" is fine)

You have three tools in your arsenal for each step:

Insert a character anywhere
Delete any character
Replace any character with another

Goal: Return the minimum steps needed to make the password strong. If it's already strong, return 0.

Input & Output

example_1.py — Short Password

$ Input: password = "a"

› Output: 5

💡 Note: The password needs 5 more characters to reach minimum length 6. We can add "A1bcd" to get "aA1bcd" which satisfies all requirements with 5 insertions.

example_2.py — Normal Length with Issues

$ Input: password = "aA1"

› Output: 3

💡 Note: Too short (need 3 more chars) but has all character types. Adding 3 characters like "bcd" gives us "aA1bcd" - minimum 3 steps.

example_3.py — Long Password

$ Input: password = "1337C0d3"

› Output: 0

💡 Note: This password is already strong: length 8 (within 6-20), has lowercase, uppercase, and digits, with no three consecutive repeating characters.

Visualization

Tap to expand

Understanding the Visualization

Assess Current State

Evaluate the fortress size, defender types, and structural weaknesses

Choose Strategy

Different approaches for small, medium, or oversized fortresses

Execute Plan

Make minimal changes that address multiple security concerns

Verify Security

Ensure all requirements are met with optimal resource usage

Key Takeaway

🎯 Key Insight: The optimal strategy adapts to password length - expand small passwords with smart insertions, reinforce medium ones with targeted replacements, and downsize large ones with strategic deletions that minimize future work.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the password to analyze all constraints simultaneously

✓ Linear Growth

Space Complexity

O(1)

Only constant extra space for counters and state tracking

✓ Linear Space

Constraints

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

Asked in

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

The optimal solution uses a length-based greedy strategy. For short passwords, prioritize insertions that simultaneously fix length and character requirements. For normal passwords, use replacements in repeating sequences. For long passwords, apply strategic deletions that minimize subsequent replacement needs. The key insight is that each operation should solve multiple constraints whenever possible.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Separate Issue Handling)	O(n²)	O(1)	Handle each requirement separately without considering overlap
Optimal Greedy Approach	O(n)	O(1)	Analyze all requirements simultaneously and apply optimal strategy based on length

Brute Force (Separate Issue Handling) — Algorithm Steps

Check if password is too short/long and calculate insertions/deletions needed
Count missing character types (lowercase, uppercase, digits)
Find all sequences of 3+ repeating characters
Sum up all required changes without optimization

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Length

Determine if password is too short or too long

Check Types

Count missing character types (lower, upper, digit)

Check Repeats

Find all repeating sequences of 3+ characters

Sum Changes

Add all required changes (suboptimal)

Code -

solution.c — C

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

int strongPasswordChecker(char* password) {
    int n = strlen(password);
    
    // Length issues
    int insertionsNeeded = (n < 6) ? 6 - n : 0;
    int deletionsNeeded = (n > 20) ? n - 20 : 0;
    
    // Missing character types
    int hasLower = 0, hasUpper = 0, hasDigit = 0;
    for (int i = 0; i < n; i++) {
        if (islower(password[i])) hasLower = 1;
        if (isupper(password[i])) hasUpper = 1;
        if (isdigit(password[i])) hasDigit = 1;
    }
    int missingTypes = (!hasLower) + (!hasUpper) + (!hasDigit);
    
    // Repeating sequences
    int repeatingChanges = 0;
    int i = 0;
    while (i < n) {
        if (i + 2 < n && password[i] == password[i+1] && password[i] == password[i+2]) {
            int seqLen = 2;
            while (i + seqLen < n && password[i] == password[i+seqLen]) {
                seqLen++;
            }
            repeatingChanges += seqLen / 3;
            i += seqLen;
        } else {
            i++;
        }
    }
    
    return insertionsNeeded + deletionsNeeded + missingTypes + repeatingChanges;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple passes through the string, with nested loops for finding repeating sequences

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters and flags

✓ Linear Space

Constraints

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

28.6K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Separate Issue Handling) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler