1118

Author: surajr

README.md

@@ -94,6 +94,7 @@ Feel free to submit pull requests, add issues and be a contributer.
 | Leetcode  | [389. Find the Difference](https://leetcode.com/problems/find-the-difference/description/) | [Java](./java/findTheDifference.java)  | _O(n)_       | _O(1)_          |  Easy       |         |
 | Leetcode  | [408. Valid Word Abbreviation](https://leetcode.com/problems/valid-word-abbreviation/description/) | [Java](./java/validWordAbbreviation.java)  | _O(n)_       | _O(1)_          |  Easy       |         |
 | Leetcode  | [422. Valid Word Square](https://leetcode.com/problems/valid-word-square/description/) | [Java](./java/validWordSquare.java)  | _O(n)_       | _O(1)_          |  Easy       |         |
+| Leetcode  | [479. Largest Palindrome Product](https://leetcode.com/problems/largest-palindrome-product/description/) | [Java](./java/largestPalindrome.java)  | _O(n)_       | _O(1)_          |  Medium      |         |
 | Leetcode  | [482. License Key Formatting](https://leetcode.com/problems/license-key-formatting/description/) | [Java](./java/licenseKeyFormatting.java)  | _O(n)_       | _O(1)_          |  Medium      |         |
 | Leetcode  | [500. Keyboard Row](https://leetcode.com/problems/keyboard-row/description/) | [Java](./java/findWords.java)  | _O(n)_       | _O(1)_          |  Easy       |         |
 | Leetcode  | [520. Detect Capital](https://leetcode.com/problems/detect-capital/description/) | [Java](./java/detectCapitalUse.java)  | _O(n)_       | _O(1)_          |  Easy       |         |
@@ -151,6 +152,7 @@ Feel free to submit pull requests, add issues and be a contributer.
 | Leetcode  | [653. Two Sum IV - Input is a BST](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/) | [Java](./java/Twosum.java)  | _O(n)_       | _O(n)_          |  Easy       |         |
 | Leetcode  | [662. Maximum Width of Binary Tree](https://leetcode.com/problems/maximum-width-of-binary-tree/description/) | [Java](./java/widthOfBinaryTree.java)  |   O(n)     |   O(d)        |  Medium       |         |
 | Leetcode  | [663. Equal Tree Partition](https://leetcode.com/problems/equal-tree-partition/description/) | [Java](./java/CheckEqualTrees.java)  |        |           |  Medium       |         |
+| Leetcode  | [677. Map Sum Pairs](https://leetcode.com/problems/map-sum-pairs/description/) | [Java](./java/MapSumii.java)  |   O(n)     |   O(1)        |  Medium      |  HashMap       |
 | Leetcode  | [687. Longest Univalue Path](https://leetcode.com/problems/longest-univalue-path/description/) | [Java](./java/longestUnivaluePath.java)  |   O(n)     |   O(1)        |  Easy      |         |
 
 
@@ -252,6 +254,7 @@ Feel free to submit pull requests, add issues and be a contributer.
 | Leetcode  | [147. Insertion Sort List](https://leetcode.com/problems/insertion-sort-list/description/) | [Java](./java/insertionSortList.java)  | _O(nlogn)_       | _O(1)_          |  Medium       |         |
 | Leetcode  | [179. Largest Number](https://leetcode.com/problems/largest-number/description/) | [Java](./java/largestNumber.java)  | _O(nlogn)_       | _O(n)_          |  Medium       |         |
 | Leetcode  | [280. Wiggle Sort](https://leetcode.com/problems/wiggle-sort/description/) | [Java](./java/wiggleSort.java)  | _O(n)_       | _O(1)_          |  Medium       |         |
+| Leetcode  | [581. Shortest Unsorted Continuous Subarray](https://leetcode.com/problems/shortest-unsorted-continuous-subarray/description/) | [Java](./java/findUnsortedSubarray.java)  | _O(nlogn)_       | _O(n)_          |  Easy       |         |
 
 ## Math
 | Website 		| Title           |  Solution    |  Time           | Space           | Difficulty    |  Note| 

java/MapSumii.java

@@ -0,0 +1,66 @@
+class MapSum {
+    
+    class TrieNode
+    {
+        Map<Character,  TrieNode> children;
+        int value;
+        boolean isWord;
+        
+        public TrieNode()
+        {
+            children = new HashMap<>();
+            value = 0;
+            isWord = false;
+        }
+    }
+
+    TrieNode root;
+    
+    /** Initialize your data structure here. */
+    public MapSum() {
+        root = new TrieNode();
+    }
+    
+    public void insert(String key, int val) {
+        TrieNode cur = root;
+        for(char c:key.toCharArray())
+        {
+            TrieNode next = cur.children.get(c);
+            if(next == null)
+            {
+                next = new TrieNode();
+                cur.children.put(c, next);
+            }
+            cur = next;            
+        }
+        cur.isWord = true;
+        cur.value = val;
+    }
+    
+    public int sum(String prefix) {
+        TrieNode cur = root;
+        for(char c:prefix.toCharArray())
+        {
+            TrieNode next = cur.children.get(c);
+            if(next == null)
+                return 0;
+            cur = next;
+        }
+        return dfs(cur);
+    }
+    
+    public int dfs(TrieNode cur)
+    {
+        int sum = 0;
+        for(char c:cur.children.keySet())
+            sum += dfs(cur.children.get(c));
+        return sum+cur.value;
+    }
+}
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * MapSum obj = new MapSum();
+ * obj.insert(key,val);
+ * int param_2 = obj.sum(prefix);
+ */

java/detectCapitalUse.java

@@ -1,8 +1,9 @@
 class Solution {
     public boolean detectCapitalUse(String word) {
-        if(word.length() < 2) return true;
-        if(word.toUpperCase().equals(word)) return true;
-        if(word.substring(1).equals(word.substring(1))) return true;
+        if(word.equals(word.toUpperCase())) return true;
+        if(word.equals(word.toLowerCase())) return true;
+        if(Character.isUpperCase(word.charAt(0)) && 
+               word.substring(1).equals(word.substring(1).toLowerCase())) return true;
 
         return false;
     }

java/findUnsortedSubarray.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int findUnsortedSubarray(int[] nums) {
+        
+        int [] numsCopy = nums.clone();
+        Arrays.sort(numsCopy);
+        
+        int start = 0, end = nums.length - 1;
+        
+        while(start < nums.length && nums[start] == numsCopy[start]) start++;
+        
+        while(end > start && nums[end] == numsCopy[end]) end--;
+        
+        return end-start+1;        
+    }
+}

java/largestPalindrome.java

@@ -0,0 +1,49 @@
+ass Solution {
+    public int largestPalindrome(int n) {
+        // 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);
+    }
+       
+}