1307. Verbal Arithmetic Puzzle

Description

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 words[i] and result are decoded as one number without leading zeros.
• Sum of numbers on the left side (words) will equal to the number on the right side (result).

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

 

Example 1:

Input: words = ["SEND","MORE"], result = "MONEY"
Output: true
Explanation: Map 'S'-> 9, 'E'->5, 'N'->6, 'D'->7, 'M'->1, 'O'->0, 'R'->8, 'Y'->'2'
Such that: "SEND" + "MORE" = "MONEY" ,  9567 + 1085 = 10652

Example 2:

Input: words = ["SIX","SEVEN","SEVEN"], result = "TWENTY"
Output: true
Explanation: Map 'S'-> 6, 'I'->5, 'X'->0, 'E'->8, 'V'->7, 'N'->2, 'T'->1, 'W'->'3', 'Y'->4
Such that: "SIX" + "SEVEN" + "SEVEN" = "TWENTY" ,  650 + 68782 + 68782 = 138214

Example 3:

Input: words = ["LEET","CODE"], result = "POINT"
Output: false
Explanation: There is no possible mapping to satisfy the equation, so we return false.
Note that two different characters cannot map to the same digit.

 

Constraints:

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

 

Solutions

Solution: Backtracking

• Time complexity: O(P(10,k)*mn)
• Space complexity: O(k)
  • k is the number of letters

 

JavaScript

/**
 * @param {string[]} words
 * @param {string} result
 * @return {boolean}
 */
const isSolvable = function (words, result) {
  const allWords = [...words, result];
  const m = allWords.length;
  const decodeMap = new Map();
  let n = 0;

  for (const word of allWords) {
    n = Math.max(word.length, n);
  }

  const solveEquation = (row, col, sum, digitMask) => {
    if (col === n) return sum === 0;
    if (row === m) {
      const isEqual = sum % 10 === 0;
      const carry = Math.floor(sum / 10);

      return isEqual && solveEquation(0, col + 1, carry, digitMask);
    }
    const word = allWords[row];

    if (col >= word.length) {
      return solveEquation(row + 1, col, sum, digitMask);
    }
    const letter = word[word.length - 1 - col];
    const sign = row === m - 1 ? -1 : 1;
    const isLeading = word.length > 1 && col === word.length - 1;

    if (decodeMap.has(letter)) {
      const digit = decodeMap.get(letter);

      if (isLeading && digit === 0) return false;
      const nextSum = digit * sign + sum;

      return solveEquation(row + 1, col, nextSum, digitMask);
    }
    const startDigit = isLeading ? 1 : 0;

    for (let digit = startDigit; digit < 10; digit++) {
      const mask = 1 << digit;

      if (digitMask & mask) continue;
      const nextSum = digit * sign + sum;

      decodeMap.set(letter, digit);
      if (solveEquation(row + 1, col, nextSum, digitMask | mask)) return true;

      decodeMap.delete(letter);
    }
    return false;
  };

  return solveEquation(0, 0, 0, 0);
};