bunch of code

Author: Dhananjay Nagargoje

Diff for: .idea/workspace.xml

@@ -0,0 +1 @@
+6 6 4

Diff for: out/production/main/input.txt

@@ -0,0 +1 @@
+4

Diff for: out/production/main/output.txt

@@ -1,9 +1 @@
-1
-7
-1 2
-1 3
-2 4
-2 5
-4 6
-4 7
-
+6 6 4

Diff for: out/production/main/problems/onbinarytree/TreeNode.class

@@ -1 +1 @@
-
+4

Diff for: out/production/main/problems/onbinarytree/TreeTraversal.class

@@ -0,0 +1,69 @@
+import java.io.*;
+import java.util.*;
+
+public class Solution implements Runnable {
+
+    BufferedReader in;
+    PrintWriter out;
+    StringTokenizer tok = new StringTokenizer("");
+
+    public static void main(String[] args) {
+        new Thread(null, new Solution(), "", 256 * (1L << 20)).start();
+    }
+
+    public void run() {
+        try {
+            long t1 = System.currentTimeMillis();
+            if (System.getProperty("ONLINE_JUDGE") != null) {
+                in = new BufferedReader(new InputStreamReader(System.in));
+                out = new PrintWriter(System.out);
+            } else {
+                in = new BufferedReader(new FileReader("src\\main\\java\\testingsystem\\misccode\\input.txt"));
+                out = new PrintWriter("src\\main\\java\\testingsystem\\misccode\\output.txt");
+            }
+            Locale.setDefault(Locale.US);
+            solve();
+            in.close();
+            out.close();
+            long t2 = System.currentTimeMillis();
+            System.err.println("Time = " + (t2 - t1));
+        } catch (Throwable t) {
+            t.printStackTrace(System.err);
+            System.exit(-1);
+        }
+    }
+
+    String readString() throws IOException {
+        while (!tok.hasMoreTokens()) {
+            tok = new StringTokenizer(in.readLine());
+        }
+        return tok.nextToken();
+    }
+
+    int readInt() throws IOException {
+        return Integer.parseInt(readString());
+    }
+
+    long readLong() throws IOException {
+        return Long.parseLong(readString());
+    }
+
+    double readDouble() throws IOException {
+        return Double.parseDouble(readString());
+    }
+
+    // solution
+
+    void solve() throws IOException {
+        long n = readInt();
+        long m = readInt();
+        long a = readInt();
+        long xn = n/a;
+        long xm = m/a;
+        if(n % a != 0) xn++;
+        if(m % a != 0) xm++;
+        out.print((xn*xm));
+
+    }
+
+}

Diff for: out/production/main/problems/onheaps/KLargestInHeap$1.class

@@ -0,0 +1 @@
+6 6 4

Diff for: out/production/main/problems/onheaps/KLargestInHeap.class

@@ -53,7 +53,7 @@ public class Admin extends Person {
   public boolean addMovie(Movie movie);
   public boolean addShow(Show show);
   public boolean blockUser(Customer customer);
-}
+}   
 
 public class FrontDeskOfficer extends Person {
   public boolean createBooking(Booking booking);
@@ -119,31 +119,6 @@ public class Payment {
 
 
 
-public class City {
-  private String name;
-  private String state;
-  private String zipCode;
-}
-
-public class Cinema {
-  private String name;
-  private int totalCinemaHalls;
-  private Address location;
-
-  private List<CinemaHall> halls;
-}
-
-public class CinemaHall {
-  private String name;
-  private int totalSeats;
-
-  private List<CinemaHallSeat> seats;
-  private List<Show> shows;
-}
-
-
-
-
 public class City {
   private String name;
   private String state;

Diff for: out/production/main/problems/test/One.class

@@ -0,0 +1 @@
+4

Diff for: out/production/main/testingsystem/misccode/input.txt

@@ -0,0 +1,47 @@
+package problems.onRecursionAndDp.backtracking;
+
+import java.util.ArrayList;
+
+public class PalindriomSequcne {
+    public static class Solution {
+        ArrayList<ArrayList<String>> res ;
+        public ArrayList<ArrayList<String>> partition(String a) {
+            res = new ArrayList<>();
+            func(a, 0, 0, new ArrayList<>());
+            return res;
+        }
+
+        public void func(String a, int parst, int curi, ArrayList<String> step) {
+            if(curi == a.length()-1){
+                if(ispalindrom(a, parst, curi)) {
+                    step.add(a.substring(parst, curi+1));
+                    res.add(new ArrayList<>(step));
+                    step.remove(step.size()-1);
+                }
+                return;
+            }
+            if(ispalindrom(a, parst, curi)) {
+                step.add(a.substring(parst, curi+1));
+                func(a, curi+1, curi+1, step);
+                step.remove(step.size()-1);
+            }
+            func(a, parst, curi+1, step);
+        }
+        private boolean ispalindrom(String str, int st, int en) {
+            while(st<=en){
+                if(str.charAt(st)!=str.charAt(en)) return false;
+                st++;
+                en--;
+            }
+            return true;
+        }
+    }
+
+    public static void main(String[] args) {
+        Solution solution
+                 = new Solution();
+      //  solution.partition("cccaacbcaabb");
+        solution.partition("aabac").stream().forEach(strings -> System.out.println(strings));
+    }
+
+}

Diff for: out/production/main/testingsystem/misccode/output.txt

@@ -0,0 +1,64 @@
+package problems.onRecursionAndDp.backtracking;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+
+public class RemoveInvalidParenthesis {
+    public static class Solution {
+        ArrayList<String> res;
+        HashSet<String> seen;
+
+        public ArrayList<String> solve(String A) {
+            res = new ArrayList<>();
+            seen = new HashSet<>();
+            func(A, 0, invalidParen(A));
+            return res;
+        }
+
+        public void func(String str, int i, int k) {
+            if (k == 0 || i == str.length()) {
+                if (k == 0 && invalidParen(str) == 0) {
+                    if (!seen.contains(str))
+                    res.add(str);
+                    seen.add(str);
+                }
+                return;
+            }
+            if (str.charAt(i) == '(' || str.charAt(i) == ')') {
+                String left = (i > 0) ? str.substring(0, Math.min(i, str.length())) : "";
+                String right = (i < str.length() - 1) ? str.substring(i + 1, str.length()) : "";
+                func(left + right, i, k - 1);
+            }
+            func(str, i + 1, k);
+        }
+
+        public int invalidParen(String A) {
+            int left = 0;
+            int right = 0;
+            int count = 0;
+            for (int i = 0; i < A.length(); i++) {
+                if (A.charAt(i) == '(') left++;
+                if (A.charAt(i) == ')') {
+                    right++;
+                    if (right > left) {
+                        count++;
+                        left = 0;
+                        right = 0;
+                    } else {
+                        left-=right;
+                        right--;
+                    }
+                }
+            }
+            count += left;
+            return count;
+        }
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.solve(")(()((((()((").toString());
+    }
+
+}

Diff for: src/main/java/Solution.java

@@ -0,0 +1,61 @@
+package problems.onbinarytree;
+
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.LinkedList;
+
+public class PostOrder {
+
+    public static ArrayList<Integer> postorderTraversal(TreeNode A) {
+        ArrayList<Integer> res = new ArrayList<>();
+        if(A == null) return res;
+        TreeNode prevLeft = null;
+        TreeNode prevRight = null;
+
+        Deque<TreeNode> deq = new LinkedList<>();
+        deq.addLast(A);
+        HashSet<TreeNode> seen = new HashSet<>();
+        while(!deq.isEmpty()) {
+            while(deq.peekLast().left != null && !seen.contains(deq.peekLast().left)) {
+                deq.addLast(deq.peekLast().left);
+            }
+
+            if(deq.peekLast().right != null) {
+                if(seen.contains(deq.peekLast().right)){
+                    TreeNode child = deq.removeLast();
+                    res.add(child.val);
+                    seen.add(child);
+                } else {
+                    deq.addLast(deq.peekLast().right);
+                }
+            } else {
+                TreeNode child = deq.removeLast();
+                res.add(child.val);
+                seen.add(child);
+            }
+
+        }
+        //helper(A, res);
+        return res;
+    }
+
+    public static void main(String[] args) {
+        TreeNode root = new TreeNode();
+
+        //level 0
+        root.val = 1;
+
+        //level 1
+        root.left = new TreeNode(2);
+        root.right = new TreeNode(3);
+
+        //level 2
+        root.left.left = new TreeNode(4);
+        root.left.right = new TreeNode(5);
+        root.right.left = new TreeNode(6);
+        root.right.right = new TreeNode(7);
+
+        postorderTraversal(root).forEach(System.out::println);
+    }
+}

Diff for: src/main/java/input.txt

@@ -5,6 +5,8 @@ public class TreeNode {
     public TreeNode left;
     public TreeNode right;
 
+    public TreeNode() {
+    }
     public TreeNode(int x) {
         val = x;
     }

Diff for: src/main/java/oopadesign/moviebookingticket.md

@@ -120,6 +120,7 @@ static void levelOrder(BinaryTreeNode<Integer> root) {
         }
     }
 
+
     public static void main(String[] args) {
         System.out.print("pre  -> ");preOrder(BinaryTreeUtils.getSampleTree(2));
         System.out.print("\npre  -> ");nonRecursivePreOrder(BinaryTreeUtils.getSampleTree(4));

Diff for: src/main/java/output.txt

@@ -28,11 +28,8 @@ public HeapEntry(int val, int index) {
 
     public static List<Integer> kLargestInBinaryHeap(List<Integer> A, int k) {
         List<Integer> res = new ArrayList<>();
-        PriorityQueue<HeapEntry> levelPq = new PriorityQueue<>(new Comparator<HeapEntry>() {
-            @Override
-            public int compare(HeapEntry o1, HeapEntry o2) {
-                return o2.val - o1.val; //reverse comparater
-            }
+        PriorityQueue<HeapEntry> levelPq = new PriorityQueue<>((o1, o2) -> {
+            return o2.val - o1.val; //reverse comparater
         });
         if (A.size() == 0) return res;
         levelPq.add(new HeapEntry(A.get(0), 0));