ToCode

cond.comparator match
            case "<" if cond.second < compressed.maxS => compressed.copy(maxS = cond.second - 1)
            case "<=" if cond.second < compressed.maxS => compressed.copy(maxS = cond.second)
            case ">" if cond.second > compressed.minS  => compressed.copy(minS = cond.second + 1)
            case ">=" if cond.second > compressed.minS  => compressed.copy(minS = cond.second)
            case _ => compressed
    }

  @main
  def day19part1(): Unit =
    val (workflows, items) = parse(Source.fromString(demoWorkflow))
    val start = workflows("in")
    println(items.filter {
      item => process(workflows, start, item)
    }.map { item =>
      item.x + item.m + item.a + item.s
    }.sum)

  def count(workflows: Workflows,
            name: String,
            ruleNumber: Int = 0,
            constraints: List[Condition] = List()): Long =
    if (name == "R") {
      0L
    } else if (name == "A") {
      sizeOf(compress(constraints))
    } else {
      val rules = workflows(name)
      val rule = rules(ruleNumber)
      if (rule.condition.second < MAX_VALUE) {
        count(workflows, rule.destination, 0, constraints :+ rule.condition) +
          count(workflows, name, ruleNumber + 1, constraints :+ inverseCondition(rule.condition))
      } else {
        count(workflows, rule.destination, 0, constraints :+ rule.condition)
      }
    }


  @main
  def day19part2(): Unit =
    val (workflows, items) = parse(Source.fromString(demoWorkflow))
    println(count(workflows, "in"))

}

