5번 문제 추가

Author: jdalma

contains-duplicate/jdalma.kt

@@ -6,12 +6,12 @@ import org.junit.jupiter.api.Test
 class `contains-duplicate`{
 
     fun containsDuplicate(nums: IntArray): Boolean {
-        return third(nums)
+        return usingSet(nums)
     }
 
-    // 시간초과
+    // 1. 중첩 반복문 - 시간초과
     // 시간복잡도: O(n^2), 공간복잡도: O(1)
-    private fun first(nums: IntArray): Boolean {
+    private fun usingNestedLoop(nums: IntArray): Boolean {
         nums.forEachIndexed { i, e1 ->
             nums.forEachIndexed { j, e2 ->
                 if (i != j && e1 == e2) {
@@ -22,8 +22,9 @@ class `contains-duplicate`{
         return false
     }
 
+    // 2. 정렬 후 순회
     // 시간복잡도:  O(n * log(n)), 공간복잡도: O(1)
-    private fun second(nums: IntArray): Boolean {
+    private fun usingSort(nums: IntArray): Boolean {
         nums.sort() // DualPivotQuicksort -> O(n log(n))
         for (index in 1 until nums.size) {
             val prev = nums[index - 1]
@@ -35,8 +36,9 @@ class `contains-duplicate`{
         return false
     }
 
+    // 3. 자료구조 Set 사용
     // 시간복잡도: O(n), 공간복잡도: O(n)
-    private fun third(nums: IntArray): Boolean {
+    private fun usingSet(nums: IntArray): Boolean {
         val set = nums.toSet()
         return nums.size != set.size
     }

number-of-1-bits/jdalma.kt

@@ -6,11 +6,12 @@ import org.junit.jupiter.api.Test
 class `number-of-1-bits` {
 
     fun hammingWeight(n: Int): Int {
-        return second(n)
+        return bitOperation(n)
     }
 
+    // 1. 직접 2진수를 구함
     // 시간복잡도: O(log n), 공간복잡도: O(1)
-    private fun first(n: Int): Int {
+    private fun binary(n: Int): Int {
         var calc = n
         var count = 0
         while(calc > 0) {
@@ -22,8 +23,9 @@ class `number-of-1-bits` {
         return count
     }
 
+    // 2. 비트 논리 연산자 사용
     // 시간복잡도: O(log n), 공간복잡도: O(1)
-    private fun second(n: Int): Int {
+    private fun bitOperation(n: Int): Int {
         var calc = n
         var count = 0
         while (calc > 0) {

palindromic-substrings/jdalma.kt

@@ -0,0 +1,90 @@
+package leetcode_study
+
+import io.kotest.matchers.equals.shouldBeEqual
+import org.junit.jupiter.api.Test
+
+class `palindromic-substrings` {
+
+    fun countSubstrings(s: String): Int {
+        return dp(s)
+    }
+
+    // 1. 브루트포스 3중 반복문
+    // 시간복잡도: O(n^3), 공간복잡도: O(1)
+    private fun bruteForce(s: String): Int {
+
+        fun isPalindrome(text: String, left: Int, right: Int): Boolean {
+            var (start, end) = left to right
+            while (start < end) {
+                if (text[start] != text[end]) {
+                    return false
+                }
+                start++
+                end--
+            }
+            return true
+        }
+
+        var count = 0
+        s.indices.forEachIndexed { left, _ ->
+            (left until s.length).forEach { right ->
+                if (isPalindrome(s, left, right)) {
+                    count++
+                }
+            }
+        }
+        return count
+    }
+
+    // 2. 문자열의 길이가 홀수,짝수를 감안하여 특정 지점부터 두 개의 포인터 left , right를 비교한다.
+    // 시간복잡도: O(n^2), 공간복잡도: O(1)
+    private fun twoPointer(s: String): Int {
+
+        fun palindromeCount(text: String, left: Int, right: Int): Int {
+            var count = 0
+            var (l , r) = left to right
+            while (l >= 0 && r < text.length && text[l--] == text[r++]) {
+                count++
+            }
+            return count
+        }
+
+        var result = 0
+        s.indices.forEachIndexed { index, e ->
+            val even = palindromeCount(s, index, index + 1)
+            val odd = palindromeCount(s, index - 1, index + 1)
+            result += even + odd + 1
+        }
+
+        return result
+    }
+
+    // 3. DP : 이전에 비교했던 결과를 기억하여 (현재 주어진 start, end  비교) && (이전 start, end 비교)
+    // 시간복잡도: O(n^2), 공간복잡도: O(n^2)
+    private fun dp(s: String): Int {
+        val len = s.length
+        val dp = Array(len) { BooleanArray(len) { false } }
+
+        for (end in 0 until len) {
+            for (start in end downTo 0) {
+                if (start == end) {
+                    dp[start][end] = true
+                } else if (start + 1 == end) {
+                    dp[start][end] = s[start] == s[end]
+                } else {
+                    dp[start][end] = s[start] == s[end] && dp[start + 1][end - 1]
+                }
+            }
+        }
+
+        return dp.sumOf { row -> row.count { it } }
+    }
+
+    @Test
+    fun `주어진 문자열의 회문인 부분 문자열의 개수를 반환한다`() {
+        countSubstrings("abc") shouldBeEqual 3
+        countSubstrings("aaa") shouldBeEqual 6
+        countSubstrings("ababa") shouldBeEqual 9
+        countSubstrings("abcda") shouldBeEqual 5
+    }
+}

top-k-frequent-elements/jdalma.kt

@@ -10,7 +10,7 @@ class `top-k-frequent-elements` {
         return third(nums, k)
     }
 
-    // Map 정렬
+    // 1. Map 정렬
     // 시간복잡도: O(n * log(n)), 공간복잡도: O(n)
     private fun first(nums: IntArray, k: Int): IntArray {
         val map = mutableMapOf<Int, Int>()
@@ -28,7 +28,7 @@ class `top-k-frequent-elements` {
             .toIntArray()
     }
 
-    // 우선순위 큐
+    // 2. 우선순위 큐
     // 시간복잡도: O(n * log(k)), 공간복잡도: O(n + k)
     private fun second(nums: IntArray, k: Int): IntArray {
         val map = mutableMapOf<Int, Int>()
@@ -44,7 +44,7 @@ class `top-k-frequent-elements` {
         return (0 until k).map { heap.poll().key }.toIntArray()
     }
 
-    // 이차원배열로 빈번도 저장
+    // 3. 이차원배열로 빈번도 저장
     // 시간복잡도: O(n), 공간복잡도: O(n)
     private fun third(nums: IntArray, k: Int): IntArray {
         val map = mutableMapOf<Int, Int>()