Verbal Arithmetic Puzzle - Practice Coding Problems

Verbal Arithmetic Puzzle - Problem

Welcome to the fascinating world of cryptarithmetic puzzles! 🧩

You're given a verbal arithmetic equation where letters represent digits. Your mission is to determine if there's a way to assign unique digits (0-9) to each letter such that the mathematical equation holds true.

The Rules:

Each unique character maps to exactly one digit (0-9)
No two characters can represent the same digit
No word can have leading zeros (unless it's a single digit)
The sum of all words on the left must equal the result on the right

Example: SEND + MORE = MONEY

This famous puzzle has the solution: S=9, E=5, N=6, D=7, M=1, O=0, R=8, Y=2
So: 9567 + 1085 = 10652 ✓

Return true if a valid digit assignment exists, false otherwise.

Input & Output

example_1.py — Classic SEND + MORE = MONEY

$ Input: words = ["SEND", "MORE"], result = "MONEY"

› Output: true

💡 Note: One valid solution: S=9, E=5, N=6, D=7, M=1, O=0, R=8, Y=2. This gives us: 9567 + 1085 = 10652, which is correct.

example_2.py — Simple Addition

$ Input: words = ["SIX", "SEVEN", "SEVEN"], result = "TWENTY"

› Output: true

💡 Note: One valid solution exists: S=6, I=5, X=0, E=8, V=7, N=2, T=1, W=3, Y=4. This gives us: 650 + 68782 + 68782 = 138214.

example_3.py — Impossible Case

$ Input: words = ["LEET", "CODE"], result = "POINT"

› Output: false

💡 Note: No valid digit assignment exists that satisfies all constraints. The equation cannot be made true with unique digit mappings.

Visualization

Tap to expand

Understanding the Visualization

Intelligence Gathering

Identify all unique letters in the message and note which ones can't be zero (first letters of multi-digit numbers)

Systematic Decryption

Try assigning digits to letters one by one, immediately discarding impossible combinations

Constraint Checking

Ensure each digit is used only once and no word starts with zero

Message Verification

When all letters are assigned, check if the mathematical equation holds true

Key Takeaway

🎯 Key Insight: Backtracking with constraint propagation transforms an intractable brute force problem into an efficient search by eliminating impossible assignments early in the decision tree.

Time & Space Complexity

Time Complexity

⏱️

O(10!)

We try all permutations of 10 digits for unique characters (worst case 10 unique chars)

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique characters for storing the mapping

✓ Linear Space

Constraints

2 ≤ words.length ≤ 5
1 ≤ words[i].length, result.length ≤ 7
words[i] and result contain only uppercase English letters
The number of different characters used in the expression is at most 10

Asked in

G Google 12 ⊞ Microsoft 8 a Amazon 6 f Meta 4

The optimal solution uses backtracking with constraint propagation to systematically assign digits to letters. Key optimizations include early pruning of invalid branches (leading zeros, duplicate digits) and checking constraints during assignment rather than after completion. Time complexity is O(10^k) where k is the number of unique characters, but pruning dramatically reduces the actual search space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(10!)	O(k)	Generate all possible digit assignments and test each one
Backtracking with Pruning (Optimal)	O(10^k)	O(k)	Use backtracking to assign digits with early pruning and constraint checking

Brute Force (Try All Permutations) — Algorithm Steps

Extract all unique characters from the equation
Generate all permutations of digits 0-9 for these characters
For each permutation, check leading zeros constraint
Convert words to numbers using the digit mapping
Check if the equation holds: sum(words) == result

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Characters

Find unique chars: S,E,N,D,M,O,R,Y

Generate Permutation

Try assignment: S=9,E=5,N=6,D=7,M=1,O=0,R=8,Y=2

Check Leading Zeros

Verify S≠0, M≠0 (first characters)

Convert & Test

9567 + 1085 = 10652 ✓

Code -

solution.c — C

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

bool backtrack(char** words, int wordsSize, char* result, char* chars, int charCount,
               bool* firstChars, int* mapping, bool* used, int index);
bool isValid(char** words, int wordsSize, char* result, int* mapping);

bool isSolvable(char** words, int wordsSize, char* result) {
    bool charSet[256] = {false};
    bool firstChars[256] = {false};
    
    // Collect unique characters
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; words[i][j]; j++) {
            charSet[words[i][j]] = true;
        }
        if (strlen(words[i]) > 1) {
            firstChars[words[i][0]] = true;
        }
    }
    
    for (int i = 0; result[i]; i++) {
        charSet[result[i]] = true;
    }
    if (strlen(result) > 1) {
        firstChars[result[0]] = true;
    }
    
    char chars[10];
    int charCount = 0;
    for (int i = 0; i < 256; i++) {
        if (charSet[i]) {
            chars[charCount++] = i;
        }
    }
    
    int mapping[256];
    bool used[10] = {false};
    
    return backtrack(words, wordsSize, result, chars, charCount, firstChars, mapping, used, 0);
}

bool backtrack(char** words, int wordsSize, char* result, char* chars, int charCount,
               bool* firstChars, int* mapping, bool* used, int index) {
    if (index == charCount) {
        return isValid(words, wordsSize, result, mapping);
    }
    
    char c = chars[index];
    for (int digit = 0; digit <= 9; digit++) {
        if (used[digit] || (firstChars[c] && digit == 0)) continue;
        
        mapping[c] = digit;
        used[digit] = true;
        
        if (backtrack(words, wordsSize, result, chars, charCount, firstChars, mapping, used, index + 1)) {
            return true;
        }
        
        used[digit] = false;
    }
    
    return false;
}

bool isValid(char** words, int wordsSize, char* result, int* mapping) {
    long long sum = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        long long num = 0;
        for (int j = 0; words[i][j]; j++) {
            num = num * 10 + mapping[words[i][j]];
        }
        sum += num;
    }
    
    long long resultNum = 0;
    for (int i = 0; result[i]; i++) {
        resultNum = resultNum * 10 + mapping[result[i]];
    }
    
    return sum == resultNum;
}

Time & Space Complexity

Time Complexity

⏱️

O(10!)

We try all permutations of 10 digits for unique characters (worst case 10 unique chars)

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique characters for storing the mapping

✓ Linear Space

Constraints

2 ≤ words.length ≤ 5
1 ≤ words[i].length, result.length ≤ 7
words[i] and result contain only uppercase English letters
The number of different characters used in the expression is at most 10

23.6K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler