Verbal Arithmetic Puzzle - Practice Coding Problems

Verbal Arithmetic Puzzle - Problem

Given an equation represented by words on the left side and the result on the right side.

You need to check if the equation is solvable under the following rules:

Each character is decoded as one digit (0-9)
No two characters can map to the same digit
Each word and result are decoded as numbers without leading zeros
Sum of numbers on the left side equals the number on the right side

Return true if the equation is solvable, otherwise return false.

Input & Output

Example 1 — Basic Solvable Case

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

› Output: true

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

Example 2 — Leading Zero Violation

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

› Output: true

💡 Note: Multiple characters make this complex, but a valid assignment exists where no leading character maps to 0.

Example 3 — Impossible Case

$ Input: words = ["THIS", "IS"], result = "TOO"

› Output: false

💡 Note: No digit assignment can make THIS + IS = TOO work while satisfying all constraints.

Constraints

2 ≤ words.length ≤ 5
1 ≤ words[i].length ≤ 7
1 ≤ 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

Visualization

Tap to expand

Understanding the Visualization

Input

Words equation: SEND + MORE = MONEY

Process

Assign unique digits to each letter

Output

Return true if valid assignment exists

Key Takeaway

🎯 Key Insight: Use backtracking to efficiently explore digit assignments while respecting leading zero constraints

Asked in

G Google 12 a Amazon 8 M Microsoft 6 f Facebook 4

The key insight is to use backtracking with constraint checking to efficiently explore digit assignments. The backtracking approach with leading zero constraints is optimal. Time: O(10!), Space: O(k) where k is the number of unique characters.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with All Permutations	O(10!)	O(k)	Try every possible digit assignment to each unique character
Optimized Backtracking	O(10!)	O(k)	Use backtracking with constraint checking and early pruning

Brute Force with All Permutations — Algorithm Steps

Find all unique characters
Generate all permutations of digits
For each permutation, check if equation holds
Verify no leading zeros exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Characters

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

Try Assignments

Test each permutation of digits 0-9

Validate

Check equation and leading zeros

Code -

solution.c — C

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

char chars[10];
int charCount = 0;
int digits[10];
bool used[10];

bool isValidAssignment(char** words, int wordCount, char* result) {
    int mapping[256];
    for (int i = 0; i < charCount; i++) {
        mapping[(int)chars[i]] = digits[i];
    }
    
    // Check leading zeros
    for (int i = 0; i < wordCount; i++) {
        if (strlen(words[i]) > 1 && mapping[(int)words[i][0]] == 0) return false;
    }
    if (strlen(result) > 1 && mapping[(int)result[0]] == 0) return false;
    
    // Calculate sum
    long long total = 0;
    for (int i = 0; i < wordCount; i++) {
        long long num = 0;
        for (int j = 0; j < strlen(words[i]); j++) {
            num = num * 10 + mapping[(int)words[i][j]];
        }
        total += num;
    }
    
    long long resultNum = 0;
    for (int i = 0; i < strlen(result); i++) {
        resultNum = resultNum * 10 + mapping[(int)result[i]];
    }
    
    return total == resultNum;
}

bool backtrack(char** words, int wordCount, char* result, int pos) {
    if (pos == charCount) {
        return isValidAssignment(words, wordCount, result);
    }
    
    for (int digit = 0; digit <= 9; digit++) {
        if (!used[digit]) {
            used[digit] = true;
            digits[pos] = digit;
            if (backtrack(words, wordCount, result, pos + 1)) {
                return true;
            }
            used[digit] = false;
        }
    }
    return false;
}

bool solution(char** words, int wordCount, char* result) {
    bool charExists[256] = {false};
    charCount = 0;
    
    // Find unique characters
    for (int i = 0; i < wordCount; i++) {
        for (int j = 0; j < strlen(words[i]); j++) {
            if (!charExists[(int)words[i][j]]) {
                charExists[(int)words[i][j]] = true;
                chars[charCount++] = words[i][j];
            }
        }
    }
    for (int i = 0; i < strlen(result); i++) {
        if (!charExists[(int)result[i]]) {
            charExists[(int)result[i]] = true;
            chars[charCount++] = result[i];
        }
    }
    
    if (charCount > 10) return false;
    
    memset(used, false, sizeof(used));
    return backtrack(words, wordCount, result, 0);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* words[10];
    int wordCount = 0;
    
    char* token = strtok(line, "[],\"\n ");
    while (token != NULL && wordCount < 10) {
        words[wordCount] = malloc(strlen(token) + 1);
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, "[],\"\n ");
    }
    
    char result[100];
    fgets(result, sizeof(result), stdin);
    result[strcspn(result, "\n")] = 0;
    
    printf(solution(words, wordCount, result) ? "true\n" : "false\n");
    
    for (int i = 0; i < wordCount; i++) {
        free(words[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10!)

At most 10 unique characters, so 10! permutations to check

✓ Linear Growth

Space Complexity

O(k)

Space for storing character-to-digit mapping where k is number of unique characters

✓ Linear Space

28.0K Views

Medium Frequency

~35 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler