Guess the Word - Practice Coding Problems

Guess the Word - Problem

Array Math String Interactive Game Theory Hard

Imagine you're playing a word guessing game similar to Mastermind, but with 6-letter words! You have an array of unique words words where each word is exactly 6 letters long. One of these words has been secretly chosen, and your job is to figure out which one it is.

You have access to a special Master object that can help you:

Call Master.guess(word) with any 6-letter word from the array
It returns -1 if the word isn't in the array
It returns the number of exact matches (same letter in the same position) between your guess and the secret word

The challenge? You have a limited number of guesses (allowedGuesses) to find the secret word. You need to be strategic - random guessing won't work!

Example: If the secret word is "acckzz" and you guess "ccbazz", you get 3 matches (positions 2, 4, and 5-6 match).

Your goal is to implement an intelligent strategy that can reliably find the secret word within the allowed number of guesses.

Input & Output

example_1.py — Python

$ Input: words = ["acckzz", "ccbazz", "eiowzz", "abcczz"], secret = "acckzz", allowedGuesses = 10

› Output: You guessed the secret word correctly.

💡 Note: Using minimax strategy, we might first guess "ccbazz" which gives 3 matches, then filter to words with 3 matches against "ccbazz", and eventually find "acckzz".

example_2.py — Python

$ Input: words = ["hamada", "khaled", "mahmud", "aaaaaa"], secret = "aaaaaa", allowedGuesses = 10

› Output: You guessed the secret word correctly.

💡 Note: The optimal strategy would recognize that "aaaaaa" is quite different from other words and can be identified efficiently through strategic guessing.

example_3.py — Python

$ Input: words = ["gaxckt", "trlccr", "jxwhkz", "ycbfps", "peayuf", "yiejjw"], secret = "gaxckt", allowedGuesses = 10

› Output: You guessed the secret word correctly.

💡 Note: Even with diverse words, the minimax approach systematically narrows down possibilities by choosing guesses that provide maximum information.

Visualization

Tap to expand

Understanding the Visualization

Gather Suspects

Start with all possible words as suspects

Strategic Questioning

Choose the suspect to question that will give you the most information

Analyze Clues

Use the similarity score to eliminate impossible suspects

Narrow Down

Repeat with remaining suspects until you find the culprit

Key Takeaway

🎯 Key Insight: The minimax strategy ensures we always make the most informative guess possible, minimizing the worst-case number of remaining suspects after each question. This mathematical approach from game theory guarantees we'll solve the mystery efficiently!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each guess, we need to evaluate all candidates and calculate partitions

⚠ Quadratic Growth

Space Complexity

O(n)

Store candidates and partition information

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
words[i].length == 6
words[i] consists of lowercase English letters
All the strings of words are unique
secret exists in words
10 ≤ allowedGuesses ≤ 30

Asked in

G Google 45 ⊞ Microsoft 32 a Amazon 28 f Meta 15

The optimal solution uses a minimax strategy from game theory. Instead of guessing randomly, we choose each guess to minimize the worst-case scenario. For each potential guess, we calculate how it would partition the remaining candidates based on possible feedback (0-6 matches). We then select the guess that results in the smallest maximum partition size, guaranteeing efficient elimination of candidates regardless of the feedback received.

Common Approaches

Approach	Time	Space	Notes
✓ Minimax Strategy (Optimal)	O(n²)	O(n)	Choose each guess to minimize worst-case scenario using game theory
Random Guessing (Brute Force)	O(n²)	O(n)	Randomly pick words from the candidate list until we find the secret

Minimax Strategy (Optimal) — Algorithm Steps

For each candidate word, simulate using it as a guess
Calculate how it would split remaining candidates by match count
Find the maximum partition size for this guess (worst case)
Choose the guess with the smallest maximum partition size
Make the guess and filter candidates based on actual feedback
Repeat until secret word is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Evaluate Options

For each potential guess, calculate how it splits candidates

Find Worst Case

Identify the largest group for each potential guess

Minimize Maximum

Choose the guess with smallest worst-case group

Make Guess

Execute the optimal choice and filter results

Code -

solution.c — C

// Minimax strategy - optimal approach
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int matches(char* word1, char* word2) {
    int count = 0;
    for (int i = 0; i < 6; i++) {
        if (word1[i] == word2[i]) count++;
    }
    return count;
}

char* getBestGuess(char** candidates, int candidatesSize) {
    if (candidatesSize <= 2) {
        return candidates[0];
    }
    
    char* bestGuess = NULL;
    int minMaxGroup = INT_MAX;
    
    // Try each candidate as a potential guess
    for (int i = 0; i < candidatesSize; i++) {
        char* guess = candidates[i];
        
        // Group remaining candidates by match count with this guess
        int groups[7] = {0}; // 0-6 matches possible
        for (int j = 0; j < candidatesSize; j++) {
            int matchCount = matches(guess, candidates[j]);
            groups[matchCount]++;
        }
        
        // Find the largest group (worst case)
        int maxGroupSize = 0;
        for (int k = 0; k < 7; k++) {
            if (groups[k] > maxGroupSize) {
                maxGroupSize = groups[k];
            }
        }
        
        // Choose guess that minimizes the worst case
        if (maxGroupSize < minMaxGroup) {
            minMaxGroup = maxGroupSize;
            bestGuess = guess;
        }
    }
    
    return bestGuess;
}

void findSecretWord(char** words, int wordsSize, Master* master) {
    char** candidates = (char**)malloc(wordsSize * sizeof(char*));
    for (int i = 0; i < wordsSize; i++) {
        candidates[i] = words[i];
    }
    int candidatesSize = wordsSize;
    
    while (candidatesSize > 1) {
        char* guess = getBestGuess(candidates, candidatesSize);
        int matchCount = master->guess(master, guess);
        
        if (matchCount == 6) {
            free(candidates);
            return; // Found the secret word!
        }
        
        // Filter candidates based on feedback
        int newSize = 0;
        for (int i = 0; i < candidatesSize; i++) {
            if (matches(guess, candidates[i]) == matchCount) {
                candidates[newSize++] = candidates[i];
            }
        }
        candidatesSize = newSize;
    }
    
    // If only one candidate left, it must be the answer
    if (candidatesSize > 0) {
        master->guess(master, candidates[0]);
    }
    
    free(candidates);
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each guess, we need to evaluate all candidates and calculate partitions

⚠ Quadratic Growth

Space Complexity

O(n)

Store candidates and partition information

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
words[i].length == 6
words[i] consists of lowercase English letters
All the strings of words are unique
secret exists in words
10 ≤ allowedGuesses ≤ 30

42.0K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Minimax Strategy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler