Random questions

src/advance/WorkingWithStrings.java

@@ -83,9 +83,6 @@ public static void playWithFile() {
         System.out.println();
     }
 
-    public static void main(String[] args) {
-
-    }
 
     private static void randomStrings() {
         String s1 = "Mickey;Bolton;12345;121216";
@@ -95,7 +92,7 @@ private static void randomStrings() {
         String str = "the lazy fox jumped over the brown fence";
 
         StringTokenizer tokenizer = new StringTokenizer(str);
-        while (tokenizer.hasMoreTokens()){
+        while (tokenizer.hasMoreTokens()) {
             System.out.println(tokenizer.nextToken());
         }
 //        System.out.println(Arrays.toString(s2.split("\\|")));
@@ -110,20 +107,99 @@ private static void randomStrings() {
         String datestring = "2015年11月17日";
         System.out.println(
                 datestring.substring(0, 4) +
-                        "-"+datestring.substring(5, 7) + "-"+
+                        "-" + datestring.substring(5, 7) + "-" +
                         datestring.substring(8, 10));
 
         String trimming = "      Peter is a workaholic  ";
         System.out.println(trimming.trim());
         long length = trimming.codePoints().count();
         int leng = trimming.length();
-        System.out.println("Length: "+length + " leng: "+ leng);
+        System.out.println("Length: " + length + " leng: " + leng);
     }
 
-    public static void dateTimeType(){
+    public static void dateTimeType() {
         System.out.println(new SimpleDateFormat("yyyy/MM/dd hh:mm.ss")
                 .format(Calendar.getInstance().getTime()));
     }
+
+    // https://leetcode.com/problems/baseball-game/description/
+    // O(N)
+    public static int baseballGame(String[] operations) {
+        Stack<Integer> ball = new Stack<>();
+
+        for (String ops : operations) {
+            switch (ops) {
+                case "+" -> ball.push(ball.peek() + ball.elementAt(ball.size() - 2));
+                case "D" -> ball.push(2 * ball.peek());
+                case "C" -> ball.pop();
+                default -> ball.push(Integer.parseInt(ops));
+            }
+        }
+        // Sum all the stack's elements as long it is not empty
+        int sum = 0;
+        while (!ball.isEmpty()) {
+            sum += ball.pop();
+        }
+        return sum;
+    }
+
+    // https://leetcode.com/problems/valid-parentheses/description/
+    public static boolean isValid(String s) {
+
+        Stack<Character> stack = new Stack<>();
+
+        for (char chr : s.toCharArray()) {
+            if (chr == '{')
+                stack.push('}');
+            else if (chr == '(')
+                stack.push(')');
+            else if (chr == '[')
+                stack.push(']');
+            else if (stack.isEmpty() || stack.pop() != chr)
+                return false;
+        }
+        return stack.isEmpty();
+    }
+
+    // https://leetcode.com/problems/1-bit-and-2-bit-characters/description/
+    public boolean isOneBitCharacter(int[] bits) {
+        int i = 0, end = bits.length - 1;
+        while (i < end) {
+            if (bits[i] != 0)
+                i++;
+            i++;
+        }
+        return i == end;
+    }
+
+    // https://leetcode.com/problems/a-number-after-a-double-reversal/description/
+    public boolean isSameAfterReversals(int num) {
+        return num <= 9 && num % 10 != 0;
+    }
+
+    // https://leetcode.com/problems/account-balance-after-rounded-purchase/
+    public int accountBalanceAfterPurchase(int purchaseAmount) {
+        if (purchaseAmount % 10 >= 5)
+            purchaseAmount += 10 - purchaseAmount % 10;
+        else
+            purchaseAmount -= purchaseAmount % 10;
+        return 100 - purchaseAmount;
+    }
+
+    // https://leetcode.com/problems/integer-to-roman/description/
+    public String intToRoman(int num){
+        String[] ones = {"","I","II","III","IV","V","VI","VII","VIII","IX"};
+        String[] tens = {"","X","XX","XXX","XL","L","LX","LXX","LXXX","XC"};
+        String[] hrns = {"","C","CC","CCC","CD","D","DC","DCC","DCCC","CM"};
+        String[] ths ={"","M","MM","MMM"};
+        return ths[num / 1000] +
+                hrns[(num % 1000) / 100] +
+                tens[(num % 100) / 10] +
+                ones[num % 10];
+    }
+    public static void main(String[] args) {
+        System.out.println(101 % 9);
+    }
 }
 
 

src/advance/linkedlist/LeetCodingLinkedList.java

@@ -187,9 +187,7 @@ public boolean isHappy(int n) {
             fast = squareOfDigits(squareOfDigits(n));
         } while (slow != fast);
 
-        if (slow == 1)
-            return true;
-        return false;
+        return slow == 1;
     }
 
     // Find square of digits

src/advance/trees/BinaryTree.java

@@ -21,6 +21,35 @@ public Node(int data) {
 public class BinaryTree {
     Node root;
 
+
+    public int heightOfTheTree(Node node){
+        if (node == null)
+            return 0;
+        return 1 + Math.max(heightOfTheTree(node.left),
+                heightOfTheTree(node.right));
+    }
+
+    public int sizeOfTheTree(Node node){
+        if (node == null) return 0;
+        return (sizeOfTheTree(node.left) + sizeOfTheTree(node.right)) + 1;
+    }
+
+    public int countLeaves(Node node){
+        if (node == null)
+            return 0;
+        if(node.left == null && node.right == null)
+            return 1;
+       return countLeaves(node.left) + countLeaves(node.right);
+    }
+
+    public int countNonLeaves(Node node){
+        if (node == null || (node.left == null && node.right == null))
+            return 0;
+        int count = 1;
+        count += countLeaves(node.left);
+        count += countLeaves(node.right);
+        return count;
+    }
     // Pre order traversal
     public void preOrder(Node node) {
         if (node == null)
@@ -194,6 +223,19 @@ public int sumOfLeftLeaves(Node root){
         return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
     }
 
+    // Check if the node is a leaf
+    public boolean isLeaf(Node node){
+        if (node == null)
+            return false;
+        return node.left == null || node.right == null;
+    }
+
+    public boolean isRootNode(Node node){
+        if(node == null)
+            return false;
+        return node.left != null && node.left != null;
+
+    }
     private static void printer() {
         BinaryTree bTree = new BinaryTree();
         bTree.root = new Node(3);
@@ -212,5 +254,6 @@ private static void printer() {
 
         System.out.println("postOrder Traversal");
         bTree.postOrder(bTree.root);
+        System.out.println(bTree.isRootNode(bTree.root.right));
     }
 }

src/intermediate/CyclicSort.java

@@ -81,12 +81,74 @@ public static int findDuplicate(int[] nums) {
                     int temp = nums[i];
                     nums[i] = nums[correctIndex];
                     nums[correctIndex] = temp;
-                } else return nums[i];
+                } else
+                    return nums[i];
             } else i++;
         }
         return -1;
     }
 
+    // https://leetcode.com/problems/first-missing-positive/
+    public int firstMissingPositive(int[] nums) {
+        int i = 0;
+        int n = nums.length;
+
+        while (i < n) {
+            int correctIndex = nums[i] - 1;
+            if (nums[i] > 0 && nums[i] <= n && nums[i] != nums[correctIndex]) {
+                swap(nums, i, correctIndex);
+            } else i++;
+        }
+        for (int index = 0; index < n; index++) {
+            if (nums[index] != index + 1)
+                return index + 1;
+        }
+        return n + 1;
+    }
+
+    // https://leetcode.com/problems/missing-number/
+    public int missingNumber(int[] nums){
+        int i = 0;
+        int n = nums.length;
+        while (i < n){
+            int correctIndex=nums[i]; // from zero
+            if (nums[i] < n && nums[i] != nums[correctIndex]){
+                swap(nums, i, correctIndex);
+            }else i++;
+        }
+        for (int index = 0; index < n; index++){
+            if (nums[index] != index)
+                return index;
+        }
+        return n;
+    }
+
+    // https://leetcode.com/problems/find-all-duplicates-in-an-array/
+    public List<Integer> findDuplicates(int[] nums) {
+        int i = 0;
+        int n = nums.length;
+
+        while(i < n){
+            int correct = nums[i] - 1;
+
+            if (nums[i] != nums[correct]){
+                swap(nums, i, correct);
+            }else i++;
+        }
+        List<Integer> result = new ArrayList<>();
+        for (int index = 0; index < n; index++){
+            if (nums[index] != index + 1){
+                result.add(nums[index]);
+            }
+        }
+        return result;
+    }
+    private static void swap(int[] nums, int a, int b) {
+        int temp = nums[a];
+        nums[a] = nums[b];
+        nums[b] = temp;
+    }
+
     public static void main(String[] args) {
         int[] nums = {1, 1};
         System.out.println(findDuplicate(nums));

src/intermediate/Searching.java

@@ -42,15 +42,13 @@ public static int[] twoSum(int[] nums, int target) {
                 ans[0] = start + 1;
                 ans[1] = end + 1;
                 break;
-            }
-            else if (sum > target) {
+            } else if (sum > target) {
                 end--;
-            }
-            else {
+            } else {
                 start++;
             }
         }
-         return ans;
+        return ans;
     }
 
 //        int start = 0, end = nums.length - 1;
