@RestController
    static class HelloWorldController {

        @GetMapping("/")
        def index() {
            Mono.just("Hello, World")
        }
    }

    static class ApplicationReadyListener implements ApplicationListener<ApplicationReadyEvent> {

        @Override
        void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {

            def applicationContext = applicationReadyEvent.getApplicationContext();

            def port = ((WebServerApplicationContext) applicationContext).getWebServer().getPort();
            def webClient = WebClient.builder().baseUrl(sprintf("http://localhost:%d", port)).build();
            webClient
                    .get().uri("/")
                    .exchange()
                    .flatMap({ r -> r.bodyToMono(String.class) })
                    .doAfterTerminate({ -> CompletableFuture.runAsync(applicationContext.&close) })
                    .subscribe(System.out.&println)
        }
    }

    static void main(String[] args) {

        def builder = new SpringApplicationBuilder(DemoApplication.class)
        builder
                .listeners(new ApplicationReadyListener())
                .run(args)
    }

groovy -Dlogging.level.root=WARN -Dspring.main.banner-mode=OFF solution.groovy

docker run -d -p 5432:5432  --name postgres1 postgres
docker cp input.txt postgres1:/tmp/
docker exec -it postgres1 bash

createdb -U postgres aoc
psql -U postgres aoc

CREATE TABLE modules(mass INTEGER);
COPY modules(mass) FROM '/tmp/input.txt';

SELECT sum(mass/3-2) FROM modules;

WITH RECURSIVE fuel_for_fuel(fuel) AS ( (1)
  SELECT mass/3-2 from modules (2)
  UNION ALL
  SELECT * FROM ( (3)
    SELECT fuel/3-2 AS fuel FROM fuel_for_fuel
  ) hlp WHERE fuel > 0
)
SELECT sum(fuel) from fuel_for_fuel;

UnaryOperator<Integer> computeFuel = mass -> mass/3 - 2;

var fuelForMass = Files.readAllLines(Path.of("input.txt")).stream() (1)
	.map(Integer::parseInt) (2)
	.map(computeFuel) (3)
	.reduce(0, Integer::sum); (4)

System.out.println("Fuel for mass " + fuelForMass);

UnaryOperator<Integer> computeFuel = mass -> mass/3 - 2;

UnaryOperator<Integer> computeFuelForFuel = fuelForIndividualMass ->  (1)
Stream
	.iterate(computeFuel.apply(fuelForIndividualMass), fuel -> fuel > 0, computeFuel) (2)
	.reduce(fuelForIndividualMass, Integer::sum); (3)

var totalFuel = Files.readAllLines(Path.of("input.txt")).stream()
	.map(Integer::parseInt)
	.map(computeFuel.andThen(computeFuelForFuel)) (4)
	.reduce(0, Integer::sum);

System.out.println("Total fuel needed " + totalFuel);

assert computeFuel.andThen(computeFuelForFuel).apply(1969) == 966;
assert computeFuel.andThen(computeFuelForFuel).apply(100756) == 50346;
assert Stream.of(1969, 100756).map(computeFuel.andThen(computeFuelForFuel))
	.reduce(0, Integer::sum) == 51312;

val program = File("input.txt").readText().split(",").map { it.trim().toInt() }

val ops : Array<(Int, Int) -> Int> = arrayOf(Int::plus, Int::times) (1)

fun run(program: List<Int>, noun: Int, verb: Int): IntArray {

	val mem = program.toIntArray() (2)
	mem[1] = noun
	mem[2] = verb

	for (i in 0..mem.size step 4) { (3)
		val inst = mem.sliceArray(i.until(min(i + 4, mem.size))) (4)
		when (inst[0]) { (5)
			in 1..2 -> mem[inst[3]] = ops[inst[0]-1].invoke(mem[inst[1]], mem[inst[2]])
			99 -> return mem
		}
	}
	return mem;
}

for(noun in 0..99) {
	for(verb in 0..99) {
		val mem = run(program, noun, verb);
		if(mem[0] == 19690720) {
			println(100 * noun + verb)
			break
		}
	}
}

static class Point {

