From ea83b10ab591675c7c8823e072d2dfb8f9b66579 Mon Sep 17 00:00:00 2001 From: jeongdalma Date: Mon, 7 Oct 2024 12:43:45 +0900 Subject: [PATCH 1/3] =?UTF-8?q?9=EC=A3=BC=EC=B0=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- linked-list-cycle/jdalma.kt | 45 +++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 linked-list-cycle/jdalma.kt diff --git a/linked-list-cycle/jdalma.kt b/linked-list-cycle/jdalma.kt new file mode 100644 index 000000000..a7a773209 --- /dev/null +++ b/linked-list-cycle/jdalma.kt @@ -0,0 +1,45 @@ +package leetcode_study + +import io.kotest.matchers.shouldBe +import org.junit.jupiter.api.Test + +class `linked-list-cycle` { + + data class ListNode(var `val`: Int) { + var next: ListNode? = null + } + + /** + * TC: O(n), SC: O(1) + */ + fun hasCycle(head: ListNode?): Boolean { + if (head == null) return false + + var slow = head + var fast = head + + while (fast?.next != null) { + slow = slow?.next + fast = fast.next?.next + + if (slow == fast) return true + } + + return false + } + + @Test + fun `입력받은 노드에 사이클이 존재한다면 참을 반환한다`() { + val three = ListNode(3) + val two = ListNode(2) + val zero = ListNode(0) + val four = ListNode(4) + + three.next = two + two.next = zero + zero.next = four + four.next = two + + hasCycle(three) shouldBe true + } +} From 4b2878a5c7b58f15ad3fc9073c902c9a2d5243cc Mon Sep 17 00:00:00 2001 From: jeongdalma Date: Tue, 8 Oct 2024 13:37:51 +0900 Subject: [PATCH 2/3] =?UTF-8?q?=EB=AC=B8=EC=A0=9C=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../jdalma.kt | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 find-minimum-in-rotated-sorted-array/jdalma.kt diff --git a/find-minimum-in-rotated-sorted-array/jdalma.kt b/find-minimum-in-rotated-sorted-array/jdalma.kt new file mode 100644 index 000000000..48364c9f9 --- /dev/null +++ b/find-minimum-in-rotated-sorted-array/jdalma.kt @@ -0,0 +1,34 @@ +class `find-minimum-in-rotated-sorted-array` { + + /** + * TC: O(log N), SC: O(1) + */ + fun findMin(nums: IntArray): Int { + var (low, high) = 0 to nums.size - 1 + + while (low + 1 < high) { + val mid = (low + high) / 2 + if (nums[mid - 1] > nums[mid]) { + return nums[mid] + } + if (nums[mid] < nums[high]) { + high = mid + } + else { + low = mid + } + } + + return min(nums[low], nums[high]) + } + + @Test + fun `입력받은 정수 배열의 최소 원소를 반환한다`() { + findMin(intArrayOf(4,5,6,7,0,1,2)) shouldBe 0 + findMin(intArrayOf(2,3,0,1)) shouldBe 0 + findMin(intArrayOf(2,3,1)) shouldBe 1 + findMin(intArrayOf(2,1,3)) shouldBe 1 + findMin(intArrayOf(2,3,4,5,1)) shouldBe 1 + findMin(intArrayOf(11,13,15,17)) shouldBe 11 + } +} From 3de39155ef5712278d41470f7a083352cc75f02d Mon Sep 17 00:00:00 2001 From: jeongdalma Date: Fri, 11 Oct 2024 17:43:30 +0900 Subject: [PATCH 3/3] =?UTF-8?q?2=EB=AC=B8=EC=A0=9C=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- merge-intervals/jdalma.kt | 73 ++++++++++++++++++++++++++ pacific-atlantic-water-flow/jdalma.kt | 75 +++++++++++++++++++++++++++ 2 files changed, 148 insertions(+) create mode 100644 merge-intervals/jdalma.kt create mode 100644 pacific-atlantic-water-flow/jdalma.kt diff --git a/merge-intervals/jdalma.kt b/merge-intervals/jdalma.kt new file mode 100644 index 000000000..474d843a8 --- /dev/null +++ b/merge-intervals/jdalma.kt @@ -0,0 +1,73 @@ +package leetcode_study + +import io.kotest.matchers.shouldBe +import org.junit.jupiter.api.Test +import kotlin.math.max + +class `merge-intervals` { + + data class CustomRange( + var start: Int, + var end: Int + ) { + fun isMergePossible(s: Int) = s <= this.end + } + + /** + * TC: O(n log n), SC: O(n) + */ + fun merge(intervals: Array): Array { + val sorted = intervals.sortedWith { i1, i2 -> i1[0].compareTo(i2[0]) } + val result = mutableListOf() + + var tmp = sorted.first().let { + CustomRange(it[0], it[1]) + } + result.add(tmp) + for (interval in sorted) { + if (tmp.isMergePossible(interval[0])) { + tmp.end = max(interval[1], tmp.end) + } else { + tmp = CustomRange(interval[0], interval[1]) + result.add(tmp) + } + } + + return result.map { intArrayOf(it.start, it.end) } + .toTypedArray() + } + + @Test + fun `2차원 배열의 원소인 start와 end만큼 병합한 결과를 반환한다`() { + merge( + arrayOf( + intArrayOf(2,6), + intArrayOf(8,10), + intArrayOf(15,18), + intArrayOf(1,3) + ) + ) shouldBe arrayOf( + intArrayOf(1,6), + intArrayOf(8,10), + intArrayOf(15,18) + ) + + merge( + arrayOf( + intArrayOf(1,4), + intArrayOf(0,4) + ) + ) shouldBe arrayOf( + intArrayOf(0,4) + ) + + merge( + arrayOf( + intArrayOf(1,4), + intArrayOf(0,1) + ) + ) shouldBe arrayOf( + intArrayOf(0,4) + ) + } +} diff --git a/pacific-atlantic-water-flow/jdalma.kt b/pacific-atlantic-water-flow/jdalma.kt new file mode 100644 index 000000000..a49b1cdcd --- /dev/null +++ b/pacific-atlantic-water-flow/jdalma.kt @@ -0,0 +1,75 @@ +package leetcode_study + +import io.kotest.matchers.shouldBe +import org.junit.jupiter.api.Test + +class `pacific-atlantic-water-flow` { + + private val dirs = listOf( + intArrayOf(0, 1), + intArrayOf(0, -1), + intArrayOf(1, 0), + intArrayOf(-1, 0) + ) + + /** + * TC: O(n * m), SC: O(n * m) + */ + fun pacificAtlantic(heights: Array): List> { + val (row, col) = heights.size to heights.first().size + val pacific = Array(row) { BooleanArray(col) } + val atlantic = Array(row) { BooleanArray(col) } + + for (index in 0 until row) { + dfs(heights, pacific, Int.MIN_VALUE, index, 0) + dfs(heights, atlantic, Int.MIN_VALUE, index, col - 1) + } + + for (index in 0 until col) { + dfs(heights, pacific, Int.MIN_VALUE, 0, index) + dfs(heights, atlantic, Int.MIN_VALUE, row - 1, index) + } + + val result = mutableListOf>() + for (i in 0 until row) { + for (j in 0 until col) { + if (pacific[i][j] && atlantic[i][j]) { + result.add(listOf(i, j)) + } + } + } + return result + } + + private fun dfs(heights: Array, visited: Array, height: Int, r: Int, c: Int) { + val (row, col) = heights.size to heights.first().size + if (r < 0 || r >= row || c < 0 || c >= col || visited[r][c] || heights[r][c] < height) + return + + visited[r][c] = true + for (dir in dirs) { + dfs(heights, visited, heights[r][c], r + dir[0], c + dir[1]) + } + } + + @Test + fun `태평양과 대서양에 모두 흐를 수 있는 셀의 위치를 반환하라`() { + pacificAtlantic( + arrayOf( + intArrayOf(1,2,2,3,5), + intArrayOf(3,2,3,4,4), + intArrayOf(2,4,5,3,1), + intArrayOf(6,7,1,4,5), + intArrayOf(5,1,1,2,4) + ) + ) shouldBe arrayOf( + intArrayOf(0,4), + intArrayOf(1,3), + intArrayOf(1,4), + intArrayOf(2,2), + intArrayOf(3,0), + intArrayOf(3,1), + intArrayOf(4,0) + ) + } +}