nextcommit

Author: shashankch

src/revision/FindPairs.java

@@ -0,0 +1,58 @@
+package revision;
+
+class ListN<t> {
+
+    public t data;
+    public ListN<t> forw;
+    public ListN<t> backw;
+
+    public ListN(t data) {
+        this.data = data;
+    }
+
+
+}
+
+
+public class FindPairs {
+
+    public static void findPairs(ListN<Integer> head, int n) {
+        // Write your code here
+
+
+        ListN<Integer> start = head;
+        ListN<Integer> end = head;
+
+        while (end.forw != null) {
+            end = end.forw;
+        }
+
+        // System.out.println(start.data+" "+end.data);
+        while (start.data < end.data) {
+
+            if (start.data + end.data == n) {
+                System.out.println(start.data + " " + end.data);
+                start = start.forw;
+                end = end.backw;
+            }
+
+            else if (start.data + end.data > n) {
+                end = end.backw;
+            }
+
+            else if (start.data + end.data < n) {
+                start = start.forw;
+            }
+
+
+        }
+
+
+
+    }
+
+    public static void main(String[] args) {
+
+    }
+
+}

src/revision/FloorValue.java

@@ -0,0 +1,33 @@
+package revision;
+
+public class FloorValue {
+
+    public static int helper(int array[], int element, int in, int mx) {
+
+        if (in == array.length) {
+            return mx;
+        }
+
+        if (array[in] <= element && array[in] > mx) {
+            mx = array[in];
+        }
+
+        return helper(array, element, in + 1, mx);
+
+    }
+
+
+    public static int findFloor(int[] array, int element) {
+
+
+        int ans = helper(array, element, 0, Integer.MIN_VALUE);
+        return ans;
+
+
+    }
+
+    public static void main(String[] args) {
+
+    }
+
+}

src/revision/GenerateParanthesis.java

@@ -0,0 +1,46 @@
+package revision;
+
+public class GenerateParanthesis {
+
+    public static void generate(String str, int n, int i, int open, int close) {
+
+        if (i == 2 * n) {
+            System.out.println(str);
+        }
+
+        if (open < n) {
+            generate(str + "(", n, i + 1, open + 1, close);
+        }
+
+        if (open > close) {
+            generate(str + ")", n, i + 1, open, close + 1);
+        }
+
+
+    }
+
+    public static void generateImp(String str, int n, int open, int close) {
+
+        if (close == n) {
+            System.out.println(str);
+
+        }
+
+        if (open < n) {
+            generateImp(str + "(", n, open + 1, close);
+        }
+        if (open > close) {
+            generateImp(str + ")", n, open, close + 1);
+        }
+
+
+
+    }
+
+    public static void main(String[] args) {
+
+        generate("", 5, 0, 0, 0);
+        generateImp("", 5, 0, 0);
+    }
+
+}

src/revision/LoopReconnect.java

@@ -0,0 +1,70 @@
+package revision;
+
+public class LoopReconnect {
+
+    public static ListNode<Integer> method(ListNode<Integer> head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+
+        ListNode<Integer> temp = head;
+        ListNode<Integer> fast = head;
+        ListNode<Integer> slow = head;
+
+        while (fast != null && fast.next != null) {
+
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+
+                break;
+            }
+
+
+
+        }
+
+        if (slow == fast) {
+
+            slow = head;
+            while (slow.next != fast.next) {
+                slow = slow.next;
+                fast = fast.next;
+            }
+        }
+
+        ListNode<Integer> val = fast.next;
+        // System.out.println(fast.next.data);
+        fast.next = null;
+
+        ListNode<Integer> mx = null;
+        // ListNode<Integer>prev=null;
+
+        while (temp.next != null) {
+
+            if (temp.data > val.data) {
+
+                mx = (mx == null || mx.data > temp.data) ? temp : mx;
+
+            }
+
+            temp = temp.next;
+
+        }
+
+        fast.next = mx;
+
+
+
+        return head;
+
+    }
+
+
+
+    public static void main(String[] args) {
+
+    }
+
+}

src/revision/Tribonacci.java

@@ -65,7 +65,7 @@ else if (n <= 2)
 
     }
 
-}
+
 
     public static void main(String[] args) {
 

src/revision/matchNumberLL.java

@@ -0,0 +1,116 @@
+package revision;
+
+public class matchNumberLL {
+
+
+    public static boolean CheckRepresentaion(ListNode<Integer> head1, ListNode<Integer> head2) {
+
+        if (head1 == null && head2 == null) {
+            return true;
+        }
+
+        if (head1 == null || head2 == null) {
+            return false;
+        }
+
+        StringBuilder num1 = new StringBuilder();
+        StringBuilder num2 = new StringBuilder();
+
+
+        while (head1 != null && head2 != null) {
+
+            num1.append(head1.data);
+            num2.append(head2.data);
+            head1 = head1.next;
+            head2 = head2.next;
+
+
+
+        }
+
+        while (head1 != null) {
+            num1.append(head1.data);
+            head1 = head1.next;
+        }
+        while (head2 != null) {
+            num2.append(head2.data);
+            head2 = head2.next;
+        }
+        while (num1.charAt(0) == '0') {
+            num1.deleteCharAt(0);
+        }
+        while (num2.charAt(0) == '0') {
+            num2.deleteCharAt(0);
+        }
+
+
+
+        return (num1.toString().compareTo(num2.toString()) != 0) ? false : true;
+    }
+
+
+    public static String convert(int n) {
+
+        if (n == 0) {
+            return "0";
+        }
+        String s = "";
+        char t;
+        while (n > 0) {
+            t = (char) (n % 10);
+            s = t + s;
+            n /= 10;
+        }
+
+        return s;
+    }
+
+    // problem with this method...c++
+    public static boolean method(ListNode<Integer> a, ListNode<Integer> b) {
+
+        String one = "", two = "";
+
+        boolean zero = false;
+
+        while (a.next != null) {
+
+            zero = true;
+            if (a != null || one.length() != 0) {
+                one += convert(a.data);
+            }
+            a = a.next;
+
+        }
+
+        if (zero == true && one.length() != 0) {
+            one = "0";
+        }
+        zero = false;
+
+        while (b.next != null) {
+            zero = true;
+            if (b != null || two.length() != 0) {
+                two += convert(b.data);
+            }
+
+            b = b.next;
+        }
+
+        if (zero == true && two.length() != 0) {
+            two = "0";
+        }
+
+        return one.equals(two);
+
+    }
+
+    public static void main(String[] args) {
+
+        ListNode<Integer> head = new ListNode<>(1);
+        ListNode<Integer> head2 = new ListNode<Integer>(14);
+
+        System.out.println(CheckRepresentaion(head, head2));
+
+    }
+
+}