Merge branch 'DaleStudy:main' into main

Author: gitsunmin

container-with-most-water/hwanmini.js

@@ -0,0 +1,28 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function(height) {
+    let maxArea = 0;
+
+    let leftIdx = 0;
+    let rightIdx = height.length - 1;
+
+    while (leftIdx <= rightIdx) {
+        const minHeight = Math.min(height[leftIdx], height[rightIdx]);
+        const distance = rightIdx - leftIdx
+
+        maxArea = Math.max(maxArea, distance * minHeight);
+
+        if (height[leftIdx] < height[rightIdx]) leftIdx++
+        else rightIdx--
+    }
+
+    return maxArea
+};
+
+console.log(maxArea([1,8,6,2,5,4,8,3,7])) //49
+console.log(maxArea([1,1])) //1

container-with-most-water/jdalma.kt

@@ -0,0 +1,40 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+
+typealias Element = Pair<Int,Int>
+
+class `container-with-most-wate` {
+
+    /**
+     * 투 포인터를 활용하여 높이가 낮은 인덱스의 값을 한 칸씩 이동하며 최대 높이를 반환한다.
+     * TC: O(n), SC: O(1)
+     */
+    fun maxArea(height: IntArray): Int {
+        var (left, right) = 0 to height.size - 1
+        var result = 0
+
+        while (left < right) {
+            result = max(result, extent(Element(height[left], left), Element(height[right], right)))
+            if (height[left] < height[right]) {
+                left++
+            } else {
+                right--
+            }
+        }
+        return result
+    }
+
+    private fun extent(e1: Element, e2: Element): Int {
+        return min(e1.first, e2.first) * abs(e1.second - e2.second)
+    }
+
+    @Test
+    fun `입력받은 높이를 표현하는 정수 배열에서 받을 수 있는 최대의 물의 양을 반환한다`() {
+        maxArea(intArrayOf(1,8,6,2,5,4,8,3,7)) shouldBe 49
+    }
+}

container-with-most-water/mangodm-web.py

@@ -0,0 +1,24 @@
+from typing import List
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        """
+        - Idea: 배열의 양쪽 끝에서 시작하는 두 포인터(left, right)를 이용해 두 선 사이의 최대 영역을 구한다. 둘 중, 높이가 낮은 쪽의 포인터는 중앙 쪽으로 이동시킨다.
+        - Time Complexity: O(n), n은 주어진 배열(height)의 길이.
+        - Space Complexity: O(1), 추가 공간은 사용하지 않는다.
+        """
+        left, right = 0, len(height) - 1
+        result = 0
+
+        while left < right:
+            current_width = right - left
+            current_height = min(height[left], height[right])
+            result = max(result, current_width * current_height)
+
+            if height[left] < height[right]:
+                left += 1
+            else:
+                right -= 1
+
+        return result

container-with-most-water/taekwon-dev.java

