From 3a22189943c23fbca74c564d5307372e8cef3052 Mon Sep 17 00:00:00 2001 From: CodersAcademy006 <104912634+CodersAcademy006@users.noreply.github.com> Date: Fri, 9 Aug 2024 12:27:23 +0530 Subject: [PATCH 1/4] Create Soltuion.cpp --- .../Soltuion.cpp | 109 ++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 solution/1300-1399/1307.Verbal Arithmetic Puzzle/Soltuion.cpp diff --git a/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Soltuion.cpp b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Soltuion.cpp new file mode 100644 index 0000000000000..3f86d4b7b2c69 --- /dev/null +++ b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Soltuion.cpp @@ -0,0 +1,109 @@ +class Solution { +public: + bool isAnyMapping(vector < string > & words, int row, int col, int bal, unordered_map < char, int > & letToDig, + vector < char > & digToLet, int totalRows, int 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 && + isAnyMapping(words, 0, col + 1, bal / 10, letToDig, digToLet, totalRows, totalCols)); + } + + string w = words[row]; + + // If the current string 'W' has no character in the ('COL')th index. + if (col >= w.length()) { + return isAnyMapping(words, row + 1, col, bal, letToDig, digToLet, totalRows, totalCols); + } + + // Take the current character in the variable letter. + char letter = w[w.length() - 1 - col]; + + // Create a variable 'SIGN' to check whether we have to add it or subtract it. + int sign; + + 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 (letToDig.count(letter) && + (letToDig[letter] != 0 || (letToDig[letter] == 0 && w.length() == 1) || col != w.length() - 1)) { + + return isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], + letToDig, digToLet, totalRows, totalCols); + + } + // Choose a new mapping. + else { + for (int i = 0; i < 10; i++) { + + // If 'i'th mapping is valid then select it. + if (digToLet[i] == '-' && (i != 0 || (i == 0 && w.length() == 1) || col != w.length() - 1)) { + digToLet[i] = letter; + letToDig[letter] = i; + + // Call the function again with the new mapping. + bool x = isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], + letToDig, digToLet, totalRows, totalCols); + + if (x == true) { + return true; + } + + // Unselect the mapping. + digToLet[i] = '-'; + if (letToDig.find(letter) != letToDig.end()){ + letToDig.erase(letter); + } + } + + } + + } + + // If nothing is correct then just return false. + return false; +} + + bool isSolvable(vector& words, string result) { + // Add the string 'RESULT' in the vector 'WORDS'. + words.push_back(result); + + int totalRows; + int totalCols; + + // Initialize 'TOTALROWS' with the size of the vector. + totalRows = words.size(); + + // Find the longest string in the vector and set 'TOTALCOLS' with the size of that string. + totalCols = 0; + + for (int i = 0; i < words.size(); i++) { + + // If the current string is the longest then update 'TOTALCOLS' with its length. + if (totalCols < words[i].size()) { + totalCols = words[i].size(); + } + + } + + // Create a HashMap for the letter to digit mapping. + unordered_map < char, int > letToDig; + + // Create a vector for the digit to letter mapping. + vector < char > digToLet(10, '-'); + + return isAnyMapping(words, 0, 0, 0, letToDig, digToLet, totalRows, totalCols); + + } +}; From 78fcd8cf5e845496ff037a473b60d3ddb1ae06b3 Mon Sep 17 00:00:00 2001 From: acbin <44314231+acbin@users.noreply.github.com> Date: Tue, 13 Aug 2024 08:18:25 +0800 Subject: [PATCH 2/4] Update and rename Soltuion.cpp to Solution.cpp --- .../Soltuion.cpp | 109 ------------------ .../Solution.cpp | 103 +++++++++++++++++ 2 files changed, 103 insertions(+), 109 deletions(-) delete mode 100644 solution/1300-1399/1307.Verbal Arithmetic Puzzle/Soltuion.cpp create mode 100644 solution/1300-1399/1307.Verbal Arithmetic Puzzle/Solution.cpp diff --git a/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Soltuion.cpp b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Soltuion.cpp deleted file mode 100644 index 3f86d4b7b2c69..0000000000000 --- a/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Soltuion.cpp +++ /dev/null @@ -1,109 +0,0 @@ -class Solution { -public: - bool isAnyMapping(vector < string > & words, int row, int col, int bal, unordered_map < char, int > & letToDig, - vector < char > & digToLet, int totalRows, int 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 && - isAnyMapping(words, 0, col + 1, bal / 10, letToDig, digToLet, totalRows, totalCols)); - } - - string w = words[row]; - - // If the current string 'W' has no character in the ('COL')th index. - if (col >= w.length()) { - return isAnyMapping(words, row + 1, col, bal, letToDig, digToLet, totalRows, totalCols); - } - - // Take the current character in the variable letter. - char letter = w[w.length() - 1 - col]; - - // Create a variable 'SIGN' to check whether we have to add it or subtract it. - int sign; - - 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 (letToDig.count(letter) && - (letToDig[letter] != 0 || (letToDig[letter] == 0 && w.length() == 1) || col != w.length() - 1)) { - - return isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], - letToDig, digToLet, totalRows, totalCols); - - } - // Choose a new mapping. - else { - for (int i = 0; i < 10; i++) { - - // If 'i'th mapping is valid then select it. - if (digToLet[i] == '-' && (i != 0 || (i == 0 && w.length() == 1) || col != w.length() - 1)) { - digToLet[i] = letter; - letToDig[letter] = i; - - // Call the function again with the new mapping. - bool x = isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], - letToDig, digToLet, totalRows, totalCols); - - if (x == true) { - return true; - } - - // Unselect the mapping. - digToLet[i] = '-'; - if (letToDig.find(letter) != letToDig.end()){ - letToDig.erase(letter); - } - } - - } - - } - - // If nothing is correct then just return false. - return false; -} - - bool isSolvable(vector& words, string result) { - // Add the string 'RESULT' in the vector 'WORDS'. - words.push_back(result); - - int totalRows; - int totalCols; - - // Initialize 'TOTALROWS' with the size of the vector. - totalRows = words.size(); - - // Find the longest string in the vector and set 'TOTALCOLS' with the size of that string. - totalCols = 0; - - for (int i = 0; i < words.size(); i++) { - - // If the current string is the longest then update 'TOTALCOLS' with its length. - if (totalCols < words[i].size()) { - totalCols = words[i].size(); - } - - } - - // Create a HashMap for the letter to digit mapping. - unordered_map < char, int > letToDig; - - // Create a vector for the digit to letter mapping. - vector < char > digToLet(10, '-'); - - return isAnyMapping(words, 0, 0, 0, letToDig, digToLet, totalRows, totalCols); - - } -}; diff --git a/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Solution.cpp b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Solution.cpp new file mode 100644 index 0000000000000..f29cee665a083 --- /dev/null +++ b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/Solution.cpp @@ -0,0 +1,103 @@ +class Solution { +public: + bool isAnyMapping(vector& words, int row, int col, int bal, unordered_map& letToDig, + vector& digToLet, int totalRows, int 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 && isAnyMapping(words, 0, col + 1, bal / 10, letToDig, digToLet, totalRows, totalCols)); + } + + string w = words[row]; + + // If the current string 'W' has no character in the ('COL')th index. + if (col >= w.length()) { + return isAnyMapping(words, row + 1, col, bal, letToDig, digToLet, totalRows, totalCols); + } + + // Take the current character in the variable letter. + char letter = w[w.length() - 1 - col]; + + // Create a variable 'SIGN' to check whether we have to add it or subtract it. + int sign; + + 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 (letToDig.count(letter) && (letToDig[letter] != 0 || (letToDig[letter] == 0 && w.length() == 1) || col != w.length() - 1)) { + + return isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], + letToDig, digToLet, totalRows, totalCols); + + } + // Choose a new mapping. + else { + for (int i = 0; i < 10; i++) { + + // If 'i'th mapping is valid then select it. + if (digToLet[i] == '-' && (i != 0 || (i == 0 && w.length() == 1) || col != w.length() - 1)) { + digToLet[i] = letter; + letToDig[letter] = i; + + // Call the function again with the new mapping. + bool x = isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], + letToDig, digToLet, totalRows, totalCols); + + if (x == true) { + return true; + } + + // Unselect the mapping. + digToLet[i] = '-'; + if (letToDig.find(letter) != letToDig.end()) { + letToDig.erase(letter); + } + } + } + } + + // If nothing is correct then just return false. + return false; + } + + bool isSolvable(vector& words, string result) { + // Add the string 'RESULT' in the vector 'WORDS'. + words.push_back(result); + + int totalRows; + int totalCols; + + // Initialize 'TOTALROWS' with the size of the vector. + totalRows = words.size(); + + // Find the longest string in the vector and set 'TOTALCOLS' with the size of that string. + totalCols = 0; + + for (int i = 0; i < words.size(); i++) { + + // If the current string is the longest then update 'TOTALCOLS' with its length. + if (totalCols < words[i].size()) { + totalCols = words[i].size(); + } + } + + // Create a HashMap for the letter to digit mapping. + unordered_map letToDig; + + // Create a vector for the digit to letter mapping. + vector digToLet(10, '-'); + + return isAnyMapping(words, 0, 0, 0, letToDig, digToLet, totalRows, totalCols); + } +}; From e910a8d8159b96bbd4b8144cb75f488281266b78 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 13 Aug 2024 08:24:03 +0800 Subject: [PATCH 3/4] Update README.md --- .../1307.Verbal Arithmetic Puzzle/README.md | 299 +++++++++++++++++- 1 file changed, 296 insertions(+), 3 deletions(-) diff --git a/solution/1300-1399/1307.Verbal Arithmetic Puzzle/README.md b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/README.md index 16dcf92e41a56..c7ab76713fea0 100644 --- a/solution/1300-1399/1307.Verbal Arithmetic Puzzle/README.md +++ b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/README.md @@ -86,19 +86,312 @@ tags: #### Python3 ```python - +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 + ) ``` #### Java ```java - +class Solution { + private boolean isAnyMapping(List words, int row, int col, int bal, + HashMap letToDig, char[] digToLet, int totalRows, int 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 + && isAnyMapping( + words, 0, col + 1, bal / 10, letToDig, digToLet, totalRows, totalCols)); + } + + String w = words.get(row); + + // If the current string 'w' has no character in the ('col')th index. + if (col >= w.length()) { + return isAnyMapping(words, row + 1, col, bal, letToDig, digToLet, totalRows, totalCols); + } + + // Take the current character in the variable letter. + char letter = w.charAt(w.length() - 1 - col); + + // Create a variable 'sign' to check whether we have to add it or subtract it. + int sign = (row < totalRows - 1) ? 1 : -1; + + // If we have a prior valid mapping, then use that mapping. + // The second condition is for the leading zeros. + if (letToDig.containsKey(letter) + && (letToDig.get(letter) != 0 || (letToDig.get(letter) == 0 && w.length() == 1) + || col != w.length() - 1)) { + + return isAnyMapping(words, row + 1, col, bal + sign * letToDig.get(letter), letToDig, + digToLet, totalRows, totalCols); + + } else { + // Choose a new mapping. + for (int i = 0; i < 10; i++) { + // If 'i'th mapping is valid then select it. + if (digToLet[i] == '-' + && (i != 0 || (i == 0 && w.length() == 1) || col != w.length() - 1)) { + digToLet[i] = letter; + letToDig.put(letter, i); + + // Call the function again with the new mapping. + if (isAnyMapping(words, row + 1, col, bal + sign * letToDig.get(letter), + letToDig, digToLet, totalRows, totalCols)) { + return true; + } + + // Unselect the mapping. + digToLet[i] = '-'; + letToDig.remove(letter); + } + } + } + + // If nothing is correct then just return false. + return false; + } + + public boolean isSolvable(String[] wordsArr, String result) { + // Add the string 'result' in the list 'words'. + List words = new ArrayList<>(); + for (String word : wordsArr) { + words.add(word); + } + words.add(result); + + int totalRows = words.size(); + + // Find the longest string in the list and set 'totalCols' with the size of that string. + int totalCols = 0; + for (String word : words) { + if (totalCols < word.length()) { + totalCols = word.length(); + } + } + + // Create a HashMap for the letter to digit mapping. + HashMap letToDig = new HashMap<>(); + + // Create a char array for the digit to letter mapping. + char[] digToLet = new char[10]; + for (int i = 0; i < 10; i++) { + digToLet[i] = '-'; + } + + return isAnyMapping(words, 0, 0, 0, letToDig, digToLet, totalRows, totalCols); + } +} ``` #### C++ ```cpp - +class Solution { +public: + bool isAnyMapping(vector& words, int row, int col, int bal, unordered_map& letToDig, + vector& digToLet, int totalRows, int 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 && isAnyMapping(words, 0, col + 1, bal / 10, letToDig, digToLet, totalRows, totalCols)); + } + + string w = words[row]; + + // If the current string 'W' has no character in the ('COL')th index. + if (col >= w.length()) { + return isAnyMapping(words, row + 1, col, bal, letToDig, digToLet, totalRows, totalCols); + } + + // Take the current character in the variable letter. + char letter = w[w.length() - 1 - col]; + + // Create a variable 'SIGN' to check whether we have to add it or subtract it. + int sign; + + 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 (letToDig.count(letter) && (letToDig[letter] != 0 || (letToDig[letter] == 0 && w.length() == 1) || col != w.length() - 1)) { + + return isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], + letToDig, digToLet, totalRows, totalCols); + + } + // Choose a new mapping. + else { + for (int i = 0; i < 10; i++) { + + // If 'i'th mapping is valid then select it. + if (digToLet[i] == '-' && (i != 0 || (i == 0 && w.length() == 1) || col != w.length() - 1)) { + digToLet[i] = letter; + letToDig[letter] = i; + + // Call the function again with the new mapping. + bool x = isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], + letToDig, digToLet, totalRows, totalCols); + + if (x == true) { + return true; + } + + // Unselect the mapping. + digToLet[i] = '-'; + if (letToDig.find(letter) != letToDig.end()) { + letToDig.erase(letter); + } + } + } + } + + // If nothing is correct then just return false. + return false; + } + + bool isSolvable(vector& words, string result) { + // Add the string 'RESULT' in the vector 'WORDS'. + words.push_back(result); + + int totalRows; + int totalCols; + + // Initialize 'TOTALROWS' with the size of the vector. + totalRows = words.size(); + + // Find the longest string in the vector and set 'TOTALCOLS' with the size of that string. + totalCols = 0; + + for (int i = 0; i < words.size(); i++) { + + // If the current string is the longest then update 'TOTALCOLS' with its length. + if (totalCols < words[i].size()) { + totalCols = words[i].size(); + } + } + + // Create a HashMap for the letter to digit mapping. + unordered_map letToDig; + + // Create a vector for the digit to letter mapping. + vector digToLet(10, '-'); + + return isAnyMapping(words, 0, 0, 0, letToDig, digToLet, totalRows, totalCols); + } +}; ``` #### Go From 50c29e2f4026a0f753cb37e4668040d1d9f988ff Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 13 Aug 2024 08:24:29 +0800 Subject: [PATCH 4/4] Update README_EN.md --- .../README_EN.md | 299 +++++++++++++++++- 1 file changed, 296 insertions(+), 3 deletions(-) diff --git a/solution/1300-1399/1307.Verbal Arithmetic Puzzle/README_EN.md b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/README_EN.md index 5d0c3a32f90ae..36ffb1fadc5ca 100644 --- a/solution/1300-1399/1307.Verbal Arithmetic Puzzle/README_EN.md +++ b/solution/1300-1399/1307.Verbal Arithmetic Puzzle/README_EN.md @@ -83,19 +83,312 @@ Note that two different characters cannot map to the same digit. #### Python3 ```python - +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 + ) ``` #### Java ```java - +class Solution { + private boolean isAnyMapping(List words, int row, int col, int bal, + HashMap letToDig, char[] digToLet, int totalRows, int 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 + && isAnyMapping( + words, 0, col + 1, bal / 10, letToDig, digToLet, totalRows, totalCols)); + } + + String w = words.get(row); + + // If the current string 'w' has no character in the ('col')th index. + if (col >= w.length()) { + return isAnyMapping(words, row + 1, col, bal, letToDig, digToLet, totalRows, totalCols); + } + + // Take the current character in the variable letter. + char letter = w.charAt(w.length() - 1 - col); + + // Create a variable 'sign' to check whether we have to add it or subtract it. + int sign = (row < totalRows - 1) ? 1 : -1; + + // If we have a prior valid mapping, then use that mapping. + // The second condition is for the leading zeros. + if (letToDig.containsKey(letter) + && (letToDig.get(letter) != 0 || (letToDig.get(letter) == 0 && w.length() == 1) + || col != w.length() - 1)) { + + return isAnyMapping(words, row + 1, col, bal + sign * letToDig.get(letter), letToDig, + digToLet, totalRows, totalCols); + + } else { + // Choose a new mapping. + for (int i = 0; i < 10; i++) { + // If 'i'th mapping is valid then select it. + if (digToLet[i] == '-' + && (i != 0 || (i == 0 && w.length() == 1) || col != w.length() - 1)) { + digToLet[i] = letter; + letToDig.put(letter, i); + + // Call the function again with the new mapping. + if (isAnyMapping(words, row + 1, col, bal + sign * letToDig.get(letter), + letToDig, digToLet, totalRows, totalCols)) { + return true; + } + + // Unselect the mapping. + digToLet[i] = '-'; + letToDig.remove(letter); + } + } + } + + // If nothing is correct then just return false. + return false; + } + + public boolean isSolvable(String[] wordsArr, String result) { + // Add the string 'result' in the list 'words'. + List words = new ArrayList<>(); + for (String word : wordsArr) { + words.add(word); + } + words.add(result); + + int totalRows = words.size(); + + // Find the longest string in the list and set 'totalCols' with the size of that string. + int totalCols = 0; + for (String word : words) { + if (totalCols < word.length()) { + totalCols = word.length(); + } + } + + // Create a HashMap for the letter to digit mapping. + HashMap letToDig = new HashMap<>(); + + // Create a char array for the digit to letter mapping. + char[] digToLet = new char[10]; + for (int i = 0; i < 10; i++) { + digToLet[i] = '-'; + } + + return isAnyMapping(words, 0, 0, 0, letToDig, digToLet, totalRows, totalCols); + } +} ``` #### C++ ```cpp - +class Solution { +public: + bool isAnyMapping(vector& words, int row, int col, int bal, unordered_map& letToDig, + vector& digToLet, int totalRows, int 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 && isAnyMapping(words, 0, col + 1, bal / 10, letToDig, digToLet, totalRows, totalCols)); + } + + string w = words[row]; + + // If the current string 'W' has no character in the ('COL')th index. + if (col >= w.length()) { + return isAnyMapping(words, row + 1, col, bal, letToDig, digToLet, totalRows, totalCols); + } + + // Take the current character in the variable letter. + char letter = w[w.length() - 1 - col]; + + // Create a variable 'SIGN' to check whether we have to add it or subtract it. + int sign; + + 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 (letToDig.count(letter) && (letToDig[letter] != 0 || (letToDig[letter] == 0 && w.length() == 1) || col != w.length() - 1)) { + + return isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], + letToDig, digToLet, totalRows, totalCols); + + } + // Choose a new mapping. + else { + for (int i = 0; i < 10; i++) { + + // If 'i'th mapping is valid then select it. + if (digToLet[i] == '-' && (i != 0 || (i == 0 && w.length() == 1) || col != w.length() - 1)) { + digToLet[i] = letter; + letToDig[letter] = i; + + // Call the function again with the new mapping. + bool x = isAnyMapping(words, row + 1, col, bal + sign * letToDig[letter], + letToDig, digToLet, totalRows, totalCols); + + if (x == true) { + return true; + } + + // Unselect the mapping. + digToLet[i] = '-'; + if (letToDig.find(letter) != letToDig.end()) { + letToDig.erase(letter); + } + } + } + } + + // If nothing is correct then just return false. + return false; + } + + bool isSolvable(vector& words, string result) { + // Add the string 'RESULT' in the vector 'WORDS'. + words.push_back(result); + + int totalRows; + int totalCols; + + // Initialize 'TOTALROWS' with the size of the vector. + totalRows = words.size(); + + // Find the longest string in the vector and set 'TOTALCOLS' with the size of that string. + totalCols = 0; + + for (int i = 0; i < words.size(); i++) { + + // If the current string is the longest then update 'TOTALCOLS' with its length. + if (totalCols < words[i].size()) { + totalCols = words[i].size(); + } + } + + // Create a HashMap for the letter to digit mapping. + unordered_map letToDig; + + // Create a vector for the digit to letter mapping. + vector digToLet(10, '-'); + + return isAnyMapping(words, 0, 0, 0, letToDig, digToLet, totalRows, totalCols); + } +}; ``` #### Go