Separated code from the Documentation repo

Author: SunilGudivada

Diff for: .DS_Store

@@ -0,0 +1,43 @@
+package geeksForGeeks.arrays;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class MaxSumNonOverlappingInternalScheduling {
+
+    static int solve(int[][] interval){
+        Arrays.sort(interval , Comparator.comparingInt(a -> a[0]));
+        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+
+        int max = 0;
+        int result = 0;
+
+        for(int[] e : interval){
+            while (!pq.isEmpty()){
+                if(pq.peek()[0] >= e[0]){
+
+                    System.out.println(Arrays.toString(e));
+                    break;
+                }
+
+
+                int[] peekElement = pq.remove();
+                max = Math.max(max, peekElement[1]);
+            }
+
+            result = Math.max(result, max+e[2]);
+            pq.add(new int[]{e[1],e[2]});
+        }
+        return result;
+    }
+    public static void main(String[] args){
+        int[][] interval
+                = { { 1, 3, 2 },
+                { 4, 5, 2 },
+                { 1, 5, 5 } };
+        int maxValue
+                = MaxSumNonOverlappingInternalScheduling.solve(interval);
+        System.out.println(maxValue);
+    }
+}

Diff for: geeksForGeeks/.DS_Store

@@ -0,0 +1,73 @@
+package geeksForGeeks.arrays;
+
+import java.util.*;
+
+/**
+ * Geek Land has a population of N people and each person's ability to rule the town is
+ * measured by a numeric value arr[i]. The two people that can together
+ * rule Geek Land must be compatible with each other i.e.,
+ * the sum of digits of their ability arr[i] must be equal.
+ * Their combined ability should be maximum amongst all the possible pairs
+ * of people. Find the combined ability of the Ruling Pair.
+ *
+ * Example 1:
+ *
+ * Input:
+ * N = 5
+ * arr[] = {55, 23, 32, 46, 88}
+ *
+ * Output:
+ * 101
+ *
+ * Explanation:
+ * All possible pairs that are
+ * compatible with each other are- (23, 32)
+ * with digit sum 5 and (55, 46) with digit
+ * sum 10. Out of these the maximum combined
+ * ability pair is (55, 46) i.e. 55 + 46 = 101
+ *
+ * Example 2:
+ *
+ * Input:
+ * N = 4
+ * arr[] = {18, 19, 23, 15}
+ *
+ * Output:
+ * -1
+ *
+ * Explanation:
+ * No two people are compatible with each other.
+ */
+public class RulingPair {
+
+    public int solve(int arr[], int n){
+
+        int maxSum = -1;
+        HashMap<Integer, Integer> digitMaxMap = new HashMap<>();
+        for(int num:arr) {
+            int digitSum = 0;
+            int tmp = num;
+            while(tmp>0) {
+                digitSum += tmp%10;
+                tmp=tmp/10;
+            }
+            Integer maxVal = digitMaxMap.get(digitSum);
+            if( maxVal == null) {
+                digitMaxMap.put(digitSum, num);
+            }else {
+                int sum = maxVal+num;
+                maxSum = Math.max(maxSum, sum);
+                if(num>maxVal) {
+                    digitMaxMap.put(digitSum, num);
+                }
+            }
+        }
+        return maxSum;
+    }
+
+    public static void main(String[] args) {
+        int n = 5;
+        int arr[] = new int[]{55,23,41,32,46,88};
+        System.out.println(new RulingPair().solve(arr, n));
+    }
+}

Diff for: geeksForGeeks/arrays/MaxSumNonOverlappingInternalScheduling.java

