Verbal Arithmetic Puzzle solution and explanation

def is_solvable(words, result):
    from itertools import permutations

    unique_chars = list(set(''.join(words) + result))
    if len(unique_chars) > 10:
        return False
    
    first_letters = set(word[0] for word in words + [result])
    
    for perm in permutations(range(10), len(unique_chars)):
        char_to_digit = dict(zip(unique_chars, perm))
        if any(char_to_digit[c] == 0 for c in first_letters):
            continue
        
        words_sum = sum(
            int(''.join(str(char_to_digit[c]) for c in word)) for word in words
        )
        
        result_value = int(''.join(str(char_to_digit[c]) for c in result))
        
        if words_sum == result_value:
            return True
    
    return False

function isSolvable(words, result) {
  const uniqueChars = new Set([...words.join(''), result]);
  if (uniqueChars.size > 10) return false;

  const firstLetters = new Set([result[0], ...words.map(word => word[0])]);
  const allChars = Array.from(uniqueChars);

  function evaluate(mapping) {
    const wordToNumber = word => [...word].reduce((acc, char) => acc * 10 + mapping[char], 0);
    const wordsSum = words.reduce((acc, word) => acc + wordToNumber(word), 0);
    return wordsSum === wordToNumber(result);
  }

  function dfs(pos, used = new Array(10).fill(false), mapping = {}) {
    if (pos === allChars.length) return evaluate(mapping);
    let char = allChars[pos];
    for (let digit = 0; digit <= 9; digit++) {
      if (used[digit] || (digit === 0 && firstLetters.has(char))) continue;
      mapping[char] = digit;
      used[digit] = true;
      if (dfs(pos + 1, used, mapping)) return true;
      used[digit] = false;
      delete mapping[char];
    }
    return false;
  }

  return dfs(0);
}

import java.util.*;

public class VerbalArithmetic {
    public boolean isSolvable(String[] words, String result) {
        Set<Character> uniqueChars = new HashSet<>();
        for (String word : words) {
            for (char c : word.toCharArray()) uniqueChars.add(c);
        }
        for (char c : result.toCharArray()) uniqueChars.add(c);
        if (uniqueChars.size() > 10) return false;

        List<Character> allChars = new ArrayList<>(uniqueChars);
        int[] charToDigit = new int[256];
        Arrays.fill(charToDigit, -1);

        Set<Integer> usedDigits = new HashSet<>();

        return dfs(0, usedDigits, charToDigit, allChars, words, result);
    }

    private boolean dfs(int pos, Set<Integer> usedDigits, int[] charToDigit, List<Character> allChars, String[] words, String result) {
        if (pos == allChars.size()) {
            return checkSolution(words, result, charToDigit);
        }

        char c = allChars.get(pos);
        for (int digit = 0; digit < 10; digit++) {
            if (!usedDigits.contains(digit)) {
                charToDigit[c] = digit;
                usedDigits.add(digit);

                if (dfs(pos + 1, usedDigits, charToDigit, allChars, words, result)) return true;

                usedDigits.remove(digit);
                charToDigit[c] = -1;
            }
        }
        return false;
    }

    private boolean checkSolution(String[] words, String result, int[] charToDigit) {
        Integer yearSum = Arrays.stream(words).mapToInt(word -> getValue(word, charToDigit)).sum();
        Integer resultValue = getValue(result, charToDigit);
        return yearSum.equals(resultValue);
    }

    private Integer getValue(String word, int[] charToDigit) {
        StringBuilder sb = new StringBuilder();
        for (char c : word.toCharArray()) sb.append(charToDigit[c]);
        return sb.charAt(0) == '0' ? -1 : Integer.parseInt(sb.toString());
    }
}

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>
using namespace std;

bool isSolvable(vector<string>& words, string result) {
    unordered_set<char> uniqueChars;
    for (auto &w : words) uniqueChars.insert(w.begin(), w.end());
    uniqueChars.insert(result.begin(), result.end());
    if (uniqueChars.size() > 10) return false;

    vector<char> allChars(uniqueChars.begin(), uniqueChars.end());
    vector<int> charValue(256, -1); 
    vector<bool> usedDigits(10, false);

    auto getDigit = [&](string &word) {
        int num = 0;
        for (char c : word) num = num * 10 + charValue[c];
        return num;
    };

    function<bool(int, int)> dfs = [&](int pos, int mask) {
        if (pos == allChars.size()) {
            int wordSum = 0;
            for (auto &word : words) wordSum += getDigit(word);
            return wordSum == getDigit(result);
        }

        char currentChar = allChars[pos];
        for (int digit = 0; digit <= 9; ++digit) {
            if (mask & (1 << digit)) continue;
            charValue[currentChar] = digit;
            if (dfs(pos + 1, mask | (1 << digit))) return true;
            charValue[currentChar] = -1;
        }
        return false;
    };

    return dfs(0, 0);
}