Merge branch 'DaleStudy:main' into main

Author: hyejjun

3sum/TonyKim9401.java

@@ -0,0 +1,30 @@
+// TC: O(n^2)
+// SC: O(n)
+public class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        Arrays.sort(nums);
+
+        List<List<Integer>> output = new ArrayList<>();
+        Map<Integer, Integer> map = new HashMap<>();
+
+        for (int i = 0; i < nums.length; ++i) map.put(nums[i], i);
+
+        for (int i = 0; i < nums.length - 2; ++i) {
+            if (nums[i] > 0) break;
+
+            for (int j = i + 1; j < nums.length - 1; ++j) {
+                int cValue = -1 * (nums[i] + nums[j]);
+
+                if (map.containsKey(cValue) && map.get(cValue) > j) {
+                    output.add(List.of(nums[i], nums[j], cValue));
+                }
+                j = map.get(nums[j]);
+            }
+
+            i = map.get(nums[i]);
+        }
+
+        return output;
+    }
+}

3sum/jdalma.kt

@@ -0,0 +1,66 @@
+package leetcode_study
+
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
+import org.junit.jupiter.api.Test
+
+class `3sum` {
+
+    fun threeSum(nums: IntArray): List<List<Int>> {
+        return usingTwoPointer(nums)
+    }
+
+    /**
+     * 1. 정수 배열을 순회하며 모두 확인한다. (시간초과)
+     * TC: O(n^3), SC: O(n)
+     */
+    private fun usingIterative(nums: IntArray): List<List<Int>> {
+        val result = mutableSetOf<List<Int>>()
+        for (first in nums.indices) {
+            for (second in first + 1 until  nums.size) {
+                for (third in second + 1 until nums.size) {
+                    if (nums[first] + nums[second] + nums[third] == 0) {
+                        result.add(listOf(nums[first], nums[second], nums[third]).sorted())
+                    }
+                }
+            }
+        }
+        return result.toList()
+    }
+
+    /**
+     * 2. 입력받은 정수 배열을 정렬하여 순회하면서 원소를 합산하여 0과 비교한 결과를 기준으로 투 포인터의 값을 조작한다.
+     * TC: O(n^2), SC: O(n)
+     */
+    private fun usingTwoPointer(nums: IntArray): List<List<Int>> {
+        val sortedNumbers = nums.sorted()
+        val result = mutableSetOf<List<Int>>()
+        for (index in nums.indices) {
+            var left = index + 1
+            var right = nums.size - 1
+            while (left < right) {
+                val sum = sortedNumbers[index] + sortedNumbers[left] + sortedNumbers[right]
+                if (sum == 0) {
+                    result.add(listOf(sortedNumbers[index], sortedNumbers[left], sortedNumbers[right]))
+                    left++
+                    right--
+                } else if (sum < 0) {
+                    left++
+                } else {
+                    right--
+                }
+            }
+        }
+        return result.toList()
+    }
+
+    @Test
+    fun `입력받은 정수 배열의 세 개의 원소의 합이 0이 되는 리스트를 반환한다`() {
+        threeSum(intArrayOf(-1,0,1,2,-1,-4)) shouldContainExactlyInAnyOrder listOf(
+            listOf(-1,-1,2),
+            listOf(-1,0,1)
+        )
+        threeSum(intArrayOf(0,0,0)) shouldContainExactlyInAnyOrder listOf(
+            listOf(0,0,0)
+        )
+    }
+}

best-time-to-buy-and-sell-stock/TonyKim9401.java

@@ -0,0 +1,16 @@
+// TC: O(n)
+// SC: O(1)
+class Solution {
+    public int maxProfit(int[] prices) {
+        int bestProfit = 0;
+        int buyPrice = prices[0];
+        for (int i = 1; i < prices.length; i++) {
+            if (buyPrice > prices[i]) {
+                buyPrice = prices[i];
+                continue;
+            }
+            bestProfit = Math.max(bestProfit, prices[i] - buyPrice);
+        }
+        return bestProfit;
+    }
+}

best-time-to-buy-and-sell-stock/jdalma.kt

@@ -0,0 +1,60 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.max
+
+class `best-time-to-buy-and-sell-stock` {
+
+    fun maxProfit(prices: IntArray): Int {
+        if (prices.size == 1) return 0
+        return usingKadaneAlgorithm(prices)
+    }
+
+    /**
+     * 1. 방향이 존재하기 때문에 투 포인터를 활용하여 주식을 팔 수 있는 경우라면 최대 값을 계산하고 만약 산 가격보다 싼 가격을 만나면 다시 산다
+     * TC: O(n), SC: O(1)
+     */
+    private fun usingTwoPointer(prices: IntArray): Int {
+        var (left, right) = 0 to 1
+        var maxProfit = 0
+
+        while (right < prices.size) {
+            if (prices[left] < prices[right]) {
+                maxProfit = max(prices[right] - prices[left], maxProfit)
+                right++
+            } else if (prices[left] >= prices[right]) {
+                left = right
+                right++
+            }
+        }
+
+        return maxProfit
+    }
+
+    /**
+     * 2. 카데인 알고리즘의 변형된 버전으로 가장 싼 경우를 buy에 저장하고 현재 최대 수익을 초과하면 업데이트한다
+     * TC: O(n), SC: O(1)
+     */
+    private fun usingKadaneAlgorithm(prices: IntArray): Int {
+        var buy = prices[0]
+        var maxProfit = 0
+
+        for (index in 1 until prices.size) {
+            if (prices[index] < buy) {
+                buy = prices[index]
+            } else if (prices[index] - buy > maxProfit) {
+                maxProfit = prices[index] - buy
+            }
+        }
+        return maxProfit
+    }
+
+    @Test
+    fun `주어진 가격 배열을 통해 최대의 수익을 반환한다`() {
+        maxProfit(intArrayOf(3,3)) shouldBe 0
+        maxProfit(intArrayOf(7,6,5,4,3,2,1,0)) shouldBe 0
+        maxProfit(intArrayOf(7,1,5,3,6,4)) shouldBe 5
+        maxProfit(intArrayOf(1,2,4,2,5,7,2,4,9,0,9)) shouldBe 9
+    }
+}

group-anagrams/TonyKim9401.java

@@ -0,0 +1,25 @@
+// TC: O(n * m log m)
+// SC: O(n * m)
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        List<List<String>> output = new ArrayList<>();
+        Map<String, List<String>> map = new HashMap<>();
+
+        for (int i = 0; i < strs.length; i++) {
+            char[] charArray = strs[i].toCharArray();
+            Arrays.sort(charArray);
+            String target = new String(charArray);
+
+            if (map.containsKey(target)) {
+                map.get(target).add(strs[i]);
+            } else {
+                List<String> inside = new ArrayList<>();
+                inside.add(strs[i]);
+                map.put(target, inside);
+            }
+        }
+
+        for (String key : map.keySet()) output.add(map.get(key));
+        return output;
+    }
+}

group-anagrams/jdalma.kt

