479_Largest_Palindrome_Product

Author: qiyuangong

README.md

@@ -148,6 +148,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 461 | [Hamming Distance](https://leetcode.com/problems/hamming-distance/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/461_Hamming_Distance.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/461_Hamming_Distance.java) | Hamming Distance is related to XOR for numbers. So, XOR then count 1. O(n) |
 | 463 | [Island Perimeter](https://leetcode.com/problems/island-perimeter/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/463_Island_Perimeter.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/463_Island_Perimeter.java) | math, find the area, actual number, then find the digit |
 | 475 | [Heaters](https://leetcode.com/problems/heaters/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/475_Heaters.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/475_Heaters.java) | 1. Binary search hourse in heater array, O(nlogn) and O(1)<br> 2. Two points, O(nlogn) and O(1) |
+| 479 | [Largest Palindrome Product](https://leetcode.com/problems/largest-palindrome-product/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/479_Largest_Palindrome_Product.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/479_Largest_Palindrome_Product.java) | Product max palindrome than check, O(n^2) and O(1) |
 | 482 | [License Key Formatting](https://leetcode.com/problems/license-key-formatting/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/482_License_Key_Formatting.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/482_License_Key_Formatting.java) | String processing, lower and len % K, O(n) and O(n) |
 | 538 | [Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/538_Convert_BST_to_Greater_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/538_Convert_BST_to_Greater_Tree.java) | Right first DFS with a variable recording sum of node.val and right.val. 1. Recursive.<br>2. Stack 3. Reverse Morris In-order Traversal |
 | 543 | [Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/543_Diameter_of_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/543_Diameter_of_Binary_Tree.java) | DFS with O(1) for max answer |

java/479_Largest_Palindrome_Product.java

@@ -0,0 +1,49 @@
+class Solution {
+    public int largestPalindrome(int n) {
+        // https://leetcode.com/problems/largest-palindrome-product/discuss/96297/Java-Solution-using-assumed-max-palindrom
+        // if input is 1 then max is 9 
+        if(n == 1){
+            return 9;
+        }
+        
+        // if n = 3 then upperBound = 999 and lowerBound = 99
+        int upperBound = (int) Math.pow(10, n) - 1, lowerBound = upperBound / 10;
+        long maxNumber = (long) upperBound * (long) upperBound;
+        
+        // represents the first half of the maximum assumed palindrom.
+        // e.g. if n = 3 then maxNumber = 999 x 999 = 998001 so firstHalf = 998
+        int firstHalf = (int)(maxNumber / (long) Math.pow(10, n));
+        
+        boolean palindromFound = false;
+        long palindrom = 0;
+        
+        while (!palindromFound) {
+            // creates maximum assumed palindrom
+            // e.g. if n = 3 first time the maximum assumed palindrom will be 998 899
+            palindrom = createPalindrom(firstHalf);
+            
+            // here i and palindrom/i forms the two factor of assumed palindrom
+            for (long i = upperBound; upperBound > lowerBound; i--) {
+                // if n= 3 none of the factor of palindrom  can be more than 999 or less than square root of assumed palindrom 
+                if (palindrom / i > maxNumber || i * i < palindrom) {
+                    break;
+                }
+                
+                // if two factors found, where both of them are n-digits,
+                if (palindrom % i == 0) {
+                    palindromFound = true;
+                    break;
+                }
+            }
+
+            firstHalf--;
+        }
+
+        return (int) (palindrom % 1337);
+    }
+
+    private long createPalindrom(long num) {
+        String str = num + new StringBuilder().append(num).reverse().toString();
+        return Long.parseLong(str);
+    }
+}

python/479_Largest_Palindrome_Product.py

@@ -0,0 +1,38 @@
+class Solution(object):
+    # def largestPalindrome(self, n):
+    #     """
+    #     :type n: int
+    #     :rtype: int
+    #     """
+    #     if n == 1:
+    #         return 9
+    #     # https://leetcode.com/problems/largest-palindrome-product/discuss/96297/Java-Solution-using-assumed-max-palindrom
+    #     upperBound = 10 ** n - 1
+    #     lowerBound = upperBound / 10
+    #     maxNum = upperBound * upperBound
+    #     firstHalf = maxNum / (10 ** n)
+    #     palindromFound = False
+    #     palindrom = 0
+    #     while not palindromFound:
+    #         palindrom = int(str(firstHalf) + str(firstHalf)[::-1])
+    #         for i in xrange(upperBound, lowerBound, -1):
+    #             if i * i < palindrom:
+    #                 break
+    #             if palindrom % i == 0:
+    #                 palindromFound = True
+    #                 break
+    #         firstHalf -= 1
+    #     return palindrom % 1337
+
+    def largestPalindrome(self, n):
+        if n == 1:
+            return 9
+        if n == 2:
+            return 987
+        for a in xrange(2, 9 * 10 ** (n - 1)):
+            hi = (10 ** n) - a
+            lo = int(str(hi)[::-1])
+            if a ** 2 - 4 * lo < 0:
+                continue
+            if (a ** 2 - 4 * lo) ** .5 == int((a ** 2 - 4 * lo) ** .5):
+                return (lo + 10 ** n * (10 ** n - a)) % 1337