rule.split(":") match
      case Array(destination) => Rule(parseCondition(""), destination)
      case Array(condition, destination) => Rule(parseCondition(condition), destination)

  // workflow - ex{x>10:one,m<20:two,a>30:R,A}
  def parseWorkflow(line: String): (String, Workflow) =
    val List(name, workflow) = """(\w+)\{(.*)}""".r.findFirstMatchIn(line).get.subgroups
    val rules = workflow.split(",").map(parseRule).toList
    (name, rules)

  def parseItem(line: String): Item =
    val pattern = """\{x=(\d+),m=(\d+),a=(\d+),s=(\d+)}""".r
    val List(x, m, a, s) = pattern.findFirstMatchIn(line).get.subgroups
    Item(x.toLong,
      m.toLong,
      a.toLong,
      s.toLong)

  def parse(source: Source): (Workflows, List[Item]) =
    val lines = source.getLines().toList
    val workflows = lines
    .takeWhile(_.nonEmpty)
    .map(parseWorkflow)
    .foldLeft(Map[String, Workflow]()) {(workflow, map) =>
      val (name, data) = map
      workflow ++ Map(name -> data)
    }
    val items = lines
      .dropWhile(_.nonEmpty)
      .drop(1)
      .map(parseItem)

    (workflows, items)

  def checkCondition(condition: Condition, item: Item): Boolean =
    val op1 = condition.first match
      case "x" => item.x
      case "m" => item.m
      case "a" => item.a
      case "s" => item.s

    condition.comparator match
      case "<" => op1 < condition.second
      case "<=" => op1 <= condition.second
      case ">" => op1 > condition.second
      case ">=" => op1 >= condition.second

  def inverseCondition(condition: Condition): Condition =
    condition.comparator match
      case "<" => condition.copy(comparator=">=")
      case "<=" => condition.copy(comparator=">")
      case ">" => condition.copy(comparator="<=")
      case ">=" => condition.copy(comparator = "<")



  def process(workflows: Workflows, current: Workflow, item: Item): Boolean =
    current.find(r => checkCondition(r.condition, item)) match
      case Some(rule) =>
        rule.destination match
          case "A" => true
          case "R" => false
          case next => process(workflows, workflows(next), item)


  def sizeOf(condition: CompressedConditions): Long =
    (condition.maxX - condition.minX + 1) *
      (condition.maxS - condition.minS + 1) *
      (condition.maxA - condition.minA + 1) *
      (condition.maxM - condition.minM + 1)

  def compress(conditions: List[Condition]): CompressedConditions =
    conditions.foldLeft(CompressedConditions(1, 4000, 1, 4000, 1, 4000, 1, 4000)) { (compressed, cond) =>
      cond.first match
        case "x" =>
          cond.comparator match
            case "<" if cond.second < compressed.maxX => compressed.copy(maxX=cond.second - 1)
            case "<=" if cond.second < compressed.maxX => compressed.copy(maxX=cond.second)
            case ">" if cond.second > compressed.minX => compressed.copy(minX=cond.second + 1)
            case ">=" if cond.second > compressed.minX => compressed.copy(minX=cond.second)
            case _ => compressed

        case "m" =>
          cond.comparator match
            case "<" if cond.second < compressed.maxM => compressed.copy(maxM=cond.second - 1)
            case "<=" if cond.second < compressed.maxM  => compressed.copy(maxM=cond.second)
            case ">" if cond.second > compressed.minM => compressed.copy(minM=cond.second + 1)
            case ">=" if cond.second > compressed.minM => compressed.copy(minM=cond.second)
            case _ => compressed

        case "a" =>
          cond.comparator match
            case "<" if cond.second < compressed.maxA => compressed.copy(maxA=cond.second - 1)
            case "<=" if cond.second < compressed.maxA => compressed.copy(maxA=cond.second)
            case ">" if cond.second > compressed.minA => compressed.copy(minA=cond.second + 1)
            case ">=" if cond.second > compressed.minA => compressed.copy(minA=cond.second)
            case _ => compressed

        case "s" =>

case "<" if cond.second < compressed.maxX => compressed.copy(maxX=cond.second - 1)
            case "<=" if cond.second < compressed.maxX => compressed.copy(maxX=cond.second)
            case ">" if cond.second > compressed.minX => compressed.copy(minX=cond.second + 1)
            case ">=" if cond.second > compressed.minX => compressed.copy(minX=cond.second)
            case _ => compressed

        case "m" =>
          cond.comparator match
            case "<" if cond.second < compressed.maxM => compressed.copy(maxM=cond.second - 1)
            case "<=" if cond.second < compressed.maxM  => compressed.copy(maxM=cond.second)
            case ">" if cond.second > compressed.minM => compressed.copy(minM=cond.second + 1)
            case ">=" if cond.second > compressed.minM => compressed.copy(minM=cond.second)
            case _ => compressed

        case "a" =>
          cond.comparator match
            case "<" if cond.second < compressed.maxA => compressed.copy(maxA=cond.second - 1)
            case "<=" if cond.second < compressed.maxA => compressed.copy(maxA=cond.second)
            case ">" if cond.second > compressed.minA => compressed.copy(minA=cond.second + 1)
            case ">=" if cond.second > compressed.minA => compressed.copy(minA=cond.second)
            case _ => compressed

        case "s" =>
          cond.comparator match
            case "<" if cond.second < compressed.maxS => compressed.copy(maxS = cond.second - 1)
            case "<=" if cond.second < compressed.maxS => compressed.copy(maxS = cond.second)
            case ">" if cond.second > compressed.minS  => compressed.copy(minS = cond.second + 1)
            case ">=" if cond.second > compressed.minS  => compressed.copy(minS = cond.second)
            case _ => compressed
    }
    
  def inverseCondition(condition: Condition): Condition =
    condition.comparator match
      case "<" => condition.copy(comparator=">=")
      case "<=" => condition.copy(comparator=">")
      case ">" => condition.copy(comparator="<=")
      case ">=" => condition.copy(comparator = "<")

import scala.io.Source
import scala.util.matching.Regex

object aoc2023day19 {
  val MAX_VALUE = 4000

  case class Item(x: Long, m: Long, a: Long, s: Long)
  case class CompressedConditions(minX: Long, maxX: Long,
                                  minM: Long, maxM: Long,
                                  minA: Long, maxA: Long,
                                  minS: Long, maxS: Long)
  case class Condition(first: String, comparator: String, second: Long)
  case class Rule(condition: Condition, destination: String)
  type Workflow = List[Rule]
  type Workflows = Map[String, Workflow]

