Merge pull request #2465 from robinyoon-dev/main

[robinyoon-dev] WEEK 04 Solutions

Author: robinyoon-dev

best-time-to-buy-and-sell-stock/robinyoon-dev.js

@@ -2,21 +2,49 @@
  * @param {number[]} prices
  * @return {number}
  */
-var maxProfit = function(prices) {
- 
-    // NOTE: 해설 보고 쓴 코드입니다.
-    // i 번째 날에 prices[i]의 가격으로 주식을 팔아서 가장 큰 이익을 내려면 주식을 언제 샀어야 했을까?
-    // 정답은 바로 i 번째 날이 오기 전에 주식이 가장 쌌던 날 입니다!
+var maxProfit = function (prices) {
 
-    let maxProfit = 0;
     let minPrice = prices[0];
+    let maxProfit = 0;
+
+    for (let i = 1; i < prices.length; i++) {
+        let currentPrice = prices[i];
 
-    for(const price of prices){
-        const profit = price - minPrice
-        maxProfit = Math.max(maxProfit, profit);
-        minPrice = Math.min(price, minPrice);
+        if (currentPrice < minPrice) {
+            minPrice = currentPrice;
+        } else{
+            let profit = currentPrice - minPrice;
+            if(profit > maxProfit){
+                maxProfit = profit;
+            }
+        }
     }
 
     return maxProfit;
-
 };
+
+
+// -----아래는 이전에 작성한 답안입니다.
+// /**
+//  * @param {number[]} prices
+//  * @return {number}
+//  */
+// var maxProfit = function(prices) {
+ 
+//     // NOTE: 해설 보고 쓴 코드입니다.
+//     // i 번째 날에 prices[i]의 가격으로 주식을 팔아서 가장 큰 이익을 내려면 주식을 언제 샀어야 했을까?
+//     // 정답은 바로 i 번째 날이 오기 전에 주식이 가장 쌌던 날 입니다!
+
+//     let maxProfit = 0;
+//     let minPrice = prices[0];
+
+//     for(const price of prices){
+//         const profit = price - minPrice
+//         maxProfit = Math.max(maxProfit, profit);
+//         minPrice = Math.min(price, minPrice);
+//     }
+
+//     return maxProfit;
+
+// };
+

coin-change/robinyoon-dev.js

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number} 
+ */
+var coinChange = function (coins, amount) {
+
+    let dp = new Array(amount + 1).fill(Infinity);
+    dp[0] = 0;
+
+    for (let i = 1; i < dp.length; i++) {
+        for (let coin of coins) {
+
+            if (coin > i) {
+                continue;
+            }
+
+            let remain = i - coin;
+            dp[i] = Math.min(dp[i], dp[remain] + 1);
+
+        }
+    };
+
+    let result = dp[amount] === Infinity ? -1 : dp[amount];
+    return result;
+}

find-minimum-in-rotated-sorted-array/robinyoon-dev.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function(nums) {
+    // nums는 rotated 된 array
+    // return 값은 이 nums에서 최솟값을 return 해야함.
+    const NUMS_LENGTH = nums.length;
+
+    let result = nums[0];
+
+    for(let i = 0; i < NUMS_LENGTH; i++ ){
+        let currentIndex = NUMS_LENGTH - i;
+
+        if(nums[currentIndex - 1] > nums[currentIndex]){
+            result = nums[currentIndex];
+        }else{
+            continue;
+        }
+    }    
+    return result;
+};

maximum-depth-of-binary-tree/robinyoon-dev.js

@@ -0,0 +1,24 @@
+/**
+ * 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) {
+
+    //NOTE: 현재 노드의 최대 깊이는 왼쪽 자식 트리의 최대 깊이와 오른쪽 자식 트리의 최대 깊이 중 큰 값에 1(현재 노드)을 더한 값
+    if (root === null) {
+        return 0;
+    }
+
+    const leftDepth = maxDepth(root.left);
+    const rightDepth = maxDepth(root.right);
+
+    return Math.max(leftDepth, rightDepth) + 1;
+};

merge-two-sorted-lists/robinyoon-dev.js

@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} list1
+ * @param {ListNode} list2
+ * @return {ListNode}
+ */
+var mergeTwoLists = function (list1, list2) {
+
+    let dummy = new ListNode(-1);
+    let current = dummy;
+
+    while (list1 !== null && list2 !== null) {
+        if (list1.val <= list2.val) {
+            current.next = list1;
+            list1 = list1.next;
+        } else {
+            current.next = list2;
+            list2 = list2.next;
+        }
+        current = current.next;
+    }
+
+    if (list1 !== null) {
+        current.next = list1;
+    } else {
+        current.next = list2;
+    }
+
+    return dummy.next;
+};
+

word-search/robinyoon-dev.js

@@ -0,0 +1,57 @@
+/**
+ * @param {character[][]} board
+ * @param {string} word
+ * @return {boolean}
+ */
+var exist = function (board, word) {
+
+    let tempResult = false;
+
+    for (let i = 0; i < board.length; i++) {
+        for (let j = 0; j < board[0].length; j++) {
+            if (board[i][j] === word[0]) {
+                tempResult = dfs(i, j, 0);
+                if (tempResult) {
+                    return true;
+                }
+            } else {
+                continue;
+            }
+        }
+    }
+
+
+    return tempResult;
+
+
+
+    function dfs(x, y, currentIndex) {
+
+        if (x < 0 || y < 0 || x >= board.length || y >= board[0].length) {
+            return false;
+        }
+
+        if (board[x][y] !== word[currentIndex]) {
+            return false;
+        }
+
+        let nextIndex = currentIndex + 1;
+
+        if (nextIndex === word.length) {
+            return true;
+        }
+
+        let tempChar = board[x][y];
+        board[x][y] = '*';
+
+
+        let hasCharOnTheLeft = dfs(x - 1, y, nextIndex);
+        let hasCharOnTheRight = dfs(x + 1, y, nextIndex);
+        let hasCharAtTheTop = dfs(x, y + 1, nextIndex);
+        let hasCharAtTheBottom = dfs(x, y - 1, nextIndex);
+
+        board[x][y] = tempChar;
+
+        return hasCharOnTheLeft || hasCharOnTheRight || hasCharAtTheTop || hasCharAtTheBottom;
+    }
+};