Cosmetic changes (indentation mostly)

3/corrupted_mul.scala

@@ -16,10 +16,9 @@ def parseAndSum(command: String): Int =
   sumOfMults(parsePairs(command))
 
 def parsePairs(command: String): List[(Int, Int)] =
-  MulPattern.findAllMatchIn(command).toList.map(
-    (patternMatch) =>
-      (patternMatch.group(1).toInt, patternMatch.group(2).toInt)
-    )
+  MulPattern.findAllMatchIn(command).toList.map(ptrnMatch =>
+    (ptrnMatch.group(1).toInt, ptrnMatch.group(2).toInt)
+  )
 
 def sumOfMults(pairs: List[(Int, Int)]): Int =
   pairs.map((a, b) => a * b).reduceLeft(_ + _)

3/dos_and_donts.scala

@@ -21,15 +21,14 @@ def parseAndSum(command: String): Int =
   sumOfMults(parsePairs(filterCommand(command)))
 
 def parsePairs(command: String): List[(Int, Int)] =
-  MulPattern.findAllMatchIn(command).toList.map(
-    (patternMatch) =>
-      (patternMatch.group(1).toInt, patternMatch.group(2).toInt)
-    )
+  MulPattern.findAllMatchIn(command).toList.map(ptrnMatch =>
+    (ptrnMatch.group(1).toInt, ptrnMatch.group(2).toInt)
+  )
 
 def sumOfMults(pairs: List[(Int, Int)]): Int =
   pairs.map((a, b) => a * b).reduceLeft(_ + _)
 
 def filterCommand(command: String): String =
-  command .split(DoPattern)
-          .map(_.split(DontPattern, 2).apply(0))
-          .mkString
+  command.split(DoPattern)
+    .map(_.split(DontPattern, 2).apply(0))
+    .mkString

4/x_cross_mas.scala

@@ -72,8 +72,8 @@ def modifyCoordsInDirection(row: Int, col: Int, dir: Direction): (Int, Int) =
 
 @tailrec
 def matchMatrixInDirectionFromPos(
-    word: String, matrix: CharMatrix2D, dir: Direction, row: Int, col: Int
-  ): Boolean =
+  word: String, matrix: CharMatrix2D, dir: Direction, row: Int, col: Int
+): Boolean =
   if word.isEmpty() then true
   else if matrix.charAtIs(row, col, word.head) then
     val (nextRow, nextCol) = modifyCoordsInDirection(row, col, dir)

4/xmas.scala

@@ -39,8 +39,8 @@ def matchesInCharMatrix(word: String, matrix: CharMatrix2D): Int =
     if char == startChar
   do
     matchCount += Direction.values.count(dir =>
-        matchMatrixInDirectionFromPos(word, matrix, dir, row, col)
-      )
+      matchMatrixInDirectionFromPos(word, matrix, dir, row, col)
+    )
 
   matchCount
 
@@ -57,8 +57,8 @@ def modifyCoordsInDirection(row: Int, col: Int, dir: Direction): (Int, Int) =
 
 @tailrec
 def matchMatrixInDirectionFromPos(
-    word: String, matrix: CharMatrix2D, dir: Direction, row: Int, col: Int
-  ): Boolean =
+  word: String, matrix: CharMatrix2D, dir: Direction, row: Int, col: Int
+): Boolean =
   if word.isEmpty() then true
   else if matrix.charAtIs(row, col, word.head) then
     val (nextRow, nextCol) = modifyCoordsInDirection(row, col, dir)

5/print_queue.scala

@@ -13,10 +13,10 @@ def main1(inputFileName: String): Unit =
   val queues = parseQueues(queueLines)
 
   println(
-      queues.filter(isQueueCorrect(_, rulesMap))
-        .map(middleElement(_))
-        .reduce(_ + _)
-    )
+    queues.filter(isQueueCorrect(_, rulesMap))
+      .map(middleElement(_))
+      .reduce(_ + _)
+  )
 
 def buildRulesMap(rules: Seq[String]): Map[Int, Set[Int]] =
   rules.map(_.split('|'))
@@ -28,11 +28,11 @@ def parseQueues(queues: Seq[String]): List[Vector[Int]] =
 
 def isQueueIncorrect[T](queue: Vector[T], rulesMap: Map[T, Set[T]]): Boolean =
   queue.zipWithIndex.exists((elem, idx) =>
-      if rulesMap.contains(elem) then
-        val elemsGoingAfter = rulesMap.apply(elem)
-        queue.take(idx).exists(elemsGoingAfter.apply(_))
-      else false
-    )
+    if rulesMap.contains(elem) then
+      val elemsGoingAfter = rulesMap.apply(elem)
+      queue.take(idx).exists(elemsGoingAfter.apply(_))
+    else false
+  )
 
 def isQueueCorrect[T](queue: Vector[T], rulesMap: Map[T, Set[T]]): Boolean =
   !isQueueIncorrect(queue, rulesMap)

5/queue_order_fixer.scala

@@ -17,11 +17,11 @@ def main2(inputFileName: String): Unit =
   val isOrderCorrectPredicate = comparisonBuilder(rulesMap)
 
   println(
-      queues.filter(isQueueIncorrect(_, rulesMap))
-        .map(_.sortWith(isOrderCorrectPredicate))
-        .map(middleElement(_))
-        .reduce(_ + _)
-    )
+    queues.filter(isQueueIncorrect(_, rulesMap))
+      .map(_.sortWith(isOrderCorrectPredicate))
+      .map(middleElement(_))
+      .reduce(_ + _)
+  )
 
 def buildRulesMap(rules: Seq[String]): Map[Int, Set[Int]] =
   rules.map(_.split('|'))
@@ -33,11 +33,11 @@ def parseQueues(queues: Seq[String]): List[Vector[Int]] =
 
 def isQueueIncorrect[T](queue: Vector[T], rulesMap: Map[T, Set[T]]): Boolean =
   queue.zipWithIndex.exists((elem, idx) =>
-      if rulesMap.contains(elem) then
-        val elemsGoingAfter = rulesMap.apply(elem)
-        queue.take(idx).exists(elemsGoingAfter.apply(_))
-      else false
-    )
+    if rulesMap.contains(elem) then
+      val elemsGoingAfter = rulesMap.apply(elem)
+      queue.take(idx).exists(elemsGoingAfter.apply(_))
+    else false
+  )
 
 def isQueueCorrect[T](queue: Vector[T], rulesMap: Map[T, Set[T]]): Boolean =
   !isQueueIncorrect(queue, rulesMap)

7/equation_builder.scala

@@ -11,13 +11,13 @@ def main1(inputFileName: String): Unit =
   val lines: Seq[String] = os.read.lines(path)
 
   val equations = (
-      for line <- lines yield
-        val pair = line.split(":\\s+", 2)
-        (
-          pair.apply(0).toLong,
-          pair.apply(1).split("\\s+").map(_.toInt).toList
-        )
-    ).toList
+    for line <- lines yield
+      val pair = line.split(":\\s+", 2)
+      (
+        pair.apply(0).toLong,
+        pair.apply(1).split("\\s+").map(_.toInt).toList
+      )
+  ).toList
 
   println(checkAndSumEquationResults(equations))
 
@@ -40,8 +40,8 @@ def calculate(numbers: List[Int], operators: List[Operator]): Long =
 
 @tailrec
 def recursiveCalculate(
-    currentValue: Long, numbers: List[Int], operators: List[Operator]
-  ): Long =
+  currentValue: Long, numbers: List[Int], operators: List[Operator]
+): Long =
   if numbers.isEmpty then currentValue
   else
     val newValue = applyOperator(operators.head, currentValue, numbers.head)
@@ -58,8 +58,8 @@ def repetitivePermutations[T](length: Int, elements: List[T]): List[List[T]] =
 // Returns new lists, created by prepending every element to the container list,
 // and then iterating upon those new lists.
 def prependEach[T](
-    elements: List[T], containerList: List[T] = List(), iterations: Int = 1
-  ): List[List[T]] =
+  elements: List[T], containerList: List[T] = List(), iterations: Int = 1
+): List[List[T]] =
   val newLists = for
     elem <- elements
   yield

7/extra_equation_builder.scala

@@ -11,13 +11,13 @@ def main2(inputFileName: String): Unit =
   val lines: Seq[String] = os.read.lines(path)
 
   val equations = (
-      for line <- lines yield
-        val pair = line.split(":\\s+", 2)
-        (
-          pair.apply(0).toLong,
-          pair.apply(1).split("\\s+").map(_.toInt).toList
-        )
-    ).toList
+    for line <- lines yield
+      val pair = line.split(":\\s+", 2)
+      (
+        pair.apply(0).toLong,
+        pair.apply(1).split("\\s+").map(_.toInt).toList
+      )
+  ).toList
 
   println(checkAndSumEquationResults(equations))
 
@@ -40,8 +40,8 @@ def calculate(numbers: List[Int], operators: List[Operator]): Long =
 
 @tailrec
 def recursiveCalculate(
-    currentValue: Long, numbers: List[Int], operators: List[Operator]
-  ): Long =
+  currentValue: Long, numbers: List[Int], operators: List[Operator]
+): Long =
   if numbers.isEmpty then currentValue
   else
     val newValue = applyOperator(operators.head, currentValue, numbers.head)
@@ -59,8 +59,8 @@ def repetitivePermutations[T](length: Int, elements: List[T]): List[List[T]] =
 // Returns new lists, created by prepending every element to the container list,
 // and then iterating upon those new lists.
 def prependEach[T](
-    elements: List[T], containerList: List[T] = List(), iterations: Int = 1
-  ): List[List[T]] =
+  elements: List[T], containerList: List[T] = List(), iterations: Int = 1
+): List[List[T]] =
   val newLists = for
     elem <- elements
   yield

