Strong Password Checker II - Practice Coding Problems

Strong Password Checker II - Problem

String Easy

Strong Password Checker II is a classic string validation problem that tests your ability to implement multiple criteria checking efficiently.

You're given a password string and need to determine if it meets all of the following security requirements:

✅ Length: At least 8 characters
✅ Lowercase: Contains at least one lowercase letter (a-z)
✅ Uppercase: Contains at least one uppercase letter (A-Z)
✅ Digit: Contains at least one digit (0-9)
✅ Special Character: Contains at least one special character from "!@#$%^&*()-+"
✅ No Adjacent Duplicates: No two identical characters appear consecutively

Goal: Return true if the password is strong (meets ALL criteria), otherwise return false.

This problem is commonly used in cybersecurity applications and user registration systems to enforce password policies.

Input & Output

example_1.py — Strong Password

$ Input: password = "IloveLe3tcode!"

› Output: true

💡 Note: The password meets all requirements: length >= 8 (14 chars), has lowercase letters (o,v,e,t,c,o,d,e), uppercase letters (I,L), digits (3), special character (!), and no adjacent duplicates.

example_2.py — Adjacent Duplicates

$ Input: password = "Me+You--IsMyDream"

› Output: false

💡 Note: Although the password has 17 characters and contains lowercase, uppercase, and special characters, it has adjacent duplicate characters '--' which violates the rule.

example_3.py — Missing Requirements

$ Input: password = "1aB!"

› Output: false

💡 Note: The password fails the length requirement (only 4 characters, needs at least 8). Even though it has all character types and no adjacent duplicates, it's too short.

Constraints

1 ≤ password.length ≤ 100
password consists of letters, digits, and special characters: "!@#$%^&*()-+"
Password must satisfy all criteria to be considered strong

Visualization

Tap to expand

Understanding the Visualization

Length Scanner

First gate checks if ID badge has minimum 8 characters

Character Analysis

Advanced scanner analyzes each character for type classification

Requirement Tracking

Security system tracks which requirements have been satisfied

Final Verification

All checkpoints must be cleared for access approval

Key Takeaway

🎯 Key Insight: Single-pass validation efficiently checks all requirements simultaneously, making it the optimal O(n) solution for password strength verification.

Asked in

⊞ Microsoft 15 a Amazon 12 G Google 8 f Meta 6

The optimal approach uses single-pass validation to check all password requirements simultaneously in O(n) time. Key insights: validate character types and adjacent duplicates in one iteration while maintaining boolean flags for each requirement.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(6n) → O(n)	O(1)	Check each requirement separately with multiple string scans
One-Pass Validation (Optimal)	O(n)	O(1)	Check all requirements simultaneously in a single pass through the string

Brute Force (Multiple Passes) — Algorithm Steps

Check if password length >= 8
Scan entire string to find any lowercase letter
Scan entire string to find any uppercase letter
Scan entire string to find any digit
Scan entire string to find any special character
Scan entire string to check for adjacent duplicate characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Length Check

First check if password has at least 8 characters

Lowercase Scan

Scan entire string looking for lowercase letters

Uppercase Scan

Scan entire string looking for uppercase letters

Digit Scan

Scan entire string looking for digits

Special Char Scan

Scan entire string looking for special characters

Adjacent Check

Scan for consecutive duplicate characters

Code -

solution.c — C

bool strongPasswordCheckerII(char* password) {
    int len = strlen(password);
    
    // Check length
    if (len < 8) {
        return false;
    }
    
    // Check for lowercase
    bool hasLower = false;
    for (int i = 0; i < len; i++) {
        if (password[i] >= 'a' && password[i] <= 'z') {
            hasLower = true;
            break;
        }
    }
    if (!hasLower) return false;
    
    // Check for uppercase
    bool hasUpper = false;
    for (int i = 0; i < len; i++) {
        if (password[i] >= 'A' && password[i] <= 'Z') {
            hasUpper = true;
            break;
        }
    }
    if (!hasUpper) return false;
    
    // Check for digit
    bool hasDigit = false;
    for (int i = 0; i < len; i++) {
        if (password[i] >= '0' && password[i] <= '9') {
            hasDigit = true;
            break;
        }
    }
    if (!hasDigit) return false;
    
    // Check for special character
    char* specialChars = "!@#$%^&*()-+";
    bool hasSpecial = false;
    for (int i = 0; i < len; i++) {
        if (strchr(specialChars, password[i]) != NULL) {
            hasSpecial = true;
            break;
        }
    }
    if (!hasSpecial) return false;
    
    // Check for adjacent duplicates
    for (int i = 0; i < len - 1; i++) {
        if (password[i] == password[i + 1]) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(6n) → O(n)

We scan the string up to 6 times (once for each requirement), making it 6n operations

✓ Linear Growth

Space Complexity

O(1)

Only using a few boolean variables and string constants

✓ Linear Space

28.0K Views

Medium Frequency

~8 min Avg. Time

850 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 (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler