Day 9

src/days/06/Day06.cpp

@@ -28,8 +28,8 @@ Result Day06::Task2() {
 vector<Day06::Record> Day06::parseRecords() const {
 	vector<Record> records;
 
-	vector<uint64> time = parseInts(input[0].substr(5));
+	vector<uint64> time = parseUInts(input[0].substr(5));
-	vector<uint64> distance = parseInts(input[1].substr(10));
+	vector<uint64> distance = parseUInts(input[1].substr(10));
 
 	for (size_t i = 0; i < time.size(); i++)
 		records.emplace_back(time[i], distance[i]);

src/days/08/Day08.cpp

@@ -1,9 +1,84 @@
 #include "Day08.h"
 
 Result Day08::Task1() {
-	return Day::Task1();
+	Map map = parseMap();
+	vector<uint8_t> instructions = parseInstructions();
+
+	uint64 steps = 0;
+	size_t instructionIndex = 0;
+	string node = "AAA";
+	while (node != "ZZZ"){
+		node = map[node][instructions[instructionIndex]];
+		steps++;
+		instructionIndex = (++instructionIndex) % instructions.size();
+	}
+
+	return to_string(steps);
 }
 
 Result Day08::Task2() {
-	return Day::Task2();
+	Map map = parseMap();
-}
+	vector<uint8_t> instructions = parseInstructions();
+
+	vector<string> nodes;
+	for (auto [node, path] : map)
+		if (node.ends_with('A'))
+			nodes.push_back(node);
+
+	vector<uint64> allSteps;
+
+	for (string &node : nodes){
+		uint64 steps = 0;
+		size_t instructionIndex = 0;
+
+		while (!node.ends_with('Z')){
+			node = map[node][instructions[instructionIndex]];
+			steps++;
+			instructionIndex = (++instructionIndex) % instructions.size();
+		}
+
+		allSteps.push_back(steps);
+	}
+
+	uint64 lcm = 1;
+	for (uint64 steps : allSteps)
+		lcm = LCM(lcm, steps);
+
+	return to_string(lcm);
+}
+
+Day08::Map Day08::parseMap() const {
+	Map map;
+
+	for (size_t i = 2; i < input.size(); i++){
+		string line = input[i];
+		string source = line.substr(0, 3);
+		string left = line.substr(7, 3);
+		string right = line.substr(12, 3);
+		map[source] = {left, right};
+	}
+
+	return map;
+}
+
+vector<uint8_t> Day08::parseInstructions() const {
+	vector<uint8_t> instructions;
+
+	for (const char c : input[0])
+		instructions.push_back(c == 'L' ? 0 : 1);
+
+	return instructions;
+}
+
+uint64 Day08::GCD(uint64 a, uint64 b) {
+	while (b != 0){
+		uint64 t = b;
+		b = a % b;
+		a = t;
+	}
+	return a;
+}
+
+uint64 Day08::LCM(uint64 a, uint64 b) {
+	return a * b / GCD(a, b);
+}

src/days/08/Day08.h

@@ -3,8 +3,14 @@
 #include "../../Day.h"
 
 class Day08 : public Day {
+	typedef map<string, std::array<string, 2>> Map;
 protected:
 	Result Task1() override;
 
 	Result Task2() override;
+
+	vector<uint8_t> parseInstructions() const;
+	Map parseMap() const;
+	static uint64 GCD(uint64 a, uint64 b);
+	static uint64 LCM(uint64 a, uint64 b);
 };

src/days/09/Day09.cpp

@@ -1,9 +1,47 @@
 #include "Day09.h"
 
 Result Day09::Task1() {
-	return Day::Task1();
+	int64 sum = 0;
+	for (auto &history : parseHistories()){
+		vector<int64> tails = {history.back()};
+		vector<int64> diff = history;
+
+		while (std::any_of(diff.begin(), diff.end(), [](int64 v){return v != 0;})){
+			for (size_t i = 0; i < diff.size() - 1; i++)
+				diff[i] = diff[i + 1] - diff[i];
+			diff.pop_back();
+			tails.push_back(diff.back());
+		}
+
+		sum += std::reduce(tails.begin(), tails.end(), 0, [](int64 a, int64 b){ return a + b; });
+	}
+	return to_string(sum);
 }
 
 Result Day09::Task2() {
-	return Day::Task2();
+	int64 sum = 0;
-}
+	for (auto &history : parseHistories()){
+		vector<int64> heads = {history.front()};
+		vector<int64> diff = history;
+
+		while (std::any_of(diff.begin(), diff.end(), [](int64 v){return v != 0;})){
+			for (size_t i = 0; i < diff.size() - 1; i++)
+				diff[i] = diff[i + 1] - diff[i];
+			diff.pop_back();
+			heads.push_back(diff.front());
+		}
+
+		for (size_t i = 0; i < heads.size(); i++)
+			sum += heads[i] * (i % 2 == 0 ? 1 : -1);
+	}
+	return to_string(sum);
+}
+
+vector<vector<int64>> Day09::parseHistories() const {
+	vector<vector<int64>> histories;
+
+	for (const string &line : input)
+		histories.push_back(parseInts(line));
+
+	return histories;
+}

src/days/09/Day09.h

@@ -7,4 +7,6 @@ protected:
 	Result Task1() override;
 
 	Result Task2() override;
+
+	vector<vector<int64>> parseHistories() const;
 };

src/util.cpp

@@ -46,7 +46,7 @@ bool isDigit(char c) {
 	return val >= 0 && val < 10;
 }
 
-vector<uint64> parseInts(const string &data) {
+vector<uint64> parseUInts(const string &data) {
 	vector<uint64> result;
 
 	uint64 value = 0;
@@ -66,5 +66,34 @@ vector<uint64> parseInts(const string &data) {
 	if (readingInt)
 		result.push_back(value);
 
+	return result;
+}
+
+vector<int64> parseInts(const string &data) {
+	vector<int64> result;
+
+	int64 value = 0;
+	bool readingInt = false;
+	bool negative = false;
+
+	for (const char c : data){
+		uint8_t digit;
+		if (isDigit(c, digit)) {
+			value = value * 10 + digit;
+			readingInt = true;
+		} else if (!readingInt && c == '-') {
+			negative = true;
+		} else if (readingInt){
+			readingInt = false;
+			result.push_back(value * (negative ? -1 : 1));
+			value = 0;
+			negative = false;
+		} else {
+			negative = false;
+		}
+	}
+	if (readingInt)
+		result.push_back(value * (negative ? -1 : 1));
+
 	return result;
 }

src/util.h

@@ -30,4 +30,5 @@ bool isDigit(char c, uint8_t &result);
 
 bool isDigit(char c);
 
-vector<uint64> parseInts(const string &data);
+vector<uint64> parseUInts(const string &data);
+vector<int64> parseInts(const string &data);