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 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 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); + } +};