@@ -0,0 +1,53 @@
+package leetcode_study
+
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
+import org.junit.jupiter.api.Test
+
+class `group-anagrams` {
+
+    fun groupAnagrams(strs: Array<String>): List<List<String>> {
+        return usingArray(strs)
+    }
+
+    /**
+     * 1. 입력받은 문자열들을 문자 배열로 변환하여 정렬된 결과를 map 의 키로 정하여 키 기준으로 문자열들을 그룹화한다.
+     * TC: O(n * k log(k)), SC: O(n)
+     */
+    private fun usingSort(strs: Array<String>): List<List<String>> {
+        val map = strs.groupBy { it.toCharArray().sorted() }
+        return map.values.toList()
+    }
+
+    /**
+     * 2. 입력받은 문자열들을 순회하며 문자열의 문자 갯수를 카운트하여 애너그램인지 구별한다.
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingArray(strs: Array<String>): List<List<String>> {
+        val map = strs.groupBy { it ->
+            val counter = IntArray(26)
+            for (ch in it) {
+                counter[ch - 'a']++
+            }
+            counter.joinToString(",") // 구분자를 넣지 않으면 arrayOf("bdddddddddd","bbbbbbbbbbc") 테케를 실패함
+        }
+
+        return map.values.toList()
+    }
+
+    @Test
+    fun `입력받은 문자열들을 애너그램 기준 그룹별로 반환한다`() {
+        groupAnagrams(arrayOf("eat","tea","tan","ate","nat","bat")) shouldContainExactlyInAnyOrder listOf(
+            listOf("tan","nat"),
+            listOf("bat"),
+            listOf("eat","tea","ate"),
+        )
+        groupAnagrams(arrayOf("cab","tin","pew","duh","may","ill","buy","bar","max","doc")) shouldContainExactlyInAnyOrder listOf(
+            listOf("max"),listOf("buy"),listOf("doc"),listOf("may"),listOf("ill"),
+            listOf("duh"),listOf("tin"),listOf("bar"),listOf("pew"),listOf("cab")
+        )
+        groupAnagrams(arrayOf("bdddddddddd","bbbbbbbbbbc")) shouldContainExactlyInAnyOrder listOf(
+            listOf("bbbbbbbbbbc"),
+            listOf("bdddddddddd")
+        )
+    }
+}

implement-trie-prefix-tree/TonyKim9401.java

@@ -0,0 +1,56 @@
+class TrieNode {
+    TrieNode[] children;
+    boolean isEndOfWord;
+
+    public TrieNode() {
+        children = new TrieNode[26];
+        isEndOfWord = false;
+    }
+}
+
+class Trie {
+
+    private TrieNode root;
+
+    public Trie() {
+        root = new TrieNode();
+    }
+
+    // TC: O(n)
+    // SC: O(n * m)
+    // -> word length * new TrieNode spaces
+    public void insert(String word) {
+        TrieNode node = root;
+        for (char c : word.toCharArray()) {
+            int idx = c - 'a';
+            if (node.children[idx] == null) {
+                node.children[idx] = new TrieNode();
+            }
+            node = node.children[idx];
+        }
+        node.isEndOfWord = true;
+    }
+
+    // TC: O(n)
+    // SC: O(1)
+    public boolean search(String word) {
+        TrieNode node = searchPrefix(word);
+        return node != null && node.isEndOfWord;
+    }
+
+    // TC: O(n)
+    // SC: O(1)
+    private TrieNode searchPrefix(String word) {
+        TrieNode node = root;
+        for (char c : word.toCharArray()) {
+            int idx = c - 'a';
+            if (node.children[idx] == null) return null;
+            node = node.children[idx];
+        }
+        return node;
+    }
+
+    public boolean startsWith(String prefix) {
+        return searchPrefix(prefix) != null;
+    }
+}

implement-trie-prefix-tree/jdalma.kt

@@ -0,0 +1,82 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `implement-trie-prefix-tree` {
+
+    /**
+     * 영어 소문자만 입력된다.
+     */
+    class Trie {
+
+        private val node = Node()
+
+        /**
+         * TC: O(n), SC: O(n)
+         */
+        fun insert(word: String) {
+            var now = node
+
+            for (char in word) {
+                val index = char - 'a'
+                if (now.next[index] == null) {
+                    now.next[index] = Node()
+                }
+                now.next[index]?.apply { now = this }
+            }
+            now.isEnd = true
+        }
+
+        /**
+         * TC: O(n), SC: O(1)
+         */
+        fun search(word: String): Boolean {
+            var now = node
+
+            for (char in word) {
+                val index = char - 'a'
+                if (now.next[index] == null) {
+                    return false
+                }
+                now.next[index]?.apply { now = this }
+            }
+
+            return now.isEnd
+        }
+
+        /**
+         * TC: O(n), SC: O(1)
+         */
+        fun startsWith(prefix: String): Boolean {
+            var now = node
+
+            for (char in prefix) {
+                val index = char - 'a'
+                if (now.next[index] == null) {
+                    return false
+                }
+                now.next[index]?.apply { now = this }
+            }
+
+            return true
+        }
+
+    }
+
+    @Test
+    fun `접두사 트리를 구현하라`() {
+        val trie = Trie()
+        trie.insert("apple")
+        trie.search("apple") shouldBe true
+        trie.search("app") shouldBe false
+        trie.startsWith("app") shouldBe true
+        trie.insert("app")
+        trie.search("app") shouldBe true
+    }
+}
+
+private class Node {
+    val next = Array<Node?>(26) { null }
+    var isEnd = false
+}