	final int x;
	final int y;

	Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	List<Point> createSegment(String s) {
		Function<Integer, Point> newPoint;
		switch (s.charAt(0)) {
			case 'R':
				newPoint = i -> new Point(x + i, y);
				break;
			case 'L':
				newPoint = i -> new Point(x - i, y);
				break;
			case 'U':
				newPoint = i -> new Point(x, y + i);
				break;
			case 'D':
				newPoint = i -> new Point(x, y - i);
				break;
			default:
				newPoint = i -> this;
		}

		var steps = Integer.parseInt(s.substring(1));
		var segment = new ArrayList<Point>(steps);
		for (int i = 1; i <= steps; ++i) {
			segment.add(newPoint.apply(i));
		}
		return segment;
	}
}

var wires = Files.readAllLines(Path.of("input.txt"));
var pointsOfWires = List.of(new HashMap<Point, Integer>(), new HashMap<Point, Integer>());
for (int i = 0; i < 2; ++i) { (1)
	var wirePoints = pointsOfWires.get(i);
	var startingPoint = new Point(0, 0); (2)
	var steps = 0;
	for (String segments : wires.get(i).split(",")) { (3)
		for (Point l : startingPoint.createSegment(segments)) {
			wirePoints.put(l, ++steps);
			startingPoint = l; (4)
		}
	}
}

var intersectingPoints = new HashSet<>(pointsOfWires.get(0).keySet());
intersectingPoints.retainAll(pointsOfWires.get(1).keySet());

intersectingPoints.stream()
	.map(p -> Math.abs(p.x) + Math.abs(p.y))
	.sorted()
	.findFirst()
	.ifPresent(System.out::println);

intersectingPoints.stream()
	.map(p -> pointsOfWires.get(0).get(p) + pointsOfWires.get(1).get(p))
	.sorted()
	.findFirst()
	.ifPresent(System.out::println);

passwords_matching_first_rules = (134792..675810).select do |v| (1)
  pairs = v.to_s.chars.each_cons(2) (2)
  pairs.any? { |p| p[0] == p[1] } && pairs.all? { |p| p[0].to_i <= p[1].to_i } (3)
end

puts "Star one #{passwords_matching_first_rules.count}"

number_of_passwords_matching_third_rule = passwords_matching_first_rules.count do |p|
  p.to_s.scan(/((\d)\2+)/).map{ |a| a[0]}.any? { |v| v.length == 2 } (1)
end

puts "Star two #{number_of_passwords_matching_third_rule}"

object Solution extends App {
}

val input = io.Source.fromFile("input.txt")
val instructions = input.getLines().flatMap( _.split(",")).map(_.trim).map(_.toInt).toSeq
input.close

abstract class Operation { (1)
  def numargs(): Int (2)

  def execute(pos: Int, args: Seq[(Int, Int)], reader: (((Int, Int)) => Int), writer: (Int, Int) => Unit): Int
}

case class Exit() extends Operation {
  def numargs(): Int = 0

  def execute(pos: Int, args: Seq[(Int, Int)], reader: (((Int, Int)) => Int), writer: (Int, Int) => Unit): Int = 0
}

trait HasOpcode {
  def opcode(): Int (1)
}

trait NumericOperation extends HasOpcode {
  val ops = Seq[(Int, Int) => Int](_ + _, _ * _) (2)

  def numargs(): Int = 3 (3)

  def opcode(): Int

  def execute(pos: Int, args: Seq[(Int, Int)], reader: (((Int, Int)) => Int), writer: (Int, Int) => Unit): Int = {
    writer(args(2)._1, ops(opcode() - 1)(reader(args(0)), reader(args(1)))) (4)
    pos + numargs() + 1
  }
}

case class Add() extends Operation with NumericOperation {

  def opcode() = 1
}

object Operation {
  def apply(pos: Int, memory: Array[Int]) = memory(pos) % 100 match {
    case 1 => Add()
    case 2 => Mul()
    case 3 => ReadInto()
    case 4 => Echo()
    case 99 => Exit()
    case opcode@_ => throw new Exception(s"Invalid opcode $opcode")
  }
}

def read(memory: Array[Int])(p: Int, mode: Int) =
  if (mode == 0) memory(p) else p (1)
def write(memory: Array[Int])(p: Int, v: Int) =
  memory(p) = v

val reader = (read(memory) _).tupled (2)
val writer = write(memory) _ (3)

