added leetcode medium questions

LMedium/Arrays/BuySellStocks.java

@@ -0,0 +1,23 @@
+package LMedium.Arrays;
+
+public class BuySellStocks {
+    public static void main(String[] args) {
+        int[] arr={1,2,5,6,7,2,4,6,9};
+        int maxprofit=0;
+        int minimumelement=arr[0];
+        for (int i = 1; i < arr.length; i++) {
+            int cost=arr[i]-minimumelement;
+            maxprofit=Math.max(cost,maxprofit);
+            minimumelement=Math.min(minimumelement,arr[i]);
+
+        }
+//        return maxprofit;
+
+        System.out.println(maxprofit);
+
+
+
+
+    }
+}
+

LMedium/Arrays/CountSubArrsum.java

@@ -0,0 +1,33 @@
+package LMedium.Arrays;
+
+public class CountSubArrsum {
+    public static void main(String[] args) {
+        int[] arr={3,1,2,4};
+        int n=arr.length;
+        int target=6;
+
+        bruteforce(arr,target);
+
+
+
+
+
+
+    }
+
+    private static void bruteforce(int[] arr, int target) {
+        int counter=0,sum=0;
+
+        for (int i = 0; i < arr.length; i++) {
+            sum=0;
+            for (int j = i; j < arr.length; j++) {
+                    sum+=arr[j];
+                    if(sum==target){
+                        counter++;
+                    }
+            }
+        }
+
+        System.out.println( counter);
+    }
+}

LMedium/Arrays/LeadersinArr.java

@@ -0,0 +1,39 @@
+package LMedium.Arrays;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+
+public class LeadersinArr {
+    public static void main(String[] args) {
+
+        int[] arr={10,22,12,3,0,6};
+        int n=arr.length;
+            List<Integer> v=new ArrayList<>();
+            boolean leader;
+            for (int i = 0; i < arr.length; i++) {
+                leader=true;
+                for (int j = i+1; j < arr.length ;j++) {
+                    if(arr[j]>arr[i]){
+                        leader=false;
+                        break;
+                    }
+                }
+                if(leader==true){
+                    v.add(arr[i]);
+                }
+            }
+            System.out.println(v);
+
+
+
+
+
+
+
+
+
+
+
+    }
+}

LMedium/Arrays/LongestConsecutiveSubsequence.java

@@ -0,0 +1,39 @@
+package LMedium.Arrays;
+
+public class LongestConsecutiveSubsequence {
+    public static void main(String[] args) {
+
+        int[] arr={102,4,100,1,101,3,2,1,1};
+        bruteforce(arr);
+
+    }
+
+    private static void bruteforce(int[] arr) {
+
+        int longest=1;
+        int x,cnt=0;
+
+        for (int i = 0; i < arr.length; i++) {
+            x=arr[i];
+            cnt=1;
+            while (ls(arr,x+1)==true){
+                x=x+1;
+                cnt++;
+            }
+            longest=Math.max(longest,cnt);
+        }
+        System.out.println(longest);
+
+    }
+
+
+    private static boolean ls(int[] arr, int i) {
+
+        for (int j = 0; j < arr.length; j++) {
+            if(arr[j]==i){
+                return true;
+            }
+        }
+        return false;
+    }
+}

LMedium/Arrays/MajorityElement.java

@@ -0,0 +1,42 @@
+package LMedium.Arrays;
+
+import java.util.*;
+
+public class MajorityElement {
+    public static void main(String[] args) {
+
+        int[] arr={2, 2, 1, 3, 1, 1, 3, 1, 1};
+        int n=arr.length;
+
+        List<Integer> ls=new ArrayList<>();
+
+        HashMap<Integer,Integer> map=new HashMap<>();
+        for (int i = 0; i < arr.length; i++) {
+            map.put(arr[i],map.getOrDefault(arr[i],0)+1);
+        }
+//        System.out.println(map);
+
+        int max=Integer.MIN_VALUE;
+        int key=0;
+
+        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+            int element = entry.getKey();
+            int occurrence = entry.getValue();
+            if(occurrence>arr.length/3)
+            {
+                ls.add(occurrence);
+            }
+        }
+//        ls.add(key);
+
+
+
+
+
+
+
+
+
+
+    }
+}

LMedium/Arrays/MaxFreqElement.java

