Introduction

In this blog post, we will explore how to solve the LeetCode problem "2744" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

You are given a 0-indexed array words consisting of distinct strings. The string words[i] can be paired with the string words[j] if: The string words[i] is equal to the reversed string of words[j]. 0 <= i < j < words.length. Return the maximum number of pairs that can be formed from the array words. Note that each string can belong in at most one pair. Example 1: Input: words = ["cd","ac","dc","ca","zz"] Output: 2 Explanation: In this example, we can form 2 pair of strings in the following way: - We pair the 0th string with the 2nd string, as the reversed string of word[0] is "dc" and is equal to words[2]. - We pair the 1st string with the 3rd string, as the reversed string of word[1] is "ca" and is equal to words[3]. It can be proven that 2 is the maximum number of pairs that can be formed. Example 2: Input: words = ["ab","ba","cc"] Output: 1 Explanation: In this example, we can form 1 pair of strings in the following way: - We pair the 0th string with the 1st string, as the reversed string of words[1] is "ab" and is equal to words[0]. It can be proven that 1 is the maximum number of pairs that can be formed. Example 3: Input: words = ["aa","ab"] Output: 0 Explanation: In this example, we are unable to form any pair of strings. Constraints: 1 <= words.length <= 50 words[i].length == 2 words consists of distinct strings. words[i] contains only lowercase English letters.

Explanation

Here's the breakdown of the solution:

• Hashing for Efficiency: Use a hash map (dictionary in Python) to store the frequency of each word in the input list. This allows for O(1) average-case lookup time when searching for reversed pairs.
• Iterate and Count Pairs: Iterate through the words list. For each word, reverse it and check if the reversed word exists in the hash map. If it does, increment the pairs count and decrement the count of the reversed word in the hash map. Avoid double-counting by decrementing the frequency count after finding a pair.

• Optimal Pair Formation: The algorithm ensures that each word is used in at most one pair by reducing the frequency count in the hash map after a pair is formed.

• Runtime & Storage Complexity: O(n), where n is the number of words, for both runtime and storage.

Code

    def max_number_of_pairs(words):
    """
    Finds the maximum number of pairs that can be formed from the array words.

    Args:
        words (list[str]): A 0-indexed array of distinct strings.

    Returns:
        int: The maximum number of pairs that can be formed.
    """

    word_counts = {}
    for word in words:
        word_counts[word] = word_counts.get(word, 0) + 1

    pairs = 0
    for word in words:
        reversed_word = word[::-1]
        if reversed_word in word_counts and word_counts[reversed_word] > 0 and word_counts[word] > 0:
            if word == reversed_word and word_counts[word] > 1:
                pairs += 1
                word_counts[word] -= 2
            elif word != reversed_word:
                if word_counts.get(word, 0) > 0 and word_counts.get(reversed_word, 0) > 0:
                    pairs += 1
                    word_counts[word] -=1
                    word_counts[reversed_word] -=1

    return pairs