Added 4 solutions

Author: varunu28

Easy/Distribute Candies to People.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int[] distributeCandies(int candies, int num_people) {
+        int[] count = new int[num_people];
+        int idx = 0;
+        int currCount = 0;
+        int startCandy = 1;
+        
+        while (currCount < candies) {
+            count[idx++] += currCount + startCandy > candies ? candies - currCount : startCandy;
+            currCount += startCandy++;
+            if (idx == num_people) {
+                idx = 0;
+            }
+        }
+        
+        return count;
+    }
+}

Hard/Number of Valid Subarrays.java

@@ -0,0 +1,27 @@
+class Solution {
+    int count = 0;
+    public int validSubarrays(int[] nums) {
+        helper(nums, 0, 0, -1);
+        return count;
+    }
+
+    private void helper(int[] nums, int firstIdx, int idx, int left) {
+        if (idx - firstIdx > 1 || idx > nums.length - 1) {
+            return;
+        }
+
+        for (int i = idx; i < nums.length; i++) {
+            if (left == -1) {
+                count++;
+                helper(nums, i, i + 1, nums[i]);
+            }
+            else if (nums[i] < left) {
+                return;
+            }
+            else {
+                count++;
+                helper(nums, firstIdx, i + 1, left);
+            }
+        }
+    }
+}

Hard/Parsing A Boolean Expression.java

@@ -0,0 +1,72 @@
+class Solution {
+    public boolean parseBoolExpr(String expression) {
+        char[] chars = expression.toCharArray();
+        Stack<Character> operations = new Stack<>();
+        Stack<Character> boolValues = new Stack<>();
+
+        for (int i = 0; i < chars.length; i++) {
+            char c = chars[i];
+            if (c == '!' || c == '&' || c == '|') {
+                operations.push(c);
+            }
+            else if (c == '(') {
+                boolValues.push('#');
+            }
+            else if (c == 't' || c == 'f') {
+                boolValues.push(chars[i]);
+            }
+            else if (c == ',') {
+                continue;
+            }
+            else {
+                List<Character> list = new ArrayList<>();
+                while (!boolValues.isEmpty()) {
+                    char temp = boolValues.pop();
+                    if (temp == '#') {
+                        break;
+                    }
+
+                    list.add(temp);
+                }
+                
+                boolValues.push(performOperation(list, operations.pop()));
+            }
+        }
+
+        return boolValues.peek() == 't' ? true : false;
+    }
+
+    private Character performOperation(List<Character> list, Character operation) {
+        if (operation == '|') {
+            return performOr(list);
+        }
+        else if (operation == '&') {
+            return performAnd(list);
+        }
+        else {
+            return list.get(0) == 't' ? 'f' : 't';
+        }
+    }
+
+    private Character performAnd(List<Character> list) {
+        boolean val = getBooleanValue(list.get(0));
+        for (int i = 1; i < list.size(); i++) {
+            val &= getBooleanValue(list.get(i));
+        }
+
+        return val ? 't' : 'f';
+    }
+
+    private Character performOr(List<Character> list) {
+        boolean val = getBooleanValue(list.get(0));
+        for (int i = 1; i < list.size(); i++) {
+            val |= getBooleanValue(list.get(i));
+        }
+
+        return val ? 't' : 'f';
+    }
+
+    private boolean getBooleanValue(Character character) {
+        return character == 't' ? true : false;
+    }
+}

Medium/Binary Search Tree to Greater Sum Tree.java

@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode bstToGst(TreeNode root) {
+        inorderReverse(root, new int[]{0});
+        return root;
+    }
+    
+    private void inorderReverse(TreeNode root, int[] currVal) {
+        if (root == null) {
+            return;
+        }
+        
+        inorderReverse(root.right, currVal);
+        currVal[0] += root.val;
+        root.val = currVal[0];
+        inorderReverse(root.left, currVal);
+    }
+}