#Modification 16

Author: amangit1314

data_from_eclipse_ide/arrays/ArrayLevel1.java

@@ -0,0 +1,17 @@
+package arrays;
+
+public class ArrayLevel1 {
+	
+	public static void main(String[] args) {
+		int[] arr;
+		arr = new int[5];
+		
+		arr[0] = 10;
+		arr[1] = 20;
+		arr[2] = 30;
+		arr[3] = 40;
+		arr[4] = 50;
+		
+		for(int i = 0 ; i <arr.length ; i++) 	System.out.println("Element at index " + i + " : " + arr[i]);
+	}
+}

data_from_eclipse_ide/arrays/ArrayLevel2.java

@@ -0,0 +1,34 @@
+package arrays;
+
+import java.io.*;
+
+//Array Implementation using try-catch & Buffers
+public class ArrayLevel2 {
+
+	public static void main(String[] args) {
+		
+		int a[];
+		a = new int[5];
+		
+		try {
+			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+			for(int i=0;i<5;i++) {
+				int j=i+1;
+				System.out.println(" Enter element no." +j);
+				String s = br.readLine();
+				a[i] = Integer.parseInt(s);
+			}
+			for(int i=0;i<5;i++) {
+			System.out.println("arr["+i+"]="+a[i]);
+			}
+		}
+		
+		catch(Exception e) {
+			System.out.println(""+e);
+		}
+	}
+}
+		
+		
+
+

data_from_eclipse_ide/arrays/Array_Problem_1.java

@@ -0,0 +1,41 @@
+package arrays;
+
+//Java program to reverse the given array
+public class Array_Problem_1 {
+		
+	static void rvereseArray(int arr[],int start, int end)
+	{
+	int temp;
+	  
+		while (start < end)
+		{
+		    temp = arr[start]; 
+		    arr[start] = arr[end];
+		    arr[end] = temp;
+		    start++;
+		    end--;
+		} 
+	}     
+	
+	/* Utility that prints out an
+	array on a line */
+	static void printArray(int arr[], int size)
+	{
+		for (int i = 0; i < size; i++)
+		     System.out.print(arr[i] + " ");
+		  
+		 System.out.println();
+	} 
+	
+	// Driver code
+	public static void main(String args[]) {
+	 
+		int arr[] = {1, 2, 3, 4, 5, 6};
+		printArray(arr, 6);
+		rvereseArray(arr, 0, 5);
+		System.out.print("Reversed array is \n");
+		printArray(arr, 6); 
+	
+	}
+
+}

data_from_eclipse_ide/arrays/Array_Problem_10.java

@@ -0,0 +1,51 @@
+package arrays;
+import java.util.*;
+import java.io.*;
+
+/*
+ *  Problem :- 
+ *   Minimum no of jumps to reach end of an array
+ */
+
+/* 
+ * Understanding of The Problem: - 
+ * 
+ * Given an array of integers where each element represents the max number of steps that can be made forward from the element
+ * Write a function to return the minimum no of jumps to reach the end of the array(starting from the first element).
+ * If an element is 0, they cannot move through that element.
+ */
+@SuppressWarnings("unused")
+public class Array_Problem_10 {
+	
+	static int minJumps(int arr[] , int l , int h) {
+		
+		//Base case: when source & destination are same
+		if(h == l)
+			return 0;
+		
+		//When nothing is reachable from the given source
+		if(arr[l] == 0)		
+			return Integer.MAX_VALUE;
+		
+		/*
+		 * Traverse through all the points reachable from array[1].
+		 * Recursively get the minimum number of jumps needed to reach array[h] from these reachable points. 
+		 */
+		
+		int min = Integer.MAX_VALUE;
+		for(int i = l + 1 ; i <= h 
+				&& i<= l + arr[l] ; i++) {
+			int jumps = minJumps(arr , i , h);
+			if(jumps != Integer.MAX_VALUE	  &&	  jumps + 1 < min)	
+				min = jumps + 1 ;
+		}
+		return min;
+	}
+
+	public static void main(String[] args) {
+		int arr[] = { 1, 3, 6, 3, 2, 3, 6, 8, 9, 5 };
+		int n = arr.length;
+		System.out.print("Minimum number of jumps to reach end is " + minJumps(arr , 0 , n -1 ));
+	}
+
+}

data_from_eclipse_ide/arrays/Array_Problem_11.java

@@ -0,0 +1,33 @@
+package arrays;
+
+/*
+ * find duplicate in an array of N+1 Integers
+ */
+public class Array_Problem_11 {
+	
+	// Implementing an array as a HashMap for finding duplicate elements	
+	void printRepeating(int m[],int size) {		
+		int i;
+		System.out.print("The repeating elements are: ");
+					
+		for(i = 0 ; i < size ; i++) {		
+		// using Math.abs() function to find the duplicate element in HashMap.		
+			if(m[Math.abs(m[i])]>=0)	m[Math.abs(m[i])] = -m[Math.abs(m[i])];
+			else						System.out.print(Math.abs(m[i]) + " ");
+		}
+	}
+				
+	//Driver Method
+	public static void main(String[] args) {
+		
+		Array_Problem_11 dublicate= new Array_Problem_11();	
+		
+		int m[] = {1,2,3,1,3,6,6};	
+		int m_size = m.length;
+		
+		dublicate.printRepeating(m,m_size);						
+					
+	}
+
+}
+

data_from_eclipse_ide/arrays/Array_Problem_12.java