8/antinode_check.scala

@@ -58,9 +58,9 @@ def findAntinodes(positions: List[Coord], matrix: Char2DMatrix): List[Coord] =
 
 @tailrec
 def recursiveFindAntinodes(
-    currentPosition: Coord, positions: List[Coord], matrix: Char2DMatrix,
-    foundAntinodes: List[Coord] = List()
-  ): List[Coord] =
+  currentPosition: Coord, positions: List[Coord], matrix: Char2DMatrix,
+  foundAntinodes: List[Coord] = List()
+): List[Coord] =
   if positions.isEmpty then foundAntinodes
   else
     val newAntinodes =
@@ -70,8 +70,8 @@ def recursiveFindAntinodes(
     )
 
 def calculateAntinodesFor(
-    pos1: Coord, pos2: Coord, matrix: Char2DMatrix
-  ): List[Coord] =
+  pos1: Coord, pos2: Coord, matrix: Char2DMatrix
+): List[Coord] =
   val coord1 = Coord(
     -2 * (pos1.row - pos2.row) + pos1.row,
     -2 * (pos1.col - pos2.col) + pos1.col

8/extra_antinode_check.scala

@@ -58,9 +58,9 @@ def findAntinodes(positions: List[Coord], matrix: Char2DMatrix): List[Coord] =
 
 @tailrec
 def recursiveFindAntinodes(
-    currentPosition: Coord, positions: List[Coord], matrix: Char2DMatrix,
-    foundAntinodes: List[Coord] = List()
-  ): List[Coord] =
+  currentPosition: Coord, positions: List[Coord], matrix: Char2DMatrix,
+  foundAntinodes: List[Coord] = List()
+): List[Coord] =
   if positions.isEmpty then foundAntinodes
   else
     val newAntinodes =
@@ -70,15 +70,15 @@ def recursiveFindAntinodes(
     )
 
 def calculateAntinodesFor(
-    pos1: Coord, pos2: Coord, matrix: Char2DMatrix
-  ): List[Coord] =
+  pos1: Coord, pos2: Coord, matrix: Char2DMatrix
+): List[Coord] =
   recursiveCalculateAntinodesFor(pos1, pos2, matrix)
 
 @tailrec
 def recursiveCalculateAntinodesFor(
-    pos1: Coord, pos2: Coord, matrix: Char2DMatrix, muliplier: Int = -1,
-    foundAntinodes: List[Coord] = List()
-  ): List[Coord] =
+  pos1: Coord, pos2: Coord, matrix: Char2DMatrix, muliplier: Int = -1,
+  foundAntinodes: List[Coord] = List()
+): List[Coord] =
   val coord1 = Coord(
     muliplier * (pos1.row - pos2.row) + pos1.row,
     muliplier * (pos1.col - pos2.col) + pos1.col

9/disk_fragmenter.scala

@@ -40,8 +40,8 @@ def fragmentMap(map: Vector[Int]): Vector[Int] =
 
 @tailrec
 def recursiveFragmentMap(
-    map: Array[Int], emptyIndex: Int, fileIndex: Int
-  ): Array[Int] =
+  map: Array[Int], emptyIndex: Int, fileIndex: Int
+): Array[Int] =
   if emptyIndex >= fileIndex then map
   else
     map(emptyIndex) = map(fileIndex)

9/disk_space_optimizer.scala

@@ -71,8 +71,8 @@ def findPrevFileRange(map: Array[Int], currentIndex: Int): Option[Range] =
 
 @tailrec
 def findFileRangeFromEnd(
-    map: Array[Int], currentIndex: Int, foundRangeEnd: Int, fileId: Int
-  ): Range =
+  map: Array[Int], currentIndex: Int, foundRangeEnd: Int, fileId: Int
+): Range =
   if currentIndex < 0 then (0 to foundRangeEnd)
   else
     if map.apply(currentIndex) != fileId then
@@ -81,8 +81,8 @@ def findFileRangeFromEnd(
 
 @tailrec
 def findFreeSpaceForRange(
-    map: Array[Int], range: Range, currentIndex: Int = 0
-  ): Option[Range] =
+  map: Array[Int], range: Range, currentIndex: Int = 0
+): Option[Range] =
   if currentIndex >= range.start then None
   else if map.apply(currentIndex) >= 0 then
     findFreeSpaceForRange(map, range, currentIndex + 1)
@@ -96,8 +96,8 @@ def findFreeSpaceForRange(
 
 @tailrec
 def findFreeSpaceRangeEnd(
-    map: Array[Int], currentIndex: Int, rangeStartIndex: Int, maxLength: Int
-  ): Int =
+  map: Array[Int], currentIndex: Int, rangeStartIndex: Int, maxLength: Int
+): Int =
   if currentIndex >= map.length then map.length - 1
   else if map.apply(currentIndex) >= 0 then currentIndex - 1
   else if (rangeStartIndex to currentIndex).length >= maxLength then currentIndex