asdf

Author: Zanger67

Diff for: README.md

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode bstFromPreorder(int[] preorder) {
+        TreeNode root = new TreeNode(preorder[0]);
+        bstHelper(preorder, root, 1, Integer.MIN_VALUE, Integer.MAX_VALUE);
+
+        return root;
+    }
+
+    private int bstHelper(int[] preorder, TreeNode curr, int indx, int lowerbound, int upperbound) {
+        if (indx >= preorder.length) {
+            return indx;
+        }
+
+        if (lowerbound < preorder[indx] && preorder[indx] < curr.val) {
+            curr.left = new TreeNode(preorder[indx]);
+            indx = bstHelper(preorder, curr.left, indx + 1, lowerbound, curr.val);
+        }
+        
+        if (indx >= preorder.length) {
+            return indx;
+        }
+        
+        if (preorder[indx] < upperbound && preorder[indx] > curr.val) {
+            curr.right = new TreeNode(preorder[indx]);
+            indx = bstHelper(preorder, curr.right, indx + 1, curr.val, upperbound);
+        }
+
+        return indx;
+    }
+}

Diff for: my-submissions/m1008 Recursion.java

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+
+int bstHelper(int* preorder, int preorderSize, struct TreeNode* curr, int indx, int lowerbound, int upperbound) {
+    if (indx >= preorderSize) {
+        return indx;
+    }
+    
+    if (lowerbound < preorder[indx] && preorder[indx] < curr->val) {
+        curr->left = (struct TreeNode*) malloc(sizeof(struct TreeNode));
+        curr->left->val = preorder[indx];
+        curr->left->left = NULL;
+        curr->left->right = NULL;
+        indx = bstHelper(preorder, preorderSize, curr->left, indx + 1, lowerbound, curr->val);
+    }
+
+    if (indx >= preorderSize) {
+        return indx;
+    }
+    
+    if (preorder[indx] < upperbound && preorder[indx] > curr->val) {
+        curr->right = (struct TreeNode*) malloc(sizeof(struct TreeNode));
+        curr->right->val = preorder[indx];
+        curr->right->right = NULL;
+        curr->right->left = NULL;
+        indx = bstHelper(preorder, preorderSize, curr->right, indx + 1, curr->val, upperbound);
+    }
+
+    return indx;
+}
+
+struct TreeNode* bstFromPreorder(int* preorder, int preorderSize) {
+    struct TreeNode* root = (struct TreeNode*) malloc(sizeof(struct TreeNode));
+    root->val = preorder[0];
+    root->left = NULL;
+    root->right = NULL;
+    bstHelper(preorder, preorderSize, root, 1, INT_MIN, INT_MAX);
+    return root;
+}

Diff for: my-submissions/m1008.c

@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* bstFromPreorder(vector<int>& preorder) {
+        TreeNode* root = new TreeNode(preorder[0]);
+        bstHelper(preorder, root, 1, INT_MIN, INT_MAX);
+        return root;
+    }
+
+    int bstHelper(vector<int>& preorder, TreeNode* curr, int indx, int lowerbound, int upperbound) {
+        if (indx >= preorder.size()) {
+            return indx;
+        }
+        
+        if (lowerbound < preorder[indx] && preorder[indx] < curr->val) {
+            curr->left = new TreeNode(preorder[indx]);
+            indx = bstHelper(preorder, curr->left, indx + 1, lowerbound, curr->val);
+        }
+
+        if (indx >= preorder.size()) {
+            return indx;
+        }
+
+        if (preorder[indx] < upperbound && preorder[indx] > curr->val) {
+            curr->right = new TreeNode(preorder[indx]);
+            indx = bstHelper(preorder, curr->right, indx + 1, curr->val, upperbound);
+        }
+        
+
+        return indx;
+    }
+};

Diff for: my-submissions/m1008.cpp

@@ -0,0 +1,24 @@
+class Solution {
+    public int[] distinctNumbers(int[] nums, int k) {
+        int[] output = new int[nums.length - k + 1];
+        HashMap<Integer, Integer> window = new HashMap<>();
+
+        for (int i = 0; i < k - 1; i++) {
+            window.put(nums[i], window.getOrDefault(nums[i], 0) + 1);
+        }
+
+        for (int i = k - 1; i < nums.length; i++) {
+            window.put(nums[i], window.getOrDefault(nums[i], 0) + 1);
+
+            output[i - k + 1] = window.size();
+
+            if (window.get(nums[i - k + 1]) == 1) {
+                window.remove(nums[i - k + 1]);
+            } else {
+                window.put(nums[i - k + 1], window.get(nums[i - k + 1]) - 1);
+            }
+        }
+
+        return output;
+    }
+}

Diff for: my-submissions/m1852.java

@@ -0,0 +1,9 @@
+int triangularSum(int* nums, int numsSize) {
+    for (int i = 0; i < numsSize; i++) {
+        for (int j = 0; j < numsSize - i - 1; j++) {
+            nums[j] = (nums[j] + nums[j + 1]) % 10;
+        }
+    }
+
+    return nums[0] % 10;
+}

Diff for: my-submissions/m2221.c

@@ -0,0 +1,11 @@
+class Solution {
+    public int triangularSum(int[] nums) {
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = 0; j < nums.length - i - 1; j++) {
+                nums[j] = (nums[j] + nums[j + 1]) % 10;
+            }
+        }
+
+        return nums[0] % 10;
+    }
+}