Add 'Delete Node In a Linked List', 'Remove Nth Node From End of List' and 'Rotate Image'

Author: juchanei

jvm/src/main/java/io/github/juchanei/leetcodeJava/DeleteNodeInALinkedList.kt

@@ -0,0 +1,13 @@
+package io.github.juchanei.leetcodeJava
+
+class DeleteNodeInALinkedList {
+    class ListNode(var `val`: Int) {
+        var next: ListNode? = null
+    }
+
+    fun deleteNode(node: ListNode?) {
+        val next = node?.next ?: return
+        node.`val` = next.`val`
+        node.next = next.next
+    }
+}

jvm/src/main/java/io/github/juchanei/leetcodeJava/RemoveNthNodeFromEndOfList.kt

@@ -0,0 +1,96 @@
+package io.github.juchanei.leetcodeJava
+
+import org.assertj.core.api.BDDAssertions.then
+import org.junit.jupiter.api.Test
+
+// https://leetcode.com/explore/interview/card/top-interview-questions-easy/93/linked-list/603/
+class RemoveNthNodeFromEndOfList {
+    class ListNode(var `val`: Int, var next: ListNode? = null)
+
+    fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? {
+        if (head == null) return null
+
+        val dummy = ListNode(0, head)
+
+        findAndRemoveNode(dummy, n) + 1
+
+        return dummy.next
+    }
+
+    private fun findAndRemoveNode(node: ListNode?, n: Int): Int {
+        if (node == null) {
+            return 0
+        } else {
+            val indexFromEnd = findAndRemoveNode(node.next, n) + 1
+
+            // 제거할 노드의 직전 노드에서 제거한다
+            if (indexFromEnd - 1 == n) {
+                removeNextNode(node)
+            }
+
+            return indexFromEnd
+        }
+    }
+
+    private fun removeNextNode(node: ListNode) {
+        node.next = node.next!!.next
+    }
+
+    @Test
+    fun example1() {
+        val head = listOf(1, 2, 3, 4, 5).toListNode()
+        val n = 2
+
+        val actual = removeNthFromEnd(head, n)
+
+        then(actual.toList()).isEqualTo(listOf(1, 2, 3, 5))
+    }
+
+    @Test
+    fun example2() {
+        val head = listOf(1).toListNode()
+        val n = 1
+
+        val actual = removeNthFromEnd(head, n)
+
+        then(actual.toList()).isEqualTo(emptyList<Int>())
+    }
+
+    @Test
+    fun example3() {
+        val head = listOf(1, 2).toListNode()
+        val n = 1
+
+        val actual = removeNthFromEnd(head, n)
+
+        then(actual.toList()).isEqualTo(listOf(1))
+    }
+
+    @Test
+    fun example4() {
+        val head = listOf(1, 2).toListNode()
+        val n = 2
+
+        val actual = removeNthFromEnd(head, n)
+
+        then(actual.toList()).isEqualTo(listOf(2))
+    }
+
+    private fun List<Int>.toListNode(): ListNode? {
+        if (isEmpty()) return null
+        return ListNode(first(), drop(1).toListNode())
+    }
+
+    private fun ListNode?.toList(): List<Int> {
+        val result = mutableListOf<Int>()
+
+        var node: ListNode? = this
+        while (true) {
+            if (node == null) break
+            result.add(node.`val`)
+            node = node.next
+        }
+
+        return result
+    }
+}

jvm/src/main/kotlin/io.github.juchanei.leetcodeKotlin/RotateImage.kt

@@ -0,0 +1,94 @@
+package io.github.juchanei.leetcodeKotlin
+
+import org.junit.jupiter.api.Assertions.assertArrayEquals
+import org.junit.jupiter.api.Test
+
+// https://leetcode.com/problems/rotate-image/
+class RotateImage {
+    fun rotate(matrix: Array<IntArray>) {
+        val n = matrix.size
+
+        for (a in 0 until n / 2) {
+            for (b in a until n - a - 1) {
+                val c = n - a - 1
+                val d = n - b - 1
+
+                val one = matrix[a][b]
+                val two = matrix[b][c]
+                val three = matrix[c][d]
+                val four = matrix[d][a]
+
+                matrix[a][b] = four
+                matrix[b][c] = one
+                matrix[c][d] = two
+                matrix[d][a] = three
+            }
+        }
+    }
+
+    @Test
+    fun example1() {
+        val expected = arrayOf(
+            intArrayOf(7, 4, 1),
+            intArrayOf(8, 5, 2),
+            intArrayOf(9, 6, 3)
+        )
+        val matrix = arrayOf(
+            intArrayOf(1, 2, 3),
+            intArrayOf(4, 5, 6),
+            intArrayOf(7, 8, 9)
+        )
+        rotate(matrix)
+
+        assertArrayEquals(expected, matrix)
+    }
+
+    @Test
+    fun example2() {
+        val expected = arrayOf(
+            intArrayOf(15, 13, 2, 5),
+            intArrayOf(14, 3, 4, 1),
+            intArrayOf(12, 6, 8, 9),
+            intArrayOf(16, 7, 10, 11)
+        )
+        val matrix = arrayOf(
+            intArrayOf(5, 1, 9, 11),
+            intArrayOf(2, 4, 8, 10),
+            intArrayOf(13, 3, 6, 7),
+            intArrayOf(15, 14, 12, 16)
+        )
+        rotate(matrix)
+
+        assertArrayEquals(expected, matrix)
+    }
+
+    @Test
+    fun example3() {
+        val expected = arrayOf(intArrayOf(1))
+        val matrix = arrayOf(intArrayOf(1))
+        rotate(matrix)
+
+        assertArrayEquals(expected, matrix)
+    }
+
+    @Test
+    fun test1() {
+        val expected = arrayOf(
+            intArrayOf(21, 15, 13, 2, 5),
+            intArrayOf(22, 14, 3, 4, 1),
+            intArrayOf(23, 12, 6, 8, 9),
+            intArrayOf(24, 16, 7, 10, 11),
+            intArrayOf(25, 10, 3, 2, 1),
+        )
+        val matrix = arrayOf(
+            intArrayOf(5, 1, 9, 11, 1),
+            intArrayOf(2, 4, 8, 10, 2),
+            intArrayOf(13, 3, 6, 7, 3),
+            intArrayOf(15, 14, 12, 16, 10),
+            intArrayOf(21, 22, 23, 24, 25)
+        )
+        rotate(matrix)
+
+        assertArrayEquals(expected, matrix)
+    }
+}