More Solutions Added

architg-op · architg-op · commit 34947e0f97a2 · 2019-02-10T22:02:09.000+05:30
diff --git a/Array/Matrix Interchange.java b/Array/Matrix Interchange.java
@@ -0,0 +1,10 @@
+void interchange(int r,int c)
+{
+    //Your code here
+    int temp = 0;
+    for(int i=0;i<r;i++) {
+        temp = arr[i][0];
+        arr[i][0] = arr[i][c - 1];
+        arr[i][c - 1] = temp;
+    }
+}
diff --git a/Array/Maximum in Struct Array.java b/Array/Maximum in Struct Array.java
@@ -0,0 +1,73 @@
+import java.util.*;
+import java.lang.*;
+class Height
+{
+    int feet;
+    int inches;
+    
+      public Height(int ft, int inc)
+      {
+           feet = ft;
+           inches = inc;
+      }
+}
+class maximum
+{
+    public static void main (String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            Height arr[] = new Height[n];
+            for(int i = 0; i < n; i++)
+            {
+                int temp1 = sc.nextInt();
+                int temp2 = sc.nextInt();
+                arr[i] = new Height(temp1, temp2);
+              
+            }
+            GfG gfg = new GfG();
+            
+            int res = gfg.findMax(arr, n);
+            System.out.println(res);
+        }
+    }
+}
+
+}
+
+/*Please note that it's Function problem i.e.
+you need to write your solution in the form of Function(s) only.
+Driver Code to call/invoke your function is mentioned above.*/
+
+/*
+Class of the element of the array is as
+class Height {
+	int feet;
+	int inches;
+	public Height(int ft, int inc)
+	{
+	    feet = ft;
+	    inches = inc;
+	}
+}
+*/
+// function must return the maximum Height
+// return the height in inches
+class GfG
+{
+    public static int findMax(Height arr[], int n)
+    {
+        int max = 0;
+        int sum = 0;
+        for (int i = 0; i < n; i++) {
+            sum = arr[i].feet * 12 + arr[i].inches;
+            if (sum > max) {
+                max = sum;
+            }
+        }
+        return max;
+    }
+}
diff --git a/Array/Missing Number in Array.java b/Array/Missing Number in Array.java
@@ -0,0 +1,22 @@
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+class GFG
+ {
+	public static void main (String[] args)
+	 {
+	     Scanner sc = new Scanner(System.in);
+	     int t = sc.nextInt();
+	     while (t-- != 0) {
+	         int n = sc.nextInt();
+	         int a[] = new int[n - 1];
+	         int sum = 0;
+	         for (int i = 0; i < n - 1; i++) {
+	             a[i] = sc.nextInt();
+	             sum += a[i];
+	         }
+	         int hyp = (n * (n + 1)) / 2;
+	         System.out.println(hyp - sum);
+	     }
+	 }
+}
diff --git a/Array/Next Permutation.java b/Array/Next Permutation.java
@@ -0,0 +1,53 @@
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+class GFG
+ {
+	public static void main (String[] args)
+	 {
+	     Scanner sc = new Scanner(System.in);
+	     int t = sc.nextInt();
+	     while (t-- != 0) {
+	         int n = sc.nextInt();
+	         int a[] = new int[n];
+	         for (int i = 0; i < n; i++) {
+	             a[i] = sc.nextInt();
+	         }
+	         int temp = 0;
+	         int f = 0;
+	         int idx = 0;
+	         for (int i = n - 1; i > 0; i--) {
+	             if (a[i] > a[i - 1]) {
+	                 f = 1;
+	                 temp = a[n - 1];
+	                 a[n - 1] = a[i - 1];
+	                 a[i - 1] = temp;
+	                 idx = i - 1;
+	                 break;
+	             }
+	         }
+	         if (f == 0) {
+	             for (int i = n - 1; i >= 0; i--) {
+	                 System.out.print(a[i] + " ");
+	             }
+	         }
+	         else {
+	             for (int i = idx + 1; i < n; i++) {
+	                 for (int j = i + 1; j < n; j++) {
+	                     if (a[j] < a[i]) {
+	                         temp = a[j];
+	                         a[j] = a[i];
+	                         a[i] = temp;
+	                     }
+	                 }
+	             }
+    	         for (int i = 0; i < n; i++) {
+    	             System.out.print(a[i] + " ");
+    	         }
+	         }
+	         System.out.println();
+	         f = 0;
+	         temp = 0;
+	     }
+	 }
+}
diff --git a/Array/Sum of bit differences.java b/Array/Sum of bit differences.java
@@ -0,0 +1,33 @@
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+class GFG
+ {
+	public static void main (String[] args)
+	 {
+	     Scanner sc = new Scanner(System.in);
+	     int t = sc.nextInt();
+	     while (t-- != 0) {
+	         int n = sc.nextInt();
+	         int a[] = new int[n];
+	         for (int i = 0; i < n; i++) {
+	             a[i] = sc.nextInt();
+	         }
+	         int sum = 0;
+	         int num = 0, rem = 0;
+	         for (int i = 0; i < n; i++) {
+	             for (int j = i + 1; j < n; j++) {
+	                 num = a[i] ^ a[j];
+	                 while (num != 0) {
+	                     rem = num % 2;
+	                     if (rem == 1) {
+	                         sum += 2;
+	                     }
+	                     num /= 2;
+	                 }
+	             }
+	         }
+	         System.out.println(sum);
+	     }
+	 }
+}
diff --git a/BST/Ceil for BST.java b/BST/Ceil for BST.java
@@ -0,0 +1,21 @@
+import java.util.*;
+
+public class solution {
+	public static int Ceil(BinaryTreeNode<Integer> node, int input) {
+       Stack<BinaryTreeNode> st = new Stack<>();
+       int res = -1;
+       BinaryTreeNode<Integer> curr = node;
+       while (curr != null || !st.isEmpty()) {
+           while (curr != null) {
+               st.push(curr);
+           	   curr = curr.left;
+           }
+           curr = st.pop();
+           if (curr.data > input) {
+               res = curr.data;
+               break;
+           }
+           curr = curr.right;
+       }
+        return res;
+	}
diff --git a/BST/Check if Array presents Level Order Traversal or not.java b/BST/Check if Array presents Level Order Traversal or not.java
@@ -0,0 +1,66 @@
+import java.io.*;
+import java.util.*;
+
+class Node {
+    int data;
+    Node left;
+    Node right;
+    
+    Node(int d) {
+        data = d;
+        left = right = null;
+    }
+  
+}
+
+
+
+class GFG {
+    static Node createTree(Node root, int d) {
+        if (root == null) {
+            root = new Node(d);
+        }
+        else if (d < root.data) {
+            root.left = createTree(root.left, d);
+        }
+        else {
+            root.right = createTree(root.right, d);
+        }
+        return root;
+    }
+    
+	public static void main (String[] args) {
+	    int j = 0;
+	    int f = 0;
+	    Node root = null;
+	    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();
+	        root = createTree(root, a[i]);
+	    }
+	    Queue<Node> q = new LinkedList<>();
+	    Node curr = null;
+	    q.add(root);
+	    while (!q.isEmpty()) {
+	        curr = q.remove();
+	        if (a[j++] != curr.data) {
+	            f = 1;
+	            break;
+	        }
+	        if (curr.left != null) {
+	            q.add(curr.left);
+	        }
+	        if (curr.right != null) {
+	            q.add(curr.right);
+	        }
+	    }
+	    if (f == 0) {
+	        System.out.println("Yes");
+	    }
+	    else {
+	        System.out.println("No");
+	    }
+	}
+}
diff --git a/BST/Check if trees are identical.java b/BST/Check if trees are identical.java
@@ -0,0 +1,39 @@
+boolean isIdentical(Node root1, Node root2)
+	{
+	    Stack<Node> st1 = new Stack<>();
+	    ArrayList<Integer> al1 = new ArrayList<>();
+	    Node curr = root1;
+	    while (!st1.empty() || curr != null) {
+	        while (curr != null) {
+	            st1.push(curr);
+	            curr = curr.left;
+	        }
+	        curr = st1.pop();
+	        al1.add(curr.data);
+	        curr = curr.right;
+	    }
+	    
+	    Stack<Node> st2 = new Stack<>();
+	    ArrayList<Integer> al2 = new ArrayList<>();
+	    curr = root2;
+	    while (!st2.empty() || curr != null) {
+	        while (curr != null) {
+	            st2.push(curr);
+	            curr = curr.left;
+	        }
+	        curr = st2.pop();
+	        al2.add(curr.data);
+	        curr = curr.right;
+	    }
+	    
+	    if (al1.size() != al2.size()) {
+	        return false;
+	    }
+	    
+	    for (int i = 0; i < al1.size(); i++) {
+	        if (al1.get(i) != al2.get(i)) {
+	            return false;
+	        }
+	    }
+	    return true;
+	}
diff --git a/BST/Floor from BST.java b/BST/Floor from BST.java
@@ -0,0 +1,21 @@
+import java.util.*;
+
+public class solution {
+	public static int Floor(BinaryTreeNode<Integer> node, int input) {	
+        Stack<BinaryTreeNode> st = new Stack<>();
+        int res = -1;
+        BinaryTreeNode<Integer> curr = node;
+        while (!st.isEmpty() || curr != null) {
+            while (curr != null) {
+                st.push(curr);
+                curr = curr.left;
+            }
+            curr = st.pop();
+            if (curr.data < input) {
+                res = curr.data;
+            }
+            curr = curr.right;
+        }
+        return res;
+    }
+}
diff --git a/BST/PreOrder to PostOrder.java b/BST/PreOrder to PostOrder.java
diff --git a/BST/kthLargest Elemenr.java b/BST/kthLargest Elemenr.java
diff --git a/Linked List/Deletion of Node in Linked List.java b/Linked List/Deletion of Node in Linked List.java
diff --git a/Linked List/Insertion in Linked List.java b/Linked List/Insertion in Linked List.java
