[eunice-hong] Week 1

contains-duplicate/eunice-hong.ts

@@ -0,0 +1,15 @@
+
+/**
+ * Determines if the array contains any duplicate values.
+ * Uses a Set to track seen numbers for O(n) time complexity.
+ *
+ * @param nums - An array of integers.
+ * @returns `true` if there are duplicates, `false` otherwise.
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ */
+function containsDuplicate(nums: number[]): boolean {
+  let numSet = new Set(nums);
+  return numSet.size != nums.length;
+};

house-robber/eunice-hong.ts

@@ -0,0 +1,16 @@
+/**
+ * Finds the maximum amount of money that can be robbed without robbing two adjacent houses.
+ * Uses dynamic programming to track the best outcome at each step.
+ * 
+ * @param {number[]} nums
+ * @return {number}
+ */
+function rob(nums: number[]): number {
+    const dp = new Array(nums.length + 1);
+    dp[0] = 0;
+    dp[1] = nums[0];
+    for (let i = 2; i < dp.length; i++) {
+        dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
+    }
+    return dp[dp.length - 1];
+};

longest-consecutive-sequence/eunice-hong.ts

@@ -0,0 +1,26 @@
+/**
+ * Finds the length of the longest consecutive elements sequence.
+ * Eliminates duplicates using a Set and only starts counting when the current number is the beginning of a sequence.
+ *
+ * @param nums - An array of integers.
+ * @returns The length of the longest consecutive sequence.
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ */
+function longestConsecutive(nums: number[]): number {
+  let longest = 0;
+  const numSet = new Set(nums);
+
+  for (const num of numSet) {
+    if (!numSet.has(num - 1)) {
+      let length = 1;
+      while (numSet.has(num + length)) {
+        length++;
+      }
+      longest = Math.max(length, longest);
+    }
+  }
+
+  return longest;
+}

top-k-frequent-elements/eunice-hong.ts

@@ -0,0 +1,23 @@
+
+/**
+ * Finds the k most frequent elements in an array.
+ * Uses a map to count occurrences and then sorts by frequency.
+ *
+ * @param nums - An array of integers.
+ * @param k - The number of most frequent elements to return.
+ * @returns An array of the k most frequent elements.
+ *
+ * Time Complexity: O(n log n)
+ * Space Complexity: O(n)
+ */
+function topKFrequent(nums: number[], k: number): number[] {
+    let numMap = new Map();
+    for (let i = 0; i < nums.length; i++) {
+        numMap.set(nums[i], (numMap.get(nums[i]) ?? 0) + 1);
+    }
+
+    return Array.from(numMap.entries())
+        .sort((a, b) => b[1] - a[1]) 
+        .slice(0, k)
+        .map(([num, _]) => num);
+};

two-sum/eunice-hong.ts

@@ -0,0 +1,24 @@
+/**
+ * Finds two numbers in the array that add up to the target value.
+ * Uses a hash map to store previously seen numbers for O(n) time complexity.
+ *
+ * @param nums - An array of integers.
+ * @param target - The target sum.
+ * @returns A tuple containing the indices of the two numbers.
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ */
+function twoSum(nums: number[], target: number): number[] {
+  const map = new Map<number, number>();
+
+  for (let i = 0; i < nums.length; i++) {
+      const complement = target - nums[i];
+      if (map.has(complement)) {
+          return [map.get(complement)!, i];
+      }
+      map.set(nums[i], i);
+  }
+
+  throw new Error("No solution found");
+}