[tedkimdev] WEEK 02 solutions

3sum/tedkimdev.go

@@ -0,0 +1,52 @@
+// TC: O(n^2)
+// SC: O(m)
+func threeSum(nums []int) [][]int {
+	result := make(map[[3]int]struct{})
+
+	sort.Ints(nums)
+
+	// target value = nums[k]
+	for k := 0; k < len(nums); k++ {
+		left := 0
+		if k == left {
+			left = 1
+		}
+		right := len(nums) - 1
+		if k == right {
+			right = len(nums) - 2
+		}
+
+		target := nums[k]
+		for left < right {
+			sum := nums[left] + nums[right] + target
+			if sum == 0 {
+				if left > k {
+					result[[3]int{nums[k], nums[left], nums[right]}] = struct{}{}
+				} else if left < k && k < right {
+					result[[3]int{nums[left], nums[k], nums[right]}] = struct{}{}
+				} else if k > right {
+					result[[3]int{nums[left], nums[right], nums[k]}] = struct{}{}
+				}
+			}
+			if sum < 0 {
+				left++
+				if k == left {
+					left++
+				}
+			} else {
+				right--
+				if k == right {
+					right--
+				}
+			}
+		}
+
+	}
+
+	filteredResult := [][]int{}
+	for k, _ := range result {
+		filteredResult = append(filteredResult, k[0:len(k)])
+	}
+
+	return result.keys()
+}

climbing-stairs/tedkimdev.rs

@@ -0,0 +1,18 @@
+// TC: O(n)
+// SC: O(1)
+impl Solution {
+    pub fn climb_stairs(n: i32) -> i32 {
+		if n <= 2 {
+			return n;
+		}
+
+		let mut arr: [i32; 2] = [1, 2];
+		let mut current = 0;
+		for n in 3..=n {
+			current = arr[0] + arr[1];
+			arr[0] = arr[1];
+			arr[1] = current;
+		}
+		current
+    }
+}

product-of-array-except-self/tedkimdev.go

@@ -0,0 +1,24 @@
+// TC: O(n)
+// SC: O(n)
+func productExceptSelf(nums []int) []int {
+	result := make([]int, 0)
+
+	left := make([]int, len(nums))
+	left[0] = 1
+
+	right := make([]int, len(nums))
+	right[len(nums)-1] = 1
+
+	for i := 1; i < len(nums); i++ {
+		left[i] = nums[i-1] * left[i-1]
+	}
+
+	for i := len(nums) - 2; i >= 0; i-- {
+		right[i] = nums[i+1] * right[i+1]
+	}
+
+	for i := 0; i < len(nums); i++ {
+		result = append(result, left[i]*right[i])
+	}
+	return result
+}

valid-anagram/tedkimdev.rs

@@ -0,0 +1,18 @@
+// TC: O(n) - n is the length of the strings
+// SC: O(1) - lowercase english letters
+impl Solution {
+    pub fn is_anagram(s: String, t: String) -> bool {
+		if s.len() != t.len() {
+			return false;
+		}
+
+		let mut count_map: HashMap<u8, i32> = HashMap::new();
+
+		for (a, b) in s.bytes().zip(t.bytes()) {
+			*count_map.entry(a).or_insert(0) += 1;
+			*count_map.entry(b).or_insert(0) -= 1;
+		}
+
+		count_map.values().all(|&v| v == 0)
+    }
+}

validate-binary-search-tree/tedkimdev.rs

@@ -0,0 +1,42 @@
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//     pub val: i32,
+//     pub left: Option<Rc<RefCell<TreeNode>>>,
+//     pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+//
+// impl TreeNode {
+//     #[inline]
+//     pub fn new(val: i32) -> Self {
+//         TreeNode {
+//             val,
+//             left: None,
+//             right: None,
+//         }
+//     }
+// }
+
+use std::rc::Rc;
+use std::cell::RefCell;
+
+// TC: O(n)
+// SC: O(n) - skewed tree
+impl Solution {
+    pub fn is_valid_bst(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+		is_valid(root, i64::MIN, i64::MAX)
+    }
+}
+fn is_valid(node: Option<Rc<RefCell<TreeNode>>>, left: i64, right: i64) -> bool {
+	if let Some(n) = node {
+		let node_ref = n.borrow();
+		let val = node_ref.val as i64;
+
+		if val <= left || val >= right {
+			return false;
+		}
+		return is_valid(node_ref.left.clone(), left, val)
+			&& is_valid(node_ref.right.clone(), val, right);
+	}
+	true
+}