Strong Password Checker II - Practice Coding Problems

Strong Password Checker II - Problem

String Easy

A password is said to be strong if it satisfies all the following criteria:

It has at least 8 characters.
It contains at least one lowercase letter.
It contains at least one uppercase letter.
It contains at least one digit.
It contains at least one special character. The special characters are the characters in the following string: "!@#$%^&*()-+".
It does not contain 2 of the same character in adjacent positions (i.e., "aab" violates this condition, but "aba" does not).

Given a string password, return true if it is a strong password. Otherwise, return false.

Input & Output

Example 1 — Strong Password

$ Input: password = "ILoveLeetcode"

› Output: false

💡 Note: Password has 13 characters with uppercase, lowercase letters but lacks digits and special characters. Also has adjacent 'e' characters.

Example 2 — Valid Strong Password

$ Input: password = "Abc1234!"

› Output: true

💡 Note: Password meets all criteria: 8+ chars, has uppercase (A), lowercase (b,c), digit (1,2,3,4), special (!), no adjacent duplicates.

Example 3 — Adjacent Duplicates

$ Input: password = "Password123!!"

› Output: false

💡 Note: Password has adjacent duplicate characters '!!' which violates the no adjacent duplicates rule.

Constraints

1 ≤ password.length ≤ 100
password consists of letters, digits, and special characters: "!@#$%^&*()-+".

Visualization

Tap to expand

Understanding the Visualization

Input

Password string to validate

Check Requirements

Validate 6 criteria: length, case, digits, specials, no adjacent duplicates

Output

Boolean result indicating if password is strong

Key Takeaway

🎯 Key Insight: Validate all password strength criteria efficiently in a single pass through the string

Asked in

M Microsoft 25 f Facebook 20

The key insight is to validate all password requirements in a single pass through the string. The optimal approach uses boolean flags to track each criterion (length, character types, no adjacent duplicates) while iterating once. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Validation	O(n)	O(1)	Check all requirements in one pass through the password
Multiple Pass Validation	O(n)	O(1)	Check each requirement with separate iterations through the password

Single Pass Validation — Algorithm Steps

Step 1: Initialize flags for each requirement
Step 2: Iterate once through password
Step 3: Update flags and check adjacent duplicates in same pass
Step 4: Return true if all flags are satisfied

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Flags

Set up boolean flags for each requirement

Single Iteration

Check all criteria while iterating once through password

Final Validation

All flags must be true for strong password

Code -

solution.c — C

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

bool solution(char* password) {
    int len = strlen(password);
    
    if (len < 8) {
        return false;
    }
    
    bool hasLower = false;
    bool hasUpper = false;
    bool hasDigit = false;
    bool hasSpecial = false;
    char* specialChars = "!@#$%^&*()-+";
    
    // Single pass through password
    for (int i = 0; i < len; i++) {
        char c = password[i];
        
        // Check adjacent duplicates
        if (i > 0 && password[i-1] == c) {
            return false;
        }
        
        // Update flags
        if (islower(c)) {
            hasLower = true;
        } else if (isupper(c)) {
            hasUpper = true;
        } else if (isdigit(c)) {
            hasDigit = true;
        } else if (strchr(specialChars, c) != NULL) {
            hasSpecial = true;
        }
    }
    
    return hasLower && hasUpper && hasDigit && hasSpecial;
}

int main() {
    char password[1000];
    fgets(password, sizeof(password), stdin);
    password[strcspn(password, "\n")] = 0;
    
    bool result = solution(password);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string of length n

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for flags and variables

✓ Linear Space

28.0K Views

Medium Frequency

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

Single Pass Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler