Implement new method: Depth First Search (DFS)

Update:
- Implemented Depth First Search (DFS) to explore possible digit assignments for each letter, with pruning to discard any paths that can't yield a valid solution. This optimization speeds up runtime by eliminating unfeasible assignments early.
- Added backtracking to revert and try alternative assignments if a partial solution doesn’t lead to a valid final solution.

How This Works:
- The solver first extracts all unique letters from the puzzle.
- DFS explores each possible digit for these letters.
- Pruning: The solver skips digits already in use and only continues exploring if the partial assignment can still lead to a valid solution.
- Backtracking: If a particular assignment fails, the solver backtracks to try the next possible digit, ensuring all potential solutions are explored efficiently.

app.py

@@ -1,60 +1,74 @@
-import itertools
 import gradio as gr
+from itertools import permutations
 
 def solve_cryptarithm(equation):
-    # Remove spaces from user input
-    equation = equation.replace(" ", "")
+    # Parse the words from the equation"
+    left, right = equation.split(" == ")
+    words = left.split(" + ") + [right]
+    
+    # Extract unique letters
+    unique_letters = set("".join(words))
+    if len(unique_letters) > 10:
+        return "Error: More than 10 unique letters in equation, unsolvable with digits 0-9."
+    
+    # Helper function to convert words to numbers based on current letter-to-digit mapping
+    def word_to_number(word, mapping):
+        return int("".join(str(mapping[char]) for char in word))
+    
+    # Depth-First Search with Pruning
+    def dfs(index, letter_to_digit, used_digits):
+        if index == len(unique_letters):
+            left_sum = sum(word_to_number(word, letter_to_digit) for word in words[:-1])
+            right_val = word_to_number(words[-1], letter_to_digit)
+            return left_sum == right_val
+        
+        # Current letter to assign
+        letter = unique_letters_list[index]
+        
+        # Try every digit for this letter
+        for digit in range(10):
+            # Prune: skip used digits
+            if digit in used_digits:
+                continue
+            # Map the letter to the current digit
+            letter_to_digit[letter] = digit
+            used_digits.add(digit)
+            
+            # Recursive DFS call
+            if dfs(index + 1, letter_to_digit, used_digits):
+                return True
+            
+            # Backtrack
+            del letter_to_digit[letter]
+            used_digits.remove(digit)
+        
+        return False
+    
+    # Main DFS invocation
+    unique_letters_list = list(unique_letters)
+    letter_to_digit = {}
+    used_digits = set()
+    
+    # Start DFS and find solution
+    if dfs(0, letter_to_digit, used_digits):
+        return {letter: letter_to_digit[letter] for letter in unique_letters}
+    else:
+        return "No solution found"
 
-    # Split the equation into left and right sides
-    left_side, right_side = equation.split('=')
-
-    # Get all unique letters from the equation
-    letters = set(filter(str.isalpha, equation))
-    letters = ''.join(letters)
-
-    # If there are too many letters (more than 10), it's impossible to solve
-    if len(letters) > 10:
-        return "Too many letters to solve!"
-
-    # Get all unique digit combinations for the letters
-    digits = '0123456789'
-    for perm in itertools.permutations(digits, len(letters)):
-        # Create mapping of letters to numbers
-        translation = str.maketrans(letters, ''.join(perm))
-
-        # Translate the equation to numbers
-        translated_left_side = left_side.translate(translation)
-        translated_right_side = right_side.translate(translation)
-
-        # Check if there are numbers starting with 0
-        if any(part.startswith('0') and len(part) > 1 for part in translated_left_side.split('+') + translated_right_side.split('+')):
-            continue
-
-        try:
-            # Evaluate whether the left side equals the right side
-            if eval(translated_left_side) == eval(translated_right_side):
-                return f"Solution found: {translated_left_side} = {translated_right_side}"
-        except Exception as e:
-            continue
-
-    return "No solution found."
-
-def solve_multiple_equations(equations):
-    results = []
+def process_input(equations):
+    results = {}
     for equation in equations.splitlines():
-        if equation.strip():  # Only process non-empty lines
-            result = solve_cryptarithm(equation)
-            results.append(result)
-    return "\n".join(results)
+        result = solve_cryptarithm(equation)
+        results[equation] = result
+    return results
+
 
-# Create Gradio interface
-iface = gr.Interface(
-    fn=solve_multiple_equations,
-    inputs=gr.Textbox(lines=10, placeholder="Enter one or more cryptarithm equations here..."),
-    outputs="text",
+interface = gr.Interface(
+    fn=process_input,
+    inputs=gr.Textbox(label="Enter Cryptarithm Equations (one per line)", placeholder="E.g., SEND + MORE == MONEY"),
+    outputs="json",
     title="Cryptarithm Solver",
-    description="Enter cryptarithm equations (e.g., SEND + MORE = MONEY) on each line."
+    description="Enter cryptarithm equations (like SEND + MORE == MONEY) one per line to find solutions. Each letter represents a unique digit from 0-9."
 )
 
-if __name__ == "__main__":
-    iface.launch(share=True)
+interface.launch()