Merge pull request #13 from nhistory/main

[Sehwan]Added solutions for week1

Author: leokim0922

best-time-to-buy-and-sell-stock/nhistory.js

@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  // Initiate left and right pointer (left: buy price / right: sell price)
+  // Make profit with initiative value 0
+  let l = 0;
+  let r = 1;
+  let profit = 0;
+  // Iterate to check profit = prices[r] - prices[l]
+  while (r < prices.length) {
+    // If profit is positive, compare profit with previous one
+    if (prices[r] > prices[l]) {
+      profit = Math.max(profit, prices[r] - prices[l]);
+      r++;
+    } else {
+      // If profit is negative, move forware left and right pointer
+      l = r;
+      r++;
+    }
+  }
+  return profit;
+};
+
+// TC: O(n)
+// SC: O(3)
+
+console.log(maxProfit([7, 1, 5, 3, 6, 4])); //5
+console.log(maxProfit([7, 6, 4, 3, 1])); //0

contains-duplicate/nhistoy.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  // 1. Make hashmap that has previous value
+  let map = {};
+  // 2. Iterate nums to check nums[i] is duplicated or not
+  for (let i = 0; i < nums.length; i++) {
+    // 2.1 Check there is same value on the map
+    // 3. Return true when their is duplicated value
+    if (nums[i] in map) {
+      return true;
+    } else map[nums[i]] = i;
+  }
+  return false;
+};
+
+// TC: O(n)
+// SC: O(n)
+
+console.log(containsDuplicate([1, 2, 3, 1])); // true
+console.log(containsDuplicate([1, 2, 3, 4])); // false
+console.log(containsDuplicate([1, 1, 1, 3, 3, 4, 3, 2, 4, 2])); // true

two-sum/nhistory.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+  // 1. Make a Hashmap to store { key(index) : value(target-num)}
+  let map = {};
+  // 2. Iterate to find value is equal to (target - nums[i])
+  // There is only one solution
+  for (let i = 0; i < nums.length; i++) {
+    const diff = target - nums[i];
+    // 3. If there is an index that has different value, return array
+    if (diff in map) return [map[diff], i];
+    map[nums[i]] = i;
+  }
+};
+
+// TC: O(n)
+// SC: O(n)
+
+console.log(twoSum([2, 7, 11, 15], 9));
+console.log(twoSum([3, 2, 4], 6));

valid-anagram/nhistory.js

@@ -0,0 +1,38 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function (s, t) {
+  /*
+    // Split string and sort charaters
+    // Compare s and t after sorting
+    return s.split("").sort().join() === t.split("").sort().join()
+    // 92ms, 53.29MB
+    */
+
+  // Made Hashmap and count number of each charater
+  let map = {};
+
+  // Check character length between s and t
+  if (s.length !== t.length) return false;
+  // Put a character and add or substract number
+  for (let i = 0; i < s.length; i++) {
+    // map[s[i]] = map[s[i]] ? map[s[i]] + 1 : 1;
+    map[s[i]] = (map[s[i]] ?? 0) + 1;
+    // map[t[i]] = map[t[i]] ? map[t[i]] - 1 : -1;
+    map[t[i]] = (map[t[i]] ?? 0) - 1;
+  }
+
+  for (let i = 0; i < s.length; i++) {
+    if (map[s[i]] !== 0) return false;
+  }
+
+  return true;
+};
+
+console.log(isAnagram("anagram", "nagaram"));
+console.log(isAnagram("rat", "car"));
+
+// TC: O(n)
+// SC: O(n)

valid-palindrome/nhistory.js

@@ -0,0 +1,43 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function (s) {
+  // 1. Create left and right pointer
+  let l = 0;
+  let r = s.length - 1;
+  // 2. Iterate while loop with l<r condition
+  while (l < r) {
+    // 3. Check character with left pointer is alphanumeric character or not
+    if (
+      (s[l] >= "a" && s[l] <= "z") ||
+      (s[l] >= "A" && s[l] <= "Z") ||
+      (s[l] >= "0" && s[l] <= "9")
+    ) {
+      // 4. Check character with right pointer is alphanumeric character or not
+      if (
+        (s[r] >= "a" && s[r] <= "z") ||
+        (s[r] >= "A" && s[r] <= "Z") ||
+        (s[r] >= "0" && s[r] <= "9")
+      ) {
+        // 5. Compare left and right pointer character
+        if (s[l].toLowerCase() !== s[r].toLowerCase()) {
+          return false;
+        } else {
+          l++;
+          r--;
+        }
+        //    If not, go to next location for right pointer
+      } else r--;
+
+      //    If not, go to next location for left pointer
+    } else l++;
+  }
+  return true;
+};
+
+// TC: O(n)
+// SC: O(n)
+
+console.log(isPalindrome("A man, a plan, a canal: Panama")); //true
+console.log(isPalindrome("race a car")); //false