2문제 추가

Author: jdalma

longest-substring-without-repeating-characters/jdalma.kt

@@ -0,0 +1,46 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.max
+
+class `longest-substring-without-repeating-characters` {
+
+    fun lengthOfLongestSubstring(s: String): Int {
+        if (s.length <= 1) return s.length
+        return usingSet(s)
+    }
+
+    /**
+     * 1. 사용한 문자를 Set에 저장하여 확인하고, 중복된다면 해당 문자의 위치까지 모든 문자를 제거한다.
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingSet(s: String): Int {
+        var left = 0
+        val used = mutableSetOf<Char>()
+        var maxLength = 0
+
+        for (right in s.indices) {
+            if (!used.contains(s[right])) {
+                maxLength = max(right - left + 1, maxLength)
+                used.add(s[right])
+            } else {
+                while (used.contains(s[right])) {
+                    used.remove(s[left])
+                    left++
+                }
+                used.add(s[right])
+            }
+        }
+
+        return maxLength
+    }
+
+    @Test
+    fun `입력받은 문자열의 반복되는 문자가 없는 가장 긴 부분 문자열의 길이를 반환한다`() {
+        lengthOfLongestSubstring("ababc") shouldBe 3
+        lengthOfLongestSubstring("bbbbb") shouldBe 1
+        lengthOfLongestSubstring("abcabcbb") shouldBe 3
+        lengthOfLongestSubstring("pwwkew") shouldBe 3
+    }
+}

number-of-islands/jdalma.kt

@@ -0,0 +1,83 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `number-of-islands` {
+
+    private data class Position(
+        val x: Int,
+        val y: Int
+    ) {
+
+        operator fun plus(other: Position) = Position(this.x + other.x, this.y + other.y)
+
+        fun isNotOutOfIndexed(board: Array<CharArray>) =
+            this.x < board.size && this.x >= 0 && this.y < board[0].size &&  this.y >= 0
+
+        companion object {
+            val MOVES: List<Position> = listOf(
+                Position(-1, 0),
+                Position(0, 1),
+                Position(1, 0),
+                Position(0, -1),
+            )
+        }
+    }
+
+    /**
+     * BFS를 사용한 탐색
+     * TC: O(n * m), SC: O(n * m)
+     */
+    fun numIslands(grid: Array<CharArray>): Int {
+        val (row, col) = grid.size to grid.first().size
+        val visited = Array(row) { BooleanArray(col) }
+        var result = 0
+
+        for (x in 0 until row) {
+            for (y in 0 until col) {
+                if (!visited[x][y] && grid[x][y] == '1') {
+                    visited[x][y] = true
+                    bfs(x, y, grid, visited)
+                    result++
+                }
+            }
+        }
+        return result
+    }
+
+    private fun bfs(x: Int, y: Int, grid: Array<CharArray>, visited: Array<BooleanArray>) {
+        val queue = ArrayDeque<Position>().apply {
+            this.add(Position(x, y))
+        }
+
+        while (queue.isNotEmpty()) {
+            val now = queue.removeFirst()
+            for (move in Position.MOVES) {
+                val moved = now + move
+                if (moved.isNotOutOfIndexed(grid) && grid[moved.x][moved.y] == '1' && !visited[moved.x][moved.y]) {
+                    visited[moved.x][moved.y] = true
+                    queue.add(moved)
+                }
+            }
+        }
+    }
+
+
+    @Test
+    fun `문자 이차원배열을 입력받으면 1로 이루어진 영역의 수를 반환한다`() {
+        numIslands(arrayOf(
+            charArrayOf('1','1','1','1','0'),
+            charArrayOf('1','1','0','1','0'),
+            charArrayOf('1','1','0','0','0'),
+            charArrayOf('0','0','0','0','0')
+        )) shouldBe 1
+
+        numIslands(arrayOf(
+            charArrayOf('1','1','0','0','0'),
+            charArrayOf('1','1','0','0','0'),
+            charArrayOf('0','0','1','0','0'),
+            charArrayOf('0','0','0','1','1')
+        )) shouldBe 3
+    }
+}