Strong Password Checker II

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

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

✓ Multiple Pass Validation

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

This approach checks each of the 6 requirements separately, making multiple passes through the password string. For each criterion, we iterate through the entire string to verify if it's satisfied.

Single Pass Validation

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

This optimized approach validates all criteria in a single iteration through the password string. We maintain flags for each requirement and update them as we encounter relevant characters, making the solution more efficient.

Multiple Pass Validation — Algorithm Steps

Step 1: Check length >= 8
Step 2: Check for lowercase letter
Step 3: Check for uppercase letter
Step 4: Check for digit
Step 5: Check for special character
Step 6: Check for no adjacent duplicates

Visualization

Tap to expand

Step-by-Step Walkthrough

Length Check

Verify password has at least 8 characters

Character Type Checks

Check for lowercase, uppercase, digit, and special character

Adjacent Check

Verify no adjacent duplicate characters

Code -

solution.c — C

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

bool solution(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 (islower(password[i])) {
            hasLower = true;
            break;
        }
    }
    if (!hasLower) return false;
    
    // Check for uppercase
    bool hasUpper = false;
    for (int i = 0; i < len; i++) {
        if (isupper(password[i])) {
            hasUpper = true;
            break;
        }
    }
    if (!hasUpper) return false;
    
    // Check for digit
    bool hasDigit = false;
    for (int i = 0; i < len; i++) {
        if (isdigit(password[i])) {
            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 no adjacent duplicates
    for (int i = 0; i < len - 1; i++) {
        if (password[i] == password[i + 1]) {
            return false;
        }
    }
    
    return true;
}

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)

6 separate passes through the string, but still linear

✓ 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

Multiple Pass Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler