#Modification 20

amangit1314 · amangit1314 · commit 7d2871c8ff99 · 2021-01-12T14:07:03.000+05:30
diff --git a/arrays/Array_Problem_12.java b/arrays/Array_Problem_12.java
@@ -34,8 +34,8 @@
 
 public class Array_Problem_12 {
 	
-	static int arr1[] = new int[] {1, 5 , 9, 10, 15, 20};
-	static int arr2[] = new int[] {2, 3, 8, 13};
+	static int[] arr1 = new int[] {1, 5 , 9, 10, 15, 20};
+	static int[] arr2 = new int[] {2, 3, 8, 13};
 	
 	static void merge(int m , int n) {
 		
diff --git a/arrays/Array_Problem_13.java b/arrays/Array_Problem_13.java
@@ -1,32 +1,4 @@
 package arrays;
-import java.util.*;
-
-/*
- * Kadane's Algorithm to find the maxSubarray Sum in O(n)[Linear Time Complexity]
- */
+/* Problem Title :->  */
 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);
-     }
-  }
-    
 }
diff --git a/arrays/Array_Problem_14.java b/arrays/Array_Problem_14.java
@@ -1,38 +1,4 @@
 package arrays;
-
-import java.util.*;
-
+/* Problem Title :->  */
 public class Array_Problem_14 {
-    public static void mergeIntervals(Interval a[]) {
-        if (a.length <= 0) {
-            return;
-        }
-
-        Stack<Interval> stack = new Stack<>();
-        Arrays.sort(a.new Comparator<Interval>() {
-            public int compare(Interval i1, Interval i2) {
-                return i1.start - i2.start;
-            }
-        });
-
-        stack.push(a[0]);
-    }
-
-    public static void main(String[] args) {
-        Interval a[] = new Interval[4];
-
-    }
-}
-
-/**
- * Interval
- */
-class Interval {
-
-    int start, end;
-
-    Interval(int start, int end) {
-        this.start = start;
-        this.end = end;
-    }
 }
diff --git a/arrays/Array_Problem_15.java b/arrays/Array_Problem_15.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_15 {
+}
diff --git a/arrays/Array_Problem_16.java b/arrays/Array_Problem_16.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_16 {
+}
diff --git a/arrays/Array_Problem_17.java b/arrays/Array_Problem_17.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_17 {
+}
diff --git a/arrays/Array_Problem_18.java b/arrays/Array_Problem_18.java
@@ -1,15 +1,10 @@
 package arrays;
 
-/*
- * find all pairs on integer array whose sum is equal to given number
- *                     OR
- * Equal_Sum_Pairs_of_Array                   
- */
-
+/* Problem Title :->   find all pairs on integer array whose sum is equal to given number     OR	 Equal_Sum_Pairs_of_Array */
 public class Array_Problem_18 {
 
 	//function to find & print the sum & elements
-	static void pairs_value(int iA[], int iN) {
+	static void pairs_value(int[] iA, int iN) {
 		System.out.println("Pairs of elements & their sum : ");
 		
 		//loop to iterate & find the pair of elements whose sum is equal
diff --git a/arrays/Array_Problem_19.java b/arrays/Array_Problem_19.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_19 {
+}
diff --git a/arrays/Array_Problem_20.java b/arrays/Array_Problem_20.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_20 {
+}
diff --git a/arrays/Array_Problem_21.java b/arrays/Array_Problem_21.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_21 {
+}
diff --git a/arrays/Array_Problem_22.java b/arrays/Array_Problem_22.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_22 {
+}
diff --git a/arrays/Array_Problem_23.java b/arrays/Array_Problem_23.java
@@ -1,12 +1,9 @@
 package arrays;
 
-/*
- * Java program for maximum product sub-array problem
- */
-
+/* Problem Title :-> Java program for maximum product sub-array problem */
 public class Array_Problem_23 {
 
-	    static void maxSubArraySum(int a[], int size) 
+	    static void maxSubArraySum(int[] a, int size)
 	    { 
 	        int max_so_far = Integer.MIN_VALUE, 
 	        max_ending_here = 0,start = 0, 
@@ -37,7 +34,7 @@ static void maxSubArraySum(int a[], int size)
 	    // Driver code 
 	    public static void main(String[] args) 
 	    { 
-	        int a[] = { -2, -3, 4, -1, -2, 1, 5, -3 }; 
+	        int[] a = { -2, -3, 4, -1, -2, 1, 5, -3 };
 	        int n = a.length; 
 	        maxSubArraySum(a, n); 
 	    } 
diff --git a/arrays/Array_Problem_24.java b/arrays/Array_Problem_24.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_24 {
+}
diff --git a/arrays/Array_Problem_25.java b/arrays/Array_Problem_25.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_25 {
+}
diff --git a/arrays/Array_Problem_26.java b/arrays/Array_Problem_26.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_26 {
+}
diff --git a/arrays/Array_Problem_27.java b/arrays/Array_Problem_27.java
@@ -0,0 +1,7 @@
+package arrays;
+
+/* Problem Title :->  */
+public class Array_Problem_27 {
+
+
+}
diff --git a/arrays/Array_Problem_28.java b/arrays/Array_Problem_28.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_28 {
+}
diff --git a/arrays/Array_Problem_29.java b/arrays/Array_Problem_29.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_29 {
+}
diff --git a/arrays/Array_Problem_30.java b/arrays/Array_Problem_30.java
@@ -0,0 +1,37 @@
+package arrays;
+/* Problem Title :-> Trapping Rain water problem */
+public class Array_Problem_30 {
+    //Function to return the maximum water that can be stored
+    public static int maxWater(int[] a, int n) {
+
+        int res = 0;
+
+        //For every element of the array, except first and last element
+        for(int i = 1; i < n - 1; i++) {
+
+            //Find max element on its left
+            int left = a[i];
+            for(int j = 0; j < i; j++) {
+                left = Math.max(left, a[j]);
+            }
+
+            //Find max element on its left
+            int right = a[i];
+            for(int j = i + 1; j < n; j++) {
+                right = Math.max(right, a[j]);
+            }
+
+            //Update maximum water value
+            res += Math.min(left, right) - a[i];
+        }
+
+        return res;
+    }
+    //Driver Code
+    public static void main(String[] args) {
+        int[] a = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
+        int n = a.length;
+        System.out.print(maxWater(a, n));
+    }
+
+}
diff --git a/arrays/Array_Problem_31.java b/arrays/Array_Problem_31.java
@@ -0,0 +1,4 @@
+package arrays;
+/* Problem Title :->  */
+public class Array_Problem_31 {
+}
diff --git a/arrays/Array_Problem_32.java b/arrays/Array_Problem_32.java
@@ -1,35 +1,31 @@
 package arrays;
 
-//Java program to find minimum number of operations to make an array palindrome
+/* Problem Title :->  find minimum number of operations to make an array palindrome */
 public class Array_Problem_32 {
-	
-	static int findMinOps(int[] a, int n) {
-		
-		//Initialize result
-		int ans = 0;
-		
-		//Start from two corners
-		for(int i=0,j=n-1;i<=j;) {
-			
-			if(a[i] == a[j]) {
-				i++;
-				j--;
-			}else if(a[i] > a[j]) {
-				j--;
-				a[j] += a[j+1];
-				ans++;
-			}else {
-				i++;
-				a[i] += a[i-1];
-				ans++;
-			}
-		}	
-		return ans;
-	}
-	
-	public static void main(String[] args) {
-		int a[] = new int[] {1,2,3,4,5,6,7,8,9,10};
-		System.out.println("Count of minimum operations is " + findMinOps(a , a.length));
-	}
+
+    static int findMinOps(int[] a, int n){
+        int ans = 0;
+        for(int i = 0, j = n-1; i <= j;){
+            if(a[i] == a[j]){
+                i++;
+                j--;
+            }
+            else if(a[i] > a[j]){
+                j--;
+                a[j] += a[j+1];
+                ans++;
+            }
+            else{
+                i++;
+                a[i] += a[i - 1];
+                ans++;
+            }
+        }
+        return ans;
+    }
+    public static void main(String[] args) {
+        int[] a = new int[]{1, 4, 5, 9, 1};
+        System.out.println("Count of minimum operations is" + findMinOps(a, a.length));
+    }
 
 }
diff --git a/arrays/Array_Problem_33.java b/arrays/Array_Problem_33.java
@@ -0,0 +1,8 @@
+package arrays;
+
+/* Problem Title :-> Three way partitioning of an array around a given value */
+public class Array_Problem_33 {
+
+
+
+}
diff --git a/arrays/Array_Problem_34.java b/arrays/Array_Problem_34.java
@@ -0,0 +1,42 @@
+package arrays;
+import java.lang.*;
+
+/* Problem Title :-> Minimum swaps required bring elements less equal K together */
+public class Array_Problem_34 {
+
+    static int minSwap(int[] a, int n, int k){
+        int count = 0;
+        for (int i = 0; i < n; ++i){
+            if (a[i] <= k)
+                ++count;
+        }
+
+        int bad = 0;
+        for (int i = 0; i < count; ++i){
+            if (a[i] > k)
+                ++bad;
+        }
+        int ans = bad;
+        for (int i = 0, j = count; j < n; ++i, ++j ){
+            if(a[i] > k)
+                --bad;
+            if(a[j] > k)
+                ++bad;
+            ans = Math.min(ans, bad);
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        int[] a = {2, 1, 5, 6, 3};
+        int n = a.length;
+        int k = 3;
+        System.out.print(minSwap(a, n, k) + "\n");
+
+        int[] a1 = {2, 7, 9, 5, 8, 7, 4};
+        n = a1.length;
+        k = 5;
+        System.out.print(minSwap(a1, n, k));
+    }
+
+}
diff --git a/arrays/Array_Problem_35.java b/arrays/Array_Problem_35.java
@@ -0,0 +1,33 @@
+package arrays;
+/* Problem Title :-> Minimum no. of operations required to make an array palindrome */
+public class Array_Problem_35 {
+
+    static int findMinOps(int[] a, int n) {
+
+        //Initialize result
+        int ans = 0;
+
+        //Start from two corners
+        for(int i=0,j=n-1;i<=j;) {
+
+            if(a[i] == a[j]) {
+                i++;
+                j--;
+            }else if(a[i] > a[j]) {
+                j--;
+                a[j] += a[j+1];
+                ans++;
+            }else {
+                i++;
+                a[i] += a[i-1];
+                ans++;
+            }
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        int[] a = new int[] {1,2,3,4,5,6,7,8,9,10};
+        System.out.println("Count of minimum operations is " + findMinOps(a , a.length));
+    }
+}
diff --git a/arrays/Array_Problem_36.java b/arrays/Array_Problem_36.java
diff --git a/arrays/Array_Problem_37.java b/arrays/Array_Problem_37.java
diff --git a/arrays/FRE.java b/arrays/FRE.java
diff --git a/arrays/KadanesAlgorithm.java b/arrays/KadanesAlgorithm.java
diff --git a/matrix/Matrix_Problem_03.java b/matrix/Matrix_Problem_03.java
diff --git a/matrix/Matrix_Problem_04.java b/matrix/Matrix_Problem_04.java
diff --git a/matrix/Matrix_Problem_05.java b/matrix/Matrix_Problem_05.java
diff --git a/matrix/Matrix_Problem_06.java b/matrix/Matrix_Problem_06.java
diff --git a/matrix/Matrix_Problem_07.java b/matrix/Matrix_Problem_07.java
diff --git a/matrix/Matrix_Problem_08.java b/matrix/Matrix_Problem_08.java
diff --git a/matrix/Matrix_Problem_09.java b/matrix/Matrix_Problem_09.java
diff --git a/matrix/Matrix_Problem_10.java b/matrix/Matrix_Problem_10.java
