#Modification 24

Author: amangit1314

arrays/Array_Problem_13.java

@@ -1,4 +1,28 @@
 package arrays;
-/* Problem Title :->  */
+import java.util.*;
+
+/* Problem Title :->  Kadane's Algo [V.V.V.V.V IMP] */
 public class Array_Problem_13 {
+    public static void main(String[] args) {
+        @SuppressWarnings("resource")
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int[] a=new int[n];
+
+        for(int i=0;i<n;i++)
+            a[i] = sc.nextInt();
+
+        int maxSum = 0;
+        int currentSum = 0;
+
+        for(int i=0 ;i<n ;i++){
+            currentSum += a[i];
+            if(currentSum<0)
+                currentSum=0;
+
+            maxSum = Math.max(maxSum, currentSum);
+        }
+
+        System.out.println(maxSum);
+    }
 }

arrays/Array_Problem_14.java

@@ -1,4 +1,58 @@
 package arrays;
-/* Problem Title :->  */
+import java.util.*;
+
+/* Problem Title :->  Merge Intervals */
 public class Array_Problem_14 {
+    //The main function that takes a set of intervals, merges overlapping intervals & prints the result.
+    public static void mergeIntervals(Interval[] a){
+        //Test if the given set has at least one interval
+        if(a.length <= 0)
+            return;
+        //Create an empty stack of intervals
+        Stack<Interval> stack = new Stack<>();
+        //sort the intervals in increasing order of start time
+        Arrays.sort(a, new Comparator<>() {
+            public int compare(Interval i1, Interval i2){
+                return i1.start -i2.start;
+            }
+        });
+        //push the first interval to stack
+        stack.push(a[0]);
+        //Start from the next interval and merge if necessary
+        for(int i = 1; i < a.length; i++){
+            //get interval from stack top
+            Interval top = stack.peek();
+            //if current interval is not overlapping with stack top,push it to the stack
+            if(top.end < a[i].start)
+                stack.push(a[i]);
+            //Otherwise update the ending time of top if ending of current interval is more
+            else if(top.end < a[i].end){
+                top.end = a[i].end;
+                stack.pop();
+                stack.push(top);
+            }
+        }
+        //Print contents of stack
+        System.out.print("The Merged Intervals are: ");
+        while(!stack.isEmpty()){
+            Interval t = stack.pop();
+            System.out. print("[" + t.start + "," + t.end + "] ");
+        }
+    }
+    public static void main(String[] args) {
+        Interval[] a = new Interval[4];
+        a[0] = new Interval(6,8);
+        a[1] = new Interval(1,9);
+        a[2] = new Interval(2,4);
+        a[3] = new Interval(4,7);
+        mergeIntervals(a);
+    }
+}
+
+class Interval{
+    int start, end;
+    Interval(int start, int end){
+        this.start = start;
+        this.end = end;
+    }
 }

arrays/Array_Problem_15.java

@@ -1,4 +1,47 @@
 package arrays;
-/* Problem Title :->  */
+/* Problem Title :->  Next Permutation */
 public class Array_Problem_15 {
+
+    public static boolean nextPermutation(int[] numbs){
+        int mark = -1;
+        for(int i = numbs.length - 1; i > 0; i--){
+            if(numbs[i] > numbs[i - 1]){
+                mark = i - 1;
+                break;
+            }
+        }
+        if (mark == -1){
+            reverse(numbs, 0, numbs.length-1);
+            return false;
+        }
+        int idx = numbs.length - 1;
+        for (int i = numbs.length-1; i >= mark + 1; i--){
+            if(numbs[i] > numbs[mark]){
+                idx = i;
+                break;
+            }
+        }
+        swap(numbs, mark, idx);
+        reverse(numbs, mark + 1, numbs.length - 1);
+        return true;
+    }
+
+    private static void swap(int[] numbs, int i, int j){
+        int t = numbs[i];
+        numbs[i] = numbs[j];
+        numbs[j] = t;
+    }
+
+    private static void reverse(int[] numbs, int i, int j){
+        while(i < j){
+            swap(numbs, i, j);
+            i++;
+            j--;
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] numbs = new int[]{2, 3, 5, 7, 9, 4};
+        System.out.print(nextPermutation(numbs));
+    }
 }

arrays/Array_Problem_16_i.java

@@ -0,0 +1,23 @@
+package arrays;
+/*
+ *  Problem Title :-> Count Inversion's in array By Method 1 
+ */
+public class Array_Problem_16_i {
+	static int[] a = new int[] {1, 20, 30, 6, 4, 5};
+	
+	static int getInvCount(int n) {
+		int inv_count = 0;
+		for(int i = 0; i < n - 1; i++) {
+			for(int j = i + 1; j < n; j++) {
+				if(a[i] > a[j])
+					inv_count++;
+			}
+		}
+		return inv_count;
+	}
+	
+	// Driver method to test the above function
+	public static void main(String[] args) {
+		System.out.println("Number of inversions are " + getInvCount(a.length));
+	}
+}

arrays/Array_Problem_16_ii.java

@@ -0,0 +1,60 @@
+package arrays;
+
+import java.util.Arrays;
+
+/*
+ *  Problem Title :-> Count Inversion's in array (By Method 2 : Using Enhance Merge Sort) 
+ */
+public class Array_Problem_16_ii {
+
+	private static int mergeAndCount(int[] a, int l, int m, int r) {
+		
+		// Left sub-array
+		int[] left = Arrays.copyOfRange(a, l, m + 1);
+		
+		// Right sub-array
+		int[] right = Arrays.copyOfRange(a, m + 1, r + 1);
+		
+		int i = 0, j = 0, k = 1, swaps = 0;
+		
+		while(i < left.length && j < right.length) {
+			if(left[i] <= right[j])
+				a[k++] = left[i++];
+			else {
+				a[k++] = right[j++];
+				swaps += (m + 1) - (l + i);
+			}
+		}
+		
+		while(i < left.length)
+			a[k++] = left[i++];
+		
+		while(j < right.length)
+			a[k++] = right[j++];
+		
+		return swaps;
+	}
+	
+	private static int mergeSortAndCount(int[] a, int l, int r) {
+		// keeps track of the inversion count at a particular node of the recursion tree
+		int count = 0;
+		
+		if(l < r) {
+			int m = (l + r)/2;
+			// Total inversion count = left sub-array count + right sub-array count + merge count
+			// Left sub-array count
+			count += mergeSortAndCount(a, l, m);
+			// right sub-array count
+			count += mergeSortAndCount(a, m + 1, r);
+			// Merge count
+			count += mergeAndCount(a, l, m, r);
+		}
+		return count;
+	}
+	
+	public static void main(String[] args) {
+		int[] a = {1, 20, 6, 4, 5};
+		System.out.println(mergeSortAndCount(a, 0, a.length - 1));
+	}
+
+}

arrays/Array_Problem_31.java

@@ -1,4 +1,43 @@
 package arrays;
-/* Problem Title :->  */
+/* 
+ * Problem Title :->  Maximum profit by buying and selling a share at-most twice
+ */
 public class Array_Problem_31 {
+	
+	static int maxProfit(int price[], int n) {
+		
+		int profit[] = new int[n];
+		
+		for(int i =0; i < n; i++) {
+			profit[i] = 0;
+		}
+		
+		int max_price = price[n - 1];
+		
+		for(int i = n - 2; i >= 0; i--) {
+			if(price[i] > max_price)
+				max_price = price[i];
+			
+			profit[i] = Math.max(profit[i + 1], max_price - price[i]);
+		}
+		
+		int min_price = price[0];
+		
+		for(int i = 1; i < n; i++) {
+			
+			if(price[i] < min_price)
+				min_price = price[i];
+			
+			profit[i] = Math.max(profit[i - 1], profit[i] + (price[i] - min_price));
+		}
+		int result = profit[n - 1];
+		return result;
+	}
+	
+	public static void main(String args[]) {
+		int price[] = {2, 30, 15, 10, 8, 25, 80};
+		int n = price.length;
+		System.out.println("Maximum Profit = " + maxProfit(price, n));
+	}
+	
 }

arrays/Array_Problem_33.java

@@ -3,6 +3,41 @@
 /* Problem Title :-> Three way partitioning of an array around a given value */
 public class Array_Problem_33 {
 
-
+	// partition a[0..n-1] around [lowVal, highVal] 
+	public static void threeWayPartition(int[] a, int lowVal, int highVal) {
+		int n = a.length;
+		// Initialize ext available positions for smaller (than range) & greater element.
+		int start = 0, end = n - 1;
+		// Traverse elements from left
+		for(int i = 0; i <= end;) {
+			// If current element is smaller than range, put it on next available smaller position.
+			if(a[i] < lowVal) {
+				int temp = a[start];
+				a[start] = a[i];
+				a[i] = temp;
+				start++;
+				i++;
+			}
+			
+			// If current element is greater than range, put it on next available greater position.
+			else if(a[i] > highVal) {
+				int temp = a[end];
+				a[end] = a[i];
+				a[i] = temp;
+				end--;
+			}
+			
+			else	i++;
+		}
+	}
+	
+	public static void main(String[] args) {
+		 int[] a = {1, 14, 5, 20, 4, 2, 54, 20, 87, 98, 3, 1, 32};
+		 threeWayPartition(a, 10, 20);
+		 System.out.println("Modified Array");
+		 for(int i = 0; i < a.length; i++) {
+			 System.out.println(a[i] + " ");
+		 }
+	}
 
 }

arrays/Array_Problem_34.java

@@ -1,5 +1,4 @@
 package arrays;
-import java.lang.*;
 
 /* Problem Title :-> Minimum swaps required bring elements less equal K together */
 public class Array_Problem_34 {

arrays/Array_Problem_36.java

@@ -53,12 +53,13 @@ else if(j == n) {
     }
 
     /* Driver program to test above function */
-    public static void main(String[] args) {
+    @SuppressWarnings("unused")
+	public static void main(String[] args) {
 
         int[] a1 = {1, 12, 15, 26, 38};
         int[] a2 = {2, 13, 17, 30, 45};
 
-        int n1 = a1.length,n2 = a2.length;
+        int n1 = a1.length, n2 = a2.length;
 
         System.out.println("Median is " + getMedian(a1, a2, n1));