Hashing-2 HW LongestPalindrome and SubarraySumEqualsK

ContiguousArray.java

@@ -0,0 +1,26 @@
+import java.util.HashMap;
+
+public class ContiguousArray {
+    public int findMaxLength(int[] nums) {
+        if(nums == null || nums.length == 0) return 0;
+        //Create HashMap to store running sum & corresponding index
+        HashMap<Integer, Integer> map = new HashMap<>();
+        int rSum = 0;
+        int max = 0;
+        map.put(0,-1); //create dummy entry in map to catch initial ssubarray
+        for(int i = 0; i < nums.length; i++){
+            if(nums[i] == 0){
+                rSum = rSum - 1;
+            } else {
+                rSum = rSum + 1;
+            }
+            if(map.containsKey(rSum)){
+                int curr = i - map.get(rSum);
+                max = Math.max(max, curr);
+            } else {
+                map.put(rSum, i);
+            }
+        }
+        return max;
+    }
+}

LongestPalindrome.java

@@ -0,0 +1,28 @@
+import java.util.HashSet;
+
+public class LongestPalindrome {
+    public static int longestPalindrome(String s) {
+        HashSet<Character> set = new HashSet<>();
+        int count = 0;
+        for(int i = 0; i < s.length(); i++){
+            char ch = s.charAt(i);
+            //Check in hashset if elements exists, if pair matches then remove from set else add it
+            if(set.contains(ch)){
+                set.remove(ch);
+                count +=2;
+            }else{
+                set.add(ch);
+            }
+        }
+        //If hashset is not empty then add 1 of the element from set
+        if(!set.isEmpty()){
+            count++;
+        }
+        return count;
+    }
+    public static void main(String[] args){
+        String s = "abccccdd";
+        System.out.println(longestPalindrome(s));
+    }
+
+}

SubarraySum.java

@@ -0,0 +1,26 @@
+import java.util.HashMap;
+
+public class SubarraySum {
+    public int subarraySum(int[] nums, int k) {
+        //create a variable for running sum
+        int rSum = 0;
+        HashMap<Integer, Integer> map = new HashMap<>();
+        map.put(0,1);
+        int count = 0;
+        for(int i = 0; i < nums.length; i ++){
+            rSum = rSum + nums[i];
+            if(map.containsKey(rSum - k)){
+                count = count + map.get(rSum - k);
+            }
+            if(!map.containsKey(rSum)){
+                map.put(rSum,1);
+            }else {
+                map.put(rSum, map.get(rSum)+1);
+            }
+        }
+        return count;
+    }
+}
+
+//Time complexity : O(n)
+//Space complexity : O(n)

out/production/Hashing-2/README.md

@@ -0,0 +1,12 @@
+# Hashing-2
+
+Explain your approach in **three sentences only** at top of your code
+
+
+## Problem1 (https://leetcode.com/problems/subarray-sum-equals-k/)
+
+
+## Problem2 (https://leetcode.com/problems/contiguous-array/)
+
+
+## Problem3 (https://leetcode.com/problems/longest-palindrome)