Kotlin - Chapter 19: Math and Geometry

* Josephus
* Maximum Collinear Points
* Reverse 32 Bits Integer
* Spiral Matrix
* Triangle Numbers

Author: marttp

kotlin/Math and Geometry/Josephus.kt

@@ -0,0 +1,10 @@
+fun josephus(n: Int, k: Int): Int {
+    // Base case: If there's only one person, the last person is person 0.
+    if (n == 1) {
+        return 0
+    }
+    // Calculate the position of the last person remaining in the reduced problem
+    // with 'n - 1' people. We use modulo 'n' to ensure the answer doesn't exceed
+    // 'n - 1'.
+    return (josephus(n - 1, k) + k) % n
+}

kotlin/Math and Geometry/JosephusOptimized.kt

@@ -0,0 +1,8 @@
+fun josephusOptimized(n: Int, k: Int): Int {
+    var res = 0
+    for (i in 2..n) {
+        // res[i] = (res[i - 1] + k) % i.
+        res = (res + k) % i
+    }
+    return res
+}

kotlin/Math and Geometry/MaximumCollinearPoints.kt

@@ -0,0 +1,55 @@
+import 
+
+fun maximumCollinearPoints(points: List<List<Int>>): Int {
+    var res = 0
+    // Treat each point as a focal point, and determine the maximum
+    // number of points that are collinear with each focal point. The
+    // largest of these maximums is the answer.
+    for (i in points.indices) {
+        res = maxOf(res, maxPointsFromFocalPoint(i, points))
+    }
+    return res
+}
+
+fun maxPointsFromFocalPoint(focalPointIndex: Int, points: List<List<Int>>): Int {
+    val slopesMap = mutableMapOf<Pair<Int, Int>, Int>()
+    var maxPoints = 0
+    // For the current focal point, calculate the slope between it and
+    // every other point. This allows us to group points that share the
+    // same slope.
+    for (j in points.indices) {
+        if (j != focalPointIndex) {
+            val currSlope = getSlope(points[focalPointIndex], points[j])
+            slopesMap[currSlope] = slopesMap.getOrDefault(currSlope, 0) + 1
+            // Update the maximum count of collinear points for the
+            // current focal point.
+            maxPoints = maxOf(maxPoints, slopesMap[currSlope]!!)
+        }
+    }
+    // Add 1 to the maximum count to include the focal point itself.
+    return maxPoints + 1
+}
+
+fun getSlope(p1: List<Int>, p2: List<Int>): Pair<Int, Int> {
+    val rise = p2[1] - p1[1]
+    val run = p2[0] - p1[0]
+    // Handle vertical lines separately to avoid dividing by 0.
+    if (run == 0) {
+        return Pair(1, 0)
+    }
+    // Simplify the slope to its reduced form.
+    val gcdVal = gcd(rise, run)
+    return Pair(rise / gcdVal, run / gcdVal)
+}
+
+// Kotlin doesn't have a built-in GCD function, so we define one here.
+fun gcd(a: Int, b: Int): Int {
+    var num1 = a
+    var num2 = b
+    while (num2 != 0) {
+        val temp = num2
+        num2 = num1 % num2
+        num1 = temp
+    }
+    return num1
+}

kotlin/Math and Geometry/Reverse32BitInteger.kt

@@ -0,0 +1,22 @@
+fun reverse32BitInteger(n: Int): Int {
+    // shadow n to make it mutable
+    var n = n
+    val intMax = Int.MAX_VALUE
+    val intMin = Int.MIN_VALUE
+    var reversedN = 0
+    // Keep looping until we've added all digits of 'n' to 'reversedN'
+    // in reverse order.
+    while (n != 0) {
+        // digit = n % 10
+        val digit = n % 10
+        // n = n / 10
+        n /= 10
+        // Check for integer overflow or underflow.
+        if (reversedN > (intMax / 10) || reversedN < (intMin / 10)) {
+            return 0
+        }
+        // Add the current digit to 'reversedN'.
+        reversedN = reversedN * 10 + digit
+    }
+    return reversedN
+}

kotlin/Math and Geometry/SpiralMatrix.kt

@@ -0,0 +1,41 @@
+fun spiralMatrix(matrix: List<List<Int>>): List<Int> {
+    if (matrix.isEmpty()) {
+        return emptyList()
+    }
+    val result = mutableListOf<Int>()
+    // Initialize the matrix boundaries.
+    var top = 0
+    var bottom = matrix.size - 1
+    var left = 0
+    var right = matrix[0].size - 1
+    // Traverse the matrix in spiral order.
+    while (top <= bottom && left <= right) {
+        // Move from left to right along the top boundary.
+        for (i in left..right) {
+            result.add(matrix[top][i])
+        }
+        top++
+        // Move from top to bottom along the right boundary.
+        for (i in top..bottom) {
+            result.add(matrix[i][right])
+        }
+        right--
+        // Check that the bottom boundary hasn't passed the top boundary
+        // before moving from right to left along the bottom boundary.
+        if (top <= bottom) {
+            for (i in right downTo left) {
+                result.add(matrix[bottom][i])
+            }
+            bottom--
+        }
+        // Check that the left boundary hasn't passed the right boundary
+        // before moving from bottom to top along the left boundary.
+        if (left <= right) {
+            for (i in bottom downTo top) {
+                result.add(matrix[i][left])
+            }
+            left++
+        }
+    }
+    return result
+}

kotlin/Math and Geometry/TriangleNumbers.kt

@@ -0,0 +1,13 @@
+fun triangleNumbers(n: Int): Int {
+    // If n is an odd-numbered row, the first even number always starts at position
+    // 2.
+    if (n % 2 != 0) {
+        return 2
+    }
+    // If n is a multiple of 4, the first even number always starts at position 3.
+    else if (n % 4 == 0) {
+        return 3
+    }
+    // For all other rows, the first even number always starts at position 4.
+    return 4
+}