  val demoWorkflowLine: String = "ex{x>10:one,m<20:two,a>30:R,A}"
  val demoWorkflow: String = """px{a<2006:qkq,m>2090:A,rfg}
                       |pv{a>1716:R,A}
                       |lnx{m>1548:A,A}
                       |rfg{s<537:gd,x>2440:R,A}
                       |qs{s>3448:A,lnx}
                       |qkq{x<1416:A,crn}
                       |crn{x>2662:A,R}
                       |in{s<1351:px,qqz}
                       |qqz{s>2770:qs,m<1801:hdj,R}
                       |gd{a>3333:R,R}
                       |hdj{m>838:A,pv}
                       |
                       |{x=787,m=2655,a=1222,s=2876}
                       |{x=1679,m=44,a=2067,s=496}
                       |{x=2036,m=264,a=79,s=2244}
                       |{x=2461,m=1339,a=466,s=291}
                       |{x=2127,m=1623,a=2188,s=1013}""".stripMargin

  // condition - x>10
  def parseCondition(condition: String): Condition =
    val pattern: Regex = "([xmas])([<>])(\\d+)".r

    condition match
      case "" => Condition("x", "<=", MAX_VALUE)
      case pattern(a, b, c) => Condition(a, b, c.toLong)


  // rule - x>10:one
  def parseRule(rule: String): Rule =

// workflow - ex{x>10:one,m<20:two,a>30:R,A}
  def parseWorkflow(line: String): (String, Workflow) =
    val List(name, workflow) = """(\w+)\{(.*)}""".r.findFirstMatchIn(line).get.subgroups
    val rules = workflow.split(",").map(parseRule).toList
    (name, rules)

  def parseItem(line: String): Item =
    val pattern = """\{x=(\d+),m=(\d+),a=(\d+),s=(\d+)}""".r
    val List(x, m, a, s) = pattern.findFirstMatchIn(line).get.subgroups
    Item(x.toLong,
      m.toLong,
      a.toLong,
      s.toLong)

  def parse(source: Source): (Workflows, List[Item]) =
    val lines = source.getLines().toList
    val workflows = lines
    .takeWhile(_.nonEmpty)
    .map(parseWorkflow)
    .foldLeft(Map[String, Workflow]()) {(workflow, map) =>
      val (name, data) = map
      workflow ++ Map(name -> data)
    }
    val items = lines
      .dropWhile(_.nonEmpty)
      .drop(1)
      .map(parseItem)

    (workflows, items)

  def checkCondition(condition: Condition, item: Item): Boolean =
    val op1 = condition.first match
      case "x" => item.x
      case "m" => item.m
      case "a" => item.a
      case "s" => item.s

    condition.comparator match
      case "<" => op1 < condition.second
      case "<=" => op1 <= condition.second
      case ">" => op1 > condition.second
      case ">=" => op1 >= condition.second

  def process(workflows: Workflows, current: Workflow, item: Item): Boolean =
    current.find(r => checkCondition(r.condition, item)) match
      case Some(rule) =>
        rule.destination match
          case "A" => true
          case "R" => false
          case next => process(workflows, workflows(next), item)

  def day19part1(): Unit =
    val (workflows, items) = parse(Source.fromResource("day19.txt"))
    val start = workflows("in")
    println(items.filter {
      item => process(workflows, start, item)
    }.map { item =>
      item.x + item.m + item.a + item.s
    }.sum)

  def count(workflows: Workflows,
            name: String,
            ruleNumber: Int = 0,
            constraints: List[Condition] = List()): Long =
    if (name == "R") {
      0L
    } else if (name == "A") {
      sizeOf(compress(constraints))
    } else {
      val rules = workflows(name)
      val rule = rules(ruleNumber)
      if (rule.condition.second < MAX_VALUE) {
        count(workflows, rule.destination, 0, constraints :+ rule.condition) +
          count(workflows, name, ruleNumber + 1, constraints :+ inverseCondition(rule.condition))
      } else {
        count(workflows, rule.destination, 0, constraints :+ rule.condition)
      }
    }

crn{x>2662:A,R}

  def sizeOf(condition: CompressedConditions): Long =
    (condition.maxX - condition.minX + 1) *
      (condition.maxS - condition.minS + 1) *
      (condition.maxA - condition.minA + 1) *
      (condition.maxM - condition.minM + 1)

  def compress(conditions: List[Condition]): CompressedConditions =
    conditions.foldLeft(CompressedConditions(1, 4000, 1, 4000, 1, 4000, 1, 4000)) { (compressed, cond) =>
      cond.first match
        case "x" =>
          cond.comparator match

px{a<2006:qkq,m>2090:A,rfg}
pv{a>1716:R,A}
lnx{m>1548:A,A}
rfg{s<537:gd,x>2440:R,A}
qs{s>3448:A,lnx}
qkq{x<1416:A,crn}
crn{x>2662:A,R}
in{s<1351:px,qqz}
qqz{s>2770:qs,m<1801:hdj,R}
gd{a>3333:R,R}
hdj{m>838:A,pv}

{x=787,m=2655,a=1222,s=2876}
{x=1679,m=44,a=2067,s=496}
{x=2036,m=264,a=79,s=2244}
{x=2461,m=1339,a=466,s=291}
{x=2127,m=1623,a=2188,s=1013}

{x=787,m=2655,a=1222,s=2876}: in -> qqz -> qs -> lnx -> A
{x=1679,m=44,a=2067,s=496}: in -> px -> rfg -> gd -> R
{x=2036,m=264,a=79,s=2244}: in -> qqz -> hdj -> pv -> A
{x=2461,m=1339,a=466,s=291}: in -> px -> qkq -> crn -> R
{x=2127,m=1623,a=2188,s=1013}: in -> px -> rfg -> A

import scala.io.Source
import scala.util.matching.Regex

object aoc2023day19 {
  val MAX_VALUE = 4000

  case class Item(x: Long, m: Long, a: Long, s: Long)
  case class CompressedConditions(minX: Long, maxX: Long,
                                  minM: Long, maxM: Long,
                                  minA: Long, maxA: Long,
                                  minS: Long, maxS: Long)
  case class Condition(first: String, comparator: String, second: Long)
  case class Rule(condition: Condition, destination: String)
  type Workflow = List[Rule]
  type Workflows = Map[String, Workflow]

  val demoWorkflowLine: String = "ex{x>10:one,m<20:two,a>30:R,A}"
  val demoWorkflow: String = """px{a<2006:qkq,m>2090:A,rfg}
                       |pv{a>1716:R,A}
                       |lnx{m>1548:A,A}
                       |rfg{s<537:gd,x>2440:R,A}
                       |qs{s>3448:A,lnx}
                       |qkq{x<1416:A,crn}
                       |crn{x>2662:A,R}
                       |in{s<1351:px,qqz}
                       |qqz{s>2770:qs,m<1801:hdj,R}
                       |gd{a>3333:R,R}
                       |hdj{m>838:A,pv}
                       |
                       |{x=787,m=2655,a=1222,s=2876}
                       |{x=1679,m=44,a=2067,s=496}
                       |{x=2036,m=264,a=79,s=2244}
                       |{x=2461,m=1339,a=466,s=291}
                       |{x=2127,m=1623,a=2188,s=1013}""".stripMargin

  // condition - x>10
  def parseCondition(condition: String): Condition =
    val pattern: Regex = "([xmas])([<>])(\\d+)".r

    condition match
      case "" => Condition("x", "<=", MAX_VALUE)
      case pattern(a, b, c) => Condition(a, b, c.toLong)


  // rule - x>10:one
  def parseRule(rule: String): Rule =
    rule.split(":") match
      case Array(destination) => Rule(parseCondition(""), destination)
      case Array(condition, destination) => Rule(parseCondition(condition), destination)

* timestamp *
value[0] = (timestamp >> 40) & 0xFF
value[1] = (timestamp >> 32) & 0xFF
value[2] = (timestamp >> 24) & 0xFF
value[3] = (timestamp >> 16) & 0xFF
value[4] = (timestamp >> 8) & 0xFF
value[5] = timestamp & 0xFF

System.arraycopy(timestamp.array(), 2, value, 0, 6);

// current timestamp in ms
$timestamp = intval(microtime(true) * 1000);

long timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

private val random = SecureRandom()

value = SecureRandom.random_bytes(16).bytes

value = :crypto.strong_rand_bytes(16) |> :binary.bin_to_list()

value = rand(UInt8, 16)

$value = random_bytes(16);

_, err := rand.Read(value[:])

(concat
  ;; timestamp
  (map byte (.toByteArray (biginteger (System/currentTimeMillis))))
  ;; version
  [(bit-or (bit-and (first rand-array) 0x0F) 0x70)]
  [(nth rand-array 1)]
  ;; variant
  [(bit-or (bit-and (nth rand-array 2) 0x3F) 0x80)]
  (drop 3 rand-array))))

(concat
    timestamp
    version
    rand_a
    variant
    rand_b)

package dictionary.images

import com.typesafe.scalalogging.Logger
import common.ClaudeSyncClient.getClass
import io.circe.generic.auto.*
import io.circe.parser.*
import sttp.client3.*
import sttp.client3.circe.*

import sttp.model.Uri

import scala.util.chaining.*

case class ImageHit(id: Int,
                     pageURL: String,
                     \type\: String,
                     tags: String,
                     previewURL: String,
                     previewWidth: Int,
                     previewHeight: Int,
                     webformatURL: String,
                     webformatWidth: Int,
                     webformatHeight: Int,
                     largeImageURL: String,
                     imageWidth: Int,
                     imageHeight: Int,
                     imageSize: Int,
                     views: Int,
                     downloads: Int,
                     collections: Int,
                     likes: Int,
                     comments: Int,
                     user_id: Int,
                     user: String,
                     userImageURL: String)

case class ApiResponse(total: Int,
                        totalHits: Int,
                        hits: List[ImageHit])

object Pixabay {
  private val API_KEY: String = System.getenv("PIXABAY_API_KEY")
  val client: SimpleHttpClient = SimpleHttpClient()
  val logger: Logger = Logger(getClass)