@@ -101,13 +99,12 @@ public static int binarySearch(int[] nums, int target) {
         while (start <= end) {
             int mid = start + (end - start) / 2;
 
-            if (target == nums[mid]) {
-                return mid;
-            } else if (target < nums[mid]) {
+            if (target < nums[mid])
                 end = mid - 1;
-            } else {
+            else if (target > nums[mid])
                 start = mid + 1;
-            }
+            else
+                return mid;
         }
         return -1;
     }
@@ -131,8 +128,7 @@ public static int orderAgnosticBinarySearch(int[] nums, int target) {
                     end = mid - 1;
                 else
                     start = mid + 1;
-            }
-            else {
+            } else {
                 if (target > nums[mid])
                     end = mid - 1; // move to left
                 else

src/oops/sub/Human.java

@@ -1,2 +1,66 @@
-package oops.sub;public class Human {
+package oops.sub;
+
+public class Human {
+
+    int age;
+    String name;
+    double salary;
+    boolean isMarried;
+    static int POPULATION = 0;
+
+    public Human() {
+    }
+
+    public Human(String name, int age, double salary, boolean isMarried) {
+        this.name = name;
+        this.age = age;
+        this.salary = salary;
+        this.isMarried = isMarried;
+        POPULATION += 1;
+    }
+
+    @Override
+    public String toString() {
+        return "Human{" +
+                "age=" + age +
+                ", name='" + name + '\'' +
+                ", salary=" + salary +
+                ", isMarried=" + isMarried +
+                '}';
+    }
+
+    static class Test {
+        String test = "Testing";
+
+        public String test(String name) {
+            return name + " is " + this.test;
+        }
+    }
+
+    public static void main(String[] args) {
+        Singleton singleton = Singleton.getInstance();
+        System.out.println(singleton.name());
+
+    }
 }
+
+class Chinese extends Human {
+
+    String language;
+
+    public Chinese() {
+        super("Chinese", 73, 40000, true);
+    }
+
+    public Chinese(String language) {
+        this.language = language;
+    }
+}
+
+class Cantonese extends Human {
+
+
+    public Cantonese(String name, int age, double salary, boolean married) {
+        super(name, age, salary, married);
+    }
+}