Add files via upload

Author: shatakshigarg

HASHMAPS/EXTRACT UNIQUE CHARACTERS.txt

@@ -0,0 +1,28 @@
+import java.util.HashMap;
+
+public class Solution {
+
+	public static String uniqueChar(String str){
+		/* Your class should be named Solution
+		 * Don't write main().
+		 * Don't read input, it is passed as function argument.
+		 * Return output and don't print it.
+	 	 * Taking input and printing output is handled automatically.
+		*/
+        HashMap<Character,Boolean> map = new HashMap<>();
+		String ans="";
+		for(int i =0;i<str.length();i++)
+		{
+			char front = str.charAt(i);
+			if(!map.containsKey(front))
+			{
+				map.put(front,true);
+				ans+=front;
+			}
+		}
+		
+		
+		return ans;
+
+	}
+}

HASHMAPS/LONGEST CONSECUTIVE SEQUENCE.txt

@@ -0,0 +1,47 @@
+import java.util.Map;
+import java.util.HashMap;
+import java.util.ArrayList;
+
+public class Solution {
+	public static ArrayList<Integer> longestConsecutiveIncreasingSequence(int[] arr) {
+		/* Your class should be named Solution
+		 * Don't write main().
+		 * Don't read input, it is passed as function argument.
+		 * Return output and don't print it.
+	 	 * Taking input and printing output is handled automatically.
+		*/
+        
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int i =0;i<arr.length;i++)
+        {
+           map.put(arr[i],1);  
+        }
+        
+        int overallcount=0,maxStart=Integer.MIN_VALUE;
+        for(int i=0;i<arr.length;i++)
+        {
+            
+            if(!map.containsKey(arr[i]-1))
+            {
+                int currentcount = 1;
+                int currentstart = arr[i];
+                
+                while(map.containsKey(currentstart+1))
+                {
+                    currentcount++;
+                    currentstart=currentstart+1;
+                }
+                if(currentcount>overallcount)
+                {
+                    overallcount=currentcount;
+                    maxStart = arr[i];
+                }
+            }
+        }
+        ArrayList<Integer> ans = new ArrayList<>();
+        ans.add(maxStart);
+        ans.add(maxStart+overallcount-1);
+        
+        return ans;
+    }
+}

HASHMAPS/MAXIMUM FREQUENCY NUMBER.txt

@@ -0,0 +1,42 @@
+import java.util.*;
+public class Solution {
+
+    public static int maxFrequencyNumber(int[] arr){ 
+		/* Your class should be named Solution
+		 * Don't write main().
+		 * Don't read input, it is passed as function argument.
+		 * Return output and don't print it.
+	 	 * Taking input and printing output is handled automatically.
+		*/
+       // import java.util.*;
+		HashMap<Integer,Integer> map = new HashMap<>();
+
+		for(int i =0;i<arr.length;i++)
+		{
+			if(map.containsKey(arr[i]))
+			{
+				int value = map.get(arr[i]);
+				value++;
+				map.put(arr[i],value);
+			}
+			else
+			{
+				map.put(arr[i],1);
+			}
+		}
+
+		int maxFreq = 0;
+		int max = Integer.MIN_VALUE;
+		for(int i : arr) {
+			if( maxFreq < map.get(i) ) {
+				maxFreq = map.get(i);
+				max = i;
+			}
+		}
+
+
+		return max;
+	}
+
+}
+

HASHMAPS/PAIR SUM TO 0.txt

@@ -0,0 +1,50 @@
+import java.util.*;
+
+public class Solution {
+	public static int PairSum(int[] input, int size) {
+		/* Your class should be named Solution
+		 * Don't write main().
+		 * Don't read input, it is passed as function argument.
+		 * Return output and don't print it.
+	 	 * Taking input and printing output is handled automatically.
+        */
+        
+        HashMap<Integer,Integer> map = new HashMap<>();
+
+        for(int i =0;i<size;i++)
+        {
+            if(map.containsKey(input[i]))
+            {
+                int value = map.get(input[i]);
+                value++;
+                map.put(input[i],value);
+            }
+            else
+            {
+                map.put(input[i],1);
+            }
+        }
+
+        int finalCount = 0;
+        for(int i=0; i < size; i++)
+        {
+            int key = input[i];
+            if(map.containsKey(-key) && map.get(key)!=0)
+            {
+                int times;
+                if (key == (-key)) { //True in case of zero
+                    int occurences = map.get(key);
+                    times = (occurences * (occurences - 1)) / 2;
+                    finalCount = finalCount+times;
+                    map.put(key, 0);
+                    continue;
+                }
+                times = map.get(key) * map.get(-key);
+                finalCount = finalCount+times;
+                map.put(key, 0);
+                map.put(-key, 0);
+            }
+        }
+        return finalCount;
+	}
+}

HASHMAPS/PAIRS WITH DIFFERNCE K.txt

@@ -0,0 +1,68 @@
+import java.util.*;
+public class Solution {
+
+	public static int getPairsWithDifferenceK(int arr[], int k) {
+		//Write your code here
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int count = 0;
+        if(k!=0)
+        {
+            for(int i =0;i<arr.length;i++)
+            {
+                int p1 = arr[i]+k;
+                int p2 = arr[i]-k;
+
+                if(map.containsKey(p1))
+                {
+                    count+=map.get(p1);
+                }
+                if(map.containsKey(p2))
+                {
+                    count+=map.get(p2);
+                }
+
+                if(!map.containsKey(arr[i]))
+                {
+                    map.put(arr[i],1);
+                }
+                else if(map.containsKey(arr[i]))
+                {
+                    int value = map.get(arr[i]);
+                    value++;
+                    map.put(arr[i],value);
+                }
+            }
+        }
+        if(k==0)
+        {
+            for(int i =0;i<arr.length;i++)
+            {
+                if(!map.containsKey(arr[i]))
+                {
+                    map.put(arr[i],1);
+                }
+                else if(map.containsKey(arr[i]))
+                {
+                    int value = map.get(arr[i]);
+                    value++;
+                    map.put(arr[i],value);
+                }
+
+            }
+
+            for(int i =0;i<arr.length;i++)
+            {
+                int n = map.get(arr[i]);
+                if(n>0){
+                    count+=(n*(n-1)/2);
+                    map.put(arr[i],0);
+                }
+            }
+
+
+
+        }
+
+        return count;
+	}
+}

HASHMAPS/PRINT INTERSECTION.txt

@@ -0,0 +1,39 @@
+import java.util.*;
+public class Solution {
+
+	public static void printIntersection(int[] arr1,int[] arr2){
+		/* Your class should be named Solution
+		 * Don't write main().
+		 * Don't read input, it is passed as function argument.
+		 * Return output and don't print it.
+	 	 * Taking input and printing output is handled automatically.
+        */
+        
+         if(arr1.length==0 || arr2.length==0)
+            return ;
+            HashMap<Integer,Integer> harr1=new HashMap<>();
+            for(int i=0;i<arr1.length;i++)
+            {   if(harr1.containsKey(arr1[i]))
+                harr1.put(arr1[i],harr1.get(arr1[i])+1);
+             else
+                 harr1.put(arr1[i],1);
+            }
+            
+            for(int i=0;i<arr2.length;i++)
+            {
+                if(harr1.containsKey(arr2[i])){
+                    if(harr1.get(arr2[i])!=0){
+                
+                    System.out.println(arr2[i]);
+                    harr1.put(arr2[i],harr1.get(arr2[i])-1);
+                    }
+                }
+                else
+                    continue;
+
+
+            }
+
+
+	}
+}