[hyunow] 24.11.19 (#100)

* 1 / Two Sum / Easy / 8m

* 104 / Maximum Depth of Binary Tree / Easy / 11m

* 141 / Linked List Cycle / Easy / 32m

* 20 / Valid Parentheses / Easy / 11m

* 202 / Happy Number / Easy / 23m

---------

Co-authored-by: user <user@cseui-MacBookPro.local>

Author: hyunow

hyunow/104_maximum_depth_of_binary_tree.js

@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxDepth = function(root) {
+    if(root === null) {
+        return 0
+    }
+    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1
+};

hyunow/141_linked_list_cycle.js

@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} head
+ * @return {boolean}
+ */
+var hasCycle = function(head) {
+    var slow_pointer = head
+    var fast_pointer = head
+
+    while(fast_pointer !== null && fast_pointer.next !== null) {
+        slow_pointer = slow_pointer.next
+        fast_pointer = fast_pointer.next.next
+        if(slow_pointer === fast_pointer) {
+            return true
+        }
+    }
+
+    return false
+};

hyunow/1_two_sum.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    const n = nums.length;
+    const ans = [];
+
+    for (let i = 0; i < n - 1; i++) {
+        for (let j = i + 1; j < n; j++) {
+            if (nums[i] + nums[j] === target) {
+                ans.push(parseInt(i))
+                ans.push(parseInt(j))
+                return ans
+            }
+        }
+    }
+};

hyunow/202_happy_number.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+var isHappy = function(n) {
+    const seen = new Set()
+
+    while(true) {
+        let sum = 0
+        while (n > 0) {
+            const num = n % 10
+            sum += num ** 2
+            n = Math.floor(n / 10)
+        }
+    
+        if(sum === 1) {
+            return true
+        }
+
+        if(seen.has(sum)) {
+            return false
+        }
+    
+        seen.add(sum)
+        n = sum
+        
+    }
+    
+};

hyunow/20_valid_parentheses.js

@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function(s) {
+    const stack = [];
+    const n = s.length;
+    for (let i = 0; i < n; i++) {
+        if (!stack) {
+            stack.push(s[i])
+        } else {
+            let temp = stack.pop()
+            if( (temp === '(' && s[i] === ')') ||
+                (temp === '{' && s[i] === '}') ||
+                (temp === '[' && s[i] === ']') ) {
+                    continue
+            } else {
+                stack.push(temp)
+                stack.push(s[i])
+            }
+        }
+    }
+    console.log(stack)
+    if(stack.length === 1) {
+        return true
+    } else {
+        return false
+    }
+};