def extractModes(of: Int) = for (i <- 3 to 5) yield
  of % Math.pow(10, i).toInt / Math.pow(10, i - 1).toInt

def run(memory: Array[Int], pos: Int = 0): Unit = {

  val operation = Operation(pos, memory)
  val modes = extractModes(memory(pos))
  val args = (1 to operation.numargs).map(i => (memory(pos + i), modes(i - 1))) (1)


  val reader = (read(memory) _).tupled (2)
  val writer = write(memory) _ (3)

  operation match { (4)
    case Exit() => Nil
    case op@_ => {
      val next = op.execute(pos, args, reader, writer)
      run(memory, next)
    }
  }
}

println("For star one, enter 1, for start two, 5")
run(instructions.toArray)

:load Solution.scala
// Using position mode, consider whether the input is equal to 8; output 1 (if it is) or 0 (if it is not).
Solution.run(Array(3,9,8,9,10,9,4,9,99,-1,8))
// Using position mode, consider whether the input is less than 8; output 1 (if it is) or 0 (if it is not).
Solution.run(Array(3,9,7,9,10,9,4,9,99,-1,8))
// Using immediate mode, consider whether the input is equal to 8; output 1 (if it is) or 0 (if it is not).
Solution.run(Array(3,3,1108,-1,8,3,4,3,99))
// Using immediate mode, consider whether the input is less than 8; output 1 (if it is) or 0 (if it is not).
Solution.run(Array(3,3,1107,-1,8,3,4,3,99))
// And a bigger example, indidicating less than, equal or greater than 8
Solution.run(Array(3,21,1008,21,8,20,1005,20,22,107,8,21,20,1006,20,31,
1106,0,36,98,0,0,1002,21,125,20,4,20,1105,1,46,104,
999,1105,1,46,1101,1000,1,20,4,20,1105,1,46,98,99))

docker run -d -p 7474:7474 -p 7687:7687 -e 'NEO4J_AUTH=neo4j/secret' --name neo4j1 neo4j:3.5.13 (1)
docker cp input.txt neo4j1:/var/lib/neo4j/import (2)
docker exec -it neo4j1 cypher-shell -u neo4j -p secret (3)

LOAD csv FROM 'file:///input.txt' AS orbits FIELDTERMINATOR ')'
MERGE (o0:Object {name: orbits[0]}) (1)
MERGE (o1:Object {name: orbits[1]})
MERGE (o0) <- [:ORBITS] - (o1) (2)
RETURN COUNT(*);

MATCH (c:Object {name: 'COM'}) WITH c
MATCH p=((:Object) -[:ORBITS*1..] -> (c))
RETURN sum(length(p));

MATCH (y:Object {name: 'YOU'}) -[:ORBITS] -> (o1:Object) (1)
MATCH (s:Object {name: 'SAN'}) -[:ORBITS] -> (o2:Object)
WITH o1, o2 (2)
MATCH p = shortestPath((o1)-[:ORBITS*1..]-(o2))  (3)
RETURN length(p);

class IO(private var input: Seq[Int] = Seq()) {
  def read: Option[Int] = input match {
    case Nil => None
    case l@_ => {
      input = input.tail
      Some(l.head)
    }
  }

  def <<(v: Int) = { (1)
    input = v +: input
    this
  }
}

class Computer(private val memory: Array[Int]) { (1)

  private def extractModes(of: Int) = for (i <- 3 to 5) yield
    of % Math.pow(10, i).toInt / Math.pow(10, i - 1).toInt

  val stdIo = new IO (2)

  private var next: Option[Int] = Some(0)

  private def load(p: Int, mode: Int) = if (mode == 0) memory(p) else p

  private def store(p: Int, v: Int) = memory(p) = v

  def run(): Option[Int] = {

    val reader = (load _).tupled
    val writer = store _

    def executionInstruction: (Int => Option[Int]) = (ptr: Int) => { (3)
      val operation = Operation(ptr, memory)
      val modes = extractModes(memory(ptr))
      val args = (1 to operation.numargs).map(i => (memory(ptr + i), modes(i - 1)))
      operation match {
        case Exit() => None
        case op@Echo() => Some(op.execute(ptr, args, reader, writer, stdIo)) (4)
        case op@_ => {
          val next = op.execute(ptr, args, reader, writer, stdIo)
          executionInstruction(next)
        }
      }
    }

    next = next.flatMap(executionInstruction)
    stdIo.read (5)
  }

  def expectsInput() = next.isDefined
}

object Computer {
  def loadProgram(instructions: Seq[Int]) = new Computer(instructions.toArray) (6)
}

def runProgram = (input: Int, computerAndPhase: (Computer, Option[Int])) => {
  val c = computerAndPhase._1
  c.stdIo << input
  computerAndPhase._2 match {
    case v@Some(_) => c.stdIo << v.get
    case _ =>
  }
  c.run().get
} (1)

def runWithoutFeedback(instructions: Seq[Int]): Int = {
  val executeSequence = (computers: Seq[(Computer, Option[Int])]) =>
    computers.foldLeft(0)(runProgram) (2)
  (0 to 4).map(Option(_))
    .permutations (3)
    .map((1 to 5).map(_ => Computer.loadProgram(instructions)).zip(_)) (4)
    .map(executeSequence).max (5)
}

val starOne = runWithoutFeedback(instructions)
println(s"Star one ${starOne}")

def runWithFeedback(instructions: Seq[Int]): Int = {
  val executeSequence2 = (phases: Seq[Option[Int]]) => {
    val computers = (1 to 5).map(_ => Computer.loadProgram(instructions))
    val availablePhases = (phases ++: LazyList.continually(None)).iterator (1)
    val nextRun = () => computers.last.expectsInput()
    var lastOutput = 0
    while (nextRun()) {
      lastOutput = computers
        .zip(availablePhases)
        .foldLeft(lastOutput)(runProgram) (2)
    }
    lastOutput
  }
  (5 to 9).map(Option(_)).permutations.map(executeSequence2).max
}

val starTwo = runWithFeedback(instructions)
println(s"Star two ${starTwo}")

:load Solution.scala
// 43210
Solution.runWithoutFeedback(Seq(3,15,3,16,1002,16,10,16,1,16,15,15,4,15,99,0,0))
// 54321
Solution.runWithoutFeedback(Seq(3,23,3,24,1002,24,10,24,1002,23,-1,23,
101,5,23,23,1,24,23,23,4,23,99,0,0))
139629729
Solution.runWithFeedback(Seq(3,26,1001,26,-4,26,3,27,1002,27,2,27,1,27,26,
27,4,27,1001,28,-1,28,1005,28,6,99,0,0,5))
// 18216
Solution.runWithFeedback(Seq(3,52,1001,52,-5,52,3,53,1,52,56,54,1007,54,5,55,1005,55,26,1001,54,
-5,54,1105,1,12,1,53,54,53,1008,54,0,55,1001,55,1,55,2,53,55,53,4,
53,1001,56,-1,56,1005,56,6,99,0,0,0,0,10))

#!/usr/bin/env python3

w = 25
h = 6
d = w * h

def chunks(lst, n):
    """Yield successive n-sized chunks from lst.

    This solution is from Andreas Zwinkau (https://github.com/qznc)
    I used `wrap` from textwrap before, but that doesn't play nice with whitespaces
    (Well, it does, but more for like text processing).
    Many other inputs have been very messed up and hardly readable.
    https://aoc-2019.netlify.com/generated/coder/qznc/generateddays#_day_08_python
    """
    for i in range(0, len(lst), n):
        yield lst[i:i + n]

with open('input.txt', 'r') as file:
    input = file.read().rstrip()

    layers = list(chunks(input, d)) (1)
    mostTransparentLayer = sorted(layers, key=lambda s: s.count("0"))[0] (2)
    starOne = mostTransparentLayer.count("1") * mostTransparentLayer.count("2")
    print(f"Star one {starOne}")

    translation = {"0": " ", "1" : "*", "2": "2"} (3)
    image = ["2" for _ in range(d)] (4)
    px = 0
    for layer in layers:
        for px in range(0, d):
            image[px] = translation[layer[px]] if image[px] == "2" else image[px]

    starTwo = "\n".join(chunks("".join(image), w)) (5)
    print("Star two")
    print(starTwo)

private final Map<Long, Long> memory;

