52 | )
53 | }
54 |
55 | ReactDOM.render(, document.getElementById('root'))
56 |
57 | */
58 |
59 | /*
60 | .App {
61 | font-family: monospace;
62 | display: flex;
63 | flex-direction: column;
64 | background-color: black;
65 | width: 300px;
66 | height: 400px;
67 | box-sizing: border-box;
68 | }
69 |
70 | .numberDisplay {
71 | height: 100px;
72 | }
73 |
74 | .buttonsDisplay {
75 | display: flex;
76 | flex-direction: row;
77 | flex-wrap: wrap;
78 | justify-content: space-around;
79 | width: 150px;
80 | }
81 |
82 | .circle {
83 | border-radius: 50%;
84 | width: 3em;
85 | height: 3em;
86 | }
87 |
88 |
89 | .orangebg {
90 | background-color: orange;
91 | }
92 |
93 | .darkGreyBg {
94 | background-color: darkgrey;
95 | color: white;
96 | text-align: center;
97 | padding-top: 1em;
98 | }
99 | */
--------------------------------------------------------------------------------
/AlgoMarathon/Strings/BackSpaceStringCompare.js:
--------------------------------------------------------------------------------
1 | /*
2 | Algo: Backspace String Compare
3 |
4 | Given two strings s and t, return true if they are equal when both are typed into empty text editors. '#' means a backspace character.
5 |
6 | Note that after backspacing an empty text, the text will continue empty.
7 |
8 | Example 1:
9 |
10 | Input: s = "ab#c", t = "ad#c"
11 | Output: true
12 | Explanation: Both s and t become "ac".
13 | Example 2:
14 |
15 | Input: s = "ab##", t = "c#d#"
16 | Output: true
17 | Explanation: Both s and t become "".
18 | Example 3:
19 |
20 | Input: s = "a#c", t = "b"
21 | Output: false
22 | Explanation: s becomes "c" while t becomes "b".
23 |
24 | */
25 |
26 | //Attempt 1 (failed) - the following is the brute force approach from other submission on Leetcode
27 |
28 | var backspaceCompare = function(s, t) {
29 | let firstString = '';
30 | let secondString = '';
31 |
32 | for(let i = 0; i < s.length; i++) {
33 | const char = s[i];
34 | if(char !== '#') {
35 | firstString += char;
36 | } else {
37 | firstString = firstString.slice(0, -1);
38 | }
39 | }
40 |
41 | for(let i = 0; i < t.length; i++) {
42 | const char = t[i];
43 | if(char !== '#') {
44 | secondString += char;
45 | } else {
46 | secondString = secondString.slice(0, -1);
47 | }
48 | }
49 |
50 | return firstString === secondString;
51 | };
52 |
53 | /*
54 | Progress Notes:
55 |
56 | Time: O(s^2 + t^2) Space: O(1)
57 | There is an iteration of the entire string (O(n) time) and the nested js ".slice" method is considered a O(n) time complexity
58 |
59 | 25mins: I have used the time to try to code out the O(s + t) time and O(1) space approach but with no success.
60 | Then, I try to see if I can just solve the problem, but I think I am not progressing at all.
61 |
62 | 5mins: reviewed through the solution generally and review through one of the submission that I find a little easier to understand
63 | But the time complexity is not good.
64 |
65 | Future attempts:
66 | - solve the problem with O(s + t) time and O(1) space
67 | - review the solution in Leetcode to fully understand the pattern
68 |
69 | */
--------------------------------------------------------------------------------
/CoreAlgos/Array/Sort/insertion.js:
--------------------------------------------------------------------------------
1 | /*
2 | Q. Given an unsorted array, perform insertion sort in ascending order.
3 |
4 | Examples:
5 | • Given an array: [1] // returns [1]
6 | • Given an array: [3, 1, 2, 4] // returns [1, 2, 3, 4]
7 |
8 | */
9 |
10 | function insertionSort(array) {
11 |
12 | }
13 |
14 | // Test Cases
15 | console.log(insertionSort([])) // []
16 | console.log(insertionSort([1])) // [1]
17 | console.log(insertionSort([3, 1, 2, 4])) // [1, 2, 3, 4]
18 | // console.log(insertionSort([-10, 1, 3, 8, -13, 32, 9, 5])) // [-13, -10, 1, 3, 5, 8, 9, 32]
19 |
20 |
21 | //----------------------------------------------------------------------------------
22 |
23 | //Approaches:
24 |
25 | /*
26 |
27 | 3 1 2 4 0
28 | i
29 | k
30 | j
31 | 0 1 2 3 4
32 |
33 | 1 2 3 4
34 |
35 | 0 1 2 3 4 5
36 |
37 | Time: O(N^2)
38 |
39 | */
40 |
41 | function insertionSort(array) {
42 | for (let i = 1; i < array.length; i++) {
43 | let key = array[i];
44 | // console.log("Key: ", key);
45 | let j = i - 1;
46 | // console.log("i:", i);
47 | // console.log("j:", j);
48 | while (j >= 0 && array[j] > key) {
49 | array[j + 1] = array[j];
50 | // console.log("array[j]:", array[j]);
51 | // console.log("array[j + 1]:", array[j + 1]);
52 | j = j - 1;
53 | // console.log("j:", j);
54 | }
55 | array[j + 1] = key;
56 | // console.log("j:", j);
57 | // console.log("array[j + 1]:", array[j + 1]);
58 | }
59 | // console.log("array:", array);
60 | return array;
61 | }
62 |
63 |
64 | /* Another Approach learned from Pair Programmer */
65 |
66 | /* Pair Learning Solution from Kedir using Java*/
67 | /*
68 | class Solution {
69 | public static void main(String[] args) {
70 | int[]input = new int[] {};
71 | insertionSort(input);
72 | System.out.println(Arrays.toString(input));
73 |
74 | }
75 |
76 | public static void insertionSort(int[]arr){
77 | if(arr.length<=1){
78 | return;
79 | }
80 | for(int i=0 ; i0 && arr[j] cannot begin with negative num
89 | negative num should not exist
90 |
91 |
92 |
93 |
94 | 1
95 | () = 1
96 |
97 | 1-1
98 |
99 | 2
100 | ()(), (()) = 2
101 | 1-1+1-1. 1+1-1-1
102 |
103 | 3
104 | ((())),()()(),(()()),(())(),()(()) = 5
105 |
106 |
107 |
108 |
109 |
110 | */
111 |
--------------------------------------------------------------------------------
/AlgoMarathon/BinaryTree/LowestCommonAncestor.js:
--------------------------------------------------------------------------------
1 | /* 07-03-22
2 | Q. Given a binary tree, find the lowest common ancestor of two given nodes in the tree and return its value.
3 |
4 | A node can be its own ancestor.
5 | Examples:
6 |
7 | Given a binary tree:
8 | 10
9 | / \
10 | 5 12
11 | / \ /
12 | 3 6 11
13 | For node1: 3, node2: 6 // returns 5
14 | For node1: 11, node2: 6 // returns 10
15 | [execution time limit] 4 seconds (js)
16 |
17 | [input] tree.integer root
18 |
19 | [input] integer val1
20 |
21 | [input] integer val2
22 |
23 | [output] integer
24 |
25 | lowest common ancestor
26 |
27 | post order tree traversal
28 |
29 | */
30 |
31 |
32 | //
33 | // Binary trees are already defined with this interface:
34 | class TreeNode {
35 | constructor(value, left = null, right = null) {
36 | this.value = value;
37 | this.left = left;
38 | this.right = right;
39 | }
40 | }
41 | function solution(root, val1, val2) {
42 |
43 | function dfs(node) {
44 | // console.log("node: ", node);
45 | //base case
46 | if (!node) {
47 | return null;
48 | }
49 | if (node.value === val1 || node.value === val2) {
50 | return node;
51 | }
52 | //recursive case
53 | let left = dfs(node.left); //5
54 | let right = dfs(node.right);
55 | // console.log("LEFT: ", left);
56 | // console.log("RIGHT: ", right);
57 |
58 | //merge case
59 | if (!left && !right) {//no val1 or val2 match found
60 | return null;
61 | }
62 | if (left && right) { //lowest common ancestor is found
63 | // console.log('common ancestor here: ', node);
64 | return node;
65 | }
66 | return left || right; //if one of them is found, return the one with the match
67 | //if left is null, return right, else return left
68 | }
69 | return dfs(root).value;
70 | }
71 |
72 | const tree1 = new TreeNode(10,
73 | new TreeNode(5,
74 | new TreeNode(3),
75 | new TreeNode(6)),
76 | new TreeNode(12,
77 | new TreeNode(11),
78 | null))
79 | console.log(solution(tree1, 3, 6)); //5
80 |
--------------------------------------------------------------------------------
/AlgoWorkout/Temi/05-10-22.js:
--------------------------------------------------------------------------------
1 | /*
2 | Given a binary tree, return the deepest node (furthest away child).
3 |
4 | Examples
5 | . a
6 | . / \
7 | . b c
8 | . /
9 | .d.
10 | returns d
11 |
12 | equal depth in both right and left - return one of them
13 |
14 |
15 | Depth (global variable)
16 |
17 |
18 | Approach#1 (Better than Approach#2): DFS + Natural Stack (Depth = height of the stack) (top to down)
19 | Time: O(n) n = num of nodes in the tree
20 | Space: O(h) h = height of the tree (worst case) | best case: O(logh) for balanced tree
21 |
22 | DFS Approach
23 | create a Stack, greatestLength, deepestNode
24 | currentNode = root
25 | push the root into the stack
26 | loop while stack != null
27 | if there is a left node, push to the stack, currentNode = LeftNode
28 | stack.length > greatestLength ,
29 | greatestLength = stack.length
30 | update deepestNode to currentNode value
31 | else if there is a right, push to the stack, currentNode = RightNode
32 |
33 |
34 |
35 | Approach#2 (as the number of nodes increase, will quickly run out of memory): DFS + Recursive Stack (Depth = passed from function to function) callstacks
36 | Time: O(n)
37 | Space: O(h)
38 |
39 |
40 |
41 | Alternative Solution:
42 |
43 | Approach #3: BFS (width - Left to right)
44 | Queue (FIFO)
45 | The deepest node is the last node
46 | Time: O(n) n = num of nodes in the tree
47 | Space: O(w)
48 |
49 | /*
50 | BFS Approach
51 |
52 | 1. initialize a queue
53 | 2. loop while queue.length > 0
54 | 3. push left & right nodes into queue if they exist
55 | 4. return the last node queue[queue.length - 1]
56 |
57 | */
58 |
59 |
60 | // Function Signature
61 | class TreeNode {
62 | constructor(value = 0, leftChild = null, rightChild = null) {
63 | this.value = value;
64 | this.left = leftChild;
65 | this.right = rightChild;
66 | }
67 | }
68 |
69 |
70 | // function deepestNode(root)
71 |
72 |
73 |
74 | function BFS(root){
75 | const q = root ? [root] : []
76 |
77 | let deepest = null
78 | while(q.length > 0){
79 | let node = q.shift()
80 |
81 | node.left && q.push(node.left)
82 | node.right && q.push(node.right)
83 | }
84 | return deepest
85 | }
86 |
87 | let tree1 = new TreeNode('a', new TreeNode('b', new TreeNode('c', new TreeNode('d'))))
88 | console.log(BFS(tree1))
--------------------------------------------------------------------------------
/CoreAlgos/LinkedList/1_Accumulating/count.js:
--------------------------------------------------------------------------------
1 | /*
2 | Q1. Given an unsorted linked list, count the number of elements (iteratively or recursively).
3 |
4 | Examples:
5 | • Given a linked list: 1 ➞ 4 ➞ 5 // returns 3
6 | • Given a linked list: 0 // returns 1
7 | */
8 |
9 | class ListNode {
10 | constructor(value = 0, next = null) {
11 | this.value = value
12 | this.next = next
13 | }
14 | }
15 |
16 | function count(head) {
17 | // Write your code here.
18 | }
19 |
20 | // Test Cases
21 | const LL1 = new ListNode(1, new ListNode(4, new ListNode(5)))
22 | console.log(count(null)) // 0
23 | console.log(count(LL1)) // 3
24 | console.log(count(new ListNode())) // 1
25 |
26 |
27 |
28 | //----------------------------------------------------------------------------------
29 |
30 | //Approaches:
31 |
32 | /*
33 | Higher Order Overview:
34 |
35 | Iterative:
36 | Declared a curr pointer and assigned it to the head of the linked list.
37 | While iterating through the linked list, increment the count until
38 | the pointer reaches the end of the linked list.
39 |
40 | */
41 |
42 | //Iterative Approach (uncomment below and see how it works in the console)
43 |
44 | function countIterative(head) {
45 | let curr = head;
46 | let count = 0;
47 | while (curr) {
48 | count++;
49 | curr = curr.next;
50 | }
51 | console.log("curr :", curr); // null
52 | console.log("head :", head); // the entire linked list
53 | return count;
54 | }
55 |
56 | //UNCOMMENT BELOW TO TEST:
57 | // const LL2 = new ListNode(1, new ListNode(4, new ListNode(5)))
58 | // console.log(countIterative(null)) // 0
59 | // console.log(countIterative(LL2)) // 3
60 | // console.log(countIterative(new ListNode())) // 1
61 |
62 |
63 | //Recursive Approach (uncomment below and see how it works in the console)
64 |
65 | function countRecursive(head) {
66 | if (!head) return 0;
67 | console.log("head :", head); //going through each node
68 | return 1 + countRecursive(head.next);
69 | }
70 |
71 | //UNCOMMENT BELOW:
72 | // const LL3 = new ListNode(1, new ListNode(4, new ListNode(5)))
73 | // console.log(countRecursive(null)) // 0
74 | // console.log(countRecursive(LL3)) // 3
75 | // console.log(countRecursive(new ListNode())) // 1
76 |
77 |
78 |
79 | /*
80 | Time Complexity (runtime): O(n)
81 |
82 | Space Complexity (memory): O(1)
83 |
84 | */
85 |
86 |
87 |
--------------------------------------------------------------------------------
/AlgoWorkout/Vinit/06-29-22.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | Define a subsequence of a string s to be a list of characters from s such that the characters appear in the same order in the list and in s.
4 |
5 | For instance, for the string abcd, a, ab, and acd are valid subsequences, whereas db is not, since b comes before d in the original string.
6 |
7 | Given an input string, return all subsequences of the string.
8 |
9 | Example:
10 |
11 | getAllSubsequences("abc") == [
12 | "a",
13 | "b",
14 | "c",
15 | "ab",
16 | "ac",
17 | "bc",
18 | "abc",
19 | ]
20 |
21 | - imagine you have a magic function that sovles your problem for the N-1
22 | - what would you do with the output of said magic function to get to the answer for your N input
23 |
24 | magicFunction("bc") =>
25 |
26 | ['b', 'c', 'bc']
27 | ['ab', 'ac', 'abc']
28 | concat both together
29 |
30 | call self with 1, str.length
31 |
32 | the result from that call we want to append each el
33 | to the char we're on and concatenate the two arrays
34 |
35 | output size => 2^n
36 |
37 | time complexity: 2^N
38 | space complexity: N
39 | where N is the length of the input string
40 |
41 | all subsequences []
42 |
43 | getAllSubsequences('abc')
44 | getAllSubsequences('bc')
45 | getAllSubsequences('c')
46 |
47 | function(n)
48 | var = function(n-1)
49 | return var + 1
50 |
51 | include a
52 | include b
53 | include c => abc
54 | exclude c => ab
55 | exclude b
56 | include c => ac
57 | exclude c => a
58 |
59 | exclude a
60 | include b
61 | include c => bc
62 | exclude c => b
63 | exclude b
64 | include c => c
65 | exclude c => ''
66 |
67 | root
68 | yes a no a
69 | yes b no b yes b no b
70 | yes c no c yes c no c yes c no c yes c no c
71 |
72 |
73 |
74 | '''
75 |
76 | def getAllSubsequences(input):
77 | if len(input) == 1:
78 | return [input]
79 |
80 | result = [input[0]]
81 |
82 | for element in getAllSubsequences(input[1:]):
83 | result.append(element)
84 | result.append(input[0] + element)
85 |
86 | return result
87 |
88 | print(len(getAllSubsequences("abcdef")))
--------------------------------------------------------------------------------
/AlgoMockedInterview/AdvancedArray/numberOfIslands_practice.js:
--------------------------------------------------------------------------------
1 | /*
2 | Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.
3 |
4 | An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
5 |
6 | Input: grid = [
7 | ["1","1","1","1","0"],
8 | ["1","1","0","1","0"],
9 | ["1","1","0","0","0"],
10 | ["0","0","0","0","0"]
11 | ]
12 | Output: 1
13 |
14 |
15 | Input: grid = [
16 | ["1","1","0","0","0"],
17 | ["1","1","0","0","0"],
18 | ["0","0","1","0","0"],
19 | ["0","0","0","1","1"]
20 | ]
21 | Output: 3
22 |
23 | */
24 |
25 | /*
26 | High level Understanding and Breaking down the problem in English USING DFS RECURSIVE APPROACH:
27 | - Iterate through the entire grid
28 | - If we encounter '1', we increment the counter by 1 since it is the first island we found
29 | - Then you want to explore how big this island is
30 | - You will then use DFS recursion method to search in four different directions for all the lands assoicated with the island (top, down, left, and right)
31 | - Make a mark once we have visited the land (instead of creating a separate visited variable, you can use flip it to '0' as an indicator that the land is already visited - based on this problem, we do not need to keep track of how how visited land)
32 | - return the number of islands (based on the counter)
33 | ___
34 |
35 | Time: O(r * c) number of elements on each row and each column of the input array
36 | Space: O(r * c) Using recursive call stack will take linear space for both visited rows and columns
37 |
38 | */
39 |
40 | var numIslands = function(grid) {
41 | let count = 0;
42 | let rowLen = grid.length;
43 | let colLen = grid[0].length;
44 |
45 | function dfs(row, col, grid) {
46 | if (row < 0 || col < 0 || row >= rowLen || col >= colLen || grid[row][col] === '0') {
47 | return;
48 | }
49 | grid[row][col] = '0'
50 | dfs(row, col + 1, grid);
51 | dfs(row + 1, col, grid);
52 | dfs(row, col - 1, grid);
53 | dfs(row - 1, col, grid);
54 | }
55 | for (let i = 0; i < rowLen; i++) {
56 | for (let j = 0; j < colLen; j++) {
57 | if (grid[i][j] === '1') {
58 | count++;
59 | dfs(i, j, grid);
60 | }
61 |
62 | }
63 | }
64 | return count;
65 | };
--------------------------------------------------------------------------------
/AlgoWorkout/Vinit/05-04-22.js:
--------------------------------------------------------------------------------
1 | /*
2 | Stack Type Problem (looks like easy but actually really hard!!)
3 |
4 | Given a list of daily temperatures T, return a list such that, for each day in the input, tells you how many days you would have to wait until a warmer temperature.
5 |
6 | Example:
7 |
8 | Given the list of temperatures T = [73, 74, 75, 71, 69, 72], your output should be [1, 1, 0, 2, 1, 0].
9 |
10 |
11 | outer loop goes through each temperature
12 | inner loop counts while there isnt a greater temperature
13 | increments a counter
14 |
15 |
16 | [74, 72, 69, 68, 70]
17 | 2 1 0
18 |
19 |
20 | Create a stack of array indices. Iterate through the array.
21 | At each position, compare two values: the value at current index we are processing in the array, and the value at the index at the top of the stack. If the current element is larger, set the value in the answers array as the difference between the current index in the last index of the stack. Repeat this until the current value is larger than the value at last index of the stack. Append the current index to the stack and move on to the next element in the array.
22 |
23 | [73, 74, 75, 71, 69, 72]
24 | */
25 |
26 | // stack: [2, 5]
27 | // result: [1, 1, _, 2, 1]
28 | // i: 6
29 | // curItem: 72
30 |
31 | // while(stack.length > 0 && 75 < 72)
32 | // stackTop: 3
33 | // result[1] => 2 - 1
34 |
35 | function findWarmerV2(temps) {
36 | const stack = [];
37 | const result = new Array(temps.length).fill(0);
38 |
39 | for (let i = 0; i < temps.length; i++) {
40 | const curItem = temps[i];
41 |
42 | while(stack.length > 0 && temps[stack[stack.length - 1]] < curItem) {
43 | const stackTop = stack[stack.length - 1];
44 | result[stackTop] = i - stackTop;
45 | stack.pop();
46 | }
47 | stack.push(i);
48 | }
49 |
50 | return result;
51 | }
52 |
53 |
54 | function findWarmer(temps){
55 | let result = [];
56 |
57 | for (let i = 0; i < temps.length; i++){
58 | const curTemp = temps[i];
59 | let j = i+1;
60 |
61 | while (curTemp >= temps[j] && j < temps.length){
62 | j++
63 | }
64 |
65 | result.push(j >= temps.length ? 0 : j-i);
66 | }
67 |
68 | return result;
69 | }
70 |
71 | // i: 2
72 | // curTemp: 75
73 | // j: 6
74 |
75 | // while (75 >= 72 && j < 6)
76 |
77 |
78 | // result: [1, 1, 0]
79 |
80 | console.log(findWarmerV2([73, 74, 75, 71, 69, 72])); // [1, 1, 0, 2, 1, 0]
--------------------------------------------------------------------------------
/1-on-1-w-Mentor-Fellow/TriePerspective_w_Mitch.js:
--------------------------------------------------------------------------------
1 | /*
2 | This is a super great session to look at how Mitch visualize the Trie data structure
3 |
4 | It is always great to listen to a different perspective on the problem. It can be hard to see it clearly when doing it by myself
5 |
6 | But once I hear others speaking through the problem, it helps me to be able to see things in their perspectives as well as in a second-person perspective
7 |
8 |
9 | Build a Trie class. Insert new strings and Search if strings exist.
10 | */
11 |
12 | // const map = new Map();
13 | // map.set('c', new Map());
14 | // console.log({map})
15 | // let children = map.get('c');
16 | // // console.log({children})
17 | // children.set('a', new Map());
18 | // children = children.get('a')
19 | // console.log({map})
20 | // children.set('t', new Map());
21 | // console.log({children})
22 |
23 |
24 |
25 | class Trie {
26 | constructor() {
27 | map = new Map();
28 | }
29 |
30 | add(word) {
31 | // for each char we will
32 | // first you have to check if the chars exist map
33 | // no:
34 | // assign the map to chars children
35 | // yes:
36 | // we will add char to our to curr map
37 | // assign the map to curr chars children
38 | }
39 |
40 | lookup(word) {
41 | //do something
42 | }
43 | }
44 |
45 |
46 | // const trie = new Trie()
47 | // trie.add("cat")
48 | // trie.lookup("cat") == true
49 | // trie.lookup("dog") == false
50 | // trie.add("dog")
51 | // trie.lookup("dog") == true
52 |
53 |
54 | /*
55 | input: cat
56 | add(cat)
57 | cat
58 | ^
59 |
60 | lookup(cat)
61 | cat
62 | ^
63 | return true
64 |
65 | add(cats)
66 | cats
67 | ^
68 |
69 | add(tats)
70 | tats
71 | ^
72 |
73 | add(tap)
74 | tap
75 | ^
76 |
77 | search(tap)
78 | tap
79 | ^
80 |
81 | tree: {
82 | t: {
83 | a : {
84 | t: {
85 | s: {}
86 | }
87 | p: {endWord: true}
88 | }
89 | }
90 | c: {
91 | a: {
92 | t: {
93 | s: {endWord: true}
94 | }
95 | }
96 | }
97 | }
98 |
99 |
100 | c t
101 | / \
102 | a a
103 | / / \
104 | t p t
105 | / \
106 | s s
107 | */
--------------------------------------------------------------------------------
/AlgoMarathon/Arrays/PairLearning/KadaneAlgowMaggie.js:
--------------------------------------------------------------------------------
1 | // PROBLEM
2 | // Given an array of integers, return maximum subarray sum.
3 | // A subarray is any contiguous set of numbers
4 |
5 | // Function Signature:
6 | // func maxSubarraySum(input: [Int]) -> Int
7 |
8 | // Examples:
9 | // [2, 2, -3, 6, -10, 4] => 7 //[2, 2, -3, 6]
10 | // [] => 0
11 | // [1] => 1
12 | // [-2, 1] => 1
13 | // [-1, -2, -3] => 0 // -1
14 |
15 | /*
16 | Approaches:
17 | #1:
18 | maxSum = -Infinity
19 | nested loop
20 | iterate through the input and adds the values as it iterates through each index
21 | sum = 2 + 2 + (-3)
22 | if (sum > maxSum) maxSum = sum;
23 | Time: O(N^2) => N = numbers of elements of the input array
24 | Space: O(1)
25 |
26 | #2: Kadane's Algo
27 |
28 | [2, 2, -3, 6, -10, 4]
29 | ^
30 | iterate through the input array once
31 | max end sum = max(num, max end sum + num). -3, 1
32 | max so far = max (max end sum, max so far)
33 |
34 | return max so far
35 |
36 | Time: O(N) => N = numbers of elements of the input array
37 | Space: O(1)
38 |
39 | */
40 |
41 | function maxSubarraySum(input) {
42 | let maxSum = input.length < 1 ? 0 : -Infinity;
43 | for (let i = 0; i < input.length - 1; i++) {
44 | let sum = input[i];
45 | for (let j = i + 1; j < input.length; j++) {
46 | sum += input[j];
47 | if (sum > maxSum) maxSum = Math.max(input[j], maxSum);
48 | }
49 | }
50 | return maxSum > 0 ? maxSum : input.length === 1 ? input[0] : 0;
51 | }
52 |
53 | //FORMATION SOLUTION
54 | // const maxSubarraySum = (nums) => {
55 | // let currentSum = 0;
56 | // let globalSum = nums[0];
57 |
58 | // for (const num of nums) {
59 | // currentSum = Math.max(num, currentSum + num);
60 | // globalSum = Math.max(globalSum, currentSum);
61 | // }
62 |
63 | // return globalSum;
64 | // };
65 |
66 | //my attempt failed for 2 elements array or 1 element array
67 |
68 | console.log(maxSubarraySum([]), 0); //edge case (empty case)
69 | console.log(maxSubarraySum([2, 2, -3, 6, -10, 4]), 7);
70 | console.log(maxSubarraySum([1, 2, 3] ), 6);
71 | console.log(maxSubarraySum([-1, -2, -3]), -1); //edge case (all negative numbers)
72 |
73 | console.log("Don't pass yet")
74 | console.log(maxSubarraySum([1]), 1); //edge case (empty case);
75 | console.log(maxSubarraySum([3, 4, -6, 7, 8, -18, 100]), 100); //edge case (empty case)
76 | console.log(maxSubarraySum([-2, 1]), 1); //edge case (empty case);
77 | console.log(maxSubarraySum([-10]), -10); //edge case (empty case);
--------------------------------------------------------------------------------
/CoreAlgos/LinkedList/2_Finding_NoPointerNeeded/findElem.js:
--------------------------------------------------------------------------------
1 | /*
2 | Q. Given a sorted linked list of unique integers, check if the list contains an element with a target value.
3 |
4 | Examples:
5 | • Given a linked list: 2 ➞ 3 ➞ 5, target: 2 // returns True
6 | • Given a linked list: 2 ➞ 3 ➞ 5, target: 4 // returns False
7 |
8 | */
9 |
10 | class ListNode {
11 | constructor(value = 0, next = null) {
12 | this.value = value
13 | this.next = next
14 | }
15 | }
16 |
17 | function search(head, target) {
18 |
19 | }
20 |
21 | // Test Cases
22 | const LL1 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(5, new ListNode(6, new ListNode(7, new ListNode(10)))))))
23 | console.log(search(null, 1)) // false
24 | console.log(search(LL1, 2)) // true
25 | console.log(search(LL1, 4)) // false
26 | console.log(search(LL1, -1)) // false
27 | console.log(search(LL1, 10)) // true
28 | console.log(search(LL1, 11)) // false
29 |
30 | //----------------------------------------------------------------------------------
31 |
32 | //Approaches:
33 |
34 | /*
35 | Higher Order Overview:
36 | 1. Create a curr pointer -> let curr = head;
37 | 2. iterate through the entire curr linked list
38 | 3. if any of the curr.value is found to equal to the target value, return true
39 | 4. keep moving to the next node
40 | 5. return false when no matching curr.value found
41 |
42 | Time: O(n)
43 | Space: O(1)
44 |
45 | */
46 |
47 |
48 | function searchIterative(head, target) {
49 |
50 | //Better Approach - no pointer is needed and if(!head) condition is redundant and can be removed
51 | while (head) { //break the loop when head is null
52 | if (head.value === target) return true;
53 | head = head.next; //move to the next node
54 | }
55 | return false;
56 |
57 | //Another Approach - use a curr pointer
58 | // if (!head) return false;
59 | // let curr = head;
60 | // while (curr) {
61 | // if (curr.value === target) return true;
62 | // curr = curr.next;
63 | // }
64 | // return false;
65 | }
66 |
67 | // Test Cases
68 | const LL2 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(5, new ListNode(6, new ListNode(7, new ListNode(10)))))))
69 | console.log(searchIterative(null, 1)) // false
70 | console.log(searchIterative(LL2, 2)) // true
71 | console.log(searchIterative(LL2, 4)) // false
72 | console.log(searchIterative(LL2, -1)) // false
73 | console.log(searchIterative(LL2, 10)) // true
74 | console.log(searchIterative(LL2, 11)) // false
--------------------------------------------------------------------------------
/AlgoMarathon/Arrays/Searching/ShiftedBinarySearch.js:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | Learn Strength Algo: Shifted Binary Search
4 |
5 | Q: What is Binary Search?
6 | Q: How to detect which side is ordered?
7 |
8 | */
9 |
10 | /*
11 | Visualization
12 | 3 4 5 1 2
13 | m
14 | l h
15 |
16 | m: 5
17 | l: 3
18 | h: 2
19 |
20 | target 1
21 |
22 | T: O(logn)
23 | S: O(1)
24 | */
25 |
26 | //Attempt # 1
27 |
28 | function shiftedBinarySearch(array, target) {
29 | let low = 0; //index
30 | let high = array.length - 1; //inclusive index
31 | while (low <= high){
32 | let mid = Math.floor((high+low)/2);
33 | if (array[mid] === target) return mid;
34 | if (array[low] <= array[mid]) {// on the LEFT SIDE
35 | if (array[low] <= target && target < array[mid]) { //found on the left
36 | high = mid - 1;
37 | }else { //found on the right
38 | low = mid + 1;
39 | }
40 | }else { // on the RIGHT SIDE
41 | if (array[mid] < target && target <= array[high]) { //on the right
42 | low = mid + 1;
43 | }else { //on the left
44 | high = mid - 1;
45 | }
46 | }
47 | }
48 | return -1;
49 | }
50 |
51 |
52 | /*
53 | Progress Notes:
54 |
55 | 10min: watch Formation video and understand the problem
56 |
57 | 15min: coding the problem (issues ~ not entirely how to solve ~ since I have failed some test cases)
58 | (specifically in Algo Expert I failed the test cases#6 and other 3 more cases)
59 |
60 | 15min: watch Algo Expert video, review hints, understand the recursive approach on the problem and rewatched the Formation video
61 |
62 | 10min: resolve the issue from my first 15 mins approach and successfully pass all the test cases
63 |
64 |
65 | Plain English:
66 | The shifted binary search is basically helping us to find the specific item
67 | by dividing up the data depends on if the target item is locating in the smaller or larger area
68 | of the middle point.
69 | Divide the playground into half.
70 | Lets take a look when the low pointer value (left pointer value) is less than or equal to the middle pointer value.
71 | In this situation, it means that potentially the left side is ordered, and the right side is not ordered
72 |
73 | If the target is smaller than or equal to the middle pointer value, and it is larger than the low pointer value, adjust the high pointer
74 | else adjust the low pointer
75 |
76 | If the lower pointer value is larger than or equal to the middle pointer value:
77 | this means potentially the left side is not ordered and the right side is ordered
78 |
79 | (similar situation on this end)
80 | */
81 |
--------------------------------------------------------------------------------
/CoreAlgos/LinkedList/5_Removing/removeAllTarget.js:
--------------------------------------------------------------------------------
1 | /*
2 | Q. Given a linked list and a target integer, remove all nodes with the value target.
3 |
4 | Examples:
5 | • Given a linked list: 4 ➞ 2 ➞ 3 ➞ 2 ➞ 2, target: 2 // returns 4 ➞ 3
6 | • Given a linked list: 4, target: 4 // returns an empty list
7 | */
8 |
9 | class ListNode {
10 | constructor(value = 0, next = null) {
11 | this.value = value
12 | this.next = next
13 | }
14 | }
15 |
16 | function arrayify(head) {
17 | let ptr = head
18 | var array = []
19 | while (ptr != null) {
20 | array.push(ptr.value)
21 | ptr = ptr.next
22 | }
23 | return array
24 | }
25 |
26 | function remove(node, target) {
27 |
28 | }
29 |
30 | // Test Cases
31 | let LL1 = new ListNode(4, new ListNode(2, new ListNode(1, new ListNode(1, new ListNode(3, new ListNode(2, new ListNode(2)))))))
32 | let LL2 = remove(null, 1);
33 | console.log(arrayify(LL2)) // []
34 | LL1 = remove(LL1, 1);
35 | console.log(arrayify(LL1)) // [4, 2, 3, 2, 2]
36 | LL1 = remove(LL1, 2);
37 | console.log(arrayify(LL1)) // [4, 3]
38 | LL1 = remove(LL1, 3);
39 | console.log(arrayify(LL1)) // [4]
40 | LL1 = remove(LL1, 4);
41 | console.log(arrayify(LL1)) // []
42 |
43 | //----------------------------------------------------------------------------------
44 |
45 | //Approaches:
46 |
47 | //Iterative Approach (uncomment below and see how it works in the console)
48 |
49 | function removeInterative(node, target) {
50 | let sentinel = new ListNode(0);
51 | sentinel.next = node;
52 | let curr = sentinel;
53 |
54 | while(curr.next) {
55 | if (curr.next.value === target) { //if the next node value is equal to the target
56 | curr.next = curr.next.next; //remove the next node value, and move the next.next node value up
57 | }else { //QUESTION: it is crucial to have 'else' here, why it can be an issue if this else is removed??
58 | curr = curr.next;
59 | }
60 | }
61 | //console.log(sentinel);
62 | return sentinel.next;
63 | }
64 |
65 | // Test Cases
66 | let LL3 = new ListNode(4, new ListNode(2, new ListNode(1, new ListNode(1, new ListNode(3, new ListNode(2, new ListNode(2)))))))
67 | let LL4 = removeInterative(null, 1);
68 | console.log(arrayify(LL4)) // []
69 | LL3 = removeInterative(LL3, 1);
70 | console.log(arrayify(LL3)) // [4, 2, 3, 2, 2]
71 | LL3 = removeInterative(LL3, 2);
72 | console.log(arrayify(LL3)) // [4, 3]
73 | LL3 = removeInterative(LL3, 3);
74 | console.log(arrayify(LL3)) // [4]
75 | LL3 = removeInterative(LL3, 4);
76 | console.log(arrayify(LL3)) // []
--------------------------------------------------------------------------------
/AlgoMarathon/BinaryTree/PairLearning/README.md:
--------------------------------------------------------------------------------
1 | # Pair Learning in Algo Marathon
2 |
3 | ## Binh Hua (05/12/22)
4 |
5 | First time working with Binh to go through this pair learning session.
6 |
7 | We went over the [Level Order Traversal]() problem. A medium Leetcode problem.
8 |
9 | **Reflection**
10 | - Really like the enthusiam of Binh when going through this problem. She learns new approach and applies immediately and this is what I think I learn the most from her.
11 |
12 |
13 | ## Angel (05/23/22)
14 |
15 | We already had several sessions together and I really like to pair learning Angel since she is always able to pinpoint what I missed in my implementation on a problem. And we always have different perspectives. That is why it is interesting to work with her!
16 |
17 | We went over the [BST to Doubly Linked List In-Order Traversal]() problem using recursive. A medium leetcode problem.
18 |
19 | Angel shared with me this resouce on Doubly Linked List: https://www.geeksforgeeks.org/doubly-linked-list/
20 |
21 | I have found the similar problem on Leetcode [here](https://leetcode.com/problems/convert-binary-search-tree-to-sorted-doubly-linked-list/)
22 |
23 | Great video walkthrough of this problem [here](https://www.youtube.com/watch?v=zy7I5wcwfh4)
24 |
25 | **Reflection**
26 | - Angel is a great host since she is able to ask questions to guide me to go over the part that I may have missed during my implementation. I totally forgot to set head to the first node, which I quickly mentioned during the pseudocode but did not write it down so I missed it entirely until Angel asked me questions and made me realize the problem I made. I like the fact that she did not give me an answer and just ask me questions to let me solve them by myself.
27 |
28 | An additional possible approach to the problem: try to solve it iteratively… (:
29 |
30 | ## Jiyoon (06/10/22) - outside of Formation schedule
31 |
32 | **Reflection & Takeaways**
33 | - Learning backtracking on powerset is really fun! I have learned a ton especially how Jiyoon explained the problem and visualized it step-by step - especially how she would use a tree structure to help her to visualize the backtracking array problem.
34 | - Biggest suggestion from Jiyoon on my performance and understanding on the problem is I still need to practice more to know how to fit `DFS on Array structure`, how to create a base case for a backtracking array problem.
35 | - Biggest take away on backtracking problem is asking `add/take or not add/take to the result`.
36 |
37 |
38 |
39 | ...
--------------------------------------------------------------------------------
/AlgoMarathon/Arrays/isMonotonicArray.js:
--------------------------------------------------------------------------------
1 | /*
2 | An array is monotonic if it is either monotone increasing or monotone decreasing.
3 |
4 | An array nums is monotone increasing if for all i <= j, nums[i] <= nums[j]. An array nums is monotone decreasing if for all i <= j, nums[i] >= nums[j].
5 |
6 | Given an integer array nums, return true if the given array is monotonic, or false otherwise.
7 |
8 |
9 |
10 | Example 1:
11 |
12 | Input: nums = [1,2,2,3]
13 | Output: true
14 | Example 2:
15 |
16 | Input: nums = [6,5,4,4]
17 | Output: true
18 | Example 3:
19 |
20 | Input: nums = [1,3,2]
21 | Output: false
22 |
23 | */
24 |
25 |
26 | //ATTEMPT #1: 05/13/22
27 |
28 | /*
29 | [1,2,2,3]
30 | i
31 |
32 | increasing: true
33 | decreasing: false
34 |
35 | output: true || false ===> true
36 |
37 |
38 | [6,5,4,4]
39 | i
40 |
41 | increasing: false
42 | decreasing: true
43 |
44 | output: false || true ===> true
45 |
46 |
47 | [1,3,2]
48 | i
49 |
50 | increasing: false
51 | decreasing: false
52 |
53 | output: false || false ===> false
54 |
55 | */
56 | var isMonotonic = function(nums) {
57 | //FORMATION SOLUTION:
58 | //bitwise AND assignment: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_AND_assignment
59 | let dec = true;
60 | let inc = true; //1
61 |
62 | for (let i = 1; i < nums.length; i++) {
63 | dec &= nums[i-1] >= nums[i]; //0
64 | inc &= nums[i-1] <= nums[i]; //1
65 | console.log(dec, inc)
66 | }
67 | console.log("out: ", dec, inc)
68 | return dec || inc; //0 = false, 1 = true
69 |
70 | //LEETCODE SOLUTION: easier to understand + cleaner solution - using one pass only
71 | // let increasing = true, decreasing = true;
72 | // for (let i = 0; i < nums.length - 1; ++i) {
73 | // if (nums[i] > nums[i+1]) increasing = false;
74 | // if (nums[i] < nums[i+1]) decreasing = false;
75 | // console.log("inside loop: ", increasing, decreasing);
76 | // }
77 | // console.log("outside loop: ", increasing, decreasing);
78 | // return increasing || decreasing;
79 |
80 | //My first approach: repetitive when doing it in two pass
81 | // if (nums.length < 2) return true; //removed in optimal solution
82 | // if (nums[0] <= nums[1]) {
83 | // for (let i = 0; i < nums.length - 1; i++) {
84 | // if (nums[i] > nums[i + 1] ) return false;
85 | // }
86 | // }
87 | // if (nums[0] >= nums[1]) {
88 | // for (let i = 0; i < nums.length - 1; i++) {
89 | // if (nums[i] < nums[i + 1]) return false;
90 | // }
91 | // }
92 | // return true;
93 | };
94 |
--------------------------------------------------------------------------------
/MockedBehavioralPhoneScreen/README.md:
--------------------------------------------------------------------------------
1 | # Mocked Phone Screen Takeaways
2 |
3 | ## Mock Interview w Lakisha (06-17-22)
4 |
5 | Takeaways:
6 | - Question on "Tell me about yourself"
7 | - quickly summarize your resume and highlight pieces of experience
8 | - highlight your technical and non-technical skillsets
9 | - highlight your area of interests
10 | - summarize your work experience so it is transferrable to your new job
11 |
12 | - Thinking of the "word" you use and say in an interview:
13 | - ie, work-life balance can be rephrased to "life-work" balance
14 | - it shows what you value most from the way you phrase
15 |
16 | - When describing the project you are proud of - make sure to highlight why?
17 | - Why you are proud of the project?
18 | - What does this accomplishment teels you as an exployee?
19 | - What do you want them to know about you?
20 |
21 | - Question on "Value"
22 | - what does the company value most <- highlight this in your answer
23 | - Talk about your values and how it is in relation to or align with the employer
24 |
25 | - Question on "Failure"
26 | - What are your `specific` takeaways
27 | - Be mindful and Know your audience:
28 | - Find out more about your interviewer if you can
29 | - If they have no coding background, it is crucial to not be using too many technical jargons
30 |
31 | - Question on "Deadline"
32 | - Quick summary of the step by step key points on how to handle the scenario
33 | - There is no need to be too detailed and description (since it is cruical to be mindful of the time spent on each question)
34 |
35 |
36 | - Question on "Weakness"
37 | - Describe the challenge and show what you have done to overcome the weakness
38 | - The weakness might still be there, but you have found a way for you to handle that weakness everytime it comes up!
39 |
40 | - You can find out more about the company culture through different platforms ie, `levels.fyi` or `Blind`
41 |
42 | - Even though you may have successfully gone through all interviews, there are still scenarios that you will not get the job, and it can be due to headcount, etc. There is no guarantee. As a result, it is crucial to remember to always `do your best each time` and have an `optimistic mindset` to keep moving forward until you finally find the ONE role.
43 |
44 | ## Mock Interview w Susan (06-19-22)
45 |
46 | Takeaways:
47 | - Amazon behavior questions can pretty intensive (can be unexpected)
48 | - Prepare approaches to multiple questions (which can prepare you to navigate through harder problems)
49 | - Time management is key -- Always keep track of the time on how long it took you to answer the question. You want to get through as many questions as possible. Try not to spend too long on a problem.
--------------------------------------------------------------------------------
/CoreAlgos/BinaryTree/sum.js:
--------------------------------------------------------------------------------
1 | /*
2 | Q. Given a binary tree, sum all elements in the tree.
3 |
4 | Example:
5 | • Given a binary tree:
6 | 1
7 | / \
8 | 7 3
9 | / \
10 | 4 5
11 | returns 20
12 | */
13 |
14 | class TreeNode {
15 | constructor(value = 0, leftChild = null, rightChild = null) {
16 | this.value = value
17 | this.left = leftChild
18 | this.right = rightChild
19 | }
20 | }
21 |
22 | function sumBT(root) {
23 |
24 | }
25 |
26 | // Test Cases
27 | console.log(sumBT(null)) // 0
28 | console.log(sumBT(new TreeNode(1, new TreeNode(2), new TreeNode(3)))) // 6
29 | console.log(sumBT(new TreeNode(1))) // 1
30 |
31 | //----------------------------------------------------------------------------------
32 |
33 | //Approaches:
34 |
35 |
36 | function sumBT(root) {
37 | //iterative (DFS Approach)
38 | if (!root) return 0;
39 | let sum = 0;
40 | let stack = root ? [root] : [];
41 | while (stack.length > 0) {
42 | let node = stack.pop();
43 | sum += node.value;
44 | if (node.left) stack.push(node.left);
45 | if (node.right) stack.push(node.right);
46 | }
47 | return sum;
48 |
49 | //Recursive
50 | // if (!root) return 0;
51 | // let sum = 0;
52 | // sum += root.value;
53 | // return sum + sumBT(root.left) + sumBT(root.right);
54 | }
55 |
56 |
57 | //----------------------------------------------------------------------------------
58 |
59 | //OTHER SIMILAR PROBLEMS:
60 |
61 | /*
62 | Algo: Sum all even elements in a binary tree (iterative & Recursive)
63 | */
64 |
65 | const sumEvenTree = (root) => {
66 | //Iterative Approach
67 | if (!root) return null;
68 | let queue = [root];
69 | let sum = 0;
70 | while (queue.length > 0) {
71 | let node = queue.pop();
72 | if (node.value % 2 === 0) sum += node.value;
73 | if (node.left) queue.push(node.left);
74 | if (node.right) queue.push(node.right);
75 | }
76 | return sum;
77 |
78 | //Recursive Approach
79 | // if (!root) return 0;
80 | // let sum = 0;
81 | // if (root.value % 2 === 0) sum += root.value;
82 | // return sum + sumEvenTree(root.left) + sumEvenTree(root.right);
83 | }
84 |
85 | const tree1 = new TreeNode(2, new TreeNode(3, new TreeNode(6)), new TreeNode(4));
86 | const tree2 = new TreeNode();
87 | const tree3 = new TreeNode(1);
88 | const tree4 = new TreeNode(null);
89 | const tree5 = new TreeNode(2, new TreeNode(6));
90 | const tree6 = new TreeNode(1, new TreeNode(3), new TreeNode(5));
91 | console.log(sumEvenTree(tree1), 12);
92 | console.log(sumEvenTree(tree2), 0);
93 | console.log(sumEvenTree(tree3), 0);
94 | console.log(sumEvenTree(tree4), 0);
95 | console.log(sumEvenTree(tree5), 8);
96 | console.log(sumEvenTree(tree6), 0);
--------------------------------------------------------------------------------
/Weekly Gather Mentor Office Hours/RobotCleanRoomwDanielTomko_06-29-22.js:
--------------------------------------------------------------------------------
1 | /**
2 | * // This is the robot's control interface.
3 | * // You should not implement it, or speculate about its implementation
4 | * function Robot() {
5 | * // Returns true if the cell in front is open and robot moves into the cell.
6 | * // Returns false if the cell in front is blocked and robot stays in the current cell.
7 | * @return {boolean}
8 | * this.move = function() {
9 | * ...
10 | * };
11 | *
12 | * // Robot will stay in the same cell after calling turnLeft/turnRight.
13 | * // Each turn will be 90 degrees.
14 | * @return {void}
15 | * this.turnLeft = function() {
16 | * ...
17 | * };
18 | *
19 | * // Robot will stay in the same cell after calling turnLeft/turnRight.
20 | * // Each turn will be 90 degrees.
21 | * @return {void}
22 | * this.turnRight = function() {
23 | * ...
24 | * };
25 | *
26 | * // Clean the current cell.
27 | * @return {void}
28 | * this.clean = function() {
29 | * ...
30 | * };
31 | * };
32 | */
33 |
34 | /*
35 | ooooo
36 | xxoxx
37 | ooooo
38 | */
39 |
40 | function cleanRoom(robot) {
41 | const key = (x, y) => [x, y].join(',');
42 | const visited = {};
43 | let direction = 0; // 0 up, 1 right, 2 down, 3 left
44 | const deltas = [
45 | [0, 1] // up
46 | [1, 0], // right
47 | [0, -1], // down
48 | [-1, 0], // left
49 | ];
50 |
51 | function changeDirection(newDir) {
52 | newDir = newDir % 4;
53 | while (direction !== newDir) {
54 | robot.turnRight();
55 | direction = (direction + 1) % 4;
56 | }
57 | }
58 |
59 |
60 | function cleanPosition(x, y) {
61 | // base case (gonna deal with this below)
62 | robot.clean();
63 | visited[key(x, y)] = true;
64 |
65 | // loop through possible adjacent positions that are not yet visited
66 | for (let i = 0; i < deltas.length; i++) {
67 | // compute new possible position
68 | const [dx, dy] = deltas[i];
69 | const newX = x + dx;
70 | const newY = y + dy;
71 |
72 | // if the new position is visited, continue (don't visit)
73 | if (visited[key(newX, newY)]) continue;
74 | // try and move to the new position (turn?)
75 | changeDirection(i);
76 |
77 | // if move was successful
78 | if (robot.move()) {
79 | cleanPosition(newX, newY);
80 | // move back
81 | changeDirection((i + 2) % 4);
82 | robot.move();
83 | } else {
84 | // mark this spot as visited
85 | visited[key(newX, newY)] = true;
86 | }
87 | }
88 | }
89 |
90 | cleanPosition(0, 0);
91 | }
--------------------------------------------------------------------------------
/Weekly Gather Mentor Office Hours/TreetoLL&BacktrackingwDaniel_06-23-22.js:
--------------------------------------------------------------------------------
1 | /*
2 | Password Generator
3 | abc, 2
4 | aa
5 | ab
6 | ba
7 | bb
8 | bc
9 | cc
10 | ca
11 | cb
12 | */
13 |
14 | function passwordGenerator(letters, length) {
15 | const stack = [];
16 | const passwords = [];
17 |
18 | function addOneLetter() {
19 | // base case
20 | if (stack.length === length) {
21 | passwords.push(stack.join(''));
22 | return;
23 | }
24 |
25 | // traverse all branches
26 | for (let i = 0; i < letters.length; i++) {
27 | stack.push(letters[i]); // O(1)
28 | addOneLetter();
29 | stack.pop(); // O(1)
30 | }
31 | }
32 |
33 | addOneLetter();
34 |
35 | return passwords;
36 | }
37 |
38 | console.log(passwordGenerator("abc", 2));
39 | console.log(passwordGenerator("abc", 7));
40 |
41 |
42 | function heightOfTree(root) {
43 | if (!root) return 0;
44 |
45 | const leftHeight = heightOfTree(root.left);
46 | const rightHeight = heightOfTree(root.right);
47 |
48 | const heightAtThisNode = Math.max(leftHeight, rightHeight) + 1;
49 |
50 | return heightAtThisNode;
51 | }
52 |
53 | function sumOfTreeValues(root) {
54 | if (!root) return 0;
55 |
56 | const leftSum = sumOfTreeValues(root.left);
57 | const rightSum = sumOfTreeValues(root.right);
58 |
59 | return leftSum + rightSum + root.value;
60 | }
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 | /*
73 |
74 | Convert Binary Tree to Sorted Doubly Linked List
75 |
76 | 5
77 | 3 9
78 | 1 4 13
79 | 10 15
80 |
81 | LeftSubTreeAsList 5 RightSubTreeAsList
82 | 1 3 4 9 10 13 15
83 | */
84 |
85 | class Node {
86 | constructor(value, left = null, right = null) {
87 | this.value = value;
88 | this.left = left;
89 | this.right = right;
90 | }
91 | }
92 |
93 | function tree2list(root, listTail = null) {
94 | if (!root) return listTail;
95 |
96 | // First, we're looking for the last node, so we're going
97 | // as far right as we can.
98 | if (root.right) {
99 | listTail = tree2list(root.right, listTail);
100 | }
101 |
102 | // If there is no right node, then this is the last one
103 | // in the in-order traversal, so prepend that to the tail
104 | // of the list and that node is now the head.
105 | let listHead = root;
106 | listHead.right = listTail;
107 | if (listTail) {
108 | listTail.left = listHead;
109 | }
110 |
111 | // Now look at the left subtree and pass in the list
112 | // we've created so far.
113 | if (root.left) {
114 | listHead = tree2list(root.left, listHead);
115 | }
116 |
117 | // Return the list as we've built it up to this point.
118 | return listHead;
119 | }
120 |
121 |
--------------------------------------------------------------------------------
/Weekly Gather Mentor Office Hours/AlgoMarathonwDaniel_06-02-22.js:
--------------------------------------------------------------------------------
1 |
2 | const array = [2, 7, 1, 45, 23, 84, 65];
3 |
4 | function findMaxRecursive(array) {
5 |
6 | function helper(array, start) {
7 | // base case
8 | if (start === array.length - 1) {
9 | return array[start];
10 | }
11 |
12 | // do some work?
13 |
14 | // recursive call
15 | const theMaxOfTheRest = helper(array, start + 1);
16 |
17 | // do some work?
18 |
19 | // merge step
20 | return Math.max(array[start], theMaxOfTheRest);
21 | }
22 |
23 | if (array.length === 0) {
24 | return NaN; // Do something reasonable
25 | }
26 |
27 | return helper(array, 0);
28 | }
29 |
30 |
31 | // 1
32 | // 2 3
33 | // 4 5 6 7
34 |
35 | // 1
36 | // 3 2
37 | // 7 6 5 4
38 |
39 | // 1
40 | // 2 3
41 |
42 |
43 | function treeFlip(root) {
44 | // base case
45 | if (root === null) {
46 | return null;
47 | }
48 |
49 | // do some work
50 | const temp = root.right;
51 | root.right = root.left;
52 | root.left = temp;
53 |
54 | // recursive calls
55 | treeFlip(root.left);
56 | treeFlip(root.right);
57 |
58 | // merge? Nope
59 |
60 | return root;
61 | }
62 |
63 | /*
64 | Q. Given a non-empty binary tree, find the maximum path sum.
65 |
66 | A path is any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root.
67 |
68 | Given a tree:
69 | 1
70 | / \
71 | 2 3
72 | /
73 | -1
74 | // returns 6 (1 + 2 + 3)
75 | */
76 |
77 | // find max path from root to any leaf node
78 | function maxPathSum(root) {
79 | // base case
80 | if (!root) {
81 | return 0;
82 | }
83 | // recursive calls
84 | const left = maxPathSum(root.left);
85 | const right = maxPathSum(root.right);
86 |
87 | // merge
88 | const maxSubTreePath = Math.max(left, right);
89 |
90 | // return something
91 | return maxSubTreePath + root.value;
92 | }
93 |
94 | /**
95 | *
96 |
97 | Original intervals:
98 | --------
99 | ---------
100 | ----------
101 | Want to insert:
102 | --
103 | ---
104 | ---
105 | ----------
106 | ---------------------
107 | */
108 |
109 | function mergeIntervals(original, newInterval) {
110 | const result = [];
111 |
112 | for (let i = 0; i < original; i++) {
113 | const interval = original[i];
114 |
115 | // Do we want to merge interval and newInterval?
116 | // if so, update newInterval
117 | // else
118 | // result.push(interval);
119 | }
120 |
121 | return result;
122 | }
--------------------------------------------------------------------------------
/CoreAlgos/BinaryTree/BinarySearchTree/insertElem.js:
--------------------------------------------------------------------------------
1 | /*
2 | Q. Given a binary search tree and a target element's value, insert the target in the appropriate position.
3 |
4 | Examples:
5 | • Given a binary search tree:
6 | 6
7 | / \
8 | 3 8
9 | / \
10 | 2 4
11 |
12 | • For target: 7 // returns:
13 | 6
14 | / \
15 | 3 8
16 | / \ /
17 | 2 4 7
18 | / \
19 | 1 5
20 |
21 | */
22 | class TreeNode {
23 | constructor(value = 0, leftChild = null, rightChild = null) {
24 | this.value = value
25 | this.left = leftChild
26 | this.right = rightChild
27 | }
28 | }
29 |
30 | function arrayifyTree(root) {
31 | if (!root) { return [] }
32 | var queue = []
33 | var array = []
34 | queue.push(root)
35 | while (queue.length !== 0) {
36 | var node = queue.shift()
37 | array.push(node.value)
38 | if (node.left) { queue.push(node.left) }
39 | if (node.right) { queue.push(node.right) }
40 | }
41 | return array
42 | }
43 |
44 | function insertBST(root, target) {
45 | }
46 |
47 | // Test Cases
48 | var tree = new TreeNode(6, new TreeNode(3, new TreeNode(2), new TreeNode(4)), new TreeNode(8))
49 |
50 | insertBST(tree, 7)
51 | console.log(arrayifyTree(tree), [6, 3, 8, 2, 4, 7])
52 | insertBST(tree, 5)
53 | console.log(arrayifyTree(tree), [6, 3, 8, 2, 4, 7, 5])
54 | insertBST(tree, 1)
55 | console.log(arrayifyTree(tree), [6, 3, 8, 2, 4, 7, 1, 5])
56 | var tree2 = insertBST(null, 1)
57 | console.log(tree2.value, 1)
58 |
59 | //----------------------------------------------------------------------------------
60 |
61 | //Approaches:
62 |
63 | //Time: O(logN) time
64 |
65 | function insertBST(root, target) {
66 | if(!root) return new TreeNode(target);
67 | let curr = root;
68 | while(curr) {
69 | if (target < curr.value) { //if the target is less than the parent node
70 | if (curr.left) { //Go to the left side, if there is a left node
71 | curr = curr.left; //Go to the next left node
72 | }else {
73 | curr.left = new TreeNode(target); //if no left node, add the new treenode with the target value
74 | break; //break out of the loop, there is no point to keep interating through the tree once the target value node is inserted
75 | }
76 | }
77 | else { //if the target is larger than the parent node
78 | if (curr.right) { //Go to the right side, if there is a right node
79 | curr = curr.right; //Go to the next right node
80 | }else {
81 | curr.right = new TreeNode(target); //if no right node, add the new treenode with the target value
82 | break; //break out of the loop, there is no point to keep interating through the tree once the target value node is inserted
83 | }
84 | }
85 | }
86 | return root;
87 | }
--------------------------------------------------------------------------------
/AlgoMarathon/Arrays/LongestPalidromicSubstring.js:
--------------------------------------------------------------------------------
1 | /*
2 | Q. Given a string, find the longest palindromic substring. You may assume there is only one longest substring.
3 |
4 | Examples:
5 |
6 | Given a string: "babe" // returns"bab"
7 | Given a string: "aefez" // returns "efe"
8 | [execution time limit] 4 seconds (js)
9 |
10 | [input] string string
11 |
12 | [output] string
13 |
14 | longest palindromic substring
15 |
16 |
17 | Input:
18 | string: ""
19 | Expected Output:
20 | ""
21 |
22 | Input:
23 | string: "it's afternoon"
24 | Expected Output:
25 | "noon"
26 |
27 | Input:
28 | string: "kb12365456321bb"
29 | Expected Output:
30 | "b12365456321b"
31 | */
32 |
33 |
34 | function longestPalidromicSubstring(str) {
35 | let res = "";
36 | let resLength = res.length;
37 |
38 | for (let i = 0; i < str.length; i++) {
39 | let left = i;
40 | let right = i;
41 | // console.log(i, str[left], str[right]);
42 | //odd
43 | while (left >= 0 && right < str.length && str[left] === str[right]) {
44 | console.log("hey")
45 | let curr_length = (right - left) + 1;
46 | if (curr_length > resLength) {
47 | resLength = curr_length;
48 | res = str.substring(left, right + 1);
49 | console.log(res);
50 | }
51 | left--;
52 | right++;
53 | }
54 | //even
55 | left = i;
56 | right = i + 1;
57 | while (left >= 0 && right < str.length && str[left] === str[right]) {
58 | console.log(left, right);
59 | let curr_length = (right - left) + 1;
60 | if (curr_length > resLength) {
61 | resLength = curr_length;
62 | res = str.substring(left, right + 1);
63 | }
64 | left--;
65 | right++;
66 | }
67 | }
68 | return res;
69 | }
70 |
71 |
72 |
73 |
74 | //MY APPROACH - FAILED!! - TRYING TO DO THIS recursively
75 | // function solution(string) {
76 | // let res = "";
77 | // let maxSubstr = 0;
78 | // let isPalidromic = false;
79 |
80 | // function helper(left, right) {
81 | //base case
82 | // if (left > right || isPalidromic === true) {
83 | // if (maxSubstr < (right - left)) {
84 | // maxSubstr = right - left;
85 | // res = string
86 | // }
87 | // return;
88 | // }
89 | //isPalidromic check
90 | // if (string[left])
91 |
92 | //recursive case
93 | // helper(left + 1, right);
94 | // helper(left, right - 1);
95 | // }
96 |
97 | // helper(0, string.length - 1);
98 |
99 | // return res;
100 | // }
101 |
102 | // console.log(longestPalidromicSubstring("babe"));
103 | console.log(longestPalidromicSubstring("cbbe"));
--------------------------------------------------------------------------------
/AlgoSprint/frequencyElem.js:
--------------------------------------------------------------------------------
1 | // Your previous Plain Text content is preserved below:
2 |
3 | // Algo Sprints Number of Unique Elements Variations
4 |
5 | // 1. Most frequent element in array*
6 | // 2. Least frequent element in array ****
7 | // 3. Number of elements with exactly 2 occurrences ([1, 2, 1, 3, 2, 4] returns 2) ***
8 |
9 |
10 | /*
11 |
12 | Approach
13 | - iterate array
14 | - map
15 | - min
16 |
17 | 1, 1, 3, 2, 6
18 | i
19 |
20 | {
21 | 1: 2
22 | 3: 1
23 | 2: 1
24 | 6: 1
25 | }
26 |
27 | Object.keys(map)
28 | */
29 |
30 | // function findLeastElem(input) {
31 | // let frequencyMap = new Map();
32 | // let min = Infinity;
33 | // let minKey = null;
34 | // for (let i = 0; i < input.length; i++) {
35 | // const count = (frequencyMap.get(input[i]) || 0) + 1;
36 | // frequencyMap.set(input[i], count);
37 | // }
38 | // // let frequencies = frequencyMap.entries();
39 |
40 | // for (const [key, value] of frequencyMap.entries()) {
41 | // if (value < min) {
42 | // min = value;
43 | // minKey = key;
44 | // }
45 | // }
46 |
47 | // return minKey;
48 | // console.log(frequencies);
49 | // }
50 |
51 | // // Test Cases
52 | // console.log(findLeastElem([]), null);
53 | // console.log(findLeastElem([9, 8, 7]), 9);
54 | // console.log(findLeastElem([1, 1, 3, 2, 6]), 3);
55 | // console.log(findLeastElem([1, 1, 1, 3, 5, 3, 2, 2, 5, 6]), 6);
56 | // console.log(findLeastElem([2, 4, 2, 1, 2, 1, 4, 5, 4, 5]), 1);
57 |
58 | // 3. Number of elements with exactly 2 occurrences ([1, 2, 1, 3, 2, 4] returns 2) ***
59 |
60 | // function exactlyTwoOccurances(input) {
61 |
62 | // let frequencyMap = new Map();
63 | // let min = Infinity;
64 | // let minKey = null;
65 | // for (let i = 0; i < input.length; i++) {
66 | // const count = (frequencyMap.get(input[i]) || 0) + 1;
67 | // frequencyMap.set(input[i], count);
68 | // }
69 |
70 | // let listOfTwo = [];
71 | // frequencyMap.forEach( (value, key)=>
72 | // {
73 | // if(value === 2) {
74 | // listOfTwo.push(key);
75 | // }
76 | // });
77 |
78 | // return listOfTwo.length;
79 |
80 | // }
81 |
82 | function findMaxElem(input) {
83 | let frequencyMap = new Map();
84 | let max = 0;
85 | let maxKey = null;
86 | for (let i = 0; i < input.length; i++) {
87 | const count = (frequencyMap.get(input[i]) || 0) + 1;
88 | frequencyMap.set(input[i], count);
89 | }
90 | // let frequencies = frequencyMap.entries();
91 |
92 | for (const [key, value] of frequencyMap.entries()) {
93 | if (value > max) {
94 | max = value;
95 | maxKey = key;
96 | }
97 | }
98 |
99 | return maxKey;
100 | // console.log(frequencies);
101 | }
102 |
103 | // Test Cases
104 |
105 | console.log(exactlyTwoOccurances([1, 1, 3, 2, 6]), 1);
--------------------------------------------------------------------------------
/Independent_Frontend_Practice/sample_react_app_sort-filter-practice.js:
--------------------------------------------------------------------------------
1 | import React, {useState} from "react";
2 |
3 | function TransactionTable({txns}) {
4 | const [date, setDate] = useState(null);
5 | const [transactionTable, setTransactionTable] = useState(txns);
6 |
7 | const sort = (e) => {
8 | e.preventDefault();
9 | let tempTable = [...transactionTable];
10 | for (let i = 0; i < tempTable.length; i++){ //bubble sort
11 | for (let j = 0; j + 1 < tempTable.length; j++) {
12 | let curAmt = tempTable[j].amount;
13 | let nextAmt = tempTable[j+1].amount;
14 | let currItem = tempTable[j];
15 | let nextItem = tempTable[j+1];
16 | if (curAmt > nextAmt) {
17 | tempTable[j] = nextItem;
18 | tempTable[j+1] = currItem;
19 | }
20 | }
21 | }
22 | setTransactionTable(tempTable);
23 | };
24 |
25 | const filter = (e) => {
26 | e.preventDefault();
27 | let fileteredTable = [];
28 | for (let item of txns) {
29 | if (item.date === date) {
30 | fileteredTable.push(item);
31 | }
32 | }
33 | setTransactionTable(fileteredTable);
34 | }
35 |
36 | const handleDateChange = (e) => {
37 | setDate(e.target.value);
38 | }
39 |
40 | return (
41 |
77 | );
78 | }
79 |
80 | export default TransactionTable;
81 |
--------------------------------------------------------------------------------
/AlgoMarathon/LinkedList/PairLearning/DeleteKNodesAfterMiddle_wGigi_07-23-22.js:
--------------------------------------------------------------------------------
1 | /*
2 | Given a linked list, delete (k) nodes after the middle.
3 | If (n) is the length of the list, the middle node is [n / 2] using zero-based indexing.
4 | Return the head of the modified list.
5 | Function Signature:
6 | function deleteKNodesAfterMiddle(head)
7 |
8 | (BE AWARE CINDY: IT is not related to delete every kth node after the middle,
9 | but it is regarding to delete K nodes after the middle )
10 |
11 | Questions:
12 | - input head is null or 1 node, should we just return the head? return head
13 | - even or odd number elements in a linked list - what is the mid point for even number of elements in a linked list? (for this problem, we will consider smaller mid point for even)
14 | - if k > number of nodes after the middle, what should we return (modified or not modified)? - need to remove all nodes after the middle when k > mid
15 |
16 |
17 | Approaches: K >= 0
18 | h 1 2 3 4 k: 2 k = 0 mid != nulll
19 | i = 2
20 | d 0 1 2 3 4 middle = 2 3 4
21 | / /
22 | f
23 | s
24 | - Find the middle node (fast and slow pointers)
25 | - traverse middle node as long as k > 0
26 | k--
27 |
28 |
29 | Time: O(2n) => 0(n)
30 | Space: O(n) => 0(n)
31 |
32 | */
33 |
34 | class ListNode {
35 | constructor(value, next = null) {
36 | this.value = value;
37 | this.next = next;
38 | }
39 | }
40 |
41 | const deleteKthNodeAfterMiddleNode = (head, k) => {
42 |
43 | if(!head) {
44 | return head;
45 | }
46 |
47 | let fast = new ListNode(0, head);
48 | let slow = new ListNode(0, head);
49 |
50 | while(fast !== null && fast.next !== null) {
51 | fast = fast.next.next;
52 | slow = slow.next;
53 | }
54 |
55 | let middle = slow;
56 |
57 | while (middle !== null && k >= 0) {
58 | middle = middle.next;
59 | k--;
60 | }
61 |
62 | slow.next = middle;
63 |
64 | return head;
65 | }
66 |
67 |
68 |
69 |
70 |
71 | /*
72 |
73 | 1, 2, null k = 3
74 | ^
75 |
76 |
77 |
78 |
79 | Test Cases:
80 | list = [1, 2, 3, 4], k = 2 => [1, 2]
81 | list = [1], k = 0 => `[1]`
82 | list = [2, 9, 4, 1, 7], k = 3 => [2, 9, 4]
83 | */
84 |
85 | const list1 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4))));
86 | const list2 = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4))));
87 | const list3 = new ListNode(1);
88 | const list4 = new ListNode(2, new ListNode(9, new ListNode(4, new ListNode(1, new ListNode(7)))));
89 |
90 | console.log(deleteKthNodeAfterMiddleNode(list1, 1)); //[1, 2, 4]
91 | // console.log(deleteKthNodeAfterMiddleNode(list2, 5)); //[1, 2]
92 | // console.log(deleteKthNodeAfterMiddleNode(list3, 0)); //[1]
93 | // console.log(deleteKthNodeAfterMiddleNode(list4, 3)); //[2, 9, 4]
94 |
95 |
96 |
--------------------------------------------------------------------------------
/Weekly Gather Mentor Office Hours/BacktrackingwSophie_06-16-22.js:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | Given an array of distinct integers candidates and a target integer target, return a list of all unique combinations of candidates where the chosen numbers sum to target. You may return the combinations in any order.
4 |
5 | The same number may be chosen from candidates an unlimited number of times. Two combinations are unique if the frequency of at least one of the chosen numbers is different.
6 |
7 | It is guaranteed that the number of unique combinations that sum up to target is less than 150 combinations for the given input.
8 |
9 |
10 | [1, 2, 3] target: 4
11 | [[1, 3], [2, 2], [1, 1, 1, 1], [1, 1, 2], [-1, 2, 3]]
12 |
13 | Relevant?
14 | - powerset
15 | - 2^n
16 |
17 | target: 8
18 | + 1 +2 +3
19 | target: 7, target: 6, target: 5
20 | x y z
21 |
22 | return x+y+z
23 |
24 | [1, 3], target: 4
25 |
26 | +3 +1
27 | target:1 target: 3
28 | [1] [1,1,1], [3]
29 |
30 | [1, 3], [1, 1, 1, 1], [1, 3]
31 |
32 | Coin change: how many ways to add to target with set of coins?, minimum coins needed to target the target
33 | 1 2 3 4
34 | 1
35 | 2
36 | 3
37 | x
38 | go through dp
39 | code up backtracking xxxxxxx
40 | next question x xxxXxx
41 |
42 | [1, 2, 3], 4
43 | ^
44 | 1, [1, 2, 3], 3 // pick
45 | ^
46 | 1 [1, 2, 3] 2
47 | ^
48 | _ [1, 2, 3] 3
49 | ^
50 |
51 | _, [1, 2, 3], 4 // dontpick (no duplicate going forward)
52 | ^
53 |
54 |
55 | [1, 2, 3], 8
56 | ^
57 |
58 | 1 [1, 2, 3], 7 /// pick
59 | ^
60 | , [1, 2, 3], 8 /// dontp ick
61 | ^
62 |
63 |
64 | [1, 2, 3] 4
65 |
66 | 1 2 3
67 | 1 2 3 2
68 | 1 1
69 | 1
70 | results = [[1, 1, 1, 1], [1, 1, 2]
71 | pick 1
72 | pick 1
73 | pick 1 pick 2
74 | pick 1 [1, 1, 2]
75 | [1, 1, 1, 1]
76 |
77 | 3
78 | 2 1
79 | 0 4 2 5
80 |
81 |
82 | */
83 |
84 | function uniqueCombos(input, target) {
85 | let results = []
86 | uniqueCombosHelper(input, target, 0, [], results)
87 | return results
88 | }
89 |
90 | function uniqueCombosHelper(input, target, i, combo, results) {
91 | if (target == 0) { // base case - we've found a valid combo!
92 | results.push([...combo])
93 | return
94 | }
95 |
96 | if (input[i] <= target) {
97 | combo.push(input[i])
98 | uniqueCombosHelper(input, target - input[i], i, combo, results) // jiyoon
99 | combo.pop()
100 | }
101 | if (i < input.length - 1) {
102 | uniqueCombosHelper(input, target, i+1, combo, results) // zaneh
103 | }
104 | }
105 |
106 | // console.log(uniqueCombos([1, 2, 3], 4))
107 | // console.log(uniqueCombos([1, 2, 3], 8))
108 | // console.log(uniqueCombos([3, 4], 5))
109 | // console.log(uniqueCombos([], 3))
110 | console.log(uniqueCombos([-1], 3))
--------------------------------------------------------------------------------
/CoreAlgos/LinkedList/7_Summing_LinkedLists/sumTwoEqualLL.js:
--------------------------------------------------------------------------------
1 | // Q. Given two linked lists of "equal" length, sum elements' value at the same position.
2 |
3 | // Examples:
4 | // Given two linked lists:
5 | //head1: 1 ➞ 3 ➞ 5
6 | //head2: -1 ➞ 3 ➞ -10 // returns 0 ➞ 6 ➞ -5
7 |
8 | // Given two linked lists:
9 | //head1: 0
10 | //head2: 0 // returns 0
11 |
12 |
13 | class ListNode {
14 | constructor(value = 0, next = null) {
15 | this.value = value
16 | this.next = next
17 | }
18 | }
19 |
20 | function arrayify(head) { //convert a Linked List output into an Array output
21 | let ptr = head
22 | var array = []
23 | while (ptr != null) {
24 | array.push(ptr.value)
25 | ptr = ptr.next
26 | }
27 | return array
28 | }
29 |
30 | function sumTwoLL(head1, head2) {
31 | // Write your code here.
32 | }
33 |
34 | // Test Cases
35 | const LL1 = new ListNode(1, new ListNode(3, new ListNode(5)))
36 | const LL2 = new ListNode(-1, new ListNode(3, new ListNode(-10)))
37 | const LL3 = new ListNode(1, new ListNode(3, new ListNode(5)))
38 | const LL4 = new ListNode(-1, new ListNode(3))
39 | console.log(arrayify(sumTwoLL(LL1, LL2))) // [0, 6, -5]
40 | console.log(arrayify(sumTwoLL(LL3, LL4))) // [0, 6]
41 | console.log(arrayify(sumTwoLL(new ListNode(0), new ListNode(0)))) //[0]
42 |
43 |
44 | //----------------------------------------------------------------------------------
45 |
46 | //Approaches:
47 |
48 | //Iterative Approach (uncomment below and see how it works in the console)
49 |
50 | /*Question: Why will the following function errors out
51 | when we only set to iterate through h1 like 'while (h1)'??? */
52 |
53 | function sumTwoLLIterative(head1, head2) {
54 | let sumHeads = new ListNode(0);
55 | let curr = sumHeads, h1 = head1, h2 = head2; //<-- variables can be declared and assigned in one line
56 |
57 | while (h1 && h2) { //break the loop when h1 or h2 is null (the loop only continue when both h1 and h2 are both NOT null, if one is null, it will break the loop)
58 | curr.next = new ListNode(h1.value + h2.value);
59 | curr = curr.next;
60 | h1 = h1.next;
61 | h2 = h2.next;
62 | }
63 | console.log("h1: ", h1);
64 | console.log("h2: ", h2);
65 | console.log("sumHeads: ", sumHeads);
66 | console.log("sumHeads.next: ", sumHeads.next);
67 | return sumHeads.next;
68 | }
69 |
70 | //UNCOMMENT BELOW TO TEST:
71 | // const LL6 = new ListNode(1, new ListNode(3, new ListNode(5)))
72 | // const LL7 = new ListNode(-1, new ListNode(3, new ListNode(-10)))
73 | // const LL8 = new ListNode(1, new ListNode(3, new ListNode(5)))
74 | // const LL9 = new ListNode(-1, new ListNode(3))
75 | // console.log(arrayify(sumTwoLLIterative(LL6, LL7))) // [0, 6, -5]
76 | // console.log(arrayify(sumTwoLLIterative(LL8, LL9))) // [0, 6]
77 | // console.log(arrayify(sumTwoLLIterative(new ListNode(0), new ListNode(0)))) //[0]
78 |
79 |
80 | /*
81 | Time Complexity (runtime): O(n)
82 |
83 | Space Complexity (memory): O(1)
84 |
85 | */
86 |
--------------------------------------------------------------------------------
/AlgoMockedInterview/DynamicProgramming/ConceptDrillwSumeet_09-27-22.js:
--------------------------------------------------------------------------------
1 | // Dynamic Programming PDF: https://www.byte-by-byte.com/wp-content/uploads/2019/04/Dynamic-Programming-for-Interviews.pdf
2 | //
3 | //
4 | // 1. First solution (NO CACHE)
5 | // Naive
6 | // Recursive
7 | // 2. Analyze the first solution
8 | // See if it works, and see its runtime complexity
9 | // 3. Identify the Subproblems
10 | // See what you could memoize (cache)
11 | // Saving the results of work you did before (pure function)
12 | //
13 | // "Top down" DP solution
14 | // 4. Turn the solution around
15 | // Bottom-up iterative solution without recursion, using a "DP Matrix"
16 | //
17 | //
18 | // Given two strings text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0.
19 | //
20 | // A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.
21 | //
22 | // For example, "ace" is a subsequence of "abcde".
23 | // A common subsequence of two strings is a subsequence that is common to both strings.
24 |
25 | // // ++..+
26 | // t1 = "ababcd"
27 | // // ++v
28 | // t2 = "abc"
29 | // r = 3
30 | // /*
31 | // "abeeeeeebcd"
32 | // "abbcdeeeeee"
33 | // */
34 | // t1 = "ace"
35 | // t2 = "abc"
36 | // r = 2
37 |
38 | // t1 = "abc"
39 | // t2 = "def"
40 | // r = 0
41 |
42 | // t1 = "aaa"
43 | // t2 = "abb"
44 | // r = 1
45 |
46 | // t1 =""
47 | // t2 = "abb"
48 | // r = 0
49 |
50 | /* v
51 | str1 = 'azc'
52 | str2 = 'ab'
53 |
54 | i = 0
55 | j = 0
56 |
57 | str1[i]==0] == "a"
58 | str2[j]==0] == "a"
59 | match, so count: 1
60 |
61 | i++
62 | j++
63 |
64 | str1[i]==1] == "z"
65 | str2[j]==1] == "b"
66 |
67 | two branches:
68 | - j++ and not i
69 | - i++ and not j
70 |
71 | - pick the bigger branch (max)
72 | */
73 |
74 | function lcs(t1, t2) {
75 | let counts = [0];
76 | let cache = {};
77 |
78 | function dfs(i, j) {
79 | const key = `${i}-${j}`;
80 | if (cache[key] !== undefined) {
81 | return cache[key];
82 | }
83 |
84 | counts[0] += 1;
85 | if (i >= t1.length) return 0;
86 | if (j >= t2.length) return 0;
87 |
88 | if (t1[i] === t2[j]) {
89 | cache[key] = 1 + dfs(i + 1, j + 1);
90 | } else {
91 | cache[key] = Math.max(dfs(i, j + 1), dfs(i + 1, j));
92 | }
93 | return cache[key];
94 | }
95 | const ret = dfs(0, 0);
96 | console.log("this took", counts, "comparisons");
97 | return ret;
98 | }
99 |
100 | console.log(lcs("abc", "abcdefabc"), 3);
101 | console.log(lcs("aaa", "abb"), 1);
102 | console.log(lcs("abc", ""), 0);
103 | console.log(
104 | lcs("abc", "ajiojwoiefjiowejfioewjfiobwjieofjoiewjfiewjfoicjiweofjoiwef"),
105 | 3
106 | );
107 | console.log(
108 | lcs(
109 | "abcjiofjawofiejawoeifjaowef",
110 | "ajiojwoiefjiowejfioewjfiobwjieofjoiewjfiewjfoicjiweofjoiwef"
111 | ),
112 | 3
113 | );
114 |
--------------------------------------------------------------------------------
/CoreAlgos/BinaryTree/BinarySearchTree/validateBST.js:
--------------------------------------------------------------------------------
1 | /*
2 | Validate a Binary Search Tree
3 |
4 | Binary Search Tree - all the left (+ child) nodes should be smaller than the root node,
5 | and all the right (+ child) nodes should be larger than the root node
6 |
7 | 6
8 | / \
9 | 3 8
10 | / \
11 | 2 4
12 |
13 |
14 | */
15 |
16 | class TreeNode {
17 | constructor(value = 0, leftChild = null, rightChild = null) {
18 | this.value = value
19 | this.left = leftChild
20 | this.right = rightChild
21 | }
22 | }
23 |
24 | function validateBST(tree) {
25 |
26 | }
27 |
28 | // Test Cases
29 | var tree1 = new TreeNode(2, new TreeNode(1), new TreeNode(3))
30 | var tree2 = new TreeNode(1, new TreeNode(2), new TreeNode(3))
31 | var tree3 = new TreeNode(8, new TreeNode(3, new TreeNode(1), new TreeNode(6)), new TreeNode(10, null, new TreeNode(14, new TreeNode(13))))
32 | console.log(validateBST(null)) // true
33 | console.log(validateBST(tree1)) // true
34 | console.log(validateBST(tree2)) // false
35 | console.log(validateBST(tree3)) // true
36 | console.log(validateBST(new TreeNode())) // true
37 |
38 | //----------------------------------------------------------------------------------
39 |
40 | //Approaches:
41 |
42 | //Recursive Approach:
43 |
44 | function validateBST(tree, min = -Infinity, max = Infinity) {
45 | if (!tree) return true;
46 | // console.log(tree);
47 | // console.log("Minimum: ", min);
48 | // console.log("Maximum: ", max);
49 | if (tree.value <= min || tree.value > max) return false;
50 | return validateBST(tree.left, min, tree.value) && validateBST(tree.right, tree.value, max);
51 | }
52 |
53 | //Another approach (but pretty confusing in the last line in the function)
54 | // function solution(root, min = -Infinity, max = Infinity) {
55 | // if (!root) return null;
56 | // if (root.value <= min || root.value > max) return false;
57 | // let left = solution(root.left, min, root.value),
58 | // right = solution(root.right, root.value, max);
59 | // return typeof left === 'undefined' && typeof right === 'undefined' ? true : left === false || right === false ? false : true;
60 | // }
61 |
62 |
63 | /*
64 | Another Approach - based on a fellow asked in Mattermost
65 | Creating a header function.
66 | */
67 | function validate_bst(node) {
68 | return helper(node, -Infinity, Infinity);
69 | }
70 |
71 | function helper(node, min, max) {
72 | if (!node) return 1;
73 | if (node.value <= min || node.value > max) return 2;
74 |
75 | const left = helper(node.left, min, node.value);
76 | const right = helper(node.right, node.value, max);
77 |
78 | if (left === 2) {
79 | return left;
80 | }else {
81 | return right;
82 | }
83 | // Same expression as the above if statement, but in the ternary expression (below):
84 | // return left === 2 ? left : right === 2 ? right : left;
85 | }
86 |
87 | const tree2 = new TreeNode(1, new TreeNode(2), new TreeNode(3))
88 | console.log(validate_bst(tree2));
--------------------------------------------------------------------------------
/CoreAlgos/LinkedList/6_Reversing/reverse.js:
--------------------------------------------------------------------------------
1 | /*
2 | Q. Reverse a given linked list.
3 |
4 | Examples:
5 | • Given a linked list: 13 ➞ 1 ➞ 5 ➞ 3 ➞ 7 ➞ 10 // returns 10 ➞ 7 ➞ 3 ➞ 5 ➞ 1 ➞ 13
6 | • Given a linked list: 1 // returns 1
7 | */
8 |
9 | class ListNode {
10 | constructor(value = 0, next = null) {
11 | this.value = value
12 | this.next = next
13 | }
14 | }
15 |
16 | function arrayify(head) {
17 | let ptr = head
18 | var array = []
19 | while (ptr != null) {
20 | array.push(ptr.value)
21 | ptr = ptr.next
22 | }
23 | return array
24 | }
25 |
26 | function reverse(head) {
27 | }
28 |
29 |
30 | // Test Cases
31 | const LL1 = new ListNode(13, new ListNode(1, new ListNode(5, new ListNode(3, new ListNode(7, new ListNode(10))))))
32 | console.log(arrayify(reverse(new ListNode(1)))) // [1]
33 | console.log(arrayify(reverse(new ListNode(1, new ListNode(2))))) // [2, 1]
34 | console.log(arrayify(reverse(LL1))) // [10, 7, 3, 5, 1, 13]
35 |
36 | //----------------------------------------------------------------------------------
37 |
38 | //Approaches: (Take a look at the visualization to help to understand the concept)
39 |
40 | //Time: O(n)
41 |
42 | function reverseIterative(head) {
43 | let curr = head;
44 | let prev;
45 | while(curr) {
46 | const holdNext = curr.next;
47 | curr.next = prev;
48 | prev = curr;
49 | curr = holdNext;
50 | }
51 | return prev;
52 | }
53 |
54 | // Test Cases
55 | const LL2 = new ListNode(13, new ListNode(1, new ListNode(5, new ListNode(3, new ListNode(7, new ListNode(10))))))
56 | console.log(arrayify(reverseIterative(new ListNode(1)))) // [1]
57 | console.log(arrayify(reverseIterative(new ListNode(1, new ListNode(2))))) // [2, 1]
58 | console.log(arrayify(reverseIterative(LL2))) // [10, 7, 3, 5, 1, 13]
59 |
60 |
61 | /*
62 | Visualization
63 |
64 | null 1 2 3 4
65 | p c
66 |
67 | null 1 (2 3 4)
68 | p c h---h
69 |
70 | (1 null)
71 | p c c.next
72 |
73 |
74 | 2 (1 null)
75 | c p
76 |
77 | (3 4)
78 | h-h
79 |
80 | 2 1 null
81 | c c.next
82 |
83 | 2 1 null
84 | p
85 |
86 | 3 (2 1 null)
87 | c p
88 |
89 | (4)
90 | h
91 |
92 | 3 2 1 null
93 | c c.next
94 |
95 | 3 2 1 null
96 | p
97 |
98 | 4 3 2 1 null
99 | c p
100 |
101 | h = null
102 |
103 | null 4 3 2 1 null
104 | c p
105 |
106 | h = null
107 |
108 | return p
109 |
110 | */
111 |
112 |
113 | /*
114 | Another Apporach (that handle edge cases):
115 |
116 | Input:
117 | list: []
118 | Expected Output:
119 | []
120 |
121 | function reverse(list) {
122 | let curr = list;
123 | let prev = null;
124 | while (curr) {
125 | let holdNext = curr.next;
126 | curr.next = prev;
127 | prev = curr;
128 | curr = holdNext;
129 | }
130 | return prev === null ? [] : prev;
131 | }
132 |
133 |
134 | */
--------------------------------------------------------------------------------
/AlgoMarathon/Arrays/PairLearning/cellTowerswBrian.js:
--------------------------------------------------------------------------------
1 | /*
2 | One-on-One with Brian Do!!! (around close to 2hrs)
3 |
4 | ATTEMPT #1
5 |
6 | Prompt (This is considered a MEDIUM TYPE problem)
7 |
8 | You are given an array representing the positions of cell towers along a 2 dimensional line. You are given a second array representing positions of customers across the same 2 dimensional line. Given these two inputs, you must determine a signal strength k such that every customer is covered by at least one cell tower. All cell towers must have the exact same signal strength and covers customers to its left and right equally.
9 |
10 | Function Signature:
11 | def search(listener, towers):
12 |
13 |
14 | leftI: 0
15 |
16 | left: 3
17 | right: Infinity
18 |
19 | time: O(nlogn + mlogm) if both arrays are unsorted
20 | time: O(n + m) if both arrays are sorted
21 |
22 |
23 |
24 | for (customers)
25 | while towers[leftI] < currCustomer
26 |
27 | towers: [2, 3, 5, 6]
28 | customers: [4, 20, 5]
29 | k = 14
30 |
31 | smallestDistanceNeeded = 3
32 | lastEncountered = customer
33 | lastEncounteredI = 4
34 |
35 | k = 3
36 |
37 | i
38 | ....1.......1....1......
39 | ...o.....o........o......
40 |
41 |
42 |
43 | 1. sort the towers array and the customers array
44 | 2. iterate through the customers array
45 | 3. find the closest tower on the left and right side of the customer and update k
46 | - set the left variable to -Infinity, the right varaible to Infinity
47 | - find the 2 towers that are closest to the customer in terms of distance, compare them, and only update k based on the highest smallest difference found.
48 | */
49 |
50 | function search(customers, towers) {
51 | customers.sort((a, b) => a - b); // also no.
52 | towers.sort((a, b) => a - b); // no.
53 |
54 | let k = 0
55 | let towerI = 0;
56 |
57 | for (let i = 0; i < customers.length; i++) {
58 | let left = -Infinity;
59 | let right = Infinity;
60 |
61 | while (customers[i] > towers[towerI]) {
62 | left = towers[towerI++]
63 | }
64 | right = towers[towerI] ?? Infinity //undefined or null. || (falsy) or ?? (nullish)
65 |
66 |
67 | const leftDistance = Math.abs(left - customers[i])
68 | const rightDistance = Math.abs(right - customers[i])
69 | const closestTowerDistance = Math.min(leftDistance, rightDistance)
70 | k = Math.max(k, closestTowerDistance)
71 | }
72 |
73 | return k
74 | }
75 |
76 |
77 | console.log(search([4, 5, 20], [2, 3, 5, 6]), 14);
78 | console.log(search([4, 5, 20], [2, 3, 5, 6, 21]), 1);
79 |
80 |
81 |
82 |
83 | // Javascript Solution (Formation)
84 | function search(listener, towers) {
85 | let maxTowerDistance = Number.MAX_SAFE_INTEGER;
86 | let towerIdx = 0;
87 | for (let i = 0; i < listener.length; i++) {
88 | while(towerIdx + 1 < towers.length
89 | && Math.abs(listener[i] - towers[towerIdx]) <= Math.abs(listener[i] - towers[towerIdx + 1])) {
90 | towerIdx++;
91 | }
92 | maxTowerDistance = Math.min(maxTowerDistance, Math.abs(listener[i] - towers[towerIdx]));
93 | }
94 | return maxTowerDistance;
95 | }
--------------------------------------------------------------------------------
/Weekly Gather Mentor Office Hours/SodukuMatrixRotateMatrixwTonyandDaniel_07-21-22.py:
--------------------------------------------------------------------------------
1 | '''
2 | Tony and Daniel Office hours on Algo Marathon
3 |
4 | Approach the problem in High level Perspective First
5 | '''
6 |
7 |
8 | def rotate(matrix):
9 |
10 | # YES: iterate through the top left corners of the enclosing boxes
11 | # YES: stop when you're at or past the center of the square matrix
12 | # NO: loop from 0 to the center
13 | nesting = 0
14 | while nesting <= len(matrix)//2:
15 |
16 | for col in range(nesting, len(matrix) - nesting - 1):
17 | # do one musical chairs
18 | musicalChairs(matrix, nesting, col)
19 |
20 | nesting += 1
21 |
22 |
23 |
24 |
25 | def musicalChairs(matrix, nesting, col): # indexing is tricky
26 | temp = matrix[nesting][col]
27 | matrix[nesting][col] = matrix[nesting][len(matrix)-col-1]
28 | matrix[nesting][len(matrix)-col-1] = matrix[len(matrix)-nesting-1][len(matrix)-col-1]
29 | matrix[len(matrix)-nesting-1][len(matrix)-col-1] = matrix[len(matrix)-nesting-1][col]
30 | matrix[len(matrix)-nesting-1][col] = temp
31 |
32 |
33 | matrix = [[1,2,3],[4,5,6],[7,8,9]]
34 | print("Pre-rotation")
35 | print(matrix)
36 | print("\n\nPost-rotation")
37 | rotate(matrix)
38 | print(matrix[0])
39 | print(matrix[1])
40 | print(matrix[2])
41 |
42 | '''
43 |
44 | store the value at [0][0] then
45 | [0][0] gets the value in
46 | [0][2] gets the value in
47 | [2][2] gets the value in
48 | [2][0]
49 |
50 | now we have to do this for all the elements in the row up to length-2
51 | now we go down and right once [1][1], repeat for all elements in the row up to length-3
52 | stop when you're at or past the center of the square matrix
53 |
54 | # Mike's algorithm aka 4 way musical chairs
55 | temp = a
56 | a = b
57 | b = c
58 | c = d
59 | d = a
60 |
61 | Input:
62 | 1 2 3 1
63 | 3 5 5 2
64 | 2 5 5 3
65 | 1 3 2 1
66 |
67 | Output:
68 | 1 2 3 1
69 | 3 5 5 2
70 | 2 5 5 3
71 | 1 3 2 1
72 |
73 | '''
74 |
75 | # Not exactly but close: https://leetcode.com/problems/valid-sudoku/
76 | # Each row must contain the digits 1-9 without repetition.
77 | # Each column must contain the digits 1-9 without repetition.
78 | # Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition.
79 |
80 | # n = number of rows/col
81 | # Time Complexity: O(nlogn)
82 | # O(n*n*n) = O(n^3)
83 |
84 |
85 | # n^2 + n^2 + n^2 = 3n^2 = O(n^2) where n is the number of rows/cols
86 | # O(r*c) where r is the number of rows and c is the number of cols
87 | # O(t) where t is the number of cells
88 | # O(1) because the size is always 81 cells
89 |
90 |
91 |
92 | # Agree |
93 | # Disagree | X
94 |
95 | """
96 | Complexity:
97 | A: O(log N) |
98 | B: O(N) |
99 | C: O(N^2) |x
100 | D: O(1) | ----- WINNER!!!!!! 😲
101 | E: O(N^3) |
102 | """
103 |
104 | def isValidSudoku(matrix):
105 | return areRowsValid(matrix) \
106 | and areColsValid(matrix) \
107 | and areCellsValid(matrix)
108 |
109 | def areRowsValid(matrix):
110 | pass
111 |
112 | def areColsValid(matrix):
113 | pass
114 |
115 | def areCellsValid(matrix):
116 | pass
--------------------------------------------------------------------------------
/AlgoMockedInterview/1-on-1-with-Mentor /Afeez_08-25-22.js:
--------------------------------------------------------------------------------
1 | /*
2 | You are given a nested list of integers nestedList. Each element is either an integer or a list whose elements may also be
3 | integers or other lists. Implement an iterator to flatten it.
4 |
5 | Implement the NestedIterator class:
6 |
7 | - NestedIterator(List nestedList) Initializes the iterator with the nested list nestedList.
8 | - int next() Returns the next integer in the nested list.
9 | - boolean hasNext() Returns true if there are still some integers in the nested list and false otherwise.
10 |
11 | Your code will be tested with the following pseudocode:
12 |
13 | initialize iterator with nestedList
14 | res = []
15 | while iterator.hasNext()
16 | append iterator.next() to the end of res
17 | return res
18 |
19 | If res matches the expected flattened list, then your code will be judged as correct.
20 |
21 | Example 1:
22 |
23 | Input: nestedList = [[1,1],2,[1,1]]
24 | Output: [1,1,2,1,1]
25 | Explanation: By calling next repeatedly until hasNext returns false,
26 | the order of elements returned by next should be: [1,1,2,1,1].
27 |
28 | Example 2:
29 |
30 | Input: nestedList = [1,[4,[6]]]
31 | Output: [1,4,6]
32 | Explanation: By calling next repeatedly until hasNext returns false,
33 | the order of elements returned by next should be: [1,4,6].
34 |
35 |
36 | next
37 |
38 | hasNext
39 |
40 | [1, 4, 6]
41 |
42 | [1,[4,6]]
43 |
44 | ^
45 |
46 | number vs array
47 |
48 | //item.length
49 |
50 | Recursion (DFS)
51 |
52 | base case: when it has reached the end of the array
53 |
54 | recrusive: everytime it is an array,
55 |
56 | dfs(i + 1)
57 |
58 | Array.isArray()
59 |
60 |
61 | edge case: object
62 |
63 | */
64 |
65 | let num = 3
66 | console.log(num.length);
67 | console.log(Number([1,2]));
68 |
69 | /**
70 | * Your NestedIterator will be called like this:
71 | * var i = new NestedIterator(nestedList), a = [];
72 | * while (i.hasNext()) a.push(i.next());
73 | */
74 | 1
75 | [1, [2, 17, 7], 4]
76 | class NestedIterator {
77 | constructor(nestedList) {
78 | this._flattenList(nestedList)
79 | }
80 |
81 | _flattenList(nestedList) {
82 | let res = [];
83 |
84 |
85 | function dfs(nestedList, age) {
86 | //recursive call when the list item is an array
87 | //dfs(nestedList)
88 |
89 | age++; //21
90 |
91 |
92 | for (let i = 0; i < nestedList.length; i++) {
93 | if (!Array.isArray(nestedList[i])) {
94 | res.push(nestedList[i]);
95 | } else {
96 | dfs(nestedList, age);
97 | }
98 |
99 | }
100 |
101 |
102 | }
103 | dfs(nestedList, 19)
104 | return res;
105 | }
106 |
107 | hasNext() {
108 | return this._position < this._integers.length;
109 | }
110 |
111 | next() {
112 | if (!this.hasNext()) return undefined;
113 |
114 | return this._integers[this._position++];
115 | }
116 | }
117 |
118 | let list = new NestedIterator([[1,1],2,[1,1]])
119 |
120 |
121 | [1, [2, 17, 7], 4]
122 |
123 | res = [1,2, 17, 7]
124 |
125 | // https://leetcode.com/problems/flatten-nested-list-iterator/
--------------------------------------------------------------------------------
/1-on-1-w-Mentor-Fellow/authurDamm_DFS_Recursion.js:
--------------------------------------------------------------------------------
1 | class TreeNode {
2 | constructor(value = 0, leftChild = null, rightChild = null) {
3 | this.value = value
4 | this.left = leftChild
5 | this.right = rightChild
6 | }
7 | }
8 |
9 | function arrayifyTree(root) {
10 | if (!root) { return [] }
11 | var queue = []
12 | var array = []
13 | queue.push(root)
14 | while (queue.length !== 0) {
15 | var node = queue.shift()
16 | array.push(node.value)
17 | if (node.left) { queue.push(node.left) }
18 | if (node.right) { queue.push(node.right) }
19 | }
20 | return array
21 | }
22 |
23 | /*
24 | Given a binary tree, return the deepest node (furthest away child).
25 | Examples
26 | . a
27 | . / \
28 | . b c
29 | . /. \
30 | .d. e
31 | \
32 | f
33 | returns d
34 | equal depth in both right and left - return one of them
35 |
36 | ORDER of DFS calls (recursive call stack): a
37 |
38 | How many approaches to solve this problem?
39 |
40 | DFS (naturally recursive)
41 | */
42 |
43 |
44 | // dfsDepth(node, depth_of_parent) // depth
45 | // each node knows its depth is 1 + depth_of_parent
46 |
47 |
48 | function depthOfTree(root) { //top down pre order
49 | let maxDepth = -Infinity;
50 | let deepestNode = null;
51 | function depthDFS(root, depth) {
52 | // if (!root) return;
53 | if (depth > maxDepth) {
54 | maxDepth = depth;
55 | deepestNode = root;
56 | }
57 | depthDFS(root.left, depth+1)
58 | depthDFS(root.right, depth+1)
59 | }
60 | depthDFS(root, 0);
61 | return deepestNode;
62 | }
63 |
64 | // const tree1 = new TreeNode('a', new TreeNode('b', new TreeNode('d')), new TreeNode('c', null, new TreeNode('e', null, new TreeNode('f'))));
65 | // console.log(depthOfTree(tree1));
66 |
67 |
68 |
69 | // Preorder, inorder, postorder
70 |
71 |
72 | // heightOfTree(root) { //bottom up post order
73 |
74 | // const nodeHeights = {}; // {node: height}
75 |
76 | // function heightDFS(node) { // node =b
77 |
78 | // if (!node) return 0;
79 |
80 | // post-order, children first then root
81 | // const left = heightDFS(node.left)
82 | // const right = heightDFS(node.right)
83 | // const myHeight = Math.max(left, right);
84 |
85 | // nodeHeights[node] = myHeight; // { d: 0, b: 1, c: 0, a:2 }
86 | // return 1 + myHeight;
87 | // }
88 |
89 | // let x = heightDFS(root); // returns 3
90 | // return nodeHeights[root];
91 |
92 | // }
93 |
94 |
95 |
96 | // let lowestCommonAncestor = (root, c1, c2) => {
97 | // return solution(root, c1, c2)
98 |
99 | // };
100 |
101 | // function solution(root, val1, val2) {
102 | // if (!root || root === val1 || root === val2) {
103 | // return root;
104 | // }
105 |
106 | // const left = solution(root.left, val1, val2);
107 | // const right = solution(root.right, val1, val2);
108 |
109 | // if (left && right) {
110 | // return root;
111 | // }
112 |
113 | // return left ? left : right;
114 | // }
--------------------------------------------------------------------------------
/Weekly Gather Mentor Office Hours/AddOneRowToATreewDaniel_07-07-22.js:
--------------------------------------------------------------------------------
1 |
2 |
3 | /*
4 | Who thinks:
5 | - BFS is easier to code ***********
6 | - DFS is easier to code *******
7 |
8 | https://leetcode.com/problems/add-one-row-to-tree/
9 |
10 |
11 | Given the root of a binary tree and two integers val and depth, add a row of nodes with value val at the given depth depth.
12 |
13 | Note that the root node is at depth 1.
14 |
15 | The adding rule is:
16 |
17 | Given the integer depth, for each not null tree node cur at the depth depth - 1, create two tree nodes with value val as cur's left subtree root and right subtree root.
18 | cur's original left subtree should be the left subtree of the new left subtree root.
19 | cur's original right subtree should be the right subtree of the new right subtree root.
20 | If depth == 1 that means there is no depth depth - 1 at all, then create a tree node with value val as the new root of the whole original tree, and the original tree is the new root's left subtree.
21 | */
22 | class Node {
23 | constructor(val, left, right) {
24 | this.val = val;
25 | this.left = left;
26 | this.right = right;
27 | }
28 | }
29 |
30 | function addOneRow(root, val, depth) {
31 |
32 | if (!root) return null;
33 |
34 | if (depth === 1) { // insert @ the root
35 | const newRoot = new Node(val, root);
36 | return newRoot;
37 | }
38 |
39 | let read = [root];
40 | let write = [];
41 | let writeDepth = 2; // if depth=2: dont enter loop (insert @ the root's children)
42 | // Collect the nodes at depth - 1 using BFS
43 | while (writeDepth < depth - 1) { // SAME AS while (writeDepth <= depth) {
44 | for (const node of read) {
45 | if (node.left) {
46 | write.push(node.left);
47 | }
48 | if (node.right) {
49 | write.push(node.right);
50 | }
51 | }
52 | read = write;
53 | write = [];
54 | writeDepth++;
55 | }
56 |
57 | // Iterate over the collected node and perform the required operations
58 | for (const node of read) {
59 | const newLeft = new Node(val, node.left);
60 | const newRight = new Node(val, node.right);
61 | node.left = newLeft;
62 | node.right = newRight;
63 | }
64 |
65 | return root;
66 | }
67 |
68 |
69 |
70 | const matrix = getMatrix();
71 |
72 | // n = total size
73 | // r = number of rows
74 | // c = number of columns
75 | // O(n)
76 | // O(r * c)
77 | // r * c = n
78 | // r == c
79 | // O(r^2)
80 |
81 | // Name: row-major traversal
82 | // for (let row = 0; row < matrix.length; row++) { // for each row
83 | // const currentRow = matrix[row];
84 | // for (let col = 0; col < currentRow.length; col++) { // for each element in that row
85 | // // do something here
86 | // }
87 | // }
88 |
89 | // Column major traveral
90 |
91 | // for (let col = 0; col < matrix[0].length; col++) { // for each column
92 | // for (let row = 0; row < matrix.length; row++) { // for each element in that column
93 | // }
94 |
95 | // for each row
96 | // describe the work to be done on that row in english
97 |
98 |
99 |
100 |
101 |
102 |
--------------------------------------------------------------------------------
/AlgoMarathon/Arrays/PairLearning/dogsAndHatswNancy.js:
--------------------------------------------------------------------------------
1 | /*
2 | One of the most common uses of a queue is to keep a list of "work to be done". Just like doing housework, often new things get added to the TODO list while doing some other task. New jobs get added to the end of the queue, and when one is complete, the next one is taken from the top of the list.
3 | Oliver is missing his favorite hat and is asking his friends at the dog park if they've seen it. Each dog either has seen it or suggests a list of other dogs to ask. Return the name of the dog who has seen the hat. Oliver starts out by asking his best friend. This function will take two parameters. The first is a map of dogs to a list of their friends. The second is Oliver's best friend, who Oliver will ask first.
4 |
5 | Function Signature:
6 | function findHat(dogs, bestFriend)
7 |
8 | Target runtime and space complexity:
9 | O(n)
10 |
11 | Examples:
12 | const dogs = {
13 | 'Carter': ['Fido', 'Ivy'],
14 | 'Ivy': ["HAT"], // Ivy has seen the hat
15 | 'Loki': ['Snoopy'],
16 | 'Pepper': ['Carter'],
17 | 'Snoopy': ['Pepper'],
18 | 'Fido': []
19 | };
20 |
21 | console.log(findHat(dogs, 'Loki')); // returns 'Ivy'
22 | */
23 |
24 |
25 | /*
26 |
27 | Questions:
28 | what if no one sees Ivy!! (we need to ask for clarification)
29 | what if no one sees the Hat!! (throw an error)
30 | Should the order of the seen dogs matter?
31 |
32 |
33 | approach:
34 | - queue: order of dogs to ask
35 | - set: dogs that we have asked
36 |
37 | */
38 |
39 |
40 | function findHat(dogs, bestFriend) {
41 | let queue =[bestFriend];
42 | let askedDogs = new Set();
43 | while (queue.length > 0) {
44 | let currentDog = queue.pop();
45 |
46 | if (dogs[currentDog][0] === 'HAT') return currentDog;
47 |
48 | dogs[currentDog].forEach(dog => {
49 | if (!askedDogs.has(dog)) askedDogs.add(dog)
50 | })
51 |
52 |
53 | // let dog = queue.pop(); //or shift()
54 | // if(!askedDogs.has(dog)) { //if we have not asked the dog
55 | // askedDogs.add(dog);
56 | // queue = [...queue, ...dogs[dog]];
57 | // }
58 | // if(dogs[dog][0] === 'HAT') {
59 | // return dog;
60 | // }
61 | }
62 | return "No Hat Found!";
63 | }
64 | /*
65 | Loki
66 | |
67 | Snoopy
68 | |
69 | Pepper
70 |
71 |
72 | W
73 | e. h
74 | t. a
75 | t.
76 |
77 |
78 |
79 | */
80 |
81 | //Test cases
82 | const dogs = {
83 | 'Carter': ['Fido', 'Ivy'],
84 | 'Ivy': ["HAT"], // Ivy has seen the hat
85 | 'Loki': ['Snoopy'],
86 | 'Pepper': ['Carter', 'loki'],
87 | 'Snoopy': ['Pepper'],
88 | 'Fido': []
89 | };
90 | const dogs2 = { //edge case that does not taken into consideration in this problem, we have assumed all the dogs at least know other dogs in the list
91 | 'Carter': ['Fido'],
92 | 'Ivy': ['HAT'],
93 | 'Loki': ['Snoopy'],
94 | 'Pepper': ['Carter'],
95 | 'Snoopy': ['Pepper'],
96 | 'Fido': []
97 | };
98 |
99 |
100 | console.log(findHat(dogs, 'Loki')); // returns 'Ivy'
101 | console.log(findHat(dogs2, 'Loki')); // return 'no hat found'
102 |
103 |
104 |
105 |
106 |
107 |
--------------------------------------------------------------------------------
/Public-Formation-Events/README.md:
--------------------------------------------------------------------------------
1 | # Formation Events
2 |
3 |
6 |
7 | ## NextDoor x Formation Panel Discussion (Live Stream) - 09/13/2022
8 |
9 | `YOU ARE WORTH SO MUCH MORE`
10 |
11 | Takeaways:
12 | - `When there are constraints, focus on your values and strength`
13 | - Sophie Advice on Job Searching:
14 | 1. Companies are taking leveling more seriously
15 | - focus more on system design is key
16 | 2. Past Experience
17 | - focus on presenting and promoting yourself to the public
18 | - Practical skills matter in actual interview setting
19 | - The more projects skill you have the better it is!
20 | - It is okay to take the time to figure out what you want
21 | - find any possible ways to help you to get into your desired companies
22 | - In terms of learning, think of yourself as a Founding Team member. Take Risk, pressure on learning, start something from ground zero
23 | - `WHAT YOU WANT` is key for job searching
24 | - FIGURE OUT your STRENGTH and what you want to work on
25 | - Companies are looking for `Good Fit People` and they want the people they hire can follow the engineering team structure!
26 | - If you are interested in and building social app?
27 | - Learn to build a news feed
28 | - Learn to build a prototype for a messenger app
29 | - building anything practical is the best way to prepare for social app companies ie, Facebook, NextDoor, etc.
30 | - `PICK THE RIGHT OPPORTUNITY` IS IMPORTANT
31 | - invest in yourself
32 | - find a role that matches your passion
33 | - invest in your network
34 | - where you start can impact and determine where you finish
35 | - WHERE IS YOUR `EXCITEMENT` AND WHERE CAN YOU `PUT YOUR ENERGY IN THE WORLD`?
36 | - `FINDING YOUR PURPOSE IN LIFE`
37 | - you can then lead with purpose and be on the driver seat
38 | - authenticity will show when you are doing what you like the most
39 | - Look into your `Ikigai` - key part of ikigai requires a concrete action that leads you closer to the meaningful goal to you. Everyone is different, so `what is your purpose in life? what do you want to do in your next role?`
40 |
41 |
42 | ## Formation Day - 10/01/2022
43 |
44 | Attended 4 events at Formation:
45 | (1) Engineering Method with Daniel
46 | (2) Algo Studio with Daniel
47 | (3) Algo Studio Session with Jeremy and Sophie
48 | (4) Algo Code Drill Session with Sophie
49 |
50 | Really helpful and knowledgable sessions. Even though I still need to work on my speed in understanding a problem and be able to fully understand what it means and what it is about.
51 |
52 | Takeaways:
53 | - Ask relevant questions to the problem
54 | - Take the time to explore the problem
55 | - Make sure to document down my high level understanding in plain English and not in Code
56 | - Make sure to fully understood the problem and make sure to have an insight on all the possible test cases (happy and edge cases) as well as knowing the input and output of the problem
57 | - It is okay in the interview that the interviewer has helped you. It would be great if you could solve the problem on your own through communicating with the interviewer, but if the interviewer can sense that you are stuck, a good intervewer will step in to make sure you can learn something from the session and able to give more guidance.
--------------------------------------------------------------------------------