Guess the Word

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.

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

Visualization

Tap to expand

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

✓ Math

⏱️ Time: N/A Space: N/A

Minimax Strategy (Optimal)

⏱️ Time: O(n²) Space: O(n)

This is the optimal strategy that uses minimax algorithm from game theory. For each potential guess, we calculate how it would partition the remaining candidates based on possible feedback values (0-6 matches). We then choose the guess that minimizes the size of the largest partition in the worst case.

Random Guessing (Brute Force)

⏱️ Time: O(n²) Space: O(n)

The simplest approach is to randomly select words from our candidate list and hope we get lucky. After each guess, we filter out words that don't match the feedback we received.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>

int power(int base, int exp) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

int solution(int n) {
    if (n <= 3) {
        return n - 1;
    }
    
    if (n % 3 == 0) {
        return power(3, n / 3);
    } else if (n % 3 == 1) {
        return power(3, n / 3 - 1) * 4;
    } else { // n % 3 == 2
        return power(3, n / 3) * 2;
    }
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler