more

Author: Sonia Mathew

.idea/workspace.xml

@@ -0,0 +1,74 @@
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * Leetcode question
+ */
+
+public class BasicCalculatorIII {
+    public static void main(String[] args) {
+        System.out.println(calculate("1 + 1")==2);
+        System.out.println(calculate(" 6-4 / 2 ")==4);
+        System.out.println(calculate("2*(5+5*2)/3+(6/2+8)")==21);
+        System.out.println(calculate("(2+6* 3+5- (3*14/7+2)*5)+3")==-12);
+        System.out.println(calculate("1-(-7)")==8);
+    }
+    public static int calculate(String s) {
+        Deque<Long> operands = new ArrayDeque<>();
+        Deque<Integer> signs = new ArrayDeque<>();
+        //1 for +, -1 for -, 2 for * and  3 for /
+
+        int sign = 1;
+        for(int i=0; i<s.length(); i++) {
+            char c = s.charAt(i);
+            if(Character.isDigit(c)) {
+                long num = 0l;
+                while(i < s.length() && Character.isDigit(s.charAt(i))) {
+                    num = num*10 + (s.charAt(i)-'0');
+                    i++;
+                }
+                i--;
+                long res = operate(operands, sign, num);
+                operands.push(res);
+            } else if(c=='+') {
+                sign = 1;
+            } else if(c=='-') {
+                sign = -1;
+            } else if(c=='*') {
+                sign = 2;
+            } else if(c=='/') {
+                sign = 3;
+            } else if(c=='(') {
+                signs.push(sign);
+                operands.push(Long.MAX_VALUE);
+                sign = 1;
+            } else if(c==')') {
+                long sum = 0;
+                while(!operands.isEmpty() && operands.peek()!=Long.MAX_VALUE) {
+                    sum += operands.pop();
+                }
+                sign = signs.pop();
+                operands.pop();
+                long res = operate(operands, sign, sum);
+                operands.push(res);
+            }
+        }
+        int sum = 0;
+        while (!operands.isEmpty()) {
+            sum += operands.pop().intValue();
+        }
+
+        return sum;
+    }
+    public static long operate(Deque<Long> operands, int sign, long num) {
+        if(sign == 1) {
+            return num;
+        } else if(sign == -1) {
+            return -num;
+        } else if(sign == 2) {
+            return operands.pop() * num;
+        } else {
+            return operands.pop()/num;
+        }
+    }
+}

src/BasicCalculatorIII.java

@@ -0,0 +1,24 @@
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * There are N prisoners standing in a circle, waiting to be executed. The executions are carried out starting with
+ * the kth person, and removing every successive kth person going clockwise until there is no one left.
+ *
+ * Given N and k, write an algorithm to determine where a prisoner should stand in order to be the last survivor.
+ */
+public class DailyCoding225 {
+    public static void main(String[] args) {
+        System.out.println(lastStanding(5, 2) == 3);
+
+    }
+    public static int lastStanding(int N, int k) {
+        //Josephus problem
+        if(N == 1) {
+           return N;
+        }
+        //since we skipped k-1 people, we have to add them back so that the index is proper
+        // since module returns from 0 to N-1, add 1 to get the right index
+        return (lastStanding(N-1, k) + k-1)%N + 1;
+    }
+}

src/DailyCoding225.java

@@ -0,0 +1,43 @@
+/**
+ * Given a list of integers, write a function that returns the largest sum of
+ * non-adjacent numbers. Numbers can be 0 or negative.
+ *
+ * For example, [2, 4, 6, 2, 5] should return 13, since we pick 2, 6, and 5.
+ * [5, 1, 1, 5] should return 10, since we pick 5 and 5.
+ *
+ * Follow-up: Can you do this in O(N) time and constant space?
+ */
+public class DailyCoding9 {
+    public static void main(String[] args) {
+        System.out.println(largestSum(new int[]{2,4,6,2,5}) == 13);
+        System.out.println(largestSum(new int[]{5,1,1,5}) == 10);
+
+        System.out.println(largestSumOptimized(new int[]{2,4,6,2,5}) == 13);
+        System.out.println(largestSumOptimized(new int[]{5,1,1,5}) == 10);
+    }
+    public static int largestSum(int[] arr) {
+        int n = arr.length;
+        int[][] dp = new int[n+1][n+1];
+        for (int i=1; i<=n ; i++) {
+            //if we don't choose the ith number
+            dp[i][0] = Math.max(dp[i-1][1], dp[i-1][0]);
+
+            //if we choose the ith number
+            dp[i][1] = dp[i-1][0]+arr[i-1];
+        }
+
+        return Math.max(dp[n][0], dp[n][1]);
+    }
+    public static int largestSumOptimized(int[] arr) {
+        int n = arr.length;
+
+        int prevIncluded = 0, prevExcluded = 0;
+        for (int i=0; i<n; i++) {
+            int currExcluded = Math.max(prevIncluded, prevExcluded);
+            int currIncluded = arr[i] + prevExcluded;
+            prevExcluded = currExcluded;
+            prevIncluded = currIncluded;
+        }
+        return Math.max(prevExcluded, prevIncluded);
+    }
+}

src/DailyCoding9.java

