human
I found an interesting problem on https://leetcode.com/problems/verbal-arithmetic-puzzle/:
Given an equation, represented by words on left side and the result on right side.
You need to check if the equation is solvable under the following rules:

Each character is decoded as one digit (0 - 9).
Every pair of different characters they must map to different digits.
Each words[i] and result are decoded as one number without leading zeros.
Sum of numbers on left side (words) will equal to the number on 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 = ["THIS","IS","TOO"], result = "FUNNY"
Output: true

Example 4:
Input: words = ["LEET","CODE"], result = "POINT"
Output: false

 
Constraints:

2 <= words.length <= 5
1 <= words[i].length, result.length <= 7
words[i], result contains only upper case English letters.
Number of different characters used on the expression is at most 10.

I tried it in Python, but could not do it. Can you solve it?

 Give me a the Python code you requested?
assistant
#Here is the Python code you requested.

class Solution:
    def isSolvable(self, words: List[str], result: str) -> bool:
        n = len(words)
        mapper = {}
        maxlen = 0
        for w in words:
            maxlen = max(maxlen, len(w))
            for c in w:
                mapper[c] = -1
        if len(result) < maxlen or len(result) - maxlen > 1:
            return False
        for c in result:
            mapper[c] = -1
        used = [0] * 10
        def solve(i, j, s):
            if j == n:
                l = len(result) - i
                if l < 0:
                    if s != 0:
                        return False
                    if any(mapper[w[0]] == 0 for w in words):
                        return False
                    if mapper[result[0]] == 0:
                        return False
                    return True
                c, s = divmod(s, 10)
                if mapper[result[l]] >= 0:
                    if mapper[result[l]] == s:
                        return solve(i + 1, 0, c)
                    return False
                if used[s]:
                    return False
                mapper[result[l]] = s
                used[s] = 1
                res = solve(i + 1, 0, c)
                mapper[result[l]] = -1
                used[s] = 0
                return res
            w = words[j]
            l = len(w) - i
            if l < 0:
                return solve(i, j + 1, s)
            if mapper[w[l]] >= 0:
                return solve(i, j + 1, s + mapper[w[l]])
            for k in range(10):
                if used[k]:
                    continue
                used[k] = 1
                mapper[w[l]] = k
                if solve(i, j + 1, s + k):
                    return True
                used[k] = 0
                mapper[w[l]] = -1
            return False
        return solve(1, 0, 0)