nextcommit

Author: shashankch

src/revision/KthSymbolGram.java

@@ -0,0 +1,32 @@
+package revision;
+
+// https://leetcode.com/problems/k-th-symbol-in-grammar/
+public class KthSymbolGram {
+
+    // here logic involves finding the parent in the previous row.
+    // look this ques. in term of tree node with left child at(2*i+1 odd)
+    // and right child at (2*i+2 even) .
+    // now if k is odd it will be left child of prev row node parent and otherwise right child
+    // if 0 then 01 and if 1 then 10 now find the parent node and then check if 1 or 0.
+
+    public static int method(int n, int k) {
+
+        if (n == 1 && k == 1) {
+            return 0;
+        }
+
+        int prevRowParent = method(n - 1, (k + 1) / 2);
+        if ((k % 2 == 0 && prevRowParent == 0) || (k % 2 == 1 && prevRowParent == 1)) {
+            return 1;
+        }
+
+        return 0;
+
+    }
+
+    public static void main(String[] args) {
+
+        System.out.println(method(5, 4));
+    }
+
+}

src/revision/Tribonacci.java

@@ -0,0 +1,74 @@
+package revision;
+
+import java.util.HashMap;
+
+public class Tribonacci {
+
+    public int tribonacci(int n) {
+
+        if (n == 0) {
+            return n;
+        }
+        if (n <= 2) {
+            return 1;
+        }
+        int a = 0, b = 1, c = 1, d;
+        for (int i = 3; i <= n; i++) {
+
+            d = a + b + c;
+            a = b;
+            b = c;
+            c = d;
+        }
+
+        return c;
+
+    }
+
+    private static HashMap<Integer, Integer> result = null;
+
+    public int tribonacci2(int n) {
+        if (result == null) {
+            result = new HashMap<>();
+        }
+        if (n <= 0) {
+            return 0;
+        } else if (n == 1) {
+            return 1;
+        }
+        if (result.containsKey(n)) {
+            return result.get(n);
+        }
+        int valu = tribonacci2(n - 1) + tribonacci2(n - 2) + tribonacci2(n - 3);
+        result.put(n, valu);
+        return valu;
+    }
+
+    int trib[] = new int[38];
+
+    public int tribonacci3(int n) {
+        if (n == 0)
+            return 0;
+        else if (n <= 2)
+            return 1;
+        if (trib[n] != 0)
+            return trib[n];
+        int val1 = tribonacci3(n - 1);
+        int val2 = tribonacci3(n - 2);
+        int val3 = tribonacci3(n - 3);
+
+        trib[n - 1] = val1;
+        trib[n - 2] = val2;
+        trib[n - 3] = val3;
+
+        return val1 + val2 + val3;
+
+    }
+
+}
+
+    public static void main(String[] args) {
+
+    }
+
+}

src/revision/incrementquery.java

@@ -0,0 +1,43 @@
+package revision;
+
+import java.util.Scanner;
+
+// given an empty array and given queries {start index,endIndex}
+// you have to increment the subarray btw the given start and end
+// brute : O(N*queries) but optimised : O(N+K)
+
+
+public class incrementquery {
+
+    public static void main(String[] args) {
+
+        int n = 1000;
+
+
+        int arr[] = new int[n];
+        Scanner sc = new Scanner(System.in);
+        int q = sc.nextInt();
+        int helper[] = new int[n];
+        while (q-- > 0) {
+
+            int start = sc.nextInt();
+            int end = sc.nextInt();
+
+            helper[start] = 1;
+            helper[end + 1] -= 1;
+        }
+        arr[0] = helper[0];
+        for (int i = 1; i < n; i++) {
+
+            arr[i] = helper[i - 1] + helper[i];
+
+        }
+
+        for (int i = 0; i < n; i++) {
+            System.out.println(arr[i] + " ");
+        }
+    }
+
+
+
+}