Cryptarithmetic Solver - Problem

A cryptarithmetic puzzle is a mathematical equation where letters represent unique digits (0-9). Your task is to find the digit assignment that makes the equation valid.

Given a cryptarithmetic equation in the form WORD1 + WORD2 = RESULT, return a dictionary/map showing which digit each letter represents. If no valid solution exists, return an empty dictionary.

Rules:

Each letter represents a unique digit (0-9)
Leading letters cannot be 0 (e.g., in SEND, S ≠ 0)
The equation must be mathematically correct

Input & Output

Example 1 — Classic SEND + MORE = MONEY

$ Input: equation = "SEND + MORE = MONEY"

› Output: {"S":9,"E":5,"N":6,"D":7,"M":1,"O":0,"R":8,"Y":2}

💡 Note: When S=9, E=5, N=6, D=7, M=1, O=0, R=8, Y=2, we get 9567 + 1085 = 10652, which is mathematically correct

Example 2 — Simple TWO + TWO = FOUR

$ Input: equation = "TWO + TWO = FOUR"

› Output: {"T":7,"W":3,"O":4,"F":1,"U":9,"R":8}

💡 Note: When T=7, W=3, O=4, F=1, U=9, R=8, we get 734 + 734 = 1468, which satisfies the equation

Example 3 — No Solution Case

$ Input: equation = "ABC + DEF = GHI"

› Output: {}

💡 Note: No valid digit assignment exists where a 3-digit + 3-digit = 3-digit with all different letters

Constraints

Each letter represents a unique digit (0-9)
Leading letters cannot be 0
Equation contains 2-10 unique letters
Input format: "WORD1 + WORD2 = RESULT"

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 A Amazon 15 f Meta 12

The key insight is to use backtracking with constraint checking to prune impossible digit assignments early. The optimal approach assigns digits one letter at a time while checking leading-zero and uniqueness constraints, dramatically reducing the search space from 10! to a much smaller set. Time: O(10^k), Space: O(k)

Common Approaches

✓ Brute Force with All Permutations

⏱️ Time: O(10!) Space: O(n)

Generate all possible ways to assign 10 digits (0-9) to the unique letters in the equation. For each assignment, check if leading letters are non-zero and if the mathematical equation holds true.

Smart Backtracking with Constraints

⏱️ Time: O(10^k) Space: O(k)

Assign digits to letters one at a time while checking constraints early. When a partial assignment cannot lead to a valid solution, backtrack immediately rather than exploring all combinations.

Brute Force with All Permutations — Algorithm Steps

Extract all unique letters from the equation
Generate all possible digit assignments (permutations)
For each assignment, check constraints (no leading zeros)
Verify if the equation is mathematically correct

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Letters

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

Generate Permutations

Try all ways to assign digits 0-9 to letters

Check Constraints

Verify no leading zeros and equation validity

Result

Return first valid assignment found

Code -

solution.c — C

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

#define MAX_LETTERS 10

typedef struct {
    char letter;
    int digit;
} Mapping;

char word1[20], word2[20], result_word[20];
char letters[MAX_LETTERS];
int letter_count = 0;
bool leading[MAX_LETTERS];
Mapping final_mapping[MAX_LETTERS];
int final_count = 0;

int wordToNumber(char* word, Mapping* mapping, int count) {
    int num = 0;
    for (int i = 0; word[i]; i++) {
        for (int j = 0; j < count; j++) {
            if (mapping[j].letter == word[i]) {
                num = num * 10 + mapping[j].digit;
                break;
            }
        }
    }
    return num;
}

bool backtrack(int pos, Mapping* mapping, bool* used) {
    if (pos == letter_count) {
        // Check leading zero constraint
        for (int i = 0; i < letter_count; i++) {
            if (leading[i] && mapping[i].digit == 0) {
                return false;
            }
        }
        
        // Check equation
        int num1 = wordToNumber(word1, mapping, letter_count);
        int num2 = wordToNumber(word2, mapping, letter_count);
        int num_result = wordToNumber(result_word, mapping, letter_count);
        
        if (num1 + num2 == num_result) {
            memcpy(final_mapping, mapping, sizeof(Mapping) * letter_count);
            final_count = letter_count;
            return true;
        }
        return false;
    }
    
    for (int digit = 0; digit <= 9; digit++) {
        if (!used[digit]) {
            mapping[pos].letter = letters[pos];
            mapping[pos].digit = digit;
            used[digit] = true;
            
            if (backtrack(pos + 1, mapping, used)) {
                return true;
            }
            
            used[digit] = false;
        }
    }
    return false;
}

int solution(char* equation) {
    // Parse equation
    char* eq_pos = strchr(equation, '=');
    *eq_pos = '\0';
    strcpy(result_word, eq_pos + 1);
    
    char* plus_pos = strchr(equation, '+');
    *plus_pos = '\0';
    strcpy(word1, equation);
    strcpy(word2, plus_pos + 1);
    
    // Get unique letters
    bool letter_seen[256] = {false};
    letter_count = 0;
    
    char all_letters[100];
    sprintf(all_letters, "%s%s%s", word1, word2, result_word);
    
    for (int i = 0; all_letters[i]; i++) {
        if (!letter_seen[(int)all_letters[i]]) {
            letters[letter_count] = all_letters[i];
            leading[letter_count] = (all_letters[i] == word1[0] || 
                                   all_letters[i] == word2[0] || 
                                   all_letters[i] == result_word[0]);
            letter_seen[(int)all_letters[i]] = true;
            letter_count++;
        }
    }
    
    Mapping mapping[MAX_LETTERS];
    bool used[10] = {false};
    
    return backtrack(0, mapping, used) ? 1 : 0;
}

int main() {
    char equation[100];
    fgets(equation, sizeof(equation), stdin);
    equation[strcspn(equation, "\n")] = 0;
    
    if (solution(equation)) {
        printf("{");
        for (int i = 0; i < final_count; i++) {
            if (i > 0) printf(",");
            printf("\"%c\":%d", final_mapping[i].letter, final_mapping[i].digit);
        }
        printf("}\n");
    } else {
        printf("{}\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10!)

Must check up to 10! = 3,628,800 possible digit assignments

✓ Linear Growth

Space Complexity

O(n)

Space for storing letter mappings and equation parsing

⚡ Linearithmic Space

12.8K Views

Medium Frequency

~25 min Avg. Time

456 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

Cryptarithmetic Solver - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler