Merge branch 'master' of https://github.com/devcordde/adventofcode-20 into master

Author: JohnnyJayJay

Day-07/kotlin/NyCodeGHG/.gitignore

@@ -0,0 +1 @@
+*.txt

Day-07/kotlin/NyCodeGHG/README.md

@@ -0,0 +1,2 @@
+# Kotlin Solution
+I recommend to use [kscript](https://github.com/holgerbrandl/kscript) by [@holgerbrandl](https://github.com/holgerbrandl) to execute the script file.

Day-07/kotlin/NyCodeGHG/solution.kts

@@ -0,0 +1,31 @@
+import java.nio.file.Files
+import java.nio.file.Paths
+import kotlin.system.exitProcess
+
+val allBags = arrayListOf<Bag>()
+
+val contentRegex = "([0-9]+) ([\\w]+ [\\w]+) bag[s]?".toRegex()
+
+val bags = Files.readAllLines(Paths.get("input.txt"))
+ .map { it.removeSuffix(".") }
+ .filterNot { it.contains("no other") }
+ .map { it.replace("bag[s]?".toRegex(), "").replace("contain", ",").split(",") }
+ .map { it.map(String::trim) }
+ .map { it[0] to Bag(it[0], toChildBags(it.subList(1, it.size))) }.toMap()
+
+println(bags.filter { it.value.hasColor("shiny gold", bags) }.count())
+println(bags["shiny gold"]?.getChildBagNumber(bags))
+
+data class Bag(val color: String, val childBags: Map<String, Int>)
+
+fun Bag.hasColor(color: String, bags: Map<String, Bag>): Boolean =
+ if (this.childBags.keys.contains(color)) true
+ else this.childBags.keys.any { bags[it]?.hasColor(color, bags) == true }
+
+fun toChildBags(bags: List<String>): Map<String, Int> {
+ return bags.map { it.substring(2) to Integer.parseInt(it.substring(0, 1)) }.toMap()
+}
+
+fun Bag.getChildBagNumber(bags: Map<String, Bag>): Int {
+ return this.childBags.map { (bags[it.key]?.getChildBagNumber(bags) ?: 0) * it.value + it.value }.sum()
+}

Day-07/python/paul2708/solution.py

@@ -0,0 +1,62 @@
+from assertions import assert_equals
+from input_reader import read_lines
+from printer import aoc_print
+
+
+def contains_bag(root: str, needle: str) -> bool:
+ ignore_counts = map(lambda x: x[0], bag_rules[root])
+
+ if needle in ignore_counts:
+ return True
+ else:
+ for bag in bag_rules[root]:
+ if contains_bag(bag[0], needle):
+ return True
+
+ return False
+
+
+def count_bags(root: str) -> int:
+ total_sum = 0
+ for rule in bag_rules[root]:
+ total_sum += rule[1] + rule[1] * count_bags(rule[0])
+
+ return total_sum
+
+
+# Parse input (plz forgive me python god and regex skiller)
+rule_list = read_lines("day07")
+
+# {str, [(int,str)]}
+bag_rules = {}
+
+for rule in rule_list:
+ rule = rule[:-1].replace("bags", "").replace("bag", "")
+
+ bag = rule.split(" contain ")[0].strip()
+ container_bags = []
+
+ container = rule.split(" contain ")[1].strip()
+ if "," in container:
+ for single_bag in container.split(", "):
+ count = int(single_bag.split(" ")[0])
+ bag_type = single_bag[len(single_bag.split(" ")[0]):].strip()
+ container_bags.append((bag_type, count))
+ elif "no " not in container:
+ count = int(container.split(" ")[0])
+ bag_type = container[len(rule.split(" contain ")[1].strip().split(" ")[0]):].strip()
+ container_bags.append((bag_type, count))
+
+ bag_rules[bag] = container_bags
+
+# Part one
+res = len([bag for bag in bag_rules.keys() if contains_bag(bag, "shiny gold")])
+
+aoc_print(f"{res} bag colors can contain at least one shiny gold.")
+assert_equals(302, res)
+
+# Part two
+res = count_bags("shiny gold")
+
+aoc_print(f"It requires {res} bags in my shiny gold bag.")
+assert_equals(4165, res)

Day-08/kotlin/NyCodeGHG/.gitignore

@@ -0,0 +1 @@
+*.txt

Day-08/kotlin/NyCodeGHG/README.md

@@ -0,0 +1,2 @@
+# Kotlin Solution
+I recommend to use [kscript](https://github.com/holgerbrandl/kscript) by [@holgerbrandl](https://github.com/holgerbrandl) to execute the script file.

Day-08/kotlin/NyCodeGHG/solution.kts

@@ -0,0 +1,69 @@
+import java.nio.file.Files
+import java.nio.file.Paths
+import kotlin.system.measureTimeMillis
+
+val instructions = Files.readAllLines(Paths.get("input.txt"))
+ .map { it.split(" ") }
+ .mapIndexed { index, splitten -> Instruction(index, splitten[0], splitten[1].toInt()) }
+ .toTypedArray()
+
+val program = Program(instructions.createCopy())
+val result = program.execute()
+println("accumulator is at ${result.accumulator}")
+
+val alternativeProgramResult = instructions
+ .filter { it.type in arrayOf("jmp", "nop") }
+ .map {
+ val program = Program(instructions.createCopy())
+ program.instructions[it.index].flipType("jmp", "nop")
+ program.execute()
+ }
+ .firstOrNull { it.exitCode == 0 }
+
+println("accumulator with fixed program is ${alternativeProgramResult?.accumulator}")
+
+fun Instruction.execute(program: Program): Int {
+ this.executions++
+ return when (type) {
+ "acc" -> {
+ program.accumulator += this.value
+ 1
+ }
+ "jmp" -> {
+ this.value
+ }
+ else -> {
+ 1
+ }
+ }
+}
+
+fun Array<Instruction>.createCopy() = this.map { it.copy() }.toTypedArray()
+
+fun Program.execute(): ExecutionResult {
+ var currentInstruction = 0
+
+ while (currentInstruction < this.instructions.size) {
+ val instruction = this.instructions[currentInstruction]
+ if (instruction.executions > 0) {
+ return ExecutionResult(accumulator, -1)
+ }
+ currentInstruction += instruction.execute(this)
+ }
+ return ExecutionResult(accumulator, 0)
+}
+
+fun Instruction.flipType(first: String, second: String) {
+ when (this.type) {
+ first -> {
+ this.type = second
+ }
+ second -> {
+ this.type = first
+ }
+ }
+}
+
+data class Program(val instructions: Array<Instruction>, var accumulator: Int = 0)
+data class ExecutionResult(val accumulator: Int, val exitCode: Int)
+data class Instruction(var index: Int, var type: String, val value: Int, var executions: Int = 0) : Cloneable

Day-08/python/paul2708/solution.py

@@ -0,0 +1,90 @@
+from assertions import assert_equals
+from input_reader import read_lines
+from printer import aoc_print
+
+
+class Program():
+ def __init__(self, instructions: [str]):
+ self.accumulator = 0
+ self.instruction_pointer = 0
+ self.instructions = list(instructions)
+
+ def run(self):
+ instruction = instructions[self.instruction_pointer]
+ op_code = instruction.split(" ")[0]
+
+ self.instruction_pointer += 1
+
+ if op_code == "nop":
+ pass
+ elif op_code == "jmp":
+ self.instruction_pointer += int(instruction.split(" ")[1]) - 1
+ elif op_code == "acc":
+ self.accumulator += int(instruction.split(" ")[1])
+ else:
+ print("invalid instruction")
+
+ def run_all(self):
+ while self.instruction_pointer < len(instructions):
+ self.run()
+
+ def terminates(self) -> bool:
+ executed_lines = set()
+
+ while self.instruction_pointer not in executed_lines:
+ executed_lines.add(program.instruction_pointer)
+
+ if self.instruction_pointer >= len(self.instructions):
+ return True
+
+ self.run()
+
+ return False
+
+
+instructions = read_lines("day08")
+program = Program(instructions)
+
+# Part one
+program.terminates()
+
+aoc_print(f"The program gets interrupted with an accumulator of {program.accumulator}.")
+assert_equals(1801, program.accumulator)
+
+
+# Part two
+def replace_all(base_list: [str], old: str, new: str) -> [[str]]:
+ total = list()
+ index = 0
+
+ while True:
+ tup = replace(list(base_list), old, new, index)
+ if tup[1] == -1:
+ break
+
+ total.append(tup[0])
+ index = tup[1]
+
+ return total
+
+
+def replace(replacement_list: [str], old: str, new: str, start: int) -> ([str], int):
+ for i in range(start, len(replacement_list)):
+ if old in replacement_list[i]:
+ replacement_list[i] = replacement_list[i].replace(old, new)
+ return replacement_list, i + 1
+
+ return [], -1
+
+
+replaced_instructions_list = replace_all(instructions, "jmp", "nop") \
+ + replace_all(instructions, "nop", "jmp")
+
+for instructions in replaced_instructions_list:
+ program = Program(instructions)
+ if program.terminates():
+ program = Program(instructions)
+ program.run_all()
+
+ aoc_print(f"The program terminates with an accumulator of {program.accumulator}.")
+ assert_equals(2060, program.accumulator)