[yhkee0404] WEEK 02 solutions

3sum/yhkee0404.kt

@@ -0,0 +1,31 @@
+class Solution {
+    fun threeSum(nums: IntArray): List<List<Int>> {
+        val ans = mutableListOf<List<Int>>()
+        nums.sort()
+        for (i in 0 until nums.size) {
+            if (i != 0 && nums[i] == nums[i - 1]) {
+                continue
+            }
+            var j = i + 1
+            var k = nums.size - 1
+            while (j < k) {
+                if (j != i + 1 && nums[j] == nums[j - 1]) {
+                    j++
+                    continue
+                }
+                val u = nums[i] + nums[j]
+                while (j < k && u > - nums[k]) {
+                    k--
+                }
+                if (j >= k) {
+                    break
+                }
+                if (u == - nums[k]) {
+                    ans.add(listOf(nums[i], nums[j], nums[k]))
+                }
+                j++
+            }
+        }
+        return ans
+    }
+}

climbing-stairs/yhkee0404.scala

@@ -0,0 +1,11 @@
+object Solution {
+    def climbStairs(n: Int): Int = {
+        val dp = Array.ofDim[Int](n + 1)
+        dp(0) = 1
+        dp(1) = 1
+        for (i <- 2 to n) {
+            dp(i) = dp(i - 1) + dp(i - 2)
+        }
+        dp(n)
+    }
+}

product-of-array-except-self/yhkee0404.rs

@@ -0,0 +1,16 @@
+impl Solution {
+    pub fn product_except_self(nums: Vec<i32>) -> Vec<i32> {
+        let mut ans = vec![1; nums.len()];
+        let mut a = 1;
+        for i in (0..nums.len()).rev() {
+            ans[i] = a * nums[i];
+            a = ans[i];
+        }
+        a = 1;
+        for i in 0..nums.len() {
+            ans[i] = a * (if i == nums.len() - 1 {1} else {ans[i + 1]});
+            a *= nums[i];
+        }
+        return ans
+    }
+}

valid-anagram/yhkee0404.go

@@ -0,0 +1,11 @@
+func isAnagram(s string, t string) bool {
+    sRune := []rune(s)
+    tRune := []rune(t)
+    sort.Slice(sRune, func(i, j int) bool {
+        return sRune[i] < sRune[j]
+    })
+    sort.Slice(tRune, func(i, j int) bool {
+        return tRune[i] < tRune[j]
+    })
+    return string(sRune) == string(tRune)
+}

validate-binary-search-tree/yhkee0404.ts

@@ -0,0 +1,19 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function isValidBST(root: TreeNode | null, left = - (1 << 30) * 2, right = - (left + 1)): boolean {
+    return root === null || root.val >= left && root.val <= right
+            && (root.left === null || root.val != (- (1 << 30) * 2) && isValidBST(root.left, left, root.val - 1))
+            && (root.right === null || root.val != - (- (1 << 30) * 2 + 1) && isValidBST(root.right, root.val + 1, right))
+};