# Solving Leetcode Interviews in Seconds with AI: Find Maximum Number of String Pairs


	# 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](https://www.chatmagic.app), 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
	```python
	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
	```