@@ -0,0 +1,69 @@
+package arrays;
+
+import java.util.Arrays;
+
+/*
+ * Problem :-
+ * Merge two sorted array without using extra space
+ */
+
+/*
+ * Understanding of the Problem :-
+ * 
+ * We are given two sorted array.
+ * We need to merge these two arrays, 
+ * such that the initial numbers(after complete sorting) are in the first array ,
+ * and the remaining numbers are in the second array.
+ * Extra space allowed in O(1). 
+ */
+
+/*
+ * Simple Discussion :
+ * This task is simple and O(m+n) if we are allowed to use extra space.
+ * But it becomes really complicated when extra space is not allowed,
+ * and doesn't look possible in less than O(m*n) worst case time.
+ */
+
+/*
+ * Idea or Approach of Solution :-
+ * The idea is to begin from last element of ar2[] and search it in ar1[].
+ * If there is a greater element in ae1[], then we moe lastt element of ar2[] at correct place in ar1[].
+ * 
+ * We can use INSERTION Sort type of insertion for this.
+ */
+
+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 void merge(int m , int n) {
+		
+		//Iterate through all elements of the last element 
+		for(int i = n-1; i >= 0; i--) {
+			
+			/*
+			 * FInd the smallest element greater than ar2[i].
+			 * Move all elements one position ahead till the smallest greater element is not found.
+			 */
+			int j , last = arr1[m -1];
+			for( j = m-2 ; j>= 0  && arr1[j] > arr2[i] ; j--)
+				arr1[j+1] = arr1[j];
+			
+			//if there was a greater element 
+			if(j != m-2 || last > arr2[i]) {
+				arr1[j+1] = arr2[i];
+				arr2[i] = last;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		merge(arr1.length, arr2.length);
+		System.out.println("After Merging nFirst Array: ");
+		System.out.println(Arrays.toString(arr1));
+		System.out.println("Second Array: ");
+		System.out.println(Arrays.toString(arr2));
+	}
+
+}

data_from_eclipse_ide/arrays/Array_Problem_18.java

@@ -0,0 +1,29 @@
+package arrays;
+
+/*
+ * 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) {
+		System.out.println("Pairs of elements & their sum : ");
+		
+		//loop to iterate & find the pair of elements whose sum is equal
+		for(int i = 0 ; i < iA.length ; i++) {
+			for(int j = i + 1 ; j < iA.length ; j++) 
+				//check if the sum of pair is equal, if equal then print the pair of elements & their sum
+				if(iA[i]+iA[j] == iN)	System.out.println(iA[i] + " + " + iA[j] + " = " + iN);
+		}
+	}
+	
+	//Driver Method
+	public static void main(String[] args) {
+		pairs_value(new int[] {2,7,4,-5,11,5,20}, 15);
+		pairs_value(new int[] {14,-15,9,16,25,45,12,8},30);
+	}
+
+}

data_from_eclipse_ide/arrays/Array_Problem_2.java

@@ -0,0 +1,55 @@
+package arrays;
+
+//Java program to find the maximum & minimum element in given or array as user input
+public class Array_Problem_2 {
+/* Class Pair is used to return two values from getMinMax() */
+    static class Pair {
+ 
+        int min;
+        int max;
+    }
+ 
+    static Pair getMinMax(int arr[], int n) {
+        Pair minmax = new  Pair();
+        int i;
+ 
+        /*If there is only one element then return it as min and max both*/
+        if (n == 1) {
+            minmax.max = arr[0];
+            minmax.min = arr[0];
+            return minmax;
+        }
+ 
+        /* If there are more than one elements, then initialize min 
+    and max*/
+        if (arr[0] > arr[1]) {
+            minmax.max = arr[0];
+            minmax.min = arr[1];
+        } else {
+            minmax.max = arr[1];
+            minmax.min = arr[0];
+        }
+ 
+        for (i = 2; i < n; i++) {
+            if (arr[i] > minmax.max) {
+                minmax.max = arr[i];
+            } else if (arr[i] < minmax.min) {
+                minmax.min = arr[i];
+            }
+        }
+ 
+        return minmax;
+    }
+ 
+    /* Driver program to test above function */
+    public static void main(String args[]) {
+        int arr[] = {1000, 11, 445, 1, 330, 3000};
+        int arr_size = 6;
+        Pair minmax = getMinMax(arr, arr_size);
+        System.out.printf("\nMinimum element is %d", minmax.min);
+        System.out.printf("\nMaximum element is %d", minmax.max);
+ 
+    }
+ 
+}
+

data_from_eclipse_ide/arrays/Array_Problem_23.java

@@ -0,0 +1,45 @@
+package arrays;
+
+/*
+ * Java program for maximum product sub-array problem
+ */
+
+public class Array_Problem_23 {
+
+	    static void maxSubArraySum(int a[], int size) 
+	    { 
+	        int max_so_far = Integer.MIN_VALUE, 
+	        max_ending_here = 0,start = 0, 
+	        end = 0, s = 0; 
+	  
+	        for (int i = 0; i < size; i++)  
+	        { 
+	            max_ending_here += a[i]; 
+	  
+	            if (max_so_far < max_ending_here)  
+	            { 
+	                max_so_far = max_ending_here; 
+	                start = s; 
+	                end = i; 
+	            } 
+	  
+	            if (max_ending_here < 0)  
+	            { 
+	                max_ending_here = 0; 
+	                s = i + 1; 
+	            } 
+	        } 
+	        System.out.println("Maximum contiguous sum is " + max_so_far); 
+	        System.out.println("Starting index " + start); 
+	        System.out.println("Ending index " + end); 
+	    } 
+	  
+	    // Driver code 
+	    public static void main(String[] args) 
+	    { 
+	        int a[] = { -2, -3, 4, -1, -2, 1, 5, -3 }; 
+	        int n = a.length; 
+	        maxSubArraySum(a, n); 
+	    } 
+	} 
+