@@ -0,0 +1,34 @@
+package geeksForGeeks.arrays;
+
+/**
+ * Array insert at end Basic Accuracy: 71.42% Submissions: 10035 Points: 1 Insertion is a basic but
+ * frequently used operation. Arrays in most languages can not be dynamically shrinked or expanded.
+ * Here, we will work with such arrays and try to insert an element at the end of the array.
+ *
+ * <p>You are given an array arr. The size of the array is given by sizeOfArray. You need to insert
+ * an element at the end.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: sizeOfArray = 6 arr[] = {1, 2, 3, 4, 5} element = 90 Output: 1 2 3 4 5 90 Explanation:
+ * After inserting 90 at the end, we have array elements as 1 2 3 4 5 90. Example 2:
+ *
+ * <p>Input: sizeOfArray = 4 arr[] = {1, 2, 3} element = 50 Output: 1 2 3 50 Explanation: After
+ * inserting 50 at the end, we have array elements as 1 2 3 50. Your Task: You don't need to read
+ * input or print anything. You only need to complete the function insertAtEnd() that takes arr,
+ * sizeOfArray, element as input and modifies arr as per requirements. The driver code takes care of
+ * the printing.
+ *
+ * <p>Expected Time Complexity: O(1). Expected Auxiliary Space: O(1).
+ *
+ * <p>Constraints: 2 <= sizeOfArray <= 1000 0 <= element, arri <= 10^6
+ */
+public class insertAtEnd {
+  static void insert(int arr[],int sizeOfArray,int element)
+  {
+    arr[sizeOfArray-1] = element;
+  }
+  public static void main(String[] args) {
+
+  }
+}

Diff for: geeksForGeeks/arrays/RulingPair.java

@@ -0,0 +1,37 @@
+package geeksForGeeks.arrays;
+
+/**
+ * Array insert at index Basic Accuracy: 51.49% Submissions: 14523 Points: 1
+ * Insertion is a basic
+ * but frequently used operation. Arrays in most languages cannnot be dynamically shrinked or
+ * expanded. Here, we will work with such arrays and try to insert an element at some index.
+ *
+ * <p>You are given an array arr(0-based index). The size of the array is given by sizeOfArray. You
+ * need to insert an element at given index and print the modified array.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: sizeOfArray = 6 arr[] = {1, 2, 3, 4, 5} index = 5, element = 90 Output: 1 2 3 4 5 90
+ * Explanation: 90 is inserted at index 5(0-based indexing). After inserting, array elements are
+ * like 1, 2, 3, 4, 5, 90. Example 2:
+ *
+ * <p>Input: sizeOfArray = 6 arr[] = {1, 2, 3, 4, 5} index = 2, element = 90 Output: 1 2 90 3 4 5
+ * Explanation: 90 is inserted at index 2(0-based indexing). After inserting, array elements are
+ * like 1, 2, 90, 3, 4, 5. Your Task: You don't need to read input or print anything.. The input is
+ * already taken care of by the driver code. You only need to complete the function insertAtIndex()
+ * that takes arr, sizeOfArray, index, element as input and modifies the array arr as per
+ * requirements. The printing is done by driver code.
+ *
+ * <p>Expected Time Complexity: O(N). Expected Auxiliary Space: O(1).
+ *
+ * <p>Constraints: 2 <= sizeOfArray <= 1000 0 <= element, arri <= 10^6 0 <= index <= sizeOfArray-1
+ */
+public class insertAtIndex {
+  void insert(int arr[], int sizeOfArray, int index, int element)
+  {
+    for(int i=sizeOfArray;i>index;i--){
+      arr[i] = arr[i-1];
+    }
+    arr[index] = element;
+  }
+}

Diff for: geeksForGeeks/arrays/insertAtEnd.java

