adventofcode2.2.scala

// Adapting part 1 to part 2 was a simple matter of changing the network of digits and transitions between them

object Xmas2 {

  case class Transition(name: Char, target: Digit)

  case class Digit(value: Int, var transitions: Vector[Transition] = Vector[Transition]()) {
    def addTransitions(newTransitions: Vector[Transition]) = {
      transitions = transitions ++ newTransitions
    }
  }

  /* Part 1

  /* 1 2 3
     4 5 6
     7 8 9  */


  val d1: Digit = Digit(1)
  val d2: Digit = Digit(2)
  val d3: Digit = Digit(3)
  val d4: Digit = Digit(4)
  val d5: Digit = Digit(5)
  val d6: Digit = Digit(6)
  val d7: Digit = Digit(7)
  val d8: Digit = Digit(8)
  val d9: Digit = Digit(9)

  // Transitions must be added after digit creation due to dependencies on each other
  d1.addTransitions(Vector(Transition('R', d2), Transition('D', d4)))
  d2.addTransitions(Vector(Transition('L', d1), Transition('D', d5), Transition('R', d3)))
  d3.addTransitions(Vector(Transition('L', d2), Transition('D', d6)))
  d4.addTransitions(Vector(Transition('U', d1), Transition('R', d5), Transition('D', d7)))
  d5.addTransitions(Vector(Transition('U', d2), Transition('R', d6), Transition('D', d8), Transition('L', d4)))
  d6.addTransitions(Vector(Transition('U', d3), Transition('D', d9), Transition('L', d5)))
  d7.addTransitions(Vector(Transition('U', d4), Transition('R', d8)))
  d8.addTransitions(Vector(Transition('U', d5), Transition('R', d9), Transition('L', d7)))
  d9.addTransitions(Vector(Transition('U', d6), Transition('L', d8)))

*/

  val d1: Digit = Digit(1)
  val d2: Digit = Digit(2)
  val d3: Digit = Digit(3)
  val d4: Digit = Digit(4)
  val d5: Digit = Digit(5)
  val d6: Digit = Digit(6)
  val d7: Digit = Digit(7)
  val d8: Digit = Digit(8)
  val d9: Digit = Digit(9)
  val d10: Digit = Digit(10)
  val d11: Digit = Digit(11)
  val d12: Digit = Digit(12)
  val d13: Digit = Digit(13)

  // Transitions must be added after digit creation due to dependencies on each other
  d1.addTransitions(Vector(Transition('D', d3)))
  d2.addTransitions(Vector(Transition('D', d6), Transition('R', d3)))
  d3.addTransitions(Vector(Transition('L', d2), Transition('U', d1), Transition('R', d4), Transition('D', d7)))
  d4.addTransitions(Vector(Transition('L', d3), Transition('D', d8)))
  d5.addTransitions(Vector(Transition('R', d6)))
  d6.addTransitions(Vector(Transition('U', d2), Transition('D', d10), Transition('L', d5), Transition('R', d7)))
  d7.addTransitions(Vector(Transition('U', d3), Transition('D', d11), Transition('L', d6), Transition('R', d8)))
  d8.addTransitions(Vector(Transition('U', d4), Transition('R', d9), Transition('L', d7), Transition('D', d12)))
  d9.addTransitions(Vector(Transition('L', d8)))
  d10.addTransitions(Vector(Transition('U', d6), Transition('R', d11)))
  d11.addTransitions(Vector(Transition('U', d7), Transition('R', d12), Transition('D', d13), Transition('L', d10)))
  d12.addTransitions(Vector(Transition('U', d8), Transition('L', d11)))
  d13.addTransitions(Vector(Transition('U', d11)))

  /*

     1
  2  3  4
5 6  7  8 9
  10 11 12
     13

   */

