From ad81a01063e5a2fc4cb2260ebadc8262a3aa624b Mon Sep 17 00:00:00 2001 From: Danila Fedorin Date: Fri, 4 Dec 2020 18:01:27 -0800 Subject: [PATCH] Add archive from Advent of Code 2017. --- day10_1.rb | 19 ++++++ day10_2.rb | 27 +++++++++ day11.kt | 24 ++++++++ day12.kt | 39 ++++++++++++ day13.kt | 35 +++++++++++ day13_2.kt | 33 ++++++++++ day13_2_crt.kt | 15 +++++ day14.kt | 7 +++ day14_1.rb | 89 +++++++++++++++++++++++++++ day15.kt | 45 ++++++++++++++ day16.kt | 85 ++++++++++++++++++++++++++ day17.kt | 21 +++++++ day18.kt | 70 +++++++++++++++++++++ day19.txt.kt | 28 +++++++++ day1_1.cpp | 16 +++++ day1_2.cpp | 16 +++++ day20.kt | 38 ++++++++++++ day20_2.kt | 40 ++++++++++++ day21.kt | 162 +++++++++++++++++++++++++++++++++++++++++++++++++ day22.kt | 33 ++++++++++ day22_2.kt | 31 ++++++++++ day23.kt | 39 ++++++++++++ day24.kt | 68 +++++++++++++++++++++ day25.kt | 46 ++++++++++++++ day2_1.rb | 12 ++++ day2_2.rb | 21 +++++++ day3_1.rb | 26 ++++++++ day3_2.rb | 56 +++++++++++++++++ day4_1.rb | 9 +++ day4_2.rb | 27 +++++++++ day5_1.rb | 9 +++ day5_2.rb | 10 +++ day6_1.rb | 20 ++++++ day7.kt | 107 ++++++++++++++++++++++++++++++++ day8.kt | 40 ++++++++++++ day9.kt | 33 ++++++++++ test.kt | 16 +++++ 37 files changed, 1412 insertions(+) create mode 100644 day10_1.rb create mode 100644 day10_2.rb create mode 100644 day11.kt create mode 100644 day12.kt create mode 100644 day13.kt create mode 100644 day13_2.kt create mode 100644 day13_2_crt.kt create mode 100644 day14.kt create mode 100644 day14_1.rb create mode 100644 day15.kt create mode 100644 day16.kt create mode 100644 day17.kt create mode 100644 day18.kt create mode 100644 day19.txt.kt create mode 100644 day1_1.cpp create mode 100644 day1_2.cpp create mode 100644 day20.kt create mode 100644 day20_2.kt create mode 100644 day21.kt create mode 100644 day22.kt create mode 100644 day22_2.kt create mode 100644 day23.kt create mode 100644 day24.kt create mode 100644 day25.kt create mode 100644 day2_1.rb create mode 100644 day2_2.rb create mode 100644 day3_1.rb create mode 100644 day3_2.rb create mode 100644 day4_1.rb create mode 100644 day4_2.rb create mode 100644 day5_1.rb create mode 100644 day5_2.rb create mode 100644 day6_1.rb create mode 100644 day7.kt create mode 100644 day8.kt create mode 100644 day9.kt create mode 100644 test.kt diff --git a/day10_1.rb b/day10_1.rb new file mode 100644 index 0000000..857abc3 --- /dev/null +++ b/day10_1.rb @@ -0,0 +1,19 @@ +initial_string = [*0..255] +# initial_string = [*0..4] +shifts = File.open('puzzle_10.txt').read.split(',').map(&:to_i) +# shifts = [3, 4, 1, 5] +skip_size = 0 +offset = 0 +for shift in shifts do + initial_string.rotate! offset + if shift > 0 then + rotated_bit = initial_string[0..shift - 1] + kept_bit = initial_string[shift..initial_string.length-1] + initial_string = rotated_bit.reverse + kept_bit + end + initial_string.rotate! -offset + offset += shift + skip_size + skip_size += 1 +end +print initial_string[0] * initial_string[1] + diff --git a/day10_2.rb b/day10_2.rb new file mode 100644 index 0000000..c2da289 --- /dev/null +++ b/day10_2.rb @@ -0,0 +1,27 @@ +initial_string = [*0..255] +suffix = [17, 31, 73, 47, 23] +# shifts = File.open('puzzle_10.txt').read.split(',').map(&:to_i) + suffix +# shifts = [1, 2, 3] + suffix +# shifts = suffix +string = '129,154,49,198,200,133,97,254,41,6,2,1,255,0,191,108' # File.open('puzzle_10.txt').read +shifts = string.split('').map(&:ord) +shifts = shifts + suffix +skip_size = 0 +offset = 0 +shifts = shifts * 64 +for shift in shifts do + initial_string.rotate! offset + if shift > 0 then + rotated_bit = initial_string[0..shift - 1] + kept_bit = initial_string[shift..initial_string.length-1] + initial_string = rotated_bit.reverse + kept_bit + end + initial_string.rotate! -offset + offset += shift + skip_size + skip_size += 1 +end +blocks = initial_string.each_slice(16).to_a +hash = blocks.map do |block| + block.inject(0) { |x, y| x^y }.to_s(16) +end +puts hash.join('') diff --git a/day11.kt b/day11.kt new file mode 100644 index 0000000..9884fc8 --- /dev/null +++ b/day11.kt @@ -0,0 +1,24 @@ +import java.io.File + +fun main(args: Array) { + val directions = mapOf("n" to (0 to 1), + "s" to (0 to-1), + "ne" to (1 to 1), + "nw" to (-1 to 1), + "se" to (1 to -1), + "sw" to (-1 to -1)) + // val instructionString = File("../puzzle_10.txt").readLines().first() + val instructionString = "sw,sw,sw,nw" + var indexX = 0 + var indexY = 0 + var maxDistance = 0 + instructionString.split(",").forEach { + name: String -> + val (dx, dy) = directions[name]!! + indexX += dx + indexY += dy + maxDistance = Math.max(maxDistance, Math.max(Math.abs(indexX), Math.abs(indexY))) + } + println("${Math.max(Math.abs(indexX), Math.abs(indexY))}") + println("$maxDistance") +} diff --git a/day12.kt b/day12.kt new file mode 100644 index 0000000..fa5aa4f --- /dev/null +++ b/day12.kt @@ -0,0 +1,39 @@ +import java.io.File + +fun findPath(current: String, to: String, connections: Map>, visited: MutableList = mutableListOf()): Boolean { + if(current == to) return true + if(visited.contains(current)) return false + visited.add(current) + return connections[current]!!.any { findPath(it, to, connections, visited) } +} + +fun findGroup(current: String, connections: Map>, visited: MutableList = mutableListOf()): MutableList { + if(visited.contains(current)) return visited + visited.add(current) + for(connection in connections[current]!!) findGroup(connection, connections, visited) + return visited +} + + +fun main(args: Array) { + val sourceFile = File("../puzzle_12.txt") + // val sourceFile = File("test.txt") + val connectionMaps = mutableMapOf>() + sourceFile.readLines().forEach { + val programId = it.split(" <-> ")[0] + val programs = it.split(" <-> ")[1].split(", ") + programs + .map { connectionMaps.computeIfAbsent(it) { mutableListOf() } } + .forEach { it.add(programId) } + connectionMaps.computeIfAbsent(programId) { mutableListOf() }.addAll(programs) + } + val total = connectionMaps.keys.sumBy { if(findPath(it, "0", connectionMaps)) 1 else 0 } + val programs = connectionMaps.keys + var groups = 0 + while(programs.size > 0) { + programs.removeAll(findGroup(programs.first(), connectionMaps)) + groups++ + } + println(total) + println(groups) +} \ No newline at end of file diff --git a/day13.kt b/day13.kt new file mode 100644 index 0000000..bdcc7e7 --- /dev/null +++ b/day13.kt @@ -0,0 +1,35 @@ +import java.io.File + +fun updateScanners(depths: MutableMap, scannerPos: MutableMap, scannerDirection: MutableMap){ + depths.forEach { t, u -> + val absent = !scannerPos.contains(t) + val position = scannerPos.computeIfAbsent(t) { -1 } + val direction = scannerDirection.computeIfAbsent(t) { 1 } + val nextPosition = (position + direction) + if(nextPosition == u - 1 || (nextPosition == 0 && !absent)) scannerDirection.put(t, -direction) + scannerPos.put(t, nextPosition) + } +} + +fun main(args: Array) { + // val sourceFile = File("../puzzle_13.txt") + val sourceFile = File("test.txt") + val allLines = sourceFile.readLines() + val firstLine = allLines.first() + val depthMap = mutableMapOf() + allLines.forEach { + depthMap.put(it.split(": ")[0].toInt(), it.split(": ")[1].toInt()) + } + val scannerPos = mutableMapOf() + val scannerDir = mutableMapOf() + var currentIndex = 0 + var cost = 0 + val goalIndex = depthMap.keys.sorted().last() + while(currentIndex <= goalIndex) { + updateScanners(depthMap, scannerPos, scannerDir) + if(!depthMap.containsKey(currentIndex)) {} + else if(scannerPos[currentIndex]!! == 0) cost += depthMap[currentIndex]!! * currentIndex + currentIndex++ + } + println(cost) +} \ No newline at end of file diff --git a/day13_2.kt b/day13_2.kt new file mode 100644 index 0000000..80b8023 --- /dev/null +++ b/day13_2.kt @@ -0,0 +1,33 @@ +import java.io.File +import kotlin.math.cos +import kotlin.system.measureTimeMillis + +fun main(args: Array){ + val file = File("../puzzle_13.txt") + // val file = File("test.txt") + val lines = file.readLines() + val scannerDepths = mutableMapOf() + lines.forEach { + val pieces = it.split(": ") + scannerDepths.put(pieces[0].toInt(), pieces[1].toInt()) + } + var offset = 0 + + val cost = scannerDepths.map { + if(it.key + offset % ((it.value - 1) * 2) == 0) it.value * it.key else 0 + }.fold(0) { a, b -> a + b} + + val time = measureTimeMillis { + while(offset < Int.MAX_VALUE){ + val cost = scannerDepths.map { + if((it.key + offset) % ((it.value - 1) * 2) == 0) it.value * it.key + 1 else 0 + }.fold(0) { a, b -> a + b} + if(cost == 0) { + println(offset) + break + } + offset++ + } + } + println(time) +} \ No newline at end of file diff --git a/day13_2_crt.kt b/day13_2_crt.kt new file mode 100644 index 0000000..f3898de --- /dev/null +++ b/day13_2_crt.kt @@ -0,0 +1,15 @@ +import java.io.File + +fun main(args: Array) { + // val file = File("../puzzle_13.txt") + val file = File("test.txt") + val lines = file.readLines() + val list = lines.map { + val pieces = it.split(": ") + val index = pieces[0].toInt() + val depth = pieces[1].toInt() + val period = (depth - 1) * 2 + val congruentTo = (-(index % period) + period) % period + period to congruentTo + }.sortedByDescending { it.first }.toMutableList() +} \ No newline at end of file diff --git a/day14.kt b/day14.kt new file mode 100644 index 0000000..0c9de56 --- /dev/null +++ b/day14.kt @@ -0,0 +1,7 @@ +import java.io.File + +fun main(args: Array){ + val inputFile = File("../day_14.txt") + val lines = inputFile.readLines() + val firstLine = lines.first() +} \ No newline at end of file diff --git a/day14_1.rb b/day14_1.rb new file mode 100644 index 0000000..720ff1b --- /dev/null +++ b/day14_1.rb @@ -0,0 +1,89 @@ +require 'set' + +def hash_code(string) + initial_string = [*0..255] + suffix = [17, 31, 73, 47, 23] + # shifts = File.open('puzzle_10.txt').read.split(',').map(&:to_i) + suffix + # shifts = [1, 2, 3] + suffix + # shifts = suffix + shifts = string.split('').map(&:ord) + shifts = shifts + suffix + skip_size = 0 + offset = 0 + shifts = shifts * 64 + for shift in shifts do + initial_string.rotate! offset + if shift > 0 then + rotated_bit = initial_string[0..shift - 1] + kept_bit = initial_string[shift..initial_string.length-1] + initial_string = rotated_bit.reverse + kept_bit + end + initial_string.rotate! -offset + offset += shift + skip_size + skip_size += 1 + end + blocks = initial_string.each_slice(16).to_a + hash = blocks.map do |block| + block.inject(0) { |x, y| x^y }.to_s(16).rjust(2, '0') + end + return hash.join('') +end + +input = "jxqlasbh" +# input = "flqrgnkx" +total = 0 +map = [] +128.times do |time| + hash_input = input + '-' + time.to_s + computed_hash = hash_code(hash_input) + binary = computed_hash.split('').map do |it| + it.to_i 16 + end.map do |it| + (it.to_s 2).rjust(4, '0') + end.join('') + total += binary.count '1' + map.push(binary.split('')) +end + +puts total + +puts "#{map[0][0..3]}" +puts "#{map[1][0..3]}" +puts "#{map[2][0..3]}" +puts "#{map[3][0..3]}" + +enabled = [] +128.times do |x| + 128.times do |y| + if map[x][y] != '1' then next end + enabled.push [[x, y]] + end +end + +def is_neighbor(a, b) + a_neighbors = [[a[0]+1,a[1]],[a[0]-1, a[1]], [a[0],a[1]+1], [a[0],a[1]-1]] + return a_neighbors.include? b +end + +final_groups = [] +modified = true +while modified do + modified = false + i = 0 + while i < enabled.length do + current = enabled[i] + j = i + 1 + while j < enabled.length do + other = enabled[j] + if (current.product other).any? { |a| is_neighbor(a[0], a[1]) } then + current.concat other + enabled.delete_at(j) + modified = true + else + j += 1 + end + end + i += 1 + end +end +puts enabled.length diff --git a/day15.kt b/day15.kt new file mode 100644 index 0000000..bdba07d --- /dev/null +++ b/day15.kt @@ -0,0 +1,45 @@ +import java.io.File + +fun generateANext(current: Long): Long { + return (current * 16807) % 2147483647 +} + +fun generateBNext(current: Long): Long { + return (current * 48271) % 2147483647 +} + +fun generateACertain(current: Long): Long { + var toReturn = current + do { + toReturn = generateANext(toReturn) + } while (toReturn % 4L != 0L) + return toReturn +} + +fun generateBCertain(current: Long): Long { + var toReturn = current + do { + toReturn = generateBNext(toReturn) + } while (toReturn % 8L != 0L) + return toReturn +} + +fun main(args: Array){ + val initialAValue = 873L + val initialBValue = 583L + var i = 0 + var count = 0 + var currentA = initialAValue + var currentB = initialBValue + while(i < 5000000) { + currentA = generateACertain(currentA) + currentB = generateBCertain(currentB) + // println(currentA.toString(2)) + // println(currentB.toString(2)) + val firstA = currentA.toShort() + val firstB = currentB.toShort() + if(firstA == firstB) count++ + i++ + } + println(count) +} \ No newline at end of file diff --git a/day16.kt b/day16.kt new file mode 100644 index 0000000..ac484b3 --- /dev/null +++ b/day16.kt @@ -0,0 +1,85 @@ +import java.io.File + +fun MutableList.shift(num: Int) { + var left = num; + while(left > 0) { + add(0, removeAt(size - 1)) + left-- + } +} + +fun MutableList.switch(a: T, b: T) { + val indexA = indexOf(a) + val indexB = indexOf(b) + set(indexB, a) + set(indexA, b) +} + +fun MutableList.switch(a: Int, b: Int){ + val elA = elementAt(a) + val elB = elementAt(b) + set(a, elB) + set(b, elA) +} + +fun main(args: Array){ + val inputFile = File("../puzzle_16.txt") + val inputLines = inputFile.readLines() + val firstLine = inputLines.first() + // "s1,x3/4,pe/b".split(",") // + val instructions = firstLine.split(",") + + val programs = MutableList('p'-'a' + 1) { + ('a' + it).toString() + } + val original = MutableList('p'-'a' + 1) { + ('a' + it).toString() + } + val swapMap = mutableMapOf() + var count = 0 + instructions.forEach { + if(it.startsWith("s")) programs.shift(it.substring(1).toInt()) + else { + val split = it.substring(1).split("/") + if(it.startsWith("x")) { + programs.switch(split[0].toInt(), split[1].toInt()) + } else { + programs.switch(split[0], split[1]) + } + } + } + println(programs.joinToString("")) + val output = programs.joinToString("") + while(true){ + instructions.forEach { + if(it.startsWith("s")) programs.shift(it.substring(1).toInt()) + else { + val split = it.substring(1).split("/") + if(it.startsWith("x")) { + programs.switch(split[0].toInt(), split[1].toInt()) + } else { + programs.switch(split[0], split[1]) + } + } + } + val newOutput = programs.joinToString("") + count++ + if(newOutput == "abcdefghijklmnop") break + } + println(count) + println(programs.joinToString("")) + for(i in 0 until (1000000000 % (count + 1))){ + instructions.forEach { + if(it.startsWith("s")) original.shift(it.substring(1).toInt()) + else { + val split = it.substring(1).split("/") + if(it.startsWith("x")) { + original.switch(split[0].toInt(), split[1].toInt()) + } else { + original.switch(split[0], split[1]) + } + } + } + } + println(original.joinToString("")) +} \ No newline at end of file diff --git a/day17.kt b/day17.kt new file mode 100644 index 0000000..625f93d --- /dev/null +++ b/day17.kt @@ -0,0 +1,21 @@ +import java.io.File +import java.util.* +import kotlin.system.measureTimeMillis + +fun main(args: Array){ + println(measureTimeMillis { + val numSteps = 301 + var iterations = 1 + var index = 0 + var memorizedNumber = 0 + while(iterations <= 50000000) { + index = (index + numSteps) % iterations + if(index == 0) { + memorizedNumber = iterations + } + index++ + iterations++ + } + println(memorizedNumber) + }) +} \ No newline at end of file diff --git a/day18.kt b/day18.kt new file mode 100644 index 0000000..e697a57 --- /dev/null +++ b/day18.kt @@ -0,0 +1,70 @@ +import java.io.File + +fun getValue(map: MutableMap, value: String): Long { + return if(value.contains(Regex("\\d"))) value.toLong() else (map[value] ?: 0) +} + +class Program(val lines: List){ + var numSent = 0 + var index = 0 + var queue = mutableListOf() + val registerMap = mutableMapOf() + var partner: Program? = null + var wait = false + fun step(){ + if(index >= lines.size) return + val it = lines[index] + val split = it.split(" ") + if(it.startsWith("add")) { + registerMap[split[1]] = getValue(registerMap, split[1]) + getValue(registerMap, split[2]) + } else if(it.startsWith("set")) { + registerMap[split[1]] = getValue(registerMap, split[2]) + } else if(it.startsWith("snd")) { + partner!!.queue.add(getValue(registerMap, split[1])) + numSent++ + } else if(it.startsWith("mul")) { + registerMap[split[1]] = getValue(registerMap, split[1]) * getValue(registerMap, split[2]) + } else if(it.startsWith("mod")) { + registerMap[split[1]] = getValue(registerMap, split[1]) % getValue(registerMap, split[2]) + } else if(it.startsWith("rcv")) { + if(queue.isEmpty()) { + wait = true + return + } + else { + registerMap[split[1]] = queue.removeAt(0) + wait = false + } + } else if(it.startsWith("jgz")) { + if(getValue(registerMap, split[1]) > 0) { + index += getValue(registerMap, split[2]).toInt() + return + } + } + index++ + } +} + +fun main(args: Array) { + val file = File("../day18.txt") + // val file = File("test.txt") + val lines = file.readLines() + val firstLine = lines.first() + + val registerMap = mutableMapOf() + var last = 0L + lines.forEach { + } + var index = 0; + val program1 = Program(lines) + val program2 = Program(lines) + program1.partner = program2 + program2.partner = program1 + program1.registerMap["p"] = 0 + program2.registerMap["p"] = 1 + while(!(program1.wait && program2.wait) && !(program1.index >= lines.size && program2.index >= lines.size)){ + program1.step() + program2.step() + } + println(program2.numSent) +} \ No newline at end of file diff --git a/day19.txt.kt b/day19.txt.kt new file mode 100644 index 0000000..af6346b --- /dev/null +++ b/day19.txt.kt @@ -0,0 +1,28 @@ +import java.io.File + +fun nextIndex(x: Int, y: Int, dir: Int) = listOf(1 + x to y, x to y-1, x-1 to y, x to y+1)[dir] +fun canMove(x: Int, y: Int, dir: Int, path: List): Boolean { + val (newX, newY) = nextIndex(x, y, dir) + return (newY in 0 until path.size) && (newX in 0 until path[newY].size) && path[newY][newX] != ' ' +} + +fun main(args: Array) { + val file = File("../puzzle_19.txt") + val path = file.readLines().toList().map { it.toCharArray() } + var (indexX, indexY) = (163 to 0) + var direction = 3 + val letterStack = mutableListOf() + var count = 1 + while(true){ + if(path[indexY][indexX] in ('A'..'Z')) letterStack.add(path[indexY][indexX]) + if(!canMove(indexX, indexY, direction, path)) { direction = (direction + 1) % 4 } + if(!canMove(indexX, indexY, direction, path)) { direction = (direction + 2) % 4 } + if(!canMove(indexX, indexY, direction, path)) break + count++ + val moveBy = nextIndex(indexX, indexY, direction) + indexX = moveBy.first + indexY = moveBy.second + } + println(letterStack.joinToString("")) + println(count) +} \ No newline at end of file diff --git a/day1_1.cpp b/day1_1.cpp new file mode 100644 index 0000000..7c236b3 --- /dev/null +++ b/day1_1.cpp @@ -0,0 +1,16 @@ +#include + +using namespace std; + +int main(){ + std::string input; + std::cin >> input; + long total = 0; + for(int i = 0; i < input.size(); i++){ + int next_index = (i + 1) % input.size(); + if(input[i] == input[next_index]){ + total += input[i] - '0'; + } + } + std::cout << total; +} diff --git a/day1_2.cpp b/day1_2.cpp new file mode 100644 index 0000000..bd3e979 --- /dev/null +++ b/day1_2.cpp @@ -0,0 +1,16 @@ +#include + +using namespace std; + +int main(){ + std::string input; + std::cin >> input; + long total = 0; + for(int i = 0; i < input.size(); i++){ + int next_index = (i + input.size() / 2) % input.size(); + if(input[i] == input[next_index]){ + total += input[i] - '0'; + } + } + std::cout << total; +} diff --git a/day20.kt b/day20.kt new file mode 100644 index 0000000..a9aea4a --- /dev/null +++ b/day20.kt @@ -0,0 +1,38 @@ +import java.io.File +import kotlin.math.absoluteValue + +data class Particle(var x: Long, var y: Long, var z: Long, + var vx: Long, var vy: Long, var vz: Long, + var ax: Long, var ay: Long, var az: Long) { + fun distance() = x.absoluteValue + y.absoluteValue + z.absoluteValue + fun step(){ + vx += ax + vy += ay + vz += az + x += vx + y += vy + z += vz + } +} + +fun main(args: Array){ + val file = File("../puzzle_20.txt") + // val file = File("test.txt") + val lines = file.readLines() + val firstLine = lines.first() + val particles = lines.map { + val split = it.split("=") + val (x, y, z) = split[1].substring(1).substringBefore(">").split(",").map { it.toLong() } + val (vx, vy, vz) = split[2].substring(1).substringBefore(">").split(",").map { it.toLong() } + val (ax, ay, az) = split[3].substring(1).substringBefore(">").split(",").map { it.toLong() } + Particle(x, y, z, vx, vy, vz, ax, ay, az) + } + var count = 0 + while(count < 1000){ + particles.forEach { + it.step() + } + count++ + } + println(particles.indexOf(particles.minBy { it.distance() })) +} \ No newline at end of file diff --git a/day20_2.kt b/day20_2.kt new file mode 100644 index 0000000..791f0ca --- /dev/null +++ b/day20_2.kt @@ -0,0 +1,40 @@ +import java.io.File +import kotlin.math.absoluteValue + +fun main(args: Array){ + val file = File("../puzzle_20.txt") + // val file = File("test.txt") + val lines = file.readLines() + val firstLine = lines.first() + val particles = lines.map { + val split = it.split("=") + val (x, y, z) = split[1].substring(1).substringBefore(">").split(",").map { it.toLong() } + val (vx, vy, vz) = split[2].substring(1).substringBefore(">").split(",").map { it.toLong() } + val (ax, ay, az) = split[3].substring(1).substringBefore(">").split(",").map { it.toLong() } + Particle(x, y, z, vx, vy, vz, ax, ay, az) + }.toMutableList() + var count = 0 + while(count < 1000){ + particles.forEach { + it.step() + } + val collidedParticles = mutableListOf() + var index = 0 + while(index < particles.size){ + val par1 = particles[index] + var index2 = index + 1; + while(index2 < particles.size){ + val par2 = particles[index2] + if(par1.x == par2.x && par1.y == par2.y && par1.z == par2.z) { + collidedParticles.add(par1) + collidedParticles.add(par2) + } + index2++ + } + index++ + } + particles.removeAll(collidedParticles) + count++ + } + println(particles.size) +} \ No newline at end of file diff --git a/day21.kt b/day21.kt new file mode 100644 index 0000000..f160f5d --- /dev/null +++ b/day21.kt @@ -0,0 +1,162 @@ +import java.io.File + + class Pattern(val size: Int){ + val map = Array(size) { CharArray(size) { ' ' } } + fun flipV(): Pattern { + val newPattern = Pattern(size) + for(x in 0 until size){ + for(y in 0 until size){ + val newX = size - 1 - x + val newY = y + newPattern.map[newY][newX] = map[y][x] + } + } + return newPattern + } + fun flipH(): Pattern { + val newPattern = Pattern(size) + for(x in 0 until size){ + for(y in 0 until size){ + val newX = x + val newY = size - 1 - y + newPattern.map[newY][newX] = map[y][x] + } + } + return newPattern + } + fun rotate(): Pattern { + val newPattern = Pattern(size) + for(x in 0 until size){ + for(y in 0 until size){ + val newX = y + val newY = size - 1 - x + newPattern.map[newY][newX] = map[y][x] + } + } + return newPattern + } + override operator fun equals(other: Any?): Boolean { + if(other !is Pattern) return false + return oneEquals(other) + } + fun equalsPattern(other: Pattern): Boolean { + if(other.size != size) return false + for(x in 0 until size) { + for(y in 0 until size){ + if(other.map[y][x] != this.map[y][x]) return false + } + } + return true + } + + fun oneEquals(other: Pattern): Boolean { + val first = rotate() + val flipH = flipH() + val flipV = flipV() + val thisMatches = equalsPattern(other) || + rotate().equalsPattern(other) || + rotate().rotate().equalsPattern(other) || + rotate().rotate().rotate().equalsPattern(other) + val flipHMatches = flipH.equalsPattern(other) || + flipH.rotate().equalsPattern(other) || + flipH.rotate().rotate().equalsPattern(other) || + flipH.rotate().rotate().rotate().equalsPattern(other) + val flipVMatches = flipV.equalsPattern(other) || + flipV.rotate().equalsPattern(other) || + flipV.rotate().rotate().equalsPattern(other) || + flipV.rotate().rotate().equalsPattern(other) + return thisMatches || flipHMatches || flipVMatches + } + + fun toStrings(): List{ + return map.map { it.joinToString(" ") } + } + + fun split(): List> { + val toReturn = mutableListOf>() + if(size % 2 == 0){ + for(y in 0 until size / 2){ + val newRow = mutableListOf() + for(x in 0 until size / 2){ + val newPattern = Pattern(2) + for(newX in 0..1){ + for(newY in 0..1){ + newPattern.map[newY][newX] = map[y * 2 + newY][x * 2 + newX] + } + } + newRow.add(newPattern) + } + toReturn.add(newRow) + } + } else { + for(y in 0 until size / 3){ + val newRow = mutableListOf() + for(x in 0 until size / 3){ + val newPattern = Pattern(3) + for(newX in 0..2){ + for(newY in 0..2){ + newPattern.map[newY][newX] = map[y * 3 + newY][x * 3 + newX] + } + } + newRow.add(newPattern) + } + toReturn.add(newRow) + } + } + return toReturn + } +} + +fun fromString(s: String): Pattern { + val lines = s.split("/") + val newPattern = Pattern(lines.size) + for(i in 0 until newPattern.size){ + newPattern.map[i] = lines[i].toCharArray() + } + return newPattern +} + +fun combine(list: List>): Pattern { + val newPattern = Pattern(list[0][0].size * list.size) + for(y in 0 until list.size){ + for(x in 0 until list.size){ + val copying = list[y][x] + for(oldY in 0 until copying.size){ + for(oldX in 0 until copying.size){ + newPattern.map[y * copying.size + oldY][x * copying.size + oldX] = + copying.map[oldY][oldX] + } + } + } + } + return newPattern +} + +fun Map.findMatching(pattern: Pattern): Pattern? { + return keys + .firstOrNull { it == pattern } + ?.let { get(it) } +} + +fun main(args: Array){ + // val file = File("test.txt") + val file = File("../puzzle_21.txt") + val lines = file.readLines() + val patternMap = mutableMapOf() + lines.forEach { + val split = it.split(" => ") + patternMap.put(fromString(split[0]), fromString(split[1])) + } + val inputPattern = fromString(".#./..#/###") + var pattern = inputPattern + var count = 0 + while (count < 18){ + val split = pattern.split() + pattern = combine(split.map { it.map { patternMap.findMatching(it)!! } }) + pattern.toStrings().forEach { println(it) } + println() + count += 1 + } + println(pattern.toStrings().joinToString("").count { it == '#' }) + +} \ No newline at end of file diff --git a/day22.kt b/day22.kt new file mode 100644 index 0000000..e4e970b --- /dev/null +++ b/day22.kt @@ -0,0 +1,33 @@ +import java.io.File +import kotlin.math.roundToLong + +fun dirToCoords(index: Int) = listOf(1L to 0L, 0L to 1L, -1L to 0L, 0L to -1L)[index] + +fun main(args: Array){ + val file = File("../puzzle_22.txt") + // val file = File("test.txt") + val lines = file.readLines() + val coordMap = mutableMapOf, Int>() + lines.forEachIndexed { y, string -> string.toCharArray().forEachIndexed { x, c -> coordMap[x.toLong() to (lines.size - 1 - y).toLong()] = if(c == '#') 2 else 0 } } + var x = Math.ceil(coordMap.keys.maxBy { it.first }!!.first.toDouble() / 2).roundToLong() + var y = Math.ceil(coordMap.keys.maxBy { it.second }!!.second.toDouble() / 2).roundToLong() + println(x to y) + var direction = 1 + var count = 0 + var infectedCount = 0 + while(count < 10000000) { + val isInfected = coordMap.computeIfAbsent(x to y) { 0 } + if(isInfected == 0) direction += 1 + else if(isInfected == 1) {} + else if(isInfected == 2) direction -= 1 + else direction = (direction + 2) % 4 + direction = (direction + 4) % 4 + coordMap[x to y] = (isInfected + 1) % 4 + if(coordMap[x to y] == 2) infectedCount++ + val (dx, dy) = dirToCoords(direction) + x += dx + y += dy + count++ + } + println(infectedCount) +} diff --git a/day22_2.kt b/day22_2.kt new file mode 100644 index 0000000..8aad27a --- /dev/null +++ b/day22_2.kt @@ -0,0 +1,31 @@ +import java.io.File +import kotlin.math.roundToLong + +fun main(args: Array){ + val file = File("../puzzle_22.txt") + // val file = File("test.txt") + val lines = file.readLines() + val coordMap = mutableMapOf, Boolean>() + lines.forEachIndexed { y, string -> string.toCharArray().forEachIndexed { x, c -> coordMap[x.toLong() to (lines.size - 1 - y).toLong()] = c == '#'} } + var x = Math.ceil(coordMap.keys.maxBy { it.first }!!.first.toDouble() / 2).roundToLong() + var y = Math.ceil(coordMap.keys.maxBy { it.second }!!.second.toDouble() / 2).roundToLong() + println(x to y) + var direction = 1 + var count = 0 + var infectedCount = 0 + while(count < 10000) { + val isInfected = coordMap.computeIfAbsent(x to y) { false } + if(isInfected) direction -= 1 + else { + direction += 1 + infectedCount++ + } + direction = (direction + 4) % 4 + coordMap[x to y] = !isInfected + val (dx, dy) = dirToCoords(direction) + x += dx + y += dy + count++ + } + println(infectedCount) +} diff --git a/day23.kt b/day23.kt new file mode 100644 index 0000000..33874cc --- /dev/null +++ b/day23.kt @@ -0,0 +1,39 @@ +import java.io.File + +fun getValue(map: Map, key: String): Long { + return if(key.contains(Regex("\\d+"))) key.toLong() else map.getOrDefault(key, 0L) +} + +fun main(args: Array) { + val file = File("../puzzle_23.txt") + // val file = File("test.txt") + val lines = file.readLines().map { it.split(" ") } + val firstLine = lines.first() + + val registers = mutableMapOf() + var index = 0 + var count = 0 + lines.forEach { + } + registers["a"] = 1 + while(index < lines.size){ + val split = lines[index] + if(split[0] == "set") { + registers[split[1]] = getValue(registers, split[2]) + } else if (split[0] == "sub") { + registers[split[1]] = (registers[split[1]] ?: 0) - getValue(registers, split[2]) + } else if(split[0] == "mul") { + registers[split[1]] = (registers[split[1]] ?: 0) * getValue(registers, split[2]) + } else if(split[0] == "jnz") { + val cond = getValue(registers, split[1]) + val offset = getValue(registers, split[2]) + if(cond != 0L) { + index += offset.toInt() + continue + } + } + index++ + } + println(count) + println(registers["h"]) +} \ No newline at end of file diff --git a/day24.kt b/day24.kt new file mode 100644 index 0000000..d445a83 --- /dev/null +++ b/day24.kt @@ -0,0 +1,68 @@ +import java.io.File + +typealias Piece = List +typealias Bridge = List + +fun Bridge.cost(): Int { + val lastcost = last().first() + val betweenCost = (0 until size - 1).map { + this[it].first() * 2 + }.sum() + return betweenCost + lastcost +} + +fun getPaths(bridge: Bridge, pieces: List): List { + val compatiblePieces = pieces.filter { it.contains(bridge.last().first() ) } + if(compatiblePieces.size != 0) { + return compatiblePieces.map { + val newPiece = it.toMutableList() + newPiece.remove(bridge.last().first()) + val newPieces = pieces.toMutableList() + newPieces.remove(it) + val newBridge = bridge.toMutableList() + newBridge.add(newPiece) + getPaths(newBridge, newPieces) + }.fold(mutableListOf()) { + a, b -> + val list = mutableListOf() + list.addAll(a) + list.addAll(b) + list + } + } else return mutableListOf(bridge) +} + +fun main(args: Array){ + val file = File("../puzzle_24.txt") + // val file = File("test.txt") + val lines = file.readLines() + val firstLine = lines.first() + val transformedLines = lines.toMutableList().map { + val split = it.split("/") + mutableListOf(split[0].toInt(), split[1].toInt()) + } + var index = 0 + var initialCombinations = transformedLines + .filter { it.contains(0) } + .map { + val withoutZero = it.toMutableList() + withoutZero.remove(0) + val withoutZeroPiece = transformedLines.toMutableList() + withoutZeroPiece.remove(it) + mutableListOf(withoutZero) to withoutZeroPiece + }.toMutableList() + val paths = initialCombinations.map { + val (bridge, pieces) = it + getPaths(bridge, pieces) + }.fold(mutableListOf()) { + a, b -> + val list = mutableListOf() + list.addAll(a) + list.addAll(b) + list + } + println(paths.map { it.cost() }.max()) + val maxLength = paths.map { it.size }.max() + val maxLenghtMaxStrength = paths.filter { it.size == maxLength }.maxBy { it.cost() } + println(maxLenghtMaxStrength!!.cost()) +} \ No newline at end of file diff --git a/day25.kt b/day25.kt new file mode 100644 index 0000000..2f6134d --- /dev/null +++ b/day25.kt @@ -0,0 +1,46 @@ +import java.io.File + +data class TuringValue(val toWrite: Int, val toMove: Int, val nextState: Char) +data class TuringState(val ifZero: TuringValue, val ifOne: TuringValue, val name: Char) + +fun readValue(lines: List, index: Int): TuringValue{ + val firstLine = lines[index] + val toWrite = firstLine[firstLine.length - 2].toInt() - '0'.toInt() + val toMove = if(lines[index+1].endsWith("left.")) -1 else 1 + val thirdLine = lines[index + 2] + val state = thirdLine[thirdLine.length - 2] + return TuringValue(toWrite, toMove, state) +} + +fun readState(lines: List, index: Int): TuringState { + val lineA = lines[index] + val name = lineA[lineA.length - 2] + return TuringState(readValue(lines, index + 2), readValue(lines, index + 6), name) +} + +fun main(args: Array){ + // val file = File("../puzzle_25.txt") + val file = File("test.txt") + val lines = file.readLines() + val firstLine = lines.first() + + val states = mutableMapOf() + (0 until 6) + .map { readState(lines, it * 10) } + .forEach { states.put(it.name, it) } + + val tape = mutableMapOf() + var currentState: Char = 'A' + var steps = 12134527 + var index = 0 + while(steps > 0){ + val tapeValue = tape.getOrDefault(index, 0) + val state = states.get(currentState)!! + val value = if(tapeValue == 0) state.ifZero else state.ifOne + tape[index] = value.toWrite + index += value.toMove + currentState = value.nextState + steps-- + } + println(tape.values.count { it == 1 }) +} \ No newline at end of file diff --git a/day2_1.rb b/day2_1.rb new file mode 100644 index 0000000..0fd6b76 --- /dev/null +++ b/day2_1.rb @@ -0,0 +1,12 @@ +total = 0 + +while(true) do + line = gets + if line == nil then break end + numbers = line.split(' ').map do |number| number.to_i end + top = numbers.max + bottom = numbers.min + total += (top - bottom) +end + +puts(total) diff --git a/day2_2.rb b/day2_2.rb new file mode 100644 index 0000000..65410d8 --- /dev/null +++ b/day2_2.rb @@ -0,0 +1,21 @@ +total = 0 + +while(true) do + line = gets + if line == nil then break end + numbers = line.split(' ').map do |num| num.to_i end + for i in (0..numbers.length - 1) do + for j in ((i + 1)..numbers.length - 1) do + pair = [numbers[i], numbers[j]] + max = pair.max + min = pair.min + + if max % min == 0 then + total += max / min + next + end + end + end +end + +puts(total) diff --git a/day3_1.rb b/day3_1.rb new file mode 100644 index 0000000..e0ca2d9 --- /dev/null +++ b/day3_1.rb @@ -0,0 +1,26 @@ +def corner_num(corner) + return corner**2 - corner +end + +puzzle_input = 289326 +corner = (1 + Math.sqrt(1 + 4*(puzzle_input - 1))) / 2 +puts corner +next_corner = corner_num(corner.ceil) +prev_corner = corner_num(corner.floor) +distance = 0 +if(next_corner == prev_corner) then + distance = 2*((corner / 2).floor) +else + halfway_point = (next_corner + prev_corner) / 2 + edge_length = next_corner - halfway_point + start_from = (puzzle_input > halfway_point) ? halfway_point : prev_corner + progress = (puzzle_input - 1 - start_from).to_f / edge_length + if(corner.floor % 2 == 1 and puzzle_input < halfway_point) then distance -= 1 end + previous_distance = (corner.ceil / 2).floor + next_distance = ((corner.floor)/2).floor + puts previous_distance + puts next_distance + distance += (corner / 2).floor + distance += (-previous_distance + (previous_distance + next_distance)*progress).abs +end +puts distance diff --git a/day3_2.rb b/day3_2.rb new file mode 100644 index 0000000..217c9f7 --- /dev/null +++ b/day3_2.rb @@ -0,0 +1,56 @@ +states = { + "left" => "down", + "down" => "right", + "right" => "up", + "up" => "left" +} +stepsx = { + "right" => 1, + "left" => -1 +} +stepsy = { + "up" => 1, + "down" => -1 +} +increases = { + "left" => 1, + "right" => 1 +} +stepsx.default = 0 +stepsy.default = 0 +increases.default = 0 + +memory = Array.new(399) +399.times do |time| + memory[time] = Array.new(399, 0) +end + +step = 1 +x = 199 +y = 199 +memory[x][y] = 1 +x += 1 +state = "up" +memory[x][y] = 1 + +input = 289326 + +while(true) do + dx = stepsx[state] + dy = stepsy[state] + step.times do |time| + x += dx + y += dy + total = 0 + for i in -1..1 do + for j in -1..1 do + if(!(j == 0 && i == 0)) then total += memory[x + i][y + j] end + end + end + puts total + if(total > input) then exit() end + memory[x][y] = total + end + state = states[state] + step += increases[state] +end diff --git a/day4_1.rb b/day4_1.rb new file mode 100644 index 0000000..2b34cf3 --- /dev/null +++ b/day4_1.rb @@ -0,0 +1,9 @@ +def is_unique(line) + original = line.split(' ') + unique = original.uniq + return original.length == unique.length +end + +contents = File.open("puzzle_4.txt", "rb").read +lines = contents.split("\n") +puts lines.select {|line| is_unique(line)}.length diff --git a/day4_2.rb b/day4_2.rb new file mode 100644 index 0000000..6ed5f59 --- /dev/null +++ b/day4_2.rb @@ -0,0 +1,27 @@ +def frequency(string) + keys = {} + keys.default = 0 + for letter in string.split('') do + keys[letter] = keys[letter] + 1 + end + return keys +end + +def is_anagram(first, second) + return frequency(first) == frequency(second) +end + +def is_unique(line) + words = line.split(' ') + for i in 0..words.length - 1 do + word = words[i] + for j in (i+1)..words.length - 1 do + if is_anagram(word, words[j]) then return false end + end + end + return true +end + +contents = File.open("puzzle_4.txt", "rb").read +lines = contents.split("\n") +puts lines.select {|line| is_unique(line)}.length diff --git a/day5_1.rb b/day5_1.rb new file mode 100644 index 0000000..0c84ecf --- /dev/null +++ b/day5_1.rb @@ -0,0 +1,9 @@ +jumpArray = File.open('puzzle_5.txt').read.split("\n").map(&:to_i) +num_steps = 0 +index = 0 +while (index < jumpArray.length) do + jumpArray[index] += 1 + index += jumpArray[index] - 1 + num_steps += 1 +end +puts num_steps diff --git a/day5_2.rb b/day5_2.rb new file mode 100644 index 0000000..777a50e --- /dev/null +++ b/day5_2.rb @@ -0,0 +1,10 @@ +jumpArray = File.open('puzzle_5.txt').read.split("\n").map(&:to_i) +num_steps = 0 +index = 0 +while (index < jumpArray.length) do + change = (jumpArray[index] >= 3) ? -1 : 1 + jumpArray[index] += change + index += jumpArray[index] - change + num_steps += 1 +end +puts num_steps diff --git a/day6_1.rb b/day6_1.rb new file mode 100644 index 0000000..1c47dac --- /dev/null +++ b/day6_1.rb @@ -0,0 +1,20 @@ +input = File.open('puzzle_6.txt').read.split(' ').map(&:to_i) +combinations = [ input.dup ] +while(true) do + to_distribute = input.max + start_at = input.index to_distribute + input[start_at] = 0 + start_at += 1 + while(to_distribute > 0) do + start_at %= input.length + to_distribute -= 1 + input[start_at] += 1 + start_at += 1 + end + if(combinations.include? input) then + puts combinations.index input + break + end + combinations.push input.clone +end +puts combinations.length diff --git a/day7.kt b/day7.kt new file mode 100644 index 0000000..34d82bb --- /dev/null +++ b/day7.kt @@ -0,0 +1,107 @@ +import java.io.File + +abstract class Tree(val weight: Int) { + abstract fun walk(parent: Tree?, name: String, function: (Tree?, String, Tree) -> Unit) + abstract fun reduce(transformFunction: (Tree) -> T, combineFunction: (T, List) -> T): T + + val combinedWeight: Int + get() { + val reduceFunction: (Tree) -> Int = { + it.weight + } + val combineFunction: (Int, List) -> Int = { + parent, children -> + parent + children.fold(0) { a, b -> a + b} + } + return reduce(reduceFunction, combineFunction) + } +} +class Placeholder : Tree(0) { + override fun reduce(transformFunction: (Tree) -> T, combineFunction: (T, List) -> T): T { + return transformFunction(this) + } + + override fun walk(parent: Tree?, name: String, function: (Tree?, String, Tree) -> Unit) { + function(parent, name, this) + } +} + +class Child(weight: Int) : Tree(weight) { + override fun reduce(transformFunction: (Tree) -> T, combineFunction: (T, List) -> T): T { + return transformFunction(this) + } + + override fun walk(parent: Tree?, name: String, function: (Tree?, String, Tree) -> Unit) { + function(parent, name, this) + } +} + +class Parent(weight: Int) : Tree(weight) { + val children = mutableMapOf() + + override fun reduce(transformFunction: (Tree) -> T, combineFunction: (T, List) -> T): T { + return combineFunction(transformFunction(this), children.map { it.value.reduce(transformFunction, combineFunction) }) + } + + override fun walk(parent: Tree?, name: String, function: (Tree?, String, Tree) -> Unit) { + function(parent, name, this) + children.forEach { t, u -> u.walk(this, t, function) } + } +} + +fun main(args: Array) { + val extractionPattern = Regex("([a-z]+)\\s*\\((\\d+)\\)\\s*(?:->\\s*(.+))?") + val baseMap = mutableMapOf() + val nodesWithParent = mutableListOf() + File("../puzzle_7.txt").readLines().forEach { + val match = extractionPattern.matchEntire(it)!! + val name = match.groupValues[1] + val weight = match.groupValues[2].toInt() + val childrenString = match.groupValues[3] + val children = if(childrenString.isEmpty()) emptyList() else childrenString.split(", ") + val newNode = if(children.isEmpty()) { + Child(weight) + } else { + val newParent = Parent(weight) + children.forEach { childName -> newParent.children.put(childName, Placeholder()) } + newParent + } + baseMap.put(name, newNode) + } + baseMap.forEach { + val treeNode = it.value as? Parent ?: return@forEach + + treeNode.children.forEach { + pair -> + val (childKey, _) = pair + val childNode = baseMap[childKey]!! + treeNode.children[childKey] = childNode + nodesWithParent.add(childNode) + } + } + val (name, node) = baseMap.filterValues { !nodesWithParent.contains(it) }.entries.first() + node.walk(null, name) { + parent, name, node -> + if(parent == null) println("root node is $name") + if(node is Parent){ + val childWeightPairs = node.children.map { it.value.combinedWeight to it.key } + val childWeights = childWeightPairs.map { it.first } + if(childWeights.toSet().size != 1) { + val frequencyMap = mutableMapOf() + childWeights.forEach { frequencyMap[it] = frequencyMap.getOrDefault(it, 0) + 1 } + val culpritWeight = frequencyMap.filter { it.value == 1 }.keys.first() + val properWeight = frequencyMap.filter { it.key != culpritWeight }.keys.first() + val culpritNode = childWeightPairs.filter { it.first == culpritWeight }.first() + val culpritChildren = (node.children[culpritNode.second] as Parent).children.values + val culpritChildrenWeights = culpritChildren.map { it.combinedWeight } + if(culpritChildrenWeights.toSet().size == 1) { + println("$culpritNode has balanced children, but doesn't weight right.") + println("Correct weight is $properWeight, but actually is $culpritWeight") + val difference = properWeight - culpritWeight + println("The difference is $difference, and must be adjusted with node weight.") + println("Correct node weight is ${difference + node.children[culpritNode.second]!!.weight}") + } + } + } + } +} \ No newline at end of file diff --git a/day8.kt b/day8.kt new file mode 100644 index 0000000..545e181 --- /dev/null +++ b/day8.kt @@ -0,0 +1,40 @@ +import java.io.File + +val instructionMap = mapOf( + "inc" to { left: Int, right: Int -> left + right}, + "dec" to { left: Int, right: Int -> left - right } +) +val conditionMap = mapOf( + "==" to { left: Int, right: Int -> left == right }, + "!=" to { left: Int, right: Int -> left != right }, + ">=" to { left: Int, right: Int -> left >= right }, + "<=" to { left: Int, right: Int -> left <= right }, + ">" to { left: Int, right: Int -> left > right }, + "<" to { left: Int, right: Int -> left < right } +) +data class Instruction(val register: String, val op: String, val operand: Int, + val conditionRegister: String, val condition: String, val conditionOperand: Int) { + fun execute(registers: MutableMap) { + if(conditionMap[condition]!!(registers.getOrDefault(conditionRegister, 0), conditionOperand)) + registers[register] = instructionMap[op]!!(registers.getOrDefault(register, 0), operand) + } +} + +fun main(args: Array) { + val registerMap = mutableMapOf() + val extractionPattern = Regex("([a-z]+) (inc|dec) (-?\\d+) if ([a-z]+) ([^\\s]+) (-?\\d+)") + val instructions = File("../puzzle_8.txt").readLines().map { + val resultingPattern = extractionPattern.matchEntire(it) ?: return + with(resultingPattern.groupValues){ + Instruction(get(1), get(2), get(3).toInt(), get(4), get(5), get(6).toInt()) + } + } + var maxValue = Int.MIN_VALUE + instructions.forEach { + it.execute(registerMap) + val currentMax = registerMap.values.sorted().last() + maxValue = Math.max(currentMax, maxValue) + } + println("Largest value in any register is ${registerMap.values.sorted().last()}") + println("Largest possible max value is $maxValue") +} \ No newline at end of file diff --git a/day9.kt b/day9.kt new file mode 100644 index 0000000..8c41f5b --- /dev/null +++ b/day9.kt @@ -0,0 +1,33 @@ +import java.io.File + +fun main(args: Array){ + val line = File("../puzzle_9.txt").readLines().first() + // val line = ">" + var indent = 0 + var totalScore = 0 + var currentIndex = 0 + var garbage = 0 + while(currentIndex < line.length) { + when { + line[currentIndex] == '{' -> indent++ + line[currentIndex] == '<' -> { + while(currentIndex < line.length && line[currentIndex] != '>') { + if(line[currentIndex] != '!') { + garbage += 1 + currentIndex += 1 + } else { + currentIndex += 2 + } + } + garbage -= 1 + } + line[currentIndex] == '}' -> { + totalScore += indent + indent-- + } + } + currentIndex++ + } + println("The score is $totalScore") + println("The garbage amount is $garbage") +} \ No newline at end of file diff --git a/test.kt b/test.kt new file mode 100644 index 0000000..cc53898 --- /dev/null +++ b/test.kt @@ -0,0 +1,16 @@ +import kotlin.math.roundToInt + +fun main(args: Array) { + var count = 0 + var startAt = 84 * 100 + 100000 + var iterations = 0 + while(iterations <= 1000) { + for(i in 2 until startAt) if(startAt % i == 0) { + count++ + break + } + startAt += 17 + iterations++ + } + println(count) +} \ No newline at end of file