Solving Cryptarithmetic Puzzles

// C++ program to implement 
// Cryptarithmetic Puzzle Solver
#include <bits/stdc++.h>
using namespace std;

// Function to remove preceeding zeroes
void removeZeroes(string &a) {
    reverse(a.begin(), a.end());

    while(a.size() > 1 && a.back() == '0') {
        a.pop_back();
    }

    reverse(a.begin(), a.end());
}

// function change character string
// to digit string
string charToDigit(string a, vector<char> &digits) {

    string res = "";
    for(int i = 0; i<a.size(); i++) {
        res += digits[a[i]-'a'];
    }
    return res;
}

// function to find sum of numbers
// in the form of strings
string findSum(string a, string b) {

    // Before proceeding further, make sure length
    // of b is larger.
    if (a.length() > b.length())
        swap(a, b);
 
    // Take an empty string for storing result
    string str = "";
 
    // Calculate length of both string
    int n1 = a.length(), n2 = b.length();
 
    // Reverse both of strings
    reverse(a.begin(), a.end());
    reverse(b.begin(), b.end());
 
    int carry = 0;
    for (int i=0; i<n1; i++) {

        // Do school mathematics, compute sum of
        // current digits and carry
        int sum = ((a[i]-'0')+(b[i]-'0')+carry);
        str.push_back(sum%10 + '0');
 
        // Calculate carry for next step
        carry = sum/10;
    }
 
    // Add remaining digits of larger number
    for (int i=n1; i<n2; i++) {

        int sum = ((b[i]-'0')+carry);
        str.push_back(sum%10 + '0');
        carry = sum/10;
    }
 
    // Add remaining carry
    if (carry)
        str.push_back(carry+'0');
    
    // reverse resultant string
    reverse(str.begin(), str.end());

    // remove preceeding zeroes
    removeZeroes(str);

    return str;
}



// function to check if puzzle is solved
bool isSolved(string &a, string &b, 
        string &sum, vector<char> &digits) {
    
    // convert the character string to digit string
    string x = charToDigit(a, digits);
    string y = charToDigit(b, digits);
    string z = charToDigit(sum, digits);

    // sum of string x and y
    string res = findSum(x, y);

    removeZeroes(z);

    // check if res and z is equal
    if(z == res) 
        return true;
    else return false;
}

// Function to solve Cryptarithmetic
// Puzzle using backtracking
bool cryptarithmeticSolver(int ind, vector<char> &digits, 
    vector<int> &characters, string &a, string &b, string &sum) {

    // if all characters are assigned
    // a unique digit
    if(ind == 26) {
        return isSolved(a, b, sum, digits);
    }

    // if current character is assigned a value
    // or need not to be assigned
    if(digits[ind] != '+') 
        return cryptarithmeticSolver(ind + 1, 
                    digits, characters, a, b, sum);

    // try to assign all possible digits
    for(char i = '0'; i <= '9'; i++) {

        // if digit is not used yet
        if(characters[i-'0'] == 0) {
            characters[i-'0'] = 1;
            digits[ind] = i;
            if(cryptarithmeticSolver(ind + 1, 
                digits, characters, a, b, sum) == true)
                return true;
            digits[ind] = '+';
            characters[i-'0'] = 0;
        }
    }

    return false;
}

// Function to solve Cryptarithmetic Puzzle
vector<string> solvePuzzle(string &a, string &b, 
                                    string &sum) {

    // to map digit assigned to the character
    vector<char> digits(26,'-');

    // to map character assigned to the digit 
    vector<int> characters(10, 0);

    // mark character that need a digit to
    // be assigned by a "+" sign
    for(auto i:a)
        digits[i-'a'] = '+';
    for(auto i:b)
        digits[i-'a'] = '+';
    for(auto i:sum)
        digits[i-'a'] = '+';

    // check if the assignment of digits is
    // possible, and find the correct one
    if(cryptarithmeticSolver(0, digits,
             characters, a, b, sum) == true) {
            
        // change the string a to digit string
        string x = charToDigit(a, digits);

        // change the string b to digit string
        string y = charToDigit(b, digits);

        // change the string sum to digit string
        string res = charToDigit(sum, digits);

        // return all three digit strings
        return {x, y, res};
    }

    // if no possible assignment exist
    else return {"-1"};
}

int main() {
    string a = "s";
    string b = "p";
    string sum = "f";
    vector<string> ans = solvePuzzle(a, b, sum);
    for(auto i:ans) {
        cout<<i<<" ";
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// Function to check if the puzzle is solvable with the given character assignments
bool solvePuzzleHelper(const string &a, const string &b, const string &sum, 
    int pos, int carry, unordered_map<char, int> &charToDigit, bitset<10> &usedDigits) {

    // Base case: if we have processed all digits
    if (pos >= sum.size()) {
        return carry == 0;
    }
    
    // Calculate sum at current position
    int sumVal = carry;
    if (pos < a.size() && charToDigit.count(a[a.size() - 1 - pos])) {
        sumVal += charToDigit[a[a.size() - 1 - pos]];
    }
    if (pos < b.size() && charToDigit.count(b[b.size() - 1 - pos])) {
        sumVal += charToDigit[b[b.size() - 1 - pos]];
    }
    
    char sumChar = sum[sum.size() - 1 - pos];
    
    // If sumChar is already assigned, check if it matches
    if (charToDigit.count(sumChar)) {
        if (charToDigit[sumChar] != sumVal % 10) {
            return false;
        }
        return solvePuzzleHelper(a, b, sum, pos + 1, 
                        sumVal / 10, charToDigit, usedDigits);
    }
    
    // Ensure digit is not already used
    if (usedDigits[sumVal % 10]) {
        return false;
    }
    
    // Assign the digit to sumChar
    charToDigit[sumChar] = sumVal % 10;
    usedDigits[sumVal % 10] = 1;
    
    // Recur for next position
    if (solvePuzzleHelper(a, b, sum, pos + 1, 
                    sumVal / 10, charToDigit, usedDigits)) {
        return true;
    }
    
    // Backtrack if assignment fails
    charToDigit.erase(sumChar);
    usedDigits[sumVal % 10] = 0;
    return false;
}

// Function to assign digits to unique characters and check if assignment is valid
bool assignDigits(const string &a, const string &b, const string &sum, int index, 
    const string &order, unordered_map<char, int> &charToDigit, bitset<10> &usedDigits) {
        
    // Base case: If all characters are assigned
    if (index == order.size()) {
        return solvePuzzleHelper(a, b, sum, 0, 0, charToDigit, usedDigits);
    }
    
    char ch = order[index];
    
    // Try assigning each digit to the character
    for (int digit = 0; digit < 10; digit++) {
        if (!usedDigits[digit]) {
            charToDigit[ch] = digit;
            usedDigits[digit] = 1;
            if (assignDigits(a, b, sum, index + 1, order, charToDigit, usedDigits)) {
                return true;
            }
            // Backtrack if unsuccessful
            usedDigits[digit] = 0;
            charToDigit.erase(ch);
        }
    }
    return false;
}

// Main function to solve Cryptarithmetic puzzle
vector<string> solvePuzzle(string a, string b, string sum) {
    unordered_map<char, int> charToDigit;
    bitset<10> usedDigits;
    unordered_set<char> uniqueChars;
    string order;
    
    // Identify unique characters in the input strings
    for (char ch : a + b + sum) {
        if (uniqueChars.insert(ch).second) {
            order += ch;
        }
    }
    
    // Assign digits to characters and check validity
    if (assignDigits(a, b, sum, 0, order, charToDigit, usedDigits)) {
        string x, y, z;
        for (char ch : a) x += '0' + charToDigit[ch];
        for (char ch : b) y += '0' + charToDigit[ch];
        for (char ch : sum) z += '0' + charToDigit[ch];
        return {x, y, z};
    }
    return {"-1"};
}

int main() {
    string a = "send", b = "more", sum = "money";
    vector<string> ans = solvePuzzle(a, b, sum);
    for (const auto &res : ans) {
        cout << res << " ";
    }
    return 0;
}