Inlägg

object Day16 {
  type Ticket = List[Int]

  case class Field(name: String, ranges: Array[Range.Inclusive]) {
    def matches(x: Int): Boolean = ranges.exists(_.contains(x))
    def matches(l: Seq[Int]): Boolean = l.forall(matches)
  }

  def toField(in: String) = {
    val Array(name, rs) = in.split(": ")
    val ranges = rs.split(" or ").map(s => s.split("-") match
    { case Array(h, t) => Range.inclusive(h.toInt, t.toInt) })
    Field(name, ranges)
  }
  
  class Categorizer(in: String) {
    val Array(fds, my, ticks) = in.split("\\n\\n").map(_.split("\\n"))

    val tickets: List[Ticket] = ticks.drop(1).map(_.split(",").map(_.toInt).toList).toList
    val myTicket = my.last.split(",").map(_.toInt).toList
    val fields = fds.map(toField).toList

    def included(in: Int, ranges: Seq[Range.Inclusive]) = {
      !ranges.forall(!_.contains(in))
    }

    def validTickets = {
      val ranges = fields.flatMap(_.ranges)
      tickets.filter(_.forall(i => included(i, ranges)))
    }
    
    def possibleCategories: List[List[Field]] = validTickets.transpose.map(column => fields.filter(_.matches(column)))
    
    def uniques[A](in: List[List[A]]): List[A] = {
      for {
        l <- in
        l2 <- in
        if l.size - l2.size == 1
      } yield l.diff(l2).head
    }

    def uppg1: Int = tickets.flatten.filter(!included(_, fields.flatMap(_.ranges))).sum
    
    def uppg2: BigInt = {
      val departureIndexes = uniques(possibleCategories).zipWithIndex.filter(_._1.name.startsWith("departure")).map(_._2)
      departureIndexes.map(myTicket(_)).foldLeft(BigInt(1))(_ * _)
    }
  }

def paths(in: List[Int]) = {
    in.tails.filter(!_.isEmpty).foldLeft(Map[Int, BigInt](0 -> BigInt(1))) {
      case (map, head::tail) => {
        val validAdapters: List[Int] = tail.takeWhile((x) => x - head < 4)
        val currentPaths: BigInt = map.get(head).get
        validAdapters.foldLeft(map) { (nmap, elem) => nmap.updated(elem, currentPaths + nmap.get(elem).getOrElse(BigInt(0)) ) }
      }
    }.get(in.last)
  }

// Uppgift 1

 input.foldLeft((0,0,0)) { case ((last, ones, threes), x) =>  if (x-last == 3) (x, ones, threes+1) else if (x-last == 1) (x, ones + 1, threes) else (x, ones, threes) }

object Xmas extends App {

  def apply(l: List[BigInt]) = new Xmas(l)

  //Uppgift 1
  def findNonValid(in: List[BigInt], preambleSize: Int):Option[BigInt] = {
    val candidates = in.drop(preambleSize)
    candidates.foldLeft(Xmas(in.take(preambleSize))) { (acc, elem) => acc.add(elem) }.nonvalids.headOption
  }

  //Uppgift 2
  def find(list: List[BigInt], wanted: BigInt): Option[BigInt] = {
    for {
      x <- 0 to list.size
      y <- x to list.size
      if (y  - x > 1)
      slice = list.slice(x,y)
      if (slice.sum == wanted)
    } return Some(slice.min + slice.max)
    None
  }

  class Xmas(val preamble: List[BigInt]) {
    import scala.collection.mutable
    val nonvalids = new mutable.Queue[BigInt]()
    val source = new mutable.Queue().addAll(preamble)
    def valids = (for { x <- source; y <- source; if x!=y } yield (x + y)).distinct

    def add(x: BigInt): Xmas = {
      if (source.contains(x) || !valids.contains(x)) nonvalids.addOne(x)
      else source.addOne(x).dequeue()
      this
    }
  }
}

def find(list: List[BigInt], wanted: BigInt): Option[BigInt] = {
    for {
      x <- 1 to list.size
      slice <- list.sliding(x)
      if (slice.sum == wanted)
    } return Some(slice.min + slice.max)
    None
  }

object Emulator extends App {

  sealed trait Errors
  case class InfiniteRecursion(line: Int) extends Errors
  case class OobAttempt(line: Int) extends Errors

  sealed trait Ops
  case class Nop(steps: Int) extends Ops
  case class Jmp(steps: Int) extends Ops
  case class Acc(value: Int) extends Ops

  def apply(program: List[String]) = new Emulator(program)

  def decode(str: String):Ops = (str.take(3), str.drop(4).toInt) match {
    case ("nop", amount) => Nop(amount)
    case ("acc", amount) => Acc(amount)
    case ("jmp", step) => Jmp(step)
    case _ => throw new IllegalArgumentException(s"Unknown op $str")
  }

  class Emulator(val program: List[String]) {

    def step(seen: Set[Int], acc:Int, pos:Int, fixed: Boolean = false):Either[Errors, Int] = {
      if (seen.contains(pos)) return Left(InfiniteRecursion(pos))
      if (pos < 0 || pos > program.size-1) return Left(OobAttempt(pos))

      val op = decode(program(pos))

      val newValue = op match {
        case Acc(value) => acc + value
        case _=> acc
      }

      //Horray, the program terminated and we have an answer
      if (pos==program.size-1) return Right(newValue)

      val newPos = op match {
        case Jmp(steps) => pos + steps
        case _ => pos + 1
      }

      val newSeen = seen + pos

      def result = step(newSeen, newValue, newPos, fixed)

      (fixed, result, op) match {
        case (_, Right(answer), _) => result //we have an answer, return it
        case (true, Left(err), _) => result //Already tried fixing once, not allowed more attempts.
        case (false, Left(err), Nop(x)) => step(newSeen, acc, pos + x, true) //Change to Jmp
        case (false, Left(err), Jmp(_)) => step(newSeen, acc, pos+1, true)  //Change to Nop
        case (false, Left(err), _) => result //Accs are never wrong, nothing to do here.
      }
    }

    def run(): Either[Errors, Int] = {
      step(Set[Int](), 0, 0)
    }
  }
}

"blå" -> ["vit", "röd", "guld"]
"svart" -> ["blå"]
"vit" -> []

Skapa en metod "sökaren" som tar emot två Stränglistor: attUndersöka och hittade.
define sökaren(attUndersöka, hittade):
  IF attUndersöka listan är tom
     RETURN "hittade" listan parametern precis som vi fick in den. Nu är vi klara, kallas basfallet i rekursion)
  ELSE plocka ut ett element "x" från attUndersöka så attUndersöka är ett element mindre.
          lägg "x" i listan över hittade
          gå igenom datastrukturen och hitta dom alla dom rader där listorna innehåller "x".
          lägg till nycklarna som pekar på dom listorna till listan attUndersöka OM dom inte redan finns där
         RETURN sökaren(nyaAttUndersöka, nyaHittade)

val BAG_MATCHER = " ?(\\d+) (.*) bag.*".r
case class Bag(weight: Int, color: String)

def contentToList(s: String): List[Bag] = {
  s.split(",").toList.flatMap {
    case BAG_MATCHER(number, color) => List(Bag(number.toInt, color))
    case default => List() // "no other bags" och ev andra strängar = tom väska
  }
}

def lineToTuple(s: String): Tuple2[String, List[Bag]] = {
  val color::content = s.split("bags contain ").map(_.trim).toList
  (color, contentToList(content.last))
}

val bags = (read.lines! pwd/"input.txt").map(lineToTuple).toMap

def totalWeight(color: String): Int = {
  bags(color) match {
    case List() => 1
    case list => (list.map { bag => bag.weight * totalWeight(bag.color) }.sum) + 1
  }
}

totalWeight("shiny gold") - 1

val groups = (read! pwd/"input.txt").split("\\n\\n").map(_.split("\\s+")
groups.map(_.reduce(_ intersect _).size).sum

List("abc", "ab", "ac").reduce { (firstString, secondString) => firstString.intersect(secondString) }  // Returnerar strängen "a"
val intersectioncounts = intersectionStrings.map( (str) => str.size)
val finalAnswer = intersectioncounts.sum // "sum" finns fördefinerad på numeric collections som collection.reduce { (x,y) => x + y }

import ammonite.ops._
val groups = (read! pwd/"input.txt").split("\\n\\n").map(_.split("\\s+")
groups.map(_.flatten.distinct.size).sum //Uppgift 1
groups.map{ (group) => group.flatten.groupBy(identity).count { case(_k,v) => v.size == group.size }}.sum //Uppgift 2

 def count(group: Array[String]): Int = {
    //För input Array("ab", "ac") gör jag flatten så vi får Array('a','b','a','c')
    //groupBy omvandlar till Map och funktionen vi skickar in berättar hur man väljer nyckel.
    // "identity" är inbyggd, det är (x) => x funktionen.
    //Så nu får vi exvis:  Map('a' -> Array('a', 'a'), 'b' -> Array('b'), 'c' -> Array('c'))
    val map:Map[Char,Array[Char]] = group.flatten.groupBy(identity)
    //Räkna hur många entries som alla svarat på, exvis Map('a' -> Array('a', 'a')
    map.count { case(_key, valueArray) => valueArray.size == group.size }
  }
}

//Mappa så vi omvandlar vår Array från att innehålla Arrays av String till att vara en Array of Int. Summera innehållet i Arrayen.
groups.map(count).sum

val l = List("hej", "hopp")  //variabeln l är List[String] men det behöver jag inte skriva, det infereras.
l.map( (s: String) => s.size)  //Ger oss List(3, 4). Detta kan även skrivas som:
l.map(_.size) //Underscore placeholder shortcut, Scala vet att det är en List[String] så kan använda String metoder på _
//Eller om vi har en funktionsreferens kan vi skicka in den direkt till map, Scala matchar in parametrarna och deras typer.
//Identity finns i PreDef så den är alltid tillgänglig: https://www.scala-lang.org/api/current/scala/Predef$.html#ide...
l.map(identity) //Returnerar List("hej", "hopp") inte oväntat.
//Och om man vill pattern matcha på tupler - det här slet jag länge med innan jag hittade rätt lösning
//första gången. Blir enkel kod men lite komplicerad typteori under.
val tuples = List(("foo",1),("bar", 2))
tuples.map ( (a,b) => ..) //detta kompilerar inte, map metoden kräver alltid en funktion som tar en parameter, inte två.
tuples.map { (a) => 
  val stringPart = a._1  //Enda stället med one-based indexing i språket. Mycket irriterande.
  val intPart = a._2
}  //Kompilerar, men känns pratigt.
//Pattern matching to the rescue. Nu slipper vi se 1-indexing också.
//Det innanför måsvingarna omvandlas till en PartialFunction[A,B] som alltså matchar parametern som behövs för map.
tuples.map { case(stringPart, intPart) => ... }

def reducer(s: String, range: List[Int], low: Char, high: Char): Int = {
  if (s.isEmpty)
    range.head
  else {
    val reducedRange = s.head match {
      case `high` => range.takeRight(range.size/2)
      case `low` => range.take(range.size/2)
    }
    reducer(s.tail, reducedRange, low, high)
  }
}

def row(s: String): Int = reducer(s.take(7), (0 to 127).toList, 'F', 'B')
def columns(s: String): Int = reducer(s.drop(7), (0 to 7).toList, 'L', 'R')
def seat(s: String) = row(s) * 8 + column(s)

import ammonite.ops._  //Syntaktiskt socker för filläsning
val seats = (read.lines! pwd/"input.txt").map(seat)

// Uppgift 1
seats.max

//Uppgift 2
val all = (seats.min+1 to seats.max-1).toList
all.diff seats

import ammonite.ops._  //Syntaktiskt socker för filläsning
def toSeat(s: String) = Integer.parseInt(s.map { case 'F' => '0'; case 'B' => '1'; case 'L' => '0'; case 'R' => '1' }, 2)
val seats = (read.lines! pwd/"input.txt").map(toSeat)
(seats.min+1 to seats.max-1).toList diff seats

// Skapa regexes. Kunde gjort regex inline i Scala match-clausen, men regex Pattern instanser kompileras
// på JVMen till Matchers. Så Matchers blir snabba, men kompileringen är en dyr operation och tvivlar
// på att kompilatorn har en regel för att kolla om regex strängen är statisk och isf hoistar ut och bara
// kompilerar en gång.
val DIG_4 = "(\\d{4})".r
val CM = "(\\d+)cm".r
val IN = "(\\d+)in".r

// Filteringsfunktionen. Eftersom regexarna har match group i sig så kan jag assigna en variabel
// (exvis birthYear) till match groupen och sen använda variabeln i case kropparna.
// Är inte konsekvent, använder in-line regex på dom 3 sista, skulle kunna gjort dom statiska som dom
// ovan och även använt dom i case matchen och sen bara returnera "true" i kroppen men tyckte det blev
// mer läsbart så här. Om det var riktig produktionskod med kritisk performance skulle jag gjort val Patterns
// utanför funktionen här med.
def validator(s: String): Boolean = {
  s.split(":") match {
    case Array("byr", DIG_4(birthYear)) => (1920 to 2002 contains birthYear.toInt)
    case Array("iyr", DIG_4(issueYear)) => (2010 to 2020 contains issueYear.toInt)
    case Array("eyr", DIG_4(expireYear)) => (2020 to 2030 contains expireYear.toInt)
    case Array("hgt", CM(height)) => (150 to 193 contains height.toInt)
    case Array("hgt", IN(height)) => (59 to 76 contains height.toInt)
    case Array("hcl", color) => color.matches("^\\#((\\d|[a-f]){6})")
    case Array("ecl", eye) => eye.matches("(amb)|(blu)|(brn)|(gry)|(grn)|(hzl)|(oth)")
    case Array("pid", pid) => pid.matches("\\d{9}")
    case _ => false
  }
}


val passports = inputFile.split("\\n\\n")

//Tokenisera och validera
val validValues = testPassports.map(_.split("\\s+").filter(validator)
//Inte kollat om det finns duplicate keys i några passports, men för att vara säker
validValues.map(a => a.distinctBy(_.take(3))).filter(_.size == 7).size