  val puzzleInput = """UULDRRRDDLRLURUUURUURDRUURRDRRURUDRURRDLLDRRRDLRUDULLRDURLULRUUURLDDRURUDRULRDDDUDRDLDDRDDRUURURRDDRLRLUDLUURURLULLLRRDRLDRLRDLULULRDRDDUURUDRRURDLRRDDDLUULDURDLDLLRLRLLUDUDLRDDLUURUUDDRDULDDLDLLDULULRLDDDUDDDRLLRURLRDUUUDUUDDURRDLDDLRDLLUDDLDRLDULDRURLUUDLURLUDRULRLRUUUURLUUUDDULLRLLURDRURLLRLRLDDRURURULRULLUUUULUDULDDDRDDLURLUURRLDDRDRUDDRRLURRDURRLDUULRRLLRDLLDDUURULLRUURRRRDRRURLULLRLRDDULULRDLDDLULLD
UUDUDDRRURRUDDRLDLURURLRLLDRLULLUURLLURDRLLURLLRRLURDLDURUDRURURDLRDRRDULRLLLRDLULDRLLDLDRLDDRUUUUULRLDUURDUUUURUUDLRDLLDRLURULDURURLDLLRDLULLULLLLLUDUDDLRLLLUDLRUUDDUUDUDDDLULDDUDUULUUDUDRRULRRRURUDUUULDDRURLLULLULURLUDRDLUUUDLDRRLRRRULLRRURRUDDDRDLDDDLDUDLLDRRDURRURRURRLDLURUULRLDLUDUDUUULULUUDDDLDDULRDULLULDRDDURRURRRULRDURULUDURRDLLUURRUURLLLULDRRULUUUURLRLRDDDDULLUUUDRRLRRLRRLLLUDDDLRDDURURRDULLLUDLUDURRLRDURUURURDRDUUURURRUDRURRULLDDURRLRRRUULDRLDRRURUDLULRLLRRDLDDRLRRULDDLLUURUDDUDRLUD
DDDUDDRRDRRRUULDRULDLDLURRRUURULRUDDRLLLLURRLRULDLURRULDRUDRRLLLLDULRDLUUURDDLDLURRLLUUURLLUDLUDRRDDULLULURDULRRDLRLDRRUUUUDLRRDLDDLDULDRUULRLLDLRURRUDLDDDRUUULLDDLULDULDUURUDDDLULUDLUURLRURUURDDUDRRLDRRRDDDDRDLUDRRDURDLDRURDDDRRLLLRDDRRRDDLDRLLUURRLDRDDRDLRDDLLDRLRDRDDDURLULLRUURDLULRURRUUDLDRLDRRDDRLDDUULLRDDRRLLLDDDUURDUDRUDUDULDULRUURLDURRDLUURRDLLDDLLURUUUDRLUURRDLUDUULRURLUDDLLRUDURRDRRRDRDLULRRLRUDULUUDRLURRRRLULURRDLLDRDDRLULURDURRDUUULLRDUUDLDUDURUDRUDDLRLULRLRLRRRLRUULLDDLUDDLDRRRLDDLLRLRLRUDULRLLLUULLDRDLDRRDULLRRLLDLDUDULUDDUUDLRDRLUUULLRLDLDDLLRUDDRDD
DDUURRLULDLULULLDUDDRURDDRLRDULUURURRLURDLRRDUUDLULDRDLDLRLULLRULLDRLDRRULUDRLDURUURLLDLLDDLUULLRLRULRLUURDDDDDRLDRLLLDLULDLDLULRRURLLLLLLRLUDLRRLRULUULLLLURDLLRLLDDUDLLULDLLURUUDLRDRDUDDDRDDUULRLLDDDLLRLURLUDLULRRUUUULLDLDLLLDRLUDRDRDLUDLRUDRDRUDRDLLDDLRRLRDLDURDLDRUUUDRLULUULDURDLUUUDDDDDLDRDURDLULDDLLUDUURRUDDLURUDDLRLUUDURUDUULULUDLDLUURDULURURULDDDLUUUUDLUUDUDLLLRDDLRDDLRURRRLLLULLURULLRDLLDRULRDDULULRLUDRRRDULRLLUDUULLRDRDDDULULRURULDLDLDRDLDUDRDULLUUUUUDLRDURDUUULLLRUULLRUULDRRUUDLLLULLUURLDDLUULLRLRLRDRLLLRLURDDURUDUULULDLRLRLLUDURRURDRUDLRDLLRDDRDUULRDRLLRULLUDDRLDLDDDDUDRDD
URDLUDUDLULURUDRLUDLUDLRLRLLDDDDDLURURUURLRDUDLRRUUDUURDURUULDRRRDDDLDUURRRDLRULRRDLRUDUDLDDDLLLRLRLRUUUUUULURRRLRLUDULURLDLLDUUDDRUDLDUDRRLULLULLDURDDRRLLRLDLLLLRLULLDDDDLDULLRDUURDUDURRUULLDRULUDLUULUUDDLDDRDLULLULDLDRLDLRULLRLURDURUDRLDURDRULRLLLLURRURLRURUDUDRRUDUUDURDDRRDRLURLURRLDRRLLRLRUDLRLLRLDLDDRDLURLLDURUDDUUDRRLRUDLUDULDRUDDRDRDRURDLRLLRULDDURLUUUUDLUDRRURDDUUURRLRRDDLULLLDLRULRRRLDRRURRURRUUDDDLDRRURLRRRRDLDLDUDURRDDLLLUULDDLRLURLRRURDRUULDDDUDRDRUDRRLRLLLLLURDULDUDRLULDRLUULUDDDDUDDRDDLDDRLLRULRRURDDDRDDLDLULRDDRRURRUDRDDDDRURDRRURUUDUDDUURULLDRDULURUDUD"""

  // apply a single transition, either moving to the new location or staying where we are
  def applyTransition(current: Digit, transitionName: Char): Digit = {

    current.transitions.find { _.name == transitionName } match {
      case Some(target) => target.target
      case None => current
    }

  }

  // apply a string of transitions returning the digit result
  // starts at d5 by default
  def applyStringTransitions(s: String, start: Digit = d5): Digit = {
    val finalDigit = s.foldLeft(start){
      (digit, name) =>
        applyTransition(digit, name)
    }

    finalDigit
  }

  // find code
  def findCode(transitions: String) = {
    val inputLines = transitions.split("\n")

    val digits = inputLines.foldLeft(List[Digit](d5)) {
      (current, trans) =>
        applyStringTransitions(trans, current.head) :: current  }

    // drop the start digit (5) and reverse the result

    val result = digits.reverse.tail

    result.foldLeft(""){ (s,a) => s + a.value.toHexString.toUpperCase }
  }

  def main(args: Array[String]): Unit = {
// a 10 b 11 c 12 d 13
//    assert(applyTransition(d1, 'U') == d1)
//    assert(applyTransition(d5, 'U') == d2)
//    assert(applyStringTransitions("RUL").value == 2)

//    val test =
//      """UU
//LRU
//RRR
//LLU"""
//
//    val result1 = findCode(test)
//
//    assert(result1 == "2231")

    val sample = """ULL
                   |RRDDD
                   |LURDL
                   |UUUUD""".stripMargin

    val result2 = findCode(sample)

    assert(result2 == "5DB3")

    val answer = findCode(puzzleInput)

    println(s"The bathroom code is $answer")

  }

}