@@ -0,0 +1,42 @@
+package geeksForGeeks.arrays;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Max and Second Max Easy Accuracy: 49.94% Submissions: 19600 Points: 2 Given an array arr[] of
+ * size N of positive integers which may have duplicates. The task is to find the maximum and second
+ * maximum from the array, and both of them should be distinct, so If no second max exists, then the
+ * second max will be -1.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: N = 3 arr[] = {2,1,2} Output: 2 1 Explanation: From the given array elements, 2 is the
+ * largest and 1 is the second largest. Example 2:
+ *
+ * <p>Input: N = 5 arr[] = {1,2,3,4,5} Output: 5 4 Explanation: From the given array elements, 5 is
+ * the largest and 4 is the second largest. Your Task: The task is to complete the function
+ * largestAndSecondLargest(), which should return maximum and second maximum element from the array
+ * with first element as maximum element and second element as second maximum(if there is no second
+ * maximum the second element should be -1)
+ *
+ * <p>Expected Time Complexity: O(N). Expected Auxiliary Space: O(1).
+ *
+ * <p>Constraints: 1 <= N <= 10^6 1 <= arr[i] <= 10^6
+ */
+public class largestAndSecondLargest {
+  public static ArrayList<Integer> largestAndSecondLargest(int sizeOfArray, int arr[]) {
+    ArrayList<Integer> res = new ArrayList<>();
+    Arrays.sort(arr);
+    res.add(arr[sizeOfArray - 1]);
+    for (int i = sizeOfArray - 1; i >= 0; i--) {
+      if (res.get(0) != arr[i]) {
+        res.add(1, arr[i]);
+        break;
+      } else {
+        res.add(1, -1);
+      }
+    }
+    return res;
+  }
+}

Diff for: geeksForGeeks/arrays/insertAtIndex.java

@@ -0,0 +1,60 @@
+package geeksForGeeks.arrays;
+
+/**
+ * Who has the majority? Basic Accuracy: 49.73% Submissions: 21797 Points: 1 We hope you are
+ * familiar with using counter variables. Counting allows us to find how may times a certain element
+ * appears in an array or list.
+ *
+ * <p>You are given an array arr[] of size N. You are also given two elements x and y. Now, you need
+ * to tell which element (x or y) appears most in the array. In other words, return the element, x
+ * or y, that has higher frequency in the array. If both elements have the same frequency, then just
+ * return the smaller element.
+ *
+ * <p>NOTE : We need to return the elements, not their counts.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: N = 11 arr[] = {1,1,2,2,3,3,4,4,4,4,5} x = 4, y = 5 Output: 4 Explanation: n=11;
+ * elements = {1,1,2,2,3,3,4,4,4,4,5}; x=4; y=5 x frequency in arr is = 4 times y frequency in arr
+ * is = 1 times x has higher frequency, so we print 4. Example 2:
+ *
+ * <p>Input: N = 8 arr[] = {1,2,3,4,5,6,7,8} x = 1, y = 7 Output: 1 Explanation: n=8; elements =
+ * {1,2,3,4,5,6,7,8}; x=1; y=7 x frequency in arr is 1 times y frequency in arr is 1 times both have
+ * same frequency, so we look for the smaller element. x=1 is smaller than y=7, so print 1. Your
+ * Task: You don't need to read input or print anything. You don't need to take any input, as it is
+ * already accomplished by the driver code. You just need to complete the function majorityWins()
+ * that takes array, n, x, y as parameters and return the element with highest frequency.
+ *
+ * <p>Expected Time Complexity: O(N). Expected Auxiliary Space: O(1).
+ *
+ * <p>Constraints: 1 <= n <= 10^3 0 <= arri , x , y <= 10^8
+ */
+public class majorityWins {
+  int get(int arr[], int n, int x,int y)
+  {
+    int count_x=0;
+    int count_y=0;
+    for(int i=0;i<n;i++){
+      if(arr[i] ==x){
+        count_x++;
+      }else if (arr[i] == y){
+        count_y++;
+      }
+    }
+
+    if(count_x>count_y)
+      return x;
+    else if(count_y>count_x)
+      return y;
+    else
+    {
+      if(x>y){
+        return y;
+      }
+      else{
+        return x;
+      }
+    }
+
+  }
+}

Diff for: geeksForGeeks/arrays/largestAndSecondLargest.java

