Merge branch 'master' of https://github.com/gitaman8481/Java-Programs

Author: amangit1314

README.md

@@ -1,7 +1,16 @@
+<<<<<<< HEAD
 # Java-Programs
 This is a repository where, I will upload and keep up to date my Java, DataStructure and algorithms code and question regarding to them,which i practiced on eclipse & IntelliJ with help of Books and programming websites. The books I prefer and use for learning java and algorithms are:
 
 1. Java for Dummies.
 2. Java The Complete Reference by Herberth Schildt.
 3. Algorithms by Sedwig.
 4. Algorithms by Cormen.
+=======
+# Java-Programs <a href="https://www.java.com" target="_blank"> <img src="https://devicons.github.io/devicon/devicon.git/icons/java/java-original-wordmark.svg" alt="java" width="40" height="40"/> </a>
+This is a repository where, I will upload and keep up to date my Java, DataStructure and algorithms code and question regarding to them,which i practiced on eclipse & IntelliJ with help of Books and programming websites. The books I prefer and use for learning java and algorithms are:
+
+1. Java for Dummies.
+2. Algorithms by Sedwig.
+3. Algorithms by Cormen.
+>>>>>>> fc390b5cc5867b507eabc367ba4f0b0ac46bf243

array/Candy_Distribution_Problem.java

@@ -0,0 +1,49 @@
+package array;
+import java.util.*;
+
+//Language: Java
+//Time Complexity: O(n) 3 Linear traversals.
+//Space Complexity: O(n) Array of candies.
+
+public class Candy_Distribution_Problem{
+	
+	public int candy(int[] ratings) {
+		   if (ratings.length < 2) 
+		     return ratings.length;
+		   
+		     
+		   int[] candies = new int[ratings.length];
+		   Arrays.fill(candies, 1);
+		     
+		   // ** Step 1: Forward **
+		   for (int i=0; i<ratings.length-1; i++) {
+		     if (ratings[i] >= ratings[i+1]) {
+		       continue;
+		     }         
+		     candies[i+1] = candies[i] + 1;    
+		   }
+		     
+		   // ** Step 2: Backward **
+		   for (int i=ratings.length-1; i>0; i--) {
+		     if (ratings[i] >= ratings[i-1]) {
+		       continue;
+		     }
+		     candies[i-1] = Math.max(candies[i] + 1, candies[i-1]);   
+		   }
+		     
+		   // ** Step 3: Count Candies **
+		   int count = 0;
+		   for (int i=0; i<candies.length; i++) {
+		     count += candies[i];
+		   }
+		     
+		   return count;     
+		}
+	
+	public static void main(String[] args) {
+		@SuppressWarnings("unused")
+		int[] ratings = {12 , 34 , 45 , 67 , 43 , 75};
+	}
+	
+}
+

array/KadanesAlgorithm.java

@@ -0,0 +1,31 @@
+package array;
+import java.util.*;
+
+/*
+ * Kadane's Algorithm to find the maxSubarray Sum in O(n)[Linear Time Complexity]
+ */
+public class KadanesAlgorithm {
+
+	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/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]);
+	}
+}

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);
+		}
+	}
+}
+		
+		
+
+

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); 
+	
+	}
+
+}

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 ));
+	}
+
+}

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);						
+					
+	}
+
+}
+

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));
+	}
+
+}

arrays/Array_Problem_13.java

@@ -0,0 +1,28 @@
+package arrays;
+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);
+    }
+}