Swap x an y values in Coordinates

This is a more common notation of coordinates.

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/grids/Coordinates.kt

@@ -3,18 +3,18 @@ package de.ronny_h.aoc.extensions.grids
 import de.ronny_h.aoc.extensions.grids.Direction.*
 import kotlin.math.abs
 
-data class Coordinates(val y: Int, val x: Int) : Comparable<Coordinates> {
+data class Coordinates(val x: Int, val y: Int) : Comparable<Coordinates> {
 
     companion object {
         val ZERO = Coordinates(0, 0)
     }
 
-    operator fun plus(other: Coordinates) = Coordinates(y + other.y, x + other.x)
-    operator fun minus(other: Coordinates) = Coordinates(y - other.y, x - other.x)
+    operator fun plus(other: Coordinates) = Coordinates(x + other.x, y + other.y)
+    operator fun minus(other: Coordinates) = Coordinates(x - other.x, y - other.y)
 
-    operator fun times(other: Int) = Coordinates(y * other, x * other)
+    operator fun times(other: Int) = Coordinates(x * other, y * other)
 
-    operator fun plus(direction: Direction) = Coordinates(y + direction.y, x + direction.x)
+    operator fun plus(direction: Direction) = Coordinates(x + direction.x, y + direction.y)
 
     fun neighbours() = listOf(this + EAST, this + SOUTH, this + WEST, this + NORTH)
 
@@ -39,20 +39,20 @@ data class Coordinates(val y: Int, val x: Int) : Comparable<Coordinates> {
      * Orders [Coordinates] in reading order: top-to-bottom, then left-to-right.
      */
     override fun compareTo(other: Coordinates): Int {
-        if (this.y == other.y) {
-            return this.x - other.x
+        if (y == other.y) {
+            return x - other.x
         }
-        return this.y - other.y
+        return y - other.y
     }
 }
 
-operator fun Int.times(other: Coordinates) = Coordinates(this * other.y, this * other.x)
+operator fun Int.times(other: Coordinates) = Coordinates(this * other.x, this * other.y)
 
-enum class Direction(val y: Int, val x: Int) {
-    NORTH(-1, 0),
-    EAST(0, +1),
-    SOUTH(+1, 0),
-    WEST(0, -1),
+enum class Direction(val x: Int, val y: Int) {
+    NORTH(0, -1),
+    EAST(+1, 0),
+    SOUTH(0, +1),
+    WEST(-1, 0),
     ;
 
     fun turnRight() = when (this) {

src/main/kotlin/de/ronny_h/aoc/extensions/grids/Grid.kt

@@ -120,7 +120,7 @@ abstract class Grid<T>(
     fun <R> forEachCoordinates(action: (position: Coordinates, element: T) -> R): Sequence<R> = sequence {
         for (row in grid.indices) {
             for (col in grid[0].indices) {
-                yield(action(Coordinates(row, col), get(row, col)))
+                yield(action(Coordinates(col, row), get(row, col)))
             }
         }
     }
@@ -131,7 +131,7 @@ abstract class Grid<T>(
      * @throws NoSuchElementException If no matching element can be found.
      */
     fun find(value: T): Coordinates = forEachElement { row, col, element ->
-        if (element == value) Coordinates(row, col) else null
+        if (element == value) Coordinates(col, row) else null
     }.filterNotNull().first()
 
     override fun toString(): String = toString(setOf())

src/main/kotlin/de/ronny_h/aoc/year2015/day06/FireHazard.kt

@@ -39,7 +39,7 @@ class FireHazard : AdventOfCode<Int>(2015, 6) {
         val (from, to) = line.substring(action.text.length).split(" through ")
         val (fromRow, fromCol) = from.split(',').map(String::toInt)
         val (toRow, toCol) = to.split(',').map(String::toInt)
-        return SwitchLight(action, Coordinates(fromRow, fromCol), Coordinates(toRow, toCol))
+        return SwitchLight(action, Coordinates(fromCol, fromRow), Coordinates(toCol, toRow))
     }
 
     private val dimmingGrid = List(1000) {

src/main/kotlin/de/ronny_h/aoc/year2015/day18/LikeAGIFForYourYard.kt

@@ -38,9 +38,9 @@ class LikeAGIFForYourYard : AdventOfCode<Int>(2015, 18) {
 
         private fun GameOfLightGrid.withCornersStuckOn(): GameOfLightGrid {
             setAt(Coordinates(0, 0), on)
-            setAt(Coordinates(0, width - 1), on)
-            setAt(Coordinates(height - 1, 0), on)
-            setAt(Coordinates(height - 1, width - 1), on)
+            setAt(Coordinates(width - 1, 0), on)
+            setAt(Coordinates(0, height - 1), on)
+            setAt(Coordinates(width - 1, height - 1), on)
             return this
         }
     }

src/main/kotlin/de/ronny_h/aoc/year2015/day25/LetItSnow.kt

@@ -18,7 +18,7 @@ fun List<String>.parseCoordinates(): Coordinates {
     val (row, col) = first()
         .substringAfter("Enter the code at row ")
         .split(", column ")
-    return Coordinates(row.toInt(), col.substring(0, col.lastIndex).toInt())
+    return Coordinates(col.substring(0, col.lastIndex).toInt(), row.toInt())
 }
 
 fun nextCodeFor(code: Int): Int = ((code * 252533L) % 33554393).toInt()

src/main/kotlin/de/ronny_h/aoc/year2017/day21/FractalArt.kt

@@ -66,7 +66,7 @@ class FractalArtGrid(size: Int) : Grid<Char>(size, size, off) {
                 if (squareSize == 2 && rule.onCount != 2 || rule.ruleMatches(square) || rule.ruleMatches(square.reversed())) {
                     newGrid.applyRuleAt(
                         rule,
-                        Coordinates(start.y + (start.y / squareSize), start.x + (start.x / squareSize))
+                        Coordinates(start.x + (start.x / squareSize), start.y + (start.y / squareSize))
                     )
                     applied = true
                     break
@@ -123,7 +123,7 @@ class FractalArtGrid(size: Int) : Grid<Char>(size, size, off) {
     private fun forEachSquareOfSize(size: Int, block: (Coordinates, List<List<Char>>) -> Unit) {
         for (row in 0..<height step size) {
             for (col in 0..<height step size) {
-                block(Coordinates(row, col), subGridAt(row, col, size))
+                block(Coordinates(col, row), subGridAt(row, col, size))
             }
         }
     }

src/main/kotlin/de/ronny_h/aoc/year2017/day22/SporificaVirus.kt

@@ -31,13 +31,13 @@ class SeeminglyInfiniteGrid(input: List<String>) {
     init {
         input.forEachIndexed { row, line ->
             line.forEachIndexed { col, node ->
-                grid[Coordinates(row, col)] = node
+                grid[Coordinates(col, row)] = node
             }
         }
     }
 
     private var direction = NORTH
-    private var position = Coordinates(input.size / 2, input[0].length / 2)
+    private var position = Coordinates(input[0].length / 2, input.size / 2)
     var causedInfection = 0
         private set
 

src/main/kotlin/de/ronny_h/aoc/year2018/day03/NoMatterHowYouSliceIt.kt

@@ -35,7 +35,7 @@ class ClaimedAreas(input: List<String>) {
         claims.forEach {
             for (x in it.x..<it.x + it.width) {
                 for (y in it.y..<it.y + it.height) {
-                    claimedAreas[Coordinates(y, x)] = claimedAreas.getValue(Coordinates(y, x)) + 1
+                    claimedAreas[Coordinates(x, y)] = claimedAreas.getValue(Coordinates(x, y)) + 1
                 }
             }
         }
@@ -47,7 +47,7 @@ class ClaimedAreas(input: List<String>) {
         .filter {
             for (x in it.x..<it.x + it.width) {
                 for (y in it.y..<it.y + it.height) {
-                    if (claimedAreas.getValue(Coordinates(y, x)) > 1) return@filter false
+                    if (claimedAreas.getValue(Coordinates(x, y)) > 1) return@filter false
                 }
             }
             true

src/main/kotlin/de/ronny_h/aoc/year2018/day06/ChronalCoordinates.kt

@@ -18,7 +18,7 @@ class ChronalCoordinates : AdventOfCode<Int>(2018, 6) {
 
 fun List<String>.parseCoordinates() = map {
     val (col, row) = it.split(", ")
-    Coordinates(row.toInt(), col.toInt())
+    Coordinates(col.toInt(), row.toInt())
 }
 
 class AreaGrid(private val coordinates: List<Coordinates>) {
@@ -52,7 +52,7 @@ class AreaGrid(private val coordinates: List<Coordinates>) {
     private fun allGridCoordinates() = sequence {
         for (row in min.y..max.y) {
             for (col in min.x..max.x) {
-                yield(Coordinates(row, col))
+                yield(Coordinates(col, row))
             }
         }
     }
@@ -61,12 +61,12 @@ class AreaGrid(private val coordinates: List<Coordinates>) {
         // coordinates on the border are part of infinite areas -> filter them out
         val borderAreas = mutableSetOf<Coordinates>()
         for (col in min.x..max.x) {
-            grid[Coordinates(min.y, col)]?.let { borderAreas.add(it) }
-            grid[Coordinates(max.y, col)]?.let { borderAreas.add(it) }
+            grid[Coordinates(col, min.y)]?.let { borderAreas.add(it) }
+            grid[Coordinates(col, max.y)]?.let { borderAreas.add(it) }
         }
         for (row in min.y..max.y) {
-            grid[Coordinates(row, min.x)]?.let { borderAreas.add(it) }
-            grid[Coordinates(row, max.x)]?.let { borderAreas.add(it) }
+            grid[Coordinates(min.x, row)]?.let { borderAreas.add(it) }
+            grid[Coordinates(max.x, row)]?.let { borderAreas.add(it) }
         }
         return coordinates.toSet() - borderAreas
     }
@@ -82,6 +82,6 @@ class AreaGrid(private val coordinates: List<Coordinates>) {
             maxRow = max(maxRow, it.y)
             maxCol = max(maxCol, it.x)
         }
-        return Coordinates(minRow, minCol) to Coordinates(maxRow, maxCol)
+        return Coordinates(minCol, minRow) to Coordinates(maxCol, maxRow)
     }
 }

src/main/kotlin/de/ronny_h/aoc/year2018/day10/TheStarsAlign.kt

@@ -47,7 +47,7 @@ class StarAlignmentGrid(initStars: List<Star>) {
         val (min, max) = findBorders()
         for (row in min.y..max.y) {
             for (col in min.x..max.x) {
-                if (Coordinates(row, col) in starPositions()) {
+                if (Coordinates(col, row) in starPositions()) {
                     print('#')
                 } else {
                     print(' ')
@@ -88,15 +88,15 @@ class StarAlignmentGrid(initStars: List<Star>) {
     private fun coordinatesColumnWise(min: Coordinates, max: Coordinates) = sequence {
         for (col in min.x..max.x) {
             for (row in min.y..max.y) {
-                yield(Coordinates(row, col))
+                yield(Coordinates(col, row))
             }
         }
     }
 
     private fun coordinatesRowWise(min: Coordinates, max: Coordinates) = sequence {
         for (row in min.y..max.y) {
             for (col in min.x..max.x) {
-                yield(Coordinates(row, col))
+                yield(Coordinates(col, row))
             }
         }
     }
@@ -106,7 +106,7 @@ class StarAlignmentGrid(initStars: List<Star>) {
         val minCol = stars.minOf { it.position.x }
         val maxRow = stars.maxOf { it.position.y }
         val maxCol = stars.maxOf { it.position.x }
-        return Coordinates(minRow, minCol) to Coordinates(maxRow, maxCol)
+        return Coordinates(minCol, minRow) to Coordinates(maxCol, maxRow)
     }
 
     companion object {
@@ -119,7 +119,7 @@ class StarAlignmentGrid(initStars: List<Star>) {
             val (pCol, pRow, vCol, vRow) = (1..4).map {
                 matcher.group(it).trim().toInt()
             }
-            Star(Coordinates(pRow, pCol), Coordinates(vRow, vCol))
+            Star(Coordinates(pCol, pRow), Coordinates(vCol, vRow))
         }
     }
 }