private long resolveAddress(long address, int mode) {

	return mode == 2 ? base + address : address;  (1)
}

private Long load(long p, int mode) {

	if (mode == 1) {
		return p;
	}

	var address = resolveAddress(p, mode);
	return this.memory.computeIfAbsent(address, i -> i > program.length ? 0L : program[Math.toIntExact(i)]);
}

private void store(long p, int mode, Long v) {

	var address = resolveAddress(p, mode);
	this.memory.put(address, v);
}

case 9 -> {
	var l = load(load(ptr++, 0), modes[0]);
	base += l;
	yield Optional.of(ptr);
}

case 3 -> {
	var v = readStdIn().orElseThrow(InputRequiredException::new);
	store(load(ptr++, 0), modes[0], v);
	yield Optional.of(ptr);
}

private Optional<Long> readStdIn() {

	return Optional.ofNullable(stdIn.poll());
}

private void writeStdOut(Long in) {

	stdOut.push(in);
}

public Computer pipe(Long in) {

	stdIn.push(in);
	return this;
}

public List<Long> drain() {

	var output = new ArrayList<Long>(this.stdOut.size());
	this.stdOut.descendingIterator().forEachRemaining(output::add);
	this.stdOut.clear();
	return output;
}

public Optional<Long> head() {

	return Optional.of(this.stdOut.poll());
}

def direction(v1, v2):
    return (v2[0]-v1[0], v2[1]-v1[1])

def length(v):
    return math.sqrt(v[0]**2 + v[1]**2)

def norm(t):
    l = length(t)
    return (round(t[0]/l,4), round(t[1]/l,4))

all = {}
for candidate in asteroids:  (1)
    targets = {}

    for other in asteroids:
        if(candidate == other):
            continue
        d = direction(candidate, other) (2)
        targets.setdefault(norm(d), []).append((other, length(d))) (3)

    for val in targets.values(): val.sort(key=lambda i:i[1]) (4)
    all[candidate] = targets

base = max(all.items(), key=lambda i:len(i[1])) (5)
print(f"Star one {len(base[1])}")

hit = []
while(len(hit) < 200 and len(base[1]) > 0):
    for val in sorted(base[1].keys(), key=lambda i:(math.atan2(i[0], i[1])), reverse=True): (1)
        targeted = base[1].get(val)
        hit.append(targeted.pop()[0]) (2)
        if(not targeted):
            del base[1][val]
        if(len(hit) == 200):
            break

print(f"Star two {hit[-1][0]*100+hit[-1][1]}")

enum Direction {
	LEFT, RIGHT;

	static Direction fromLong(long instruction) {
		return instruction == 0L ? LEFT : RIGHT;
	}
}

enum View {
	NORTH("^"), SOUTH("v"), WEST("<"), EAST(">");

	private final String rep;

	View(String rep) {
		this.rep = rep;
	}

	View turn(Direction direction) {
		return switch (this) {
			case NORTH -> direction == Direction.LEFT ? WEST : EAST;
			case WEST -> direction == Direction.LEFT ? SOUTH : NORTH;
			case SOUTH -> direction == Direction.LEFT ? EAST : WEST;
			case EAST -> direction == Direction.LEFT ? NORTH : SOUTH;
		};
	}

	@Override
	public String toString() {
		return this.rep;
	}
}

static class Panel {
	private final int x;
	private final int y;