@@ -0,0 +1,40 @@
+package geeksForGeeks.arrays;
+
+/**
+ * Maximum occured integer Easy Accuracy: 44.71% Submissions: 11865 Points: 2 Given N integer
+ * ranges, the task is to find the maximum occurring integer in these ranges. If more than one such
+ * integer exits, find the smallest one. The ranges are given as two arrays L[] and R[]. L[i]
+ * consists of starting point of range and R[i] consists of corresponding end point of the range.
+ *
+ * <p>For example consider the following ranges. L[] = {2, 1, 3}, R[] = {5, 3, 9) Ranges represented
+ * by above arrays are. [2, 5] = {2, 3, 4, 5} [1, 3] = {1, 2, 3} [3, 9] = {3, 4, 5, 6, 7, 8, 9} The
+ * maximum occurred integer in these ranges is 3.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: N = 4 L[] = {1,4,3,1} R[] = {15,8,5,4} Output: 4 Explanation: The given ranges are
+ * [1,15] [4, 8] [3, 5] [1, 4]. The number that is most common or appears most times in the ranges
+ * is 4.
+ *
+ * <p>Example 2:
+ *
+ * <p>Input: N = 5 L[] = {1,5,9,13,21} R[] = {15,8,12,20,30} Output: 5 Explanation: The given ranges
+ * are [1,15] [5, 8] [9, 12] [13, 20] [21, 30]. The number that is most common or appears most times
+ * in the ranges is 5.
+ *
+ * <p>Your Task: The task is to complete the function maxOccured() which returns the maximum occured
+ * integer in all ranges.
+ *
+ * <p>Expected Time Complexity: O(N). Expected Auxiliary Space: O(N).
+ *
+ * <p>Constraints: 1 <= n <= 10^6 0 <= L[i], R[i] <= 10^6
+ */
+public class maximumOccuredInteger {
+
+  static int maxOccured(int L[], int R[], int n, int maxx) {
+
+    return 0;
+  }
+
+  public static void main(String[] args) {}
+}

Diff for: geeksForGeeks/arrays/majorityWins.java

@@ -0,0 +1,53 @@
+package geeksForGeeks.arrays;
+
+import java.util.Arrays;
+
+/**
+ * Mean And Median of Array Easy Accuracy: 50.0% Submissions: 15197 Points: 2 Given an array a[ ] of
+ * size N. The task is to find the median and mean of the array elements. Mean is average of the
+ * numbers and median is the element which is smaller than half of the elements and greater than
+ * remaining half. If there are odd elements, the median is simply the middle element in the sorted
+ * array. If there are even elements, then the median is floor of average of two middle numbers in
+ * the sorted array. If mean is floating point number, then we need to print floor of it.
+ *
+ * <p>Note: To find the median, you might need to sort the array. Since sorting is covered in later
+ * tracks, we have already provided the sort function to you in the code.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: N = 5 a[] = {1, 2, 19, 28, 5} Output: 11 5 Explanation: For array of 5 elements, mean
+ * is (1 + 2 + 19 + 28 + 5)/5 = 11. Median is 5 (middle element after sorting) Example 2:
+ *
+ * <p>Input: N = 4 a[] = {2, 8, 3, 4} Output: 4 3 Explanation: For array of 4 elements, mean is
+ * floor((2 + 8 + 3 + 4)/4) = 4. Median is floor((4 + 3)/2) = 3 Your Task: You don't need to read
+ * input or print anything.. You just need to complete the following two function:
+ *
+ * <p>mean(): It takes the array and its size N as parameters and returns the mean as an integer.
+ * median(): It takes the array and its size N as parameters and returns the median as an integer.
+ * Expected Time Complexity: O(N log(N)). Expected Auxiliary Space: O(1).
+ *
+ * <p>Constraints: 1 <= N <= 10^6 1 <= a[i] <= 10^6
+ */
+public class medianAndMean {
+  public int median(int A[], int N) {
+
+    Arrays.sort(A);
+    if (N % 2 == 0) {
+      return ((A[N / 2] + A[(N - 1) / 2]) / 2);
+    } else {
+      return A[N / 2];
+    }
+
+    // Your code here
+    // If median is fraction then conver it to integer and return
+  }
+
+  public int mean(int A[], int N) {
+    // Your code here
+    int sum = 0;
+    for (int i = 0; i < N; i++) {
+      sum += A[i];
+    }
+    return sum / N;
+  }
+}