The Wording Game - Practice Coding Problems

The Wording Game - Problem

Array Math Two Pointers String Greedy Game Theory Hard

The Wording Game is an exciting two-player word competition between Alice and Bob! 🎮

Each player has their own lexicographically sorted array of words. The game follows these strategic rules:

🎯 Goal: Be the last player able to make a valid move
📝 Rules:
• Players alternate turns, with Alice starting first using her lexicographically smallest word
• Each subsequent word must be "closely greater" than the previous word
• The first player unable to make a valid move loses

🔍 "Closely Greater" Definition:
A word w is closely greater than word z if:
1. w is lexicographically greater than z
2. The first letter of w is either the same as the first letter of z, OR the next letter in the alphabet

Example: "care" is closely greater than "book" (c comes after b) and "car" (same first letter, lexicographically greater), but NOT closely greater than "ant" (c is not immediately after a) or "cook" (care < cook lexicographically).

Given both players play optimally, determine if Alice can guarantee a win!

Input & Output

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Game Simulation	O(2^(n+m))	O(n+m)	Simulate all possible game sequences recursively to determine the winner
Binary Search on Game Outcomes	O(log(n+m) * 2^(n+m))	O(n+m + 2^(n+m))	Use binary search to find the minimum winning strategy space
Optimized Game Theory with State Pruning	O(2^(n+m) * (n+m))	O(2^(n+m))	Use memoization with optimized state representation to reduce computation

Recursive Game Simulation — Algorithm Steps

Start with Alice playing her lexicographically smallest word
For each game state, find all valid moves for the current player
Recursively explore each possible move
A position is winning if there exists at least one move that leads to a losing position for the opponent
A position is losing if all possible moves lead to winning positions for the opponent
Cache results to avoid recomputing the same game states

Visualization

Tap to expand

Step-by-Step Walkthrough

Alice's Opening

Alice starts with her lexicographically smallest word

Bob's Response

Bob finds all valid moves that are closely greater

Recursive Exploration

Continue exploring until no moves are possible

Backtrack & Evaluate

Determine if position is winning or losing

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool isCloselyGreater(char* w1, char* w2) {
    if (strcmp(w1, w2) <= 0) return false;
    int diff = w1[0] - w2[0];
    return diff == 0 || diff == 1;
}

bool canWin(char** a, int aSize, char** b, int bSize, char* lastWord, bool aliceTurn, bool* usedA, bool* usedB) {
    char** words = aliceTurn ? a : b;
    int wordsSize = aliceTurn ? aSize : bSize;
    bool* used = aliceTurn ? usedA : usedB;
    
    for (int i = 0; i < wordsSize; i++) {
        if (!used[i] && isCloselyGreater(words[i], lastWord)) {
            bool* newUsedA = (bool*)malloc(aSize * sizeof(bool));
            bool* newUsedB = (bool*)malloc(bSize * sizeof(bool));
            memcpy(newUsedA, usedA, aSize * sizeof(bool));
            memcpy(newUsedB, usedB, bSize * sizeof(bool));
            
            if (aliceTurn) newUsedA[i] = true;
            else newUsedB[i] = true;
            
            bool opponentCanWin = canWin(a, aSize, b, bSize, words[i], !aliceTurn, newUsedA, newUsedB);
            
            free(newUsedA);
            free(newUsedB);
            
            if (!opponentCanWin) return true;
        }
    }
    
    return false;
}

bool canAliceWin(char** a, int aSize, char** b, int bSize) {
    bool* usedA = (bool*)calloc(aSize, sizeof(bool));
    bool* usedB = (bool*)calloc(bSize, sizeof(bool));
    usedA[0] = true;
    
    bool result = canWin(a, aSize, b, bSize, a[0], false, usedA, usedB);
    
    free(usedA);
    free(usedB);
    return result;
}

int main() {
    char* a[] = {"a", "aa"};
    char* b[] = {"b", "bb"};
    printf("%s\n", canAliceWin(a, 2, b, 2) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n+m))

In worst case, we explore all possible game sequences, which can be exponential in the total number of words

✓ Linear Growth

Space Complexity

O(n+m)

Space for recursion stack and memoization table, where n and m are sizes of Alice's and Bob's arrays

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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