	Panel(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public int getX() {
		return x;
	}

	public int getY() {
		return y;
	}

	Panel next(View view) {
		int dx = 0;
		int dy = 0;

		switch (view) {
			case NORTH -> dy = 1;
			case WEST -> dx = -1;
			case SOUTH -> dy = -1;
			case EAST -> dx = 1;
		}
		return new Panel(this.x + dx, this.y + dy);
	}
}

enum Color {
	BLACK, WHITE;
}

static Map<Panel, Color> walkHull(Computer computer, Map.Entry<Panel, Color> startPanel, Consumer<Event> callback) {

	var panelComparator = Comparator
		.comparing(Panel::getY).reversed().thenComparing(Panel::getX); (1)
	var panels = new TreeMap<Panel, Color>(panelComparator);

	Consumer<Event> handler = event -> {
		if (event instanceof PanelPaintedEvent) {
			PanelPaintedEvent panelPaintedEvent = (PanelPaintedEvent) event;
			panels.put(panelPaintedEvent.getPanel(), panelPaintedEvent.getPayload());
		}
	};
	handler = handler.andThen(callback);

	var currentView = View.NORTH;
	var currentPanel = startPanel.getKey();
	var currentColor = startPanel.getValue();

	// Need to initialize the start color
	handler.accept(new PanelPaintedEvent(currentPanel, currentColor));
	do {
		// Compute
		computer
			.pipe(panels.getOrDefault(currentPanel, Color.BLACK).toLong()) (2)
			.run(false);
		var output = computer.drain();

		// Paint
		currentColor = Color.fromLong(output.get(0));
		handler.accept(new PanelPaintedEvent(currentPanel, currentColor));

		// Move
		currentView = currentView.turn(Direction.fromLong(output.get(1)));
		currentPanel = currentPanel.next(currentView);
		handler.accept(new MovedToPanelEvent(currentPanel, currentView));
	} while (computer.expectsInput());

	handler.accept(new StoppedEvent(currentPanel));

	computer.reset();
	return panels;
}

class Array
	def add(other)
    [self,other].transpose.map { |x| x.reduce(:+) }
	end
end

# Other methods obmitteted for brevity

class Moon
  attr_reader :position
  attr_reader :vel
  attr_reader :gravity

  def add_gravity_of(other_moon)

    @gravity = @gravity.add([
      compare_value_of_axis(@position[0], other_moon.position[0]),
      compare_value_of_axis(@position[1], other_moon.position[1]),
      compare_value_of_axis(@position[2], other_moon.position[2]),
    ])

    self
  end

moons = input.map(&:clone) (1)

(1..1000).each do
  moons
    .product(moons).select { |p| p[0] != p[1] } (2)
    .each{ |m1,m2| m1.add_gravity_of(m2) }
  moons.each{ |m| m.apply_gravity.apply_velocity }
end

total_energy = moons.map(&:energy).reduce(:+)  (3)

puts "Star one #{total_energy}"

moons = input.map(&:clone)

cnt = 0
cycles = [-1, -1, -1]
c = [nil, nil, nil]
axes = Array.new(3) { Set.new }

loop do
  moons
    .product(moons).select { |p| p[0] != p[1] }
    .each{ |m1,m2| m1.add_gravity_of(m2) }
  moons.each{ |m| m.apply_gravity.apply_velocity }

  (0..2).each.select { |i| cycles[i] < 0}.each do |i| (1)
    axis = moons.map { |m| [m.position[i], m.vel[i]].flatten }
    cycles[i] = cnt if axes[i].include? axis
    axes[i].add(axis)
  end

  cnt += 1
  break if moons == input or cycles.all? {|v| v != -1} (2)
end

cycles_until_start = cycles.reduce(&:lcm) (3)

puts "Star two #{cycles_until_start}"

var computer = Computer.loadProgram(instructions);
var output = computer.run().drain();
int cnt = 0;
for (int i = 0; i < output.size(); ++i) {
	if (i % 3 == 2 && TileType.fromLong(output.get(i)) == TileType.BLOCK) {
		++cnt;
	}
}
System.out.println(String.format("Star one %d", cnt));

instructions.set(0, 2L); (1)

var paddlePattern = List.of(TileType.EMPTY.toLong(), TileType.PADDLE.toLong(), TileType.EMPTY.toLong()); (2)
for (int i = 0; i < instructions.size(); i += 2) {
	if (instructions.subList(i, i + 3).equals(paddlePattern)) { (3)
		var paddleAt = i + 1;
		var j = paddleAt;
		while (instructions.get(--j) != TileType.WALL.toInt()) {
			instructions.set(j, TileType.PADDLE.toLong());
		}
		j = paddleAt;
		while (instructions.get(++j) != TileType.WALL.toInt()) {
			instructions.set(j, TileType.PADDLE.toLong());
		}
		break;
	}
}

var computer = Computer.loadProgram(instructions); (4)
while (computer.run(false).expectsInput()) {
	computer.pipe(0L); (5)
}
computer.head()
	.ifPresent(d -> System.out.println(String.format("Star two %d", d)));