Merge branch 'DaleStudy:main' into main

Author: jylee2033

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

@@ -23,7 +23,6 @@ var maxProfit = function (prices) {
     return maxProfit;
 };
 
-
 // -----아래는 이전에 작성한 답안입니다.
 // /**
 //  * @param {number[]} prices

best-time-to-buy-and-sell-stock/soobing.ts

@@ -1,14 +1,16 @@
+// 3rd tried
 function maxProfit(prices: number[]): number {
-  let minPrice = Infinity;
-  let maxProfit = 0;
-  for (let i = 0; i < prices.length; i++) {
-    if (prices[i] < minPrice) {
-      minPrice = prices[i];
-    }
+  let left = 0;
+  let right = 1;
+  let max = 0;
 
-    if (prices[i] - minPrice > maxProfit) {
-      maxProfit = prices[i] - minPrice;
-    }
+  while(left < right && right < prices.length) {
+      if(prices[right] - prices[left] > 0) {
+          max = Math.max(max, prices[right] - prices[left])
+      } else {
+          left = right;
+      }
+      right++;
   }
-  return maxProfit;
-}
+  return max;
+};

encode-and-decode-strings/soobing.ts

@@ -1,34 +1,26 @@
+// 3rd tried
 class Solution {
   /**
-   * 문자열 배열을 하나의 문자열로 인코딩합니다.
-   * @param strs - 문자열 배열
-   * @returns 인코딩된 하나의 문자열
+   * @param {string[]} strs
+   * @returns {string}
    */
-  encode(strs: string[]): string {
-    return strs.map((str) => str.length + "#" + str).join("");
+  encode(strs) {
+      return strs.map((str) => `${str.length}#${str}`).join('');
   }
 
   /**
-   * 인코딩된 문자열을 원래 문자열 배열로 디코딩합니다.
-   * @param str - 인코딩된 문자열
-   * @returns 디코딩된 문자열 배열
+   * @param {string} str
+   * @returns {string[]}
    */
-  decode(str: string): string[] {
-    const result: string[] = [];
-
-    let i = 0;
-    while (i < str.length) {
-      let j = i;
-      while (str[j] !== "#") {
-        j++;
+  decode(str) {
+      const result: string[] = [];
+      let i = 0;
+      while(i < str.length) {
+          const j = str.indexOf('#', i);
+          const length = Number(str.slice(i, j));
+          result.push(str.slice(j + 1, j + 1 + length));
+          i = j + 1 + length;
       }
-
-      const length = parseInt(str.slice(i, j));
-      const word = str.slice(j + 1, j + 1 + length);
-      result.push(word);
-      i = j + 1 + length;
-    }
-
-    return result;
+      return result;
   }
 }

group-anagrams/robinyoon-dev.js

@@ -0,0 +1,45 @@
+/**
+ * @param {string[]} strs
+ * @return {string[][]}
+ */
+
+// 문제는 풀었으나 시간 복잡도 측면에서 효율이 너무 떨어지는 풀이 방법....
+var groupAnagrams = function (strs) {
+    let outputArr = [];
+    let countArr = [];
+
+    const A_ASCII = 'a'.charCodeAt(0);
+    const Z_ASCII = 'z'.charCodeAt(0);
+
+    let charCounts = Z_ASCII - A_ASCII + 1;
+    let charCountArr = new Array(charCounts).fill(0); //인덱스가 알파벳을 나타냄.
+
+    for (str of strs) {
+        let strCountString = getStrCountString(str);
+
+        let hasSameCountIndex = countArr.findIndex((item) => item === strCountString);
+
+        if (hasSameCountIndex !== -1) {
+            outputArr[hasSameCountIndex].push(str);
+        } else {
+            countArr.push(strCountString);
+
+            outputArr.push([str]);
+        }
+    }
+
+    return outputArr;
+
+    function getStrCountString(str) {
+        let tempArr = [...charCountArr];
+
+        for (char of str) {
+            let charAscii = char.charCodeAt(0);
+            let charIndex = charAscii - A_ASCII;
+            tempArr[charIndex] += 1;
+        }
+        return tempArr.join(',');
+    }
+};
+
+

group-anagrams/soobing.ts

@@ -1,15 +1,11 @@
-// idea: 배열에 담긴 모든 애들을 다 sorting하면서 sorting된 결과를 key로 바인딩하고 Record<string, string[]> 에 맞게 매핑하여 values들만 리턴하면 될것 같음
+// 3rd tried
 function groupAnagrams(strs: string[]): string[][] {
-  const map = new Map<string, string[]>();
+  const map = new Map();
 
-  for (let i = 0; i < strs.length; i++) {
-    const key = strs[i].split("").sort().join("");
-    const group = map.get(key);
-    if (group) {
-      group.push(strs[i]);
-    } else {
-      map.set(key, [strs[i]]);
-    }
+  for(const str of strs) {
+      const key = str.split('').sort().join('');
+      const value = map.get(key);
+      map.set(key, value ? [...value, str] : [str])
   }
-  return [...map.values()];
-}
+  return Array.from(map.values());
+};

implement-trie-prefix-tree/robinyoon-dev.js

@@ -0,0 +1,68 @@
+// 문제풀이 해설 보고 푼 문제입니다.
+
+var TrieNode = function () {
+    this.children = {};
+    this.isEnd = false;
+}
+
+var Trie = function () {
+    this.root = new TrieNode();
+};
+
+/** 
+ * @param {string} word
+ * @return {void}
+ */
+Trie.prototype.insert = function (word) {
+    let currentNode = this.root;
+    for (let i = 0; i < word.length; i++) {
+        let char = word[i];
+        if (!currentNode.children[char]) {
+            currentNode.children[char] = new TrieNode();
+
+        }
+        currentNode = currentNode.children[char];
+    }
+
+    currentNode.isEnd = true;
+};
+
+/** 
+ * @param {string} word
+ * @return {boolean}
+ */
+Trie.prototype.search = function (word) {
+    let currentNode = this.root;
+    for (let i = 0; i < word.length; i++) {
+        let char = word[i];
+        if (!currentNode.children[char]) {
+            return false;
+        }
+        currentNode = currentNode.children[char];
+    }
+    return currentNode.isEnd;
+};
+
+/** 
+ * @param {string} prefix
+ * @return {boolean}
+ */
+Trie.prototype.startsWith = function (prefix) {
+    let currentNode = this.root;
+    for (let i = 0; i < prefix.length; i++) {
+        let char = prefix[i];
+        if (!currentNode.children[char]) {
+            return false;
+        }
+        currentNode = currentNode.children[char];
+    }
+    return true;
+};
+
+/** 
+ * Your Trie object will be instantiated and called as such:
+ * var obj = new Trie()
+ * obj.insert(word)
+ * var param_2 = obj.search(word)
+ * var param_3 = obj.startsWith(prefix)
+ */

implement-trie-prefix-tree/soobing.ts

@@ -1,46 +1,53 @@
+// 3rd tried
 class TrieNode {
   children: Map<string, TrieNode>;
   isEnd: boolean;
-
   constructor() {
-    this.children = new Map();
-    this.isEnd = false;
+      this.children = new Map();
+      this.isEnd = false
   }
 }
-
 class Trie {
   root: TrieNode;
 
   constructor() {
-    this.root = new TrieNode();
+      this.root = new TrieNode();
   }
 
   insert(word: string): void {
-    let node = this.root;
-    for (const char of word) {
-      if (!node.children.has(char)) {
-        node.children.set(char, new TrieNode());
+      let node = this.root;
+      for(const ch of word) {
+          if(!node.children.has(ch)) {
+              node.children.set(ch, new TrieNode());
+          }
+          node = node.children.get(ch)!
       }
-      node = node.children.get(char)!;
-    }
-    node.isEnd = true;
+      node.isEnd = true;
   }
 
   search(word: string): boolean {
-    const node = this._findNode(word);
-    return node !== null && node.isEnd;
+      let node = this.root;
+      for(const ch of word) {
+          if(!node.children.has(ch)) return false;
+          node = node.children.get(ch)!;
+      }
+      return node.isEnd;
   }
 
   startsWith(prefix: string): boolean {
-    return this._findNode(prefix) !== null;
-  }
-
-  private _findNode(word: string): TrieNode | null {
-    let node = this.root;
-    for (const char of word) {
-      if (!node.children.has(char)) return null;
-      node = node.children.get(char)!;
-    }
-    return node;
+      let node = this.root;
+      for(const ch of prefix) {
+          if(!node.children.has(ch)) return false;
+          node = node.children.get(ch)!;
+      }
+      return true;
   }
 }
+
+/**
+* Your Trie object will be instantiated and called as such:
+* var obj = new Trie()
+* obj.insert(word)
+* var param_2 = obj.search(word)
+* var param_3 = obj.startsWith(prefix)
+*/