@@ -0,0 +1,115 @@
+package LMedium.Arrays;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Vector;
+
+public class MaxFreqElement {
+    public static void main(String[] args) {
+//        Vector<Integer> v = new Vector<>();
+//        v.add(2);
+//        v.add(2);
+//        v.add(1);
+//        v.add(3);
+//        v.add(1);
+//        v.add(1);
+//        v.add(3);
+//        v.add(1);
+//        v.add(1);
+        int[] arr={2,2,1,1,1,2,2};
+        int n=arr.length;
+        optimal(arr);
+
+
+
+
+//        bruteforce(v);
+//        better(v);
+
+
+    }
+
+    private static void optimal(int[] arr) {
+        int counter=0;
+        int element=0;
+
+        for (int i = 0; i < arr.length; i++) {
+            if(counter==0){
+                counter=1;
+                element=arr[i];
+            }else if(arr[i]==element){
+                counter++;
+            }else{
+                counter--;
+            }
+        }
+
+        int counter2=0;
+        for (int i = 0; i <arr.length; i++) {
+            if(arr[i]==element){
+                counter2++;
+            }
+        }
+        if (counter2>arr.length/2){
+            System.out.println(element);
+            System.out.println("yes");
+        }
+
+    }
+
+    private static void bruteforce(Vector<Integer> arr) {
+
+
+//        for (int i = 0; i < arr.size(); i++) {
+//
+//            int counter=0;
+//            for (int j = 0; j <arr.size() ; j++) {
+//
+//                if(arr[j]==arr[i]){
+//                    counter++;
+//                }
+//
+//            }
+//            if(counter>arr.size()/2){
+//
+//                System.out.println("yes",arr[i]);
+//            }
+//
+//        }
+
+
+
+
+    }
+
+    private static void better(Vector<Integer> v) {
+        Map<Integer, Integer> map = new HashMap<>();
+
+        for (int i = 0; i < v.size(); i++) {
+            int key = v.get(i);
+            map.put(key, map.getOrDefault(key, 0) + 1);
+        }
+
+        int max = 0;
+        int keyWithMaxFreq = -1;
+
+        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+            int currentKey = entry.getKey();
+            int currentFrequency = entry.getValue();
+
+            if (currentFrequency > max) {
+                max = currentFrequency;
+                keyWithMaxFreq = currentKey;
+            }
+        }
+
+        System.out.println(max);
+        System.out.println(keyWithMaxFreq);
+
+        if (keyWithMaxFreq > v.size() / 2) {
+            System.out.println("yes");
+        }
+
+    }
+
+}

LMedium/Arrays/MaxSubarr_KadensAlgo.java

@@ -0,0 +1,46 @@
+package LMedium.Arrays;
+
+public class MaxSubarr_KadensAlgo {
+    public static void main(String[] args) {
+
+        int[] arr={-2,1,-3,4,-1,2,1,-5,4};
+        int target=6;
+        bruteforce(arr,target);
+//        bruteforce(arr,target);
+
+        optimal(arr);
+    }
+
+    private static void optimal(int[] arr) {
+        int max=Integer.MIN_VALUE;
+        int sum=0;
+        for (int i = 0; i < arr.length; i++) {
+
+            sum+=arr[i];
+            if(sum>max){
+                max=sum;
+            }
+
+            if(sum<0){
+                sum=0;
+            }
+
+        }
+        System.out.println(max);
+    }
+
+    private static void bruteforce(int[] arr, int target) {
+        int sum=0;int max=Integer.MIN_VALUE;
+        for (int i = 0; i <arr.length ; i++) {
+            for (int j = i; j < arr.length; j++) {
+                    sum+=arr[j];
+                    max = Math.max(max, sum);
+
+            }
+
+        }
+        System.out.println(max);
+
+
+    }
+}

LMedium/Arrays/MergeOverlapping.java

@@ -0,0 +1,42 @@
+package LMedium.Arrays;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+public class MergeOverlapping {
+    public static void main(String[] args) {
+
+        int[][] arr = {{1, 3}, {8, 10}, {2, 6}, {15, 18}};
+        mergeOverlappingIntervals(arr);
+
+
+
+
+    }
+
+    private static void mergeOverlappingIntervals(int[][] arr) {
+        int n=arr.length;
+        Arrays.sort(arr, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                return o1[0]-o2[0];
+            }
+        });
+
+        for (int i = 0; i < arr.length; i++) {
+            for (int j = 0; j <arr.length ; j++) {
+
+                System.out.print(arr[i][j]+" ");
+
+            }
+            System.out.println();
+
+        }
+
+//        return 0;
+
+
+
+    }
+}