feat: add python solution to lc problem: No.1307

solution/1300-1399/1307.Verbal Arithmetic Puzzle/Solution.py

@@ -0,0 +1,100 @@
+class Solution:
+    def isAnyMapping(
+        self, words, row, col, bal, letToDig, digToLet, totalRows, totalCols
+    ):
+        # If traversed all columns.
+        if col == totalCols:
+            return bal == 0
+
+        # At the end of a particular column.
+        if row == totalRows:
+            return bal % 10 == 0 and self.isAnyMapping(
+                words, 0, col + 1, bal // 10, letToDig, digToLet, totalRows, totalCols
+            )
+
+        w = words[row]
+
+        # If the current string 'w' has no character in the ('col')th index.
+        if col >= len(w):
+            return self.isAnyMapping(
+                words, row + 1, col, bal, letToDig, digToLet, totalRows, totalCols
+            )
+
+        # Take the current character in the variable letter.
+        letter = w[len(w) - 1 - col]
+
+        # Create a variable 'sign' to check whether we have to add it or subtract it.
+        if row < totalRows - 1:
+            sign = 1
+        else:
+            sign = -1
+
+        # If we have a prior valid mapping, then use that mapping.
+        # The second condition is for the leading zeros.
+        if letter in letToDig and (
+            letToDig[letter] != 0
+            or (letToDig[letter] == 0 and len(w) == 1)
+            or col != len(w) - 1
+        ):
+
+            return self.isAnyMapping(
+                words,
+                row + 1,
+                col,
+                bal + sign * letToDig[letter],
+                letToDig,
+                digToLet,
+                totalRows,
+                totalCols,
+            )
+
+        # Choose a new mapping.
+        else:
+            for i in range(10):
+                # If 'i'th mapping is valid then select it.
+                if digToLet[i] == "-" and (
+                    i != 0 or (i == 0 and len(w) == 1) or col != len(w) - 1
+                ):
+                    digToLet[i] = letter
+                    letToDig[letter] = i
+
+                    # Call the function again with the new mapping.
+                    if self.isAnyMapping(
+                        words,
+                        row + 1,
+                        col,
+                        bal + sign * letToDig[letter],
+                        letToDig,
+                        digToLet,
+                        totalRows,
+                        totalCols,
+                    ):
+                        return True
+
+                    # Unselect the mapping.
+                    digToLet[i] = "-"
+                    if letter in letToDig:
+                        del letToDig[letter]
+
+        # If nothing is correct then just return false.
+        return False
+
+    def isSolvable(self, words, result):
+        # Add the string 'result' in the list 'words'.
+        words.append(result)
+
+        # Initialize 'totalRows' with the size of the list.
+        totalRows = len(words)
+
+        # Find the longest string in the list and set 'totalCols' with the size of that string.
+        totalCols = max(len(word) for word in words)
+
+        # Create a HashMap for the letter to digit mapping.
+        letToDig = {}
+
+        # Create a list for the digit to letter mapping.
+        digToLet = ["-"] * 10
+
+        return self.isAnyMapping(
+            words, 0, 0, 0, letToDig, digToLet, totalRows, totalCols
+        )