@@ -0,0 +1,72 @@
+import java.util.*;
+
+/**
+ * We're given a hashmap associating each courseId key with a list of courseIds values,
+ * which represents that the prerequisites of courseId are courseIds. Return a sorted ordering
+ * of courses such that we can finish all courses.
+ *
+ * Return null if there is no such ordering.
+ *
+ * Leetcode 207
+ */
+public class DailyCoding92 {
+    public static void main(String[] args) {
+        HashMap<String, List<String>> courses = new HashMap<>();
+
+        List<String> list1 = new ArrayList<>();
+        list1.add("CSC100");
+        list1.add("CSC200");
+
+        courses.put("CSC300", list1);
+
+        List<String> list2 = new ArrayList<>();
+        list2.add("CSC100");
+        courses.put("CSC200", list2);
+
+        courses.put("CSC100", new ArrayList<>());
+
+        List<String> ordering = getCourseOrdering(courses);
+
+        if (ordering!=null){
+            Utility.printStr(ordering);
+        }
+    }
+
+    public static List<String> getCourseOrdering(HashMap<String, List<String>> courses) {
+        HashMap<String, Set<String>> prerequisites = new HashMap<>();
+        Deque<String> queue = new ArrayDeque<>();
+        for (Map.Entry<String, List<String>> entry : courses.entrySet()) {
+            if (entry.getValue().size()==0) {
+                queue.add(entry.getKey());
+            }
+            for (String course : entry.getValue()) {
+                if (!prerequisites.containsKey(course)) {
+                    prerequisites.put(course, new HashSet<>());
+                }
+                Set<String> set = prerequisites.get(course);
+                set.add(entry.getKey());
+                prerequisites.put(course, set);
+            }
+        }
+
+        List<String> result = new ArrayList<>();
+        while (!queue.isEmpty()){
+            String c = queue.poll();
+            result.add(c);
+
+            Set<String> dep = prerequisites.getOrDefault(c, new HashSet<>());
+            for (String s : dep) {
+                List<String> cs = courses.get(s);
+                cs.remove(c);
+                if (cs.size()==0) {
+                    queue.add(s);
+                } else {
+                    courses.put(s, cs);
+                }
+
+            }
+        }
+        return result.size()!=courses.size() ? null : result;
+    }
+
+}

src/DailyCoding92.java

@@ -0,0 +1,70 @@
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * Check if two expressions are equivalent
+ *
+ * -(a+b+c) is same as -a-b-c
+ * -(c+b+a) is same as -c-b-a
+ * a-b-(c-d) is not same as a-b-c-d
+ *
+ * Each operand appears only once. Operands are lower case variables a-z.
+ * Operators will be only + or -
+ */
+public class ExpressionEquivalence {
+    public static void main(String[] args) {
+        System.out.println(equals("-(a+b+c)", "-a-b-c"));
+        System.out.println(equals("a-b-(c-d)", "a-b-c-d"));
+        System.out.println(equals("a+((b)+(c))", "((b+c)+a)"));
+    }
+    public static boolean equals(String exp1, String exp2) {
+        Deque<Integer> stack = new ArrayDeque<>(); // 1 for +, -1 for -
+
+        int sign = 1;
+        int[] count = new int[26];
+        for(char c : exp1.toCharArray()) {
+            if (c=='+') {
+                sign = 1;
+            } else if (c=='-') {
+                sign = -1;
+            } else if (c=='(') {
+                stack.push(sign);
+                sign = 1;
+            } else if (c==')') {
+                sign = stack.pop();
+            } else {
+                int global = 1;
+                if (!stack.isEmpty()) {
+                    global = stack.peek();
+                }
+                count[c-'a'] += sign * global;
+            }
+        }
+        sign = 1;
+        for (char c : exp2.toCharArray()) {
+            if (c=='+') {
+                sign = 1;
+            } else if (c=='-') {
+                sign = -1;
+            } else if (c=='(') {
+                stack.push(sign);
+                sign = 1;
+            } else if (c==')') {
+                sign = stack.pop();
+            } else {
+                int global = 1;
+                if (!stack.isEmpty()) {
+                    global = stack.peek();
+                }
+                count[c-'a'] -= sign*global;
+            }
+        }
+
+        for (int n: count) {
+            if (n!=0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/ExpressionEquivalence.java

@@ -0,0 +1,69 @@
+/**
+ * A binary tree is level order sorted (Each level is sorted). Find a given node.
+ * It is a full binary tree. The left and right edges are sorted.
+ * Could you do better than O(n).
+ */
+public class FindNode {
+    public static void main(String[] args) {
+        TreeNode root = new TreeNode(1);
+
+        TreeNode left = new TreeNode(2);
+        left.left = new TreeNode(8);
+        left.right = new TreeNode(9);
+
+        TreeNode right = new TreeNode(3);
+        right.left = new TreeNode(10);
+        right.right = new TreeNode(11);
+
+        root.left = left;
+        root.right = right;
+
+        System.out.println(findNode(root, 10));
+        System.out.println(findNode(root, 6));
+    }
+    public static int findNode(TreeNode root, int val) {
+        if (root == null) {
+            return -1;
+        }
+
+        //find the level in which the element may appear
+        TreeNode tmp = root;
+        int level = 0;
+        while(tmp.left!=null && tmp.left.val <= val) {
+            tmp = tmp.left;
+            level++;
+        }
+
+        //Number of nodes in the level
+        int count = (int)Math.pow(2, level);
+
+
+        int start = 0, end = count-1;
+        while (start <= end) {
+            int mid = (start + end)/2;
+            int divPt = count/2; // this needs to be set everytime since we are traversing from root all over again
+            int pos = mid;
+            tmp = root;
+            for (int l=0; l<level; l++) {
+                int dir = pos/divPt;
+
+                if(dir == 0) {
+                    tmp = tmp.left;
+                } else {
+                    tmp = tmp.right;
+                    pos -= divPt;
+                }
+                divPt /= 2;
+            }
+
+            if (val == tmp.val) {
+                break;
+            } else if (val > tmp.val) {
+                start = mid+1;
+            } else {
+                end = mid -1;
+            }
+        }
+        return val == tmp.val ? val : -1;
+    }
+}