Longest Password: Codility Challenge In Python

Oct 29, 2025 by Jhon Lennon 47 views

Let's dive into a classic coding challenge: the "Longest Password" problem on Codility. This problem tests your ability to parse strings, apply specific rules, and determine the longest valid password from a given input. We'll explore the problem statement, discuss the constraints, and then walk through a Python solution with detailed explanations.

Understanding the Problem

The "Longest Password" problem presents you with a string S containing multiple words separated by spaces. Your task is to identify the longest word that qualifies as a valid password according to the following rules:

Only alphanumeric characters: A valid password must consist only of letters (a-z, A-Z) and digits (0-9).
Even number of letters: A valid password must contain an even number of letters.
Odd number of digits: A valid password must contain an odd number of digits.

Your function should return the length of the longest valid password found in the string S. If no valid password exists, the function should return -1.

Example:

Let's say the input string S is:

"test 5 a0A pass007 abcdefg"

Here's how we'd evaluate the words:

test: Valid (4 letters, 0 digits) - Length: 4
5: Invalid (not alphanumeric)
a0A: Valid (2 letters, 1 digit) - Length: 3
pass007: Valid (4 letters, 3 digits) - Length: 7
abcdefg: Invalid (odd number of letters)

Therefore, the longest valid password is "pass007", and the function should return 7.

Breaking Down the Requirements

Before we jump into the Python code, let's solidify our understanding of the rules. This is crucial for crafting an accurate and efficient solution.

Alphanumeric Check: We need a way to quickly determine if a character is a letter or a digit. Python's built-in string methods like .isalpha() and .isdigit() will be our friends here.
Counting Letters and Digits: We'll need to iterate through each word and keep track of the number of letters and digits we encounter.
Validity Check: After counting, we'll apply the even-letter and odd-digit rules. If a word meets both criteria, it's a potential valid password.
Finding the Longest: We'll need to maintain a variable to store the length of the longest valid password found so far. We'll update this variable whenever we encounter a longer valid password.
Handling No Valid Passwords: Don't forget the edge case where the input string contains no valid passwords. In this scenario, our function should return -1.

Python Solution with Detailed Explanations

Alright, guys, let's get our hands dirty with some Python code. Here's a solution to the "Longest Password" problem, followed by a step-by-step explanation.

def longestPassword(S):
    words = S.split()
    max_length = -1

    for word in words:
        letter_count = 0
        digit_count = 0
        is_valid = True

        for char in word:
            if char.isalpha():
                letter_count += 1
            elif char.isdigit():
                digit_count += 1
            else:
                is_valid = False
                break

        if is_valid and letter_count % 2 == 0 and digit_count % 2 != 0:
            max_length = max(max_length, len(word))

    return max_length

# Example usage:
S = "test 5 a0A pass007 abcdefg"
result = longestPassword(S)
print(f"The length of the longest password is: {result}")  # Output: 7

S = "my00 50 1z"
result = longestPassword(S)
print(f"The length of the longest password is: {result}") # Output: -1

Explanation:

longestPassword(S) function: This function takes the input string S as an argument.
words = S.split(): We split the input string into a list of individual words using the split() method. This separates the words based on spaces.
max_length = -1: We initialize max_length to -1. This variable will store the length of the longest valid password we find. Starting at -1 handles the case where no valid passwords exist.
for word in words:: We iterate through each word in the words list.
letter_count = 0 and digit_count = 0: For each word, we initialize letter_count and digit_count to 0. These variables will keep track of the number of letters and digits in the current word.
is_valid = True: We initialize is_valid to True. This flag will indicate whether the current word is a potential valid password. We'll set it to False if we encounter a non-alphanumeric character.
for char in word:: We iterate through each character in the current word.
if char.isalpha():: If the character is a letter (a-z, A-Z), we increment letter_count.
elif char.isdigit():: If the character is a digit (0-9), we increment digit_count.
else:: If the character is neither a letter nor a digit, the word is invalid. We set is_valid to False and break out of the inner loop using break. No need to check the rest of the characters in the word if it's already invalid.
if is_valid and letter_count % 2 == 0 and digit_count % 2 != 0:: After processing all characters in the word, we check if the word is valid (is_valid is still True) and if it meets the even-letter and odd-digit criteria.
max_length = max(max_length, len(word)): If the word is a valid password, we update max_length to be the maximum of its current value and the length of the current word.
return max_length: After processing all words, we return the final value of max_length. This will be the length of the longest valid password found, or -1 if no valid passwords were found.

Optimizations and Considerations

While the above solution is clear and concise, let's think about potential optimizations and things to consider in real-world scenarios.

Early Exit: The current solution iterates through the entire word even if it's already determined to be invalid (e.g., contains a non-alphanumeric character). We can optimize this by breaking out of the inner loop as soon as we find an invalid character. The provided code already includes this optimization.
Regular Expressions: For the alphanumeric check, you could use regular expressions. While this might be more concise, it can sometimes be less performant than using isalpha() and isdigit(), especially for simple cases. However, if you need more complex pattern matching, regular expressions can be very powerful.
Large Input Strings: If you're dealing with extremely large input strings, consider using generators or iterators to process the words in a more memory-efficient manner. This can prevent you from loading the entire string into memory at once.
Character Encoding: Be mindful of character encoding, especially if you're dealing with international characters. Ensure your code handles Unicode characters correctly.

Common Mistakes to Avoid

Forgetting the -1 Return: A common mistake is to forget to return -1 when no valid passwords are found. Always handle edge cases!
Incorrectly Counting Letters and Digits: Double-check your logic for counting letters and digits. Make sure you're only counting alphanumeric characters and that you're using the correct methods (isalpha() and isdigit()).
Not Handling Non-Alphanumeric Characters: Ensure your code correctly identifies and handles characters that are not letters or digits.
Premature Optimization: Don't over-optimize prematurely. Focus on writing a correct and readable solution first, and then profile your code to identify any performance bottlenecks before attempting to optimize.

Alternative Approaches

While the provided solution is efficient and easy to understand, here are a couple of alternative approaches you could consider:

Using List Comprehensions: You could potentially use list comprehensions to make the code more concise, but this might sacrifice some readability.
Functional Programming: You could explore a more functional approach using map and filter to process the words and characters.

Conclusion

The "Longest Password" Codility challenge is a great exercise in string manipulation, conditional logic, and problem-solving. By understanding the problem statement, breaking it down into smaller parts, and writing clear and concise code, you can successfully tackle this challenge and improve your coding skills. Remember to handle edge cases, consider potential optimizations, and choose the approach that best suits your needs and coding style. Keep practicing, guys, and you'll become coding masters in no time!