#Modification 10

Author: amangit1314

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "POSTFIX.C": "cpp"
+    }
+}

arrays/Candy_Distribution_Problem.java

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

basics/Operators.java

@@ -6,7 +6,7 @@ public static void main(String[] args) {
 		int a = 7,b= 6;
 		int c = a*b;    //* (multiplication) operator
 		int d = a+b;	// + addition operator
-		int e = a/b;	// - substration operator
+		int e = a/b;	// - subtraction operator
 		int f = a%b;	// % modulus operator
 		int g = a^b;	// ^ power operator
 		long h = b^a;

dp/CoinChoiseProblem.java

@@ -0,0 +1,51 @@
+package dp;
+
+import java.util.*;
+
+public class CoinChoiseProblem {
+
+	public static void main(String[] args) {
+		
+		
+		int n = 18;
+		int a[] = {7, 5, 1};
+		int dp[] = new int[n+1];
+		
+		Arrays.fill(dp, -1);
+		dp[0] = 0;
+		
+		int ans = minCoins(n, a, dp);
+		System.out.println(ans);
+		
+		for(int x: dp) 
+			System.out.println(x + " ");
+	}
+	
+	static int minCoins(int n, int a[], int dp[]) {
+		
+		if(n == 0)	
+			return 0;
+		
+		int ans = Integer.MAX_VALUE;
+		
+		for(int i = 0; i<a.length; i++) {
+			
+			if(n - a[i] >= 0) {
+				
+				int subAns = 0;
+				
+				if(dp[n-a[i]] != -1) 
+					subAns = dp[n-a[i]];
+				
+				else 
+					subAns = minCoins(n-a[i],a, dp);
+				
+				if(subAns != Integer.MAX_VALUE && subAns + 1 < ans) 
+					ans = subAns + 1;
+			}
+		}
+		
+	return dp[n] = ans;
+	
+	}
+}

graphs/Graph.java

@@ -0,0 +1,41 @@
+package graphs;
+import java.util.*;
+
+public class Graph {
+	
+	private LinkedList<Integer> adj[];
+	
+	@SuppressWarnings("unchecked")
+	public Graph(int v) {
+		//array of Linked List
+		adj = new LinkedList[v]; 
+		
+		for(int i=0;i<v;i++) {
+			adj[i] = new LinkedList<Integer>();
+		}
+	}
+	
+	public void addEdge(int source, int destination) {
+		adj[source].add(destination);
+		adj[destination].add(source);	
+	}
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Enter number of vertices and edges");
+		int v = sc.nextInt();
+		int e = sc.nextInt();
+		
+		Graph graph = new Graph(v);
+		System.out.println("Enter " + e + " edges");
+		
+		for(int i=0;i<e;i++) {
+			int source = sc.nextInt();
+			int destination = sc.nextInt();
+			graph.addEdge(source,  destination);
+		}
+		
+		sc.close();
+	}
+}

graphs/Graph_Traversal_DFS.java

@@ -0,0 +1,57 @@
+package graphs;
+import java.util.*;
+
+public class Graph_Traversal_DFS{
+	
+	@SuppressWarnings("unused")
+	private int v;
+	private LinkedList<Integer> adj[];
+	
+	@SuppressWarnings("unchecked")
+	public Graph_Traversal_DFS(int v){
+		adj = new LinkedList[v];
+		for(int i = 0 ; i < v ; ++i)
+			adj[i] = new LinkedList<Integer>();	
+	}
+	
+	void addEdge(int v, int w) {
+		adj[v].add(w);
+	}
+	
+	void DFSUtil(int v, boolean visited[]) {
+		visited[v] = true;
+		System.out.println(v + " ");
+		
+		Iterator<Integer> i = adj[v].listIterator();
+		while(i.hasNext()) {
+			int n = i.next();
+			if(!visited[n])
+				DFSUtil(n,visited);
+		}	
+	}
+	
+	void DFS(int v) {
+		boolean visited[] = new boolean[v];
+		DFSUtil(v,visited);
+	}
+	
+	public static void main(String[] args) {
+
+		Graph_Traversal_DFS d = new Graph_Traversal_DFS(4);
+ 
+        d.addEdge(0, 1);
+        d.addEdge(0, 2);
+        d.addEdge(1, 2);
+        d.addEdge(2, 0);
+        d.addEdge(2, 3);
+        d.addEdge(3, 3);
+ 
+        System.out.println(
+            "Following is Depth First Traversal "
+            + "(starting from vertex 2)");
+ 
+        d.DFS(2);
+		
+	}
+
+}

matrix/Matrix_Problem_01.java

@@ -0,0 +1,87 @@
+package matrix;
+import java.io.*;
+
+/*
+ * Spiral traversal on a Matrix
+ */
+
+/*
+ * GIven an 2D array, print it in spiral form.
+ * See the following examples.
+ * 
+ * Inputs:
+ * 01 02 03 04
+ * 05 06 07 08
+ * 09 10 11 12
+ * 13 14 15 16
+ * 
+ * Output:
+ * 1 2 3 4 8 12 16 15  14 13 9 5 6 7 11 10
+ * 
+ * Explanation:
+ * The output is matrix in spiral format.
+ */
+
+/* Graphical Try:
+ * 
+ * 01-- 02-- 03-- 04
+ *                |
+ * 05-- 06-- 07   08
+ * |         |    |
+ * 09   10   11   12
+ * |              |
+ * 13-- 14-- 15 --16
+ *
+ * Output:
+ * 1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10
+ */
+
+@SuppressWarnings("unused")
+public class Matrix_Problem_01 {
+	
+	static void spiralPrint(int m, int n, int[][] a) {
+		
+		System.out.println("Spiral Traversal of given matrix is: ");
+		int i, k = 0, l = 0;
+		
+		/*
+		 * k - starting row index
+		 * m - ending row index
+		 * l - starting column index
+		 * n - ending column index
+		 * i - iterator
+		 */
+		
+		while(k < m && l < n) {
+			
+			
+			for( i = l ; i < n ; ++i) 
+				System.out.print(a[k][i] + " ");
+			k++;
+			
+			for(i = k ; i < m ; ++i) 
+				System.out.print(a[i][n - 1] + " ");
+			n--;
+			
+			if(l < n) {
+				for(i = m - 1 ; i >= k ; --i) 
+					System.out.print(a[i][l] + " ");
+				l++;
+			}
+		}
+		
+	}
+
+	public static void main(String[] args) {
+		
+		int R = 3;
+		int C = 6;
+		int a[][] = { { 1 , 2 , 3 , 4 , 5 , 6 },
+					  { 7 , 8 , 9 , 10 , 11 , 12 },
+					  { 13 , 14 , 15 , 16 , 17 , 18 }
+					};
+		
+		spiralPrint(R,C,a);
+	}
+
+}