Started Day 3

Author: zarethrex

include/advent_of_code/day_2.hxx

@@ -14,9 +14,8 @@
 #include "spdlog/spdlog.h"
 
 namespace AdventOfCode24::Day2 {
-    const int BUFFER_SIZE{1024};
     bool safe_pair(int val_1, int val_2, int direction);
-    int check_intervals(const std::vector<int>& numbers);
-    bool report_is_safe(std::istringstream& line);
+    std::optional<int> check_intervals(const std::vector<int>& numbers);
+    bool report_is_safe(std::istringstream& line, bool allow_dampening);
     std::vector<bool> check_reactor_safety(const std::filesystem::path& input_file, bool problem_dampening);
 };

include/advent_of_code/day_3.hxx

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "spdlog/spdlog.h"
+#include <sstream>
+#include <vector>
+#include <regex>
+
+namespace AdventOfCode24::Day3 {
+    std::vector<std::pair<int, int>> parse_line(std::istringstream& line);
+};

solutions/data/day_3.txt

@@ -1,6 +1,6 @@
 #include "advent_of_code/day_2.hxx"
 #include "spdlog/spdlog.h"
-#include <string>
+#include <optional>
 
 namespace AdventOfCode24::Day2 {
     bool safe_pair(int val_1, int val_2, int direction) {
@@ -26,7 +26,7 @@ namespace AdventOfCode24::Day2 {
         return true;
     }
 
-    int check_intervals(const std::vector<int>& numbers) {
+    std::optional<int> check_intervals(const std::vector<int>& numbers) {
         std::vector<int> directions(numbers.size() - 1);
 
         std::transform(
@@ -45,27 +45,31 @@ namespace AdventOfCode24::Day2 {
 
         spdlog::debug("\t- Overall direction is " + std::string((overall_dir < 0) ? "Negative" : "Positive"));
 
-        if(!overall_dir) {
+        if(overall_dir == 0) {
             spdlog::debug("\t- All intervals failed with value 0");
-            return overall_dir;
+            return {};
         }
 
         const int differences = std::count_if(
             directions.begin(), 
             directions.end(), 
             [&overall_dir](int x){
-                const bool x_forward{x < 0};
-                const bool overall_dir_forward{overall_dir < 0};
-                if(x_forward != overall_dir_forward) {
-                    spdlog::debug("\t- Mismatch in direction between interval " + std::to_string(x) + " and direction " + std::to_string(overall_dir_forward));
+                if(x == 0) {
+                    spdlog::debug("\t- Interval of zero found. ");
+                    return true;
                 }
-                return x_forward != overall_dir_forward;
+                const int x_vec{x / std::abs(x)};
+                const int overall_dir_vec{overall_dir / std::abs(overall_dir)};
+                if(x_vec != overall_dir_vec) {
+                    spdlog::debug("\t- Mismatch in direction between interval " + std::to_string(x) + " and direction " + std::to_string(overall_dir_vec));
+                }
+                return x_vec != overall_dir_vec;
             }
         );
 
         if(differences > 0) {
             spdlog::debug("\t- Intervals failed due to variance in direction.");
-            return 0;
+            return {};
         }
 
         return overall_dir;
@@ -90,27 +94,38 @@ namespace AdventOfCode24::Day2 {
             numbers.push_back(number);
         }
 
-        int interval_check{check_intervals(numbers)};
+        std::optional<int> interval_check{check_intervals(numbers)};
+
+        if(!interval_check.has_value()) return false;
 
-        if(!interval_check && !allow_dampening) return false;
+        const std::optional<int> fail_index{check_report_values(numbers, interval_check.value())};
 
-        const std::optional<int> fail_index{check_report_values(numbers, interval_check)};
+        if(!fail_index.has_value()) {
+            if(interval_check == 0) return false;
+            return true;
+        }
 
-        if(!fail_index.has_value()) return true;
         if(!allow_dampening) return false;
 
+        spdlog::debug("\t* Dampen lower bound");
+
         std::vector<int> dampened_first{numbers.begin(), numbers.end()};
         dampened_first.erase(dampened_first.begin() + fail_index.value() - 1);
         interval_check = check_intervals(dampened_first);
 
-        const std::optional<int> damp_fail_index_first{check_report_values(dampened_first, interval_check)};
-        if(!damp_fail_index_first.has_value()) return true;
+        if(interval_check.has_value()) {
+            const std::optional<int> damp_fail_index_first{check_report_values(dampened_first, interval_check.value())};
+            if(!damp_fail_index_first.has_value()) return true;
+        }
 
+        spdlog::debug("\t* Dampen upper bound");
         std::vector<int> dampened_second{numbers.begin(), numbers.end()};
         dampened_second.erase(dampened_second.begin() + fail_index.value());
         interval_check = check_intervals(dampened_second);
 
-        const std::optional<int> damp_fail_index_second{check_report_values(dampened_second, interval_check)};
+        if(!interval_check.has_value()) return false;
+
+        const std::optional<int> damp_fail_index_second{check_report_values(dampened_second, interval_check.value())};
         if(!damp_fail_index_second.has_value()) return true;
 
         return false;

src/day_2.cxx

@@ -0,0 +1,47 @@
+#include "advent_of_code/day_3.hxx"
+#include "spdlog/spdlog.h"
+#include <regex>
+#include <stdexcept>
+#include <string>
+
+namespace AdventOfCode24::Day3 {
+    std::vector<std::pair<int, int>> parse_line(std::istringstream& line) {
+        std::vector<std::pair<int, int>> operations;
+
+        const std::string line_str{line.str()};
+
+        const std::regex find_valid_mul_statements{"mul\\(-?\\d+,-?\\d+\\)"};
+        const std::regex find_numbers{"-?\\d+"};
+
+        auto results_begin{std::sregex_iterator(line_str.begin(), line_str.end(), find_valid_mul_statements)};
+        auto results_end {std::sregex_iterator()};
+
+        for(std::sregex_iterator iter{results_begin}; iter != results_end; ++iter) {
+            const std::smatch match{*iter};
+            const std::string match_str{match.str()};
+
+            auto numbers_begin{std::sregex_iterator(match_str.begin(), match_str.end(), find_numbers)};
+            auto numbers_end {std::sregex_iterator()};
+
+            std::pair<int, int> arguments{-1000, -1000};
+
+            for(std::sregex_iterator n_iter{numbers_begin}; n_iter != numbers_end; ++n_iter) {
+                const std::smatch n_match{*n_iter};
+                int n_match_int{0};
+
+                try {
+                    n_match_int = std::stoi(match.str());
+                } catch(std::invalid_argument& e) {
+                    spdlog::error("Could not parse " + n_match.str());
+                    return operations;
+                }
+
+                if(arguments.first == -1000) arguments.first = n_match_int;
+                else arguments.second = n_match_int;
+            }
+
+            operations.push_back(arguments);
+        }
+        return operations;
+    }
+};

src/day_3.cxx

@@ -22,4 +22,6 @@
 31 34 32 30 28 27 24 22
 75 77 72 70 69
 52 51 52 49 47 45
-8 9 10 11
+8 9 10 11
+8 7 8 10 13 15 17
+90 89 91 93 95 94

tests/data/day_2_2.txt

@@ -0,0 +1 @@
+xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))

tests/data/day_3_1.txt

@@ -5,11 +5,24 @@
 #include "spdlog/spdlog.h"
 
 #include <filesystem>
+#include <sstream>
 
 #ifndef ADVENT_OF_CODE_DATA
   #error "ADVENT_OF_CODE_DATA is not defined!"
 #endif
 
+TEST(TestAOC, TestDay2pt2_fail_scenario_1) {
+    spdlog::set_level(spdlog::level::debug);
+    std::istringstream sstr(std::string("90 89 91 93 95 94"), std::ios::in);
+    ASSERT_FALSE(AdventOfCode24::Day2::report_is_safe(sstr, true));
+}
+
+TEST(TestAOC, TestDay2pt2_fail_scenario_2) {
+    spdlog::set_level(spdlog::level::debug);
+    std::istringstream sstr(std::string("1 1 1 1 1"), std::ios::in);
+    ASSERT_FALSE(AdventOfCode24::Day2::report_is_safe(sstr, true));
+}
+
 TEST(TestAOC, TestDay2pt1_file1) {
     spdlog::set_level(spdlog::level::debug);
     const std::filesystem::path input_file = std::filesystem::path(ADVENT_OF_CODE_DATA) / "day_2_1.txt";
@@ -29,11 +42,11 @@ TEST(TestAOC, TestDay2pt1_file2) {
 
     const std::vector<bool> layer_safety = AdventOfCode24::Day2::check_reactor_safety(input_file, true);
 
-    ASSERT_EQ(layer_safety.size(), 25);
+    ASSERT_EQ(layer_safety.size(), 27);
 
     const int n_safe = std::count_if(layer_safety.begin(), layer_safety.end(), [](bool x){return x;});
 
-    ASSERT_EQ(n_safe, 24);
+    ASSERT_EQ(n_safe, 25);
 }
 
 TEST(TestAOC, TestDay2pt2) {

tests/test_day_2.cxx

@@ -0,0 +1,22 @@
+#include <gtest/gtest.h>
+#include "advent_of_code/day_3.hxx"
+
+
+#include <filesystem>
+#include <sstream>
+#include <utility>
+#include <vector>
+
+#ifndef ADVENT_OF_CODE_DATA
+  #error "ADVENT_OF_CODE_DATA is not defined!"
+#endif
+
+TEST(TestAOC, TestDay3pt1_line_parse) {
+    std::istringstream sstr(std::string("Gmul(4,5)L3£9mul(34,)&3yMul(3,4)?"), std::ios::in);
+    const std::vector<std::pair<int,int>> parsed{AdventOfCode24::Day3::parse_line(sstr)};
+    
+    ASSERT_EQ(parsed.size(), 1);
+
+    ASSERT_EQ(parsed[0].first, 4);
+    ASSERT_EQ(parsed[0].second, 5);
+}