  def searchImages(query: String): ApiResponse =
    val queryParams = Map(
      "key" -> API_KEY,
      "q" -> query,
      "image_type" -> "photo",
      "page" -> "1"
    )
    val baseUrl = uri"https://pixabay.com/api/"
    val uriWithParams: Uri = uri"$baseUrl?$queryParams"
    println(uriWithParams)
    basicRequest
      .get(uriWithParams)
      .response(asJson[ApiResponse])
      .pipe(client.send)
      .body match
        case Right(response) => response
        case Left(err) =>
          logger.error("Pixabay error: ", err)
          throw Exception(s"Error getting images from pixabay", err)

  @main
  def testImageSearchPixabay(): Unit =
    val response = searchImages("raisin")
    println(response.hits.head.previewURL)

}

scalacOptions ++= Seq("-Xmax-inlines", "100")

import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerTransactionGraph
import org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal
import scala.jdk.CollectionConverters._

val graph = TinkerTransactionGraph.open
val g = traversal.withEmbedded(graph)

g.addV("item").next()
g.addV("item").next()
g.addV("item").next()

scala> g.V().hasLabel("item").limit(2).elementMap().toList.asScala

val res21: scala.collection.mutable.Buffer[java.util.Map[Object, Object]] = Buffer({id=0, label=item}, {id=1, label=item})

scala> val allItems = g.V().hasLabel("item").limit(2).toList.asScala.toList
val allItems: List[org.apache.tinkerpop.gremlin.structure.Vertex] = List(v[0], v[1])

scala> g.V(allItems: _*).elementMap().toList
val res22: java.util.List[java.util.Map[Object, Object]] = [{id=0, label=item}, {id=1, label=item}]

scala> val allItems = g.V().hasLabel("x").limit(2).toList.asScala.toList
val allItems: List[org.apache.tinkerpop.gremlin.structure.Vertex] = List()

scala> g.V(allItems: _*).elementMap().toList
val res23: java.util.List[java.util.Map[Object, Object]] = [{id=0, label=item}, {id=1, label=item}, {id=2, label=item}]

['1', '2'].map(parseInt)

[ 1, NaN ]

> parseInt(2)
2

> ['1', '2'].map(parseFloat)
[ 1, 2 ]

> parseInt('2', 1)
NaN

> Array(100).fill(0).map((_, i) => \${i}\).map(parseInt)
[
    0, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN,  10,  12,
   14,  16,  18,  20,  22,  24,  26,  28,  40,  43,  46,  49,
   52,  55,  58,  61,  64,  67,  90,  94,  98, 102, 106, 110,
  114, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN,
  NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN,
  NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN,
  NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN,
  NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN,
  NaN, NaN, NaN, NaN
]