practice

Author: shashankch

src/Prep/AllPossibleSubstring.java

@@ -0,0 +1,45 @@
+package Prep;
+
+import java.util.Scanner;
+
+public class AllPossibleSubstring {
+
+
+    public static void helper(String str, int i, String out) {
+
+
+        if (i == str.length()) {
+
+            System.out.println(out);
+            return;
+        }
+
+        for (int j = str.length() - 1; j >= i; j--) {
+
+            String temp = '[' + str.substring(i, j + 1) + ']';
+
+            helper(str, j + 1, out + temp);
+        }
+
+
+
+    }
+
+
+    public static void main(String[] args) {
+
+
+        Scanner sc = new Scanner(System.in);
+
+        String input = sc.nextLine();
+        int n = input.length();
+
+        System.out.println((int)Math.pow(2, n - 1));
+
+        helper(input, 0, "");
+
+
+
+    }
+
+}

src/Prep/DistributeSweetsHappy.java

@@ -0,0 +1,67 @@
+package Prep;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class DistributeSweetsHappy {
+
+
+
+    public static void main(String[] args) {
+
+
+        Scanner sc = new Scanner(System.in);
+
+        int n = sc.nextInt();
+
+        int min[] = new int[n];
+        int max[] = new int[n];
+
+        for (int i = 0; i < n; i++) {
+
+            min[i] = sc.nextInt();
+            max[i] = sc.nextInt();
+
+
+        }
+
+
+        Arrays.sort(min);
+        Arrays.sort(max);
+
+        int curr = 0, res = 0;
+        int sweets = 0;
+        int i = 0, j = 0;
+
+        while (i < n && j < n) {
+
+
+            if (min[i] <= max[j]) {
+
+                curr += 1;
+                if (curr > res) {
+                    res = curr;
+                    sweets = min[i];
+                }
+
+                i++;
+
+            } else {
+
+                curr -= 1;
+                j++;
+
+            }
+
+
+
+        }
+
+
+        System.out.println(sweets + " " + res);
+
+
+
+    }
+
+}

src/Prep/FloorCeil.java

@@ -0,0 +1,40 @@
+package Prep;
+
+public class FloorCeil {
+
+
+    // binary search approach
+
+    // other
+    public static void helper(int arr[], int x) {
+
+
+        int fInd = -1, cInd = -1;
+        int n = arr.length;
+
+        int fDist = Integer.MAX_VALUE, cDist = Integer.MAX_VALUE;
+
+        for (int i = 0; i < n; i++) {
+
+            if (arr[i] >= x && cDist > (arr[i] - x)) {
+                cInd = i;
+                cDist = arr[i] - x;
+            }
+
+
+            if (arr[i] <= x && fDist > (x - arr[i])) {
+                fInd = i;
+                fDist = x - arr[i];
+            }
+        }
+
+        System.out.println("floor" + arr[fInd] + "  ceil" + arr[cInd]);
+    }
+
+    public static void main(String[] args) {
+
+
+
+    }
+
+}

src/Prep/GoodBadString.java

@@ -0,0 +1,51 @@
+package Prep;
+
+import java.util.Scanner;
+
+public class GoodBadString {
+
+
+    public static String helper(String str) {
+        
+        String ans = "";
+        for (int i = 0; i < str.length(); i++) 
+        {
+            
+            int j = i;
+            
+            while (j < str.length() && str.charAt(i) == str.charAt(j)) 
+            {
+                j++;
+            }
+
+            ans += str.charAt(i);
+             i=j-1;
+
+        }
+
+
+        return ans;
+
+
+    } 
+
+
+    public static void main(String[] args) {
+        
+        Scanner sc = new Scanner(System.in);
+
+        int n = sc.nextInt();
+
+        while (n-- > 0) {
+            
+            String input = sc.next();
+
+            String ans = helper(input);
+
+            System.out.println(ans);
+
+        }
+
+    }
+    
+}

src/Prep/LargestForest.java

@@ -0,0 +1,65 @@
+package Prep;
+
+import java.util.Scanner;
+
+public class LargestForest {
+    
+    public static int helper(int i, int j, String mat[], int n) {
+
+        if (i < 0 || i >= n || j < 0 || j >= n) {
+            return 0;
+        }
+        if (mat[i].charAt(j) == 'X' || mat[i].charAt(j) == 'W') {
+            return 0;
+        }
+
+        // mat[i][j] = 'X';
+
+        int x[] = {0, 0, 1, -1};
+        int y[] = {1, -1, 0, 0};
+        int res = 1;
+        for (int k = 0; k < 4; k++) {
+
+            int xn = x[k] + i;
+            int yn = y[k] + j;
+            res += helper(xn, yn, mat, n);
+        }
+
+
+        return res;
+
+    }
+
+    public static void main(String[] args) {
+
+       
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        String mat[] = new String[n];
+      
+        for (int i = 0; i < n; i++) {
+        
+            mat[i] = sc.nextLine();
+        
+        }
+
+
+      
+        int ans = 0;
+        for (int i = 0; i < n; i++) {
+
+
+            for (int j = 0; j < n; j++) {
+                if (mat[i].charAt(j) == 'T') {
+
+                    ans = Math.max(ans, helper(i, j, mat, n));
+                }
+            }
+        }
+
+
+        System.out.print(ans);
+        
+    }
+
+}

src/Prep/MaxSumNonAdj.java

@@ -0,0 +1,66 @@
+package Prep;
+
+public class MaxSumNonAdj {
+
+
+    public static int helper2(int arr[], int i, int prev) {
+
+
+        if (i == arr.length) {
+
+            return 0;
+        }
+
+        int ex = helper2(arr, i + 1, prev);
+
+        int in = 0;
+
+        if (prev + 1 != i) {
+
+            in = helper2(arr, i + 1, i) + arr[i];
+
+        }
+
+
+        return Math.max(ex, in);
+
+
+
+    }
+
+
+    public static int helper(int arr[]) {
+
+        int inc = arr[0];
+        int exc = 0;
+        int temp;
+
+        for (int i = 1; i < arr.length; i++) {
+
+            temp = Math.max(inc, exc);
+
+            inc = exc + arr[i];
+            exc = temp;
+
+
+
+        }
+
+
+        return Math.max(inc, exc);
+
+
+
+    }
+
+    public static void main(String[] args) {
+
+
+        int arr[] = {-2, 1, 3, -4, 5};
+
+        System.out.println(helper(arr));
+
+
+    }
+
+}

src/Prep/MaxdistBtwOccur.java

@@ -0,0 +1,33 @@
+package Prep;
+
+import java.util.HashMap;
+
+public class MaxdistBtwOccur {
+
+
+    public static void main(String[] args) {
+
+        int arr[] = {3, 2, 1, 2, 1, 4, 5, 8, 6, 7, 4, 2};
+
+        HashMap<Integer, Integer> mp = new HashMap<>();
+        int max = 0;
+
+        for (int i = 0; i < arr.length; i++) {
+
+            if (!mp.containsKey(arr[i])) {
+
+                mp.put(arr[i], i);
+            } else {
+
+                max = Math.max(max, i - mp.get(arr[i]));
+            }
+
+        }
+
+        System.out.println(max);
+
+
+    }
+
+
+}