@@ -0,0 +1,28 @@
+/**
+ *  시간 복잡도: O(n)
+ *  공간 복잡도: O(1)
+ *
+ *  최대로 많은 물을 저장하기 위해 가장 우선적으로 고려해야 하는 것은 짧은 막대의 길이
+ *  따라서, 짧은 높이를 가지는 쪽의 포인터를 이동하면서 최대 저장 가능한 값을 비교
+ *
+ */
+class Solution {
+    public int maxArea(int[] height) {
+        int answer = 0;
+        int left = 0;
+        int right = height.length - 1;
+
+        while (left < right) {
+            int water = Math.min(height[left], height[right]) * (right - left);
+            answer = Math.max(answer, water);
+
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+
+        return answer;
+    }
+}

container-with-most-water/whewchews.ts

@@ -0,0 +1,24 @@
+function maxArea(height: number[]): number {
+  let left = 0;
+  let right = height.length - 1;
+  let maxSize = 0;
+
+  while (left < right) {
+    maxSize = Math.max(maxSize, getMaxSize(height, left, right));
+
+    if (height[left] < height[right]) {
+      left++;
+    } else {
+      right--;
+    }
+  }
+
+  return maxSize;
+}
+
+function getMaxSize(height: number[], left: number, right: number) {
+  return Math.min(...[height[right], height[left]]) * (right - left);
+}
+
+// TC: O(n)
+// SC: O(1)

design-add-and-search-words-data-structure/hwanmini.js

@@ -0,0 +1,68 @@
+// 시간복잡도
+// addWord: O(n) (n은 추가하는 단어의 길이)
+// search: O(m^n) (m은 각 노드의 최대 자식 수, n은 검색하는 단어의 길이)
+
+// 공간복잡도
+// addWord: O(n) (n은 추가하는 단어의 길이)
+// search: O(n) (n은 검색하는 단어의 길이, 재귀 호출 스택의 깊이)
+
+class TrieNode {
+    constructor() {
+        this.children = {}
+        this.endOfWord = false
+    }
+}
+
+class WordDictionary {
+    constructor() {
+        this.root = new TrieNode()
+    }
+    addWord(word) {
+        let curNode = this.root
+
+        for (let i = 0 ; i < word.length; i++) {
+            if (!curNode.children[word[i]]) {
+                curNode.children[word[i]] = new TrieNode();
+            }
+
+            curNode = curNode.children[word[i]];
+        }
+
+        curNode.endOfWord = true
+    }
+    search(word) {
+        return this.searchInNode(word, this.root);
+    }
+
+    searchInNode(word, node) {
+        let curNode = node;
+
+        for (let i = 0; i < word.length; i++) {
+            if (word[i] === '.') {
+                for (let key in curNode.children) {
+                    if (this.searchInNode(word.slice(i + 1), curNode.children[key])) return true
+                }
+                return false
+            }
+
+            if (word[i] !== '.') {
+                if (!curNode.children[word[i]]) return false
+                curNode = curNode.children[word[i]];
+            }
+        }
+
+        return curNode.endOfWord
+    }
+}
+
+
+const wordDictionary = new WordDictionary();
+wordDictionary.addWord("bad");
+wordDictionary.addWord("dad");
+wordDictionary.addWord("mad");
+console.log(wordDictionary.search("pad")); // return False
+console.log(wordDictionary.search("bad")); // return True
+console.log(wordDictionary.search(".ad")); // return True
+console.log(wordDictionary.search("b..")); // return True
+
+

design-add-and-search-words-data-structure/jdalma.kt

@@ -0,0 +1,98 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import leetcode_study.Type.*
+import org.junit.jupiter.api.Test
+
+class `design-add-and-search-words-data-structure` {
+
+    class Node {
+        var isEnd: Boolean = false
+        val next: MutableMap<Char, Node> = mutableMapOf()
+    }
+
+    class WordDictionary {
+        private val root = Node()
+
+        /**
+         * TC: O(n), SC: O(n)
+         */
+        fun addWord(word: String) {
+            var now = root
+
+            for (index in word.indices) {
+                val node =
+                    if (now.next.containsKey(word[index])) { now.next[word[index]] }
+                    else Node().also { now.next[word[index]] = it }
+                node?.let { now = it }
+            }
+            now.isEnd = true
+        }
+
+        /**
+         * TC: O(26^n), SC: O(n)
+         */
+        fun search(word: String): Boolean {
+
+            fun dfs(node: Node, word: String, index: Int): Boolean {
+                return if (index == word.length) node.isEnd
+                else if (word[index] == '.') {
+                    node.next.values.any { dfs(it, word, index + 1) }
+                }
+                else {
+                    node.next[word[index]]?.let { dfs(it, word, index + 1) } ?: false
+                }
+            }
+
+            return dfs(this.root, word, 0)
+        }
+    }
+
+    @Test
+    fun `문자열을 저장하고 검색하는 자료구조를 구현하라`() {
+        inputCommands(
+            Command(ADD, "bad"),
+            Command(ADD, "dad"),
+            Command(ADD, "mad"),
+            Command(SEARCH, "pad", false),
+            Command(SEARCH, "bad", true),
+            Command(SEARCH, ".ad", true),
+            Command(SEARCH, "b..", true),
+        )
+        inputCommands(
+            Command(ADD, "at"),
+            Command(ADD, "and"),
+            Command(ADD, "an"),
+            Command(ADD, "add"),
+            Command(SEARCH, "a", false),
+            Command(SEARCH, ".at", false),
+            Command(ADD, "bat"),
+            Command(SEARCH,".at", true),
+            Command(SEARCH,"an.", true),
+            Command(SEARCH,"a.d.", false),
+            Command(SEARCH,"b.", false),
+            Command(SEARCH,"a.d", true),
+            Command(SEARCH,".",  false)
+        )
+    }
+
+    private fun inputCommands(vararg commands: Command) {
+        val dictionary = WordDictionary()
+        for (command in commands) {
+            when(command.type) {
+                ADD -> dictionary.addWord(command.word)
+                SEARCH -> dictionary.search(command.word) shouldBe command.expect
+            }
+        }
+    }
+}
+
+data class Command(
+    val type: Type,
+    val word: String,
+    val expect : Boolean? = null
+)
+
+enum class Type {
+    ADD, SEARCH;
+}

design-add-and-search-words-data-structure/taekwon-dev.java

@@ -0,0 +1,58 @@
+class WordDictionary {
+
+    private class TrieNode {
+        Map<Character, TrieNode> children = new HashMap<>();
+        boolean isEndOfWord = false;
+    }
+
+    private TrieNode root;
+
+    public WordDictionary() {
+        root = new TrieNode();
+    }
+
+    /**
+     *  시간 복잡도: O(n), n = 단어의 길이
+     *  공간 복잡도: O(n)
+     */
+    public void addWord(String word) {
+        TrieNode node = root;
+
+        for (int i = 0; i < word.length(); i++) {
+            char c = word.charAt(i);
+            node.children.putIfAbsent(c, new TrieNode());
+            node = node.children.get(c);
+        }
+        node.isEndOfWord = true;
+    }
+
+    /**
+     *  시간 복잡도: O(26^n), n = 단어의 길이
+     *  공간 복잡도: O(n)
+     */
+    public boolean search(String word) {
+        return searchInNode(word, 0, root);
+    }
+
+    private boolean searchInNode(String word, int index, TrieNode node) {
+        if (index == word.length()) {
+            return node.isEndOfWord;
+        }
+
+        char c = word.charAt(index);
+        if (c != '.') {
+            if (node.children.containsKey(c)) {
+                return searchInNode(word, index + 1, node.children.get(c));
+            } else {
+                return false;
+            }
+        } else {
+            for (TrieNode childNode : node.children.values()) {
+                if (searchInNode(word, index + 1, childNode)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}