Enhancing Password Strength

Problem Statement

We are given a task to enhance the strength of a password to meet specific criteria. A password is considered strong if it satisfies the following conditions:

It must be at least 6 characters and, at most, 20 characters long.
It should include at least one lowercase letter, one uppercase letter, and one digit.
It must not contain three consecutive repeating characters.

Your goal is to determine the minimum number of steps required to make the given password strong. If the password already meets the criteria, return 0.

In a single step, you are allowed to perform one of the following actions:

Insert one character into the password.
Delete one character from the password.
Replace one character in the password with another character.

Provide a function that takes the current password as input and returns the minimum number of steps needed to strengthen it.

Java Implementation of above approach

Java Approach 1

import java.util.Scanner; 
public class PasswordStrength {
//main function
    public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); 
System.out.print("Enter the password: ");
        String password = scanner.nextLine();

int result = calculateStepsToStrongPassword(password);
System.out.println("Minimum steps to make the password strong: " + result); 
scanner.close();
    }
//function validates the given password according to specified criteria
    public static intcalculateStepsToStrongPassword(String password) {
int res = 0, a = 1, A = 1, d = 1;
char[] carr = password.toCharArray();
int[] arr = new int[carr.length];
        for (inti = 0; i<arr.length;) {
            if (Character.isLowerCase(carr[i])) a = 0;
            if (Character.isUpperCase(carr[i])) A = 0;
            if (Character.isDigit(carr[i])) d = 0; 
int j = i;   
while (i<carr.length&&carr[i] == carr[j]) i++;   
arr[j] = i - j;
        }
inttotal_missing = (a + A + d); 
        if (arr. length < 6) {   
res += total_missing + Math.max(0, 6 - (arr.length + total_missing)); 
        } else {
intover_len = Math.max(arr.length - 20, 0), left_over = 0;
res += over_len;
for (int k = 1; k < 3; k++) {     
for (inti = 0; i<arr.length&&over_len> 0; i++) {        
if (arr[i] < 3 || arr[i] % 3 != (k - 1)) continue;         
arr[i] -= Math.min(over_len, k);       
over_len -= k;    
}
            }  
for (inti = 0; i<arr.length; i++) {
if (arr[i] >= 3 &&over_len> 0) {      
int need = arr[i] - 2;
arr[i] -= over_len;
over_len -= need;     
}
                if (arr[i] >= 3) left_over += arr[i] / 3;
            }     
res += Math.max(total_missing, left_over);
        }
        return res;
    }
}

Output:

Enter the password: p@ssw0rd123
Minimum steps to make the password strong: 0

Code Explanation:

The Above Java code aims to determine the minimum number of steps required to strengthen a password based on specific criteria. The conditions for a strong password include having a length between 6 and 20 characters, containing at least one lowercase letter, one uppercase letter, and one digit, and avoiding three consecutive repeating characters.

Iterative Character Analysis:

The code uses a character array to analyze the password iteratively. It keeps track of the counts of lowercase letters (a), uppercase letters (A), and digits (d). Additionally, it identifies consecutive repeating characters and stores their counts in an array (arr).

Password Length Check:

If the password length is less than 6, the code calculates the total missing elements (lowercase, uppercase, digit) and adds the necessary characters to meet the minimum length requirement (6). If the password is longer than 6 characters, the code addresses the possibility of exceeding the maximum length (20).

Adjusting Password Length:

If the password length exceeds 20 characters, the code calculates the excess characters (over_len). It then proceeds to adjust the length by removing characters.

Handling Consecutive Repeating Characters:

The code iterates through the consecutive repeating character counts (arr). It strategically reduces the counts to avoid three consecutive repeating characters, minimizing the overall steps required.

Calculating Remaining Steps:

After adjusting the length and handling repeating characters, the code calculates the remaining steps needed to satisfy the strong password conditions. It considers missing lowercase, uppercase, and digit characters, as well as any remaining characters that could be added to fulfill the criteria.