Completed Day 3

Author: zarethrex

.github/workflows/build_test.yaml

@@ -36,3 +36,5 @@ jobs:
               run: ./build/solutions/day_1 solutions/data/day_1.txt
             - name: Run Day 2 Solution
               run: ./build/solutions/day_2 solutions/data/day_2.txt
+            - name: Run Day 3 Solution
+              run: ./build/solutions/day_3 solutions/data/day_3.txt

README.md

@@ -7,7 +7,7 @@ The solutions have been created in the C++ programming language as a library.
 | | ||||||
 |-|-|-|-|-|-|-|
 ||1|2|3|4|5|6|
-||:x: | ||| | |
+||:x: | |:x:|| | |
 |7|8|9|10|11|12|13|
 | | | | | | | | |
 |14|15|16|17|18|19|20|

include/advent_of_code/day_3.hxx

@@ -1,10 +1,20 @@
 #pragma once
-
-#include "spdlog/spdlog.h"
-#include <sstream>
 #include <vector>
 #include <regex>
+#include <filesystem>
+#include <fstream>
+#include <numeric>
+#include <functional>
+#include <stdexcept>
+#include <optional>
+#include <string>
+
+#include "spdlog/spdlog.h"
 
 namespace AdventOfCode24::Day3 {
-    std::vector<std::pair<int, int>> parse_line(std::istringstream& line);
+    typedef std::pair<std::vector<int>, std::vector<int>> logic_set;
+    bool use_calculation(int operation_index, logic_set logic_indexes);
+    logic_set get_logic_indexes(const std::string& line);
+    std::vector<std::pair<int, int>> parse_line(const std::string& line, bool logic_enabled, bool& do_state);
+    std::vector<int> calculate_file_lines(const std::filesystem::path& input_file, bool logic_enabled);
 };

solutions/day_3.cxx

@@ -0,0 +1,27 @@
+#include <filesystem>
+#include <string>
+#include "spdlog/spdlog.h"
+
+#include "advent_of_code/day_3.hxx"
+
+using namespace AdventOfCode24::Day3;
+
+int main(int argc, char** argv) {
+    if(argc != 2) {
+        spdlog::error("Expected input data file!");
+        return 1;
+    }
+
+    spdlog::set_level(spdlog::level::debug);
+
+    const std::filesystem::path input_file{argv[1]};
+    const std::vector<int> line_totals{calculate_file_lines(input_file, false)};
+    const std::vector<int> line_totals_w_logic{calculate_file_lines(input_file, true)};
+    const int overall_total = std::accumulate(line_totals.begin(), line_totals.end(), 0);
+    const int overall_total_w_logic = std::accumulate(line_totals_w_logic.begin(), line_totals_w_logic.end(), 0);
+
+    spdlog::info("For file '" + input_file.string() + "' the program returned " + std::to_string(overall_total));
+    spdlog::info("With logic statements enabled, this changes to " + std::to_string(overall_total_w_logic));
+
+    return 0;
+}

src/day_3.cxx

@@ -1,36 +1,83 @@
 #include "advent_of_code/day_3.hxx"
-#include "spdlog/spdlog.h"
-#include <regex>
-#include <stdexcept>
+#include <algorithm>
+#include <iterator>
 #include <string>
 
 namespace AdventOfCode24::Day3 {
-    std::vector<std::pair<int, int>> parse_line(std::istringstream& line) {
-        std::vector<std::pair<int, int>> operations;
+    bool use_calculation(int operation_index, logic_set logic_indexes, const bool& current_state) {
+        auto last_do_before_val = std::find_if(
+            logic_indexes.first.rbegin(),
+            logic_indexes.first.rend(),
+            [operation_index](int value){return value < operation_index;}
+        );
+
+        auto last_dont_before_val = std::find_if(
+            logic_indexes.second.rbegin(),
+            logic_indexes.second.rend(),
+            [operation_index](int value){return value < operation_index;}
+        );
 
-        const std::string line_str{line.str()};
+        // If we have not yet encountered any logic statements enable by default
+        if(last_do_before_val == logic_indexes.first.rend() && last_dont_before_val == logic_indexes.second.rend()) return current_state;
+
+        return (*last_do_before_val) > (*last_dont_before_val);
+    }
+    logic_set get_logic_indexes(const std::string& line) {
+        const std::regex find_dos("do\\(\\)");
+        const std::regex find_donts("don't\\(\\)");
+
+        logic_set logic_indexes;
+
+        auto dos_begin{std::sregex_iterator(line.begin(), line.end(), find_dos)};
+        auto dos_end {std::sregex_iterator()};
+        auto donts_begin{std::sregex_iterator(line.begin(), line.end(), find_donts)};
+        auto donts_end {std::sregex_iterator()};
+
+        for(std::sregex_iterator iter{dos_begin}; iter != dos_end; ++iter) {
+            const std::smatch do_match{*iter};
+            const size_t index = std::distance(line.begin(), line.begin() + do_match.position());
+            logic_indexes.first.push_back(static_cast<int>(index));
+        }
+
+        for(std::sregex_iterator iter{donts_begin}; iter != donts_end; ++iter) {
+            const std::smatch dont_match{*iter};
+            const size_t index = std::distance(line.begin(), line.begin() + dont_match.position());
+            logic_indexes.second.push_back(static_cast<int>(index));
+        }
+
+        return logic_indexes;
+    }
+
+    std::vector<std::pair<int, int>> parse_line(const std::string& line, bool logic_enabled, bool& do_state) {
+        std::vector<std::pair<int, int>> operations;
 
         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_begin{std::sregex_iterator(line.begin(), line.end(), find_valid_mul_statements)};
         auto results_end {std::sregex_iterator()};
 
+        std::optional<std::pair<std::vector<int>, std::vector<int>>> logic_indexes = {};
+        
+        if(logic_enabled) logic_indexes = get_logic_indexes(line);
+
         for(std::sregex_iterator iter{results_begin}; iter != results_end; ++iter) {
             const std::smatch match{*iter};
             const std::string match_str{match.str()};
+            bool calculation_active{true};
 
             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};
+            const size_t match_position = std::distance(line.begin(), line.begin() + match.position());
 
             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());
+                    n_match_int = std::stoi(n_match.str());
                 } catch(std::invalid_argument& e) {
                     spdlog::error("Could not parse " + n_match.str());
                     return operations;
@@ -40,8 +87,40 @@ namespace AdventOfCode24::Day3 {
                 else arguments.second = n_match_int;
             }
 
-            operations.push_back(arguments);
+            bool state_result{do_state};
+            
+            if(logic_enabled) state_result = use_calculation(match_position, logic_indexes.value(), do_state);
+
+            if(!logic_enabled || state_result) operations.push_back(arguments);
+
+            // Update global state with latest state result
+            do_state = state_result;
         }
         return operations;
     }
+
+    std::vector<int> calculate_file_lines(const std::filesystem::path& input_file, bool logic_enabled) {
+        std::vector<int> calculation_results;
+
+        std::ifstream read_in(input_file, std::ios::in);
+        std::string line;
+        bool do_state{true};
+
+        while (std::getline(read_in, line)) {
+            const std::vector<std::pair<int, int>> line_calculations{parse_line(line, logic_enabled, do_state)};
+
+            const int line_total = std::accumulate(
+                line_calculations.begin(), 
+                line_calculations.end(), 
+                0, 
+                [](int total, std::pair<int, int> couplet){
+                    spdlog::debug("\t" + std::to_string(couplet.first) + " * " + std::to_string(couplet.second));
+                    return total + (couplet.first * couplet.second);
+                }
+            );
+            calculation_results.push_back(line_total);
+        }
+
+        return calculation_results;
+    }
 };

tests/data/day_3_2.txt

@@ -0,0 +1 @@
+xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))

tests/data/day_3_3.txt

@@ -0,0 +1,2 @@
+do(asd"kj*£"!)mul(1,2)don't()(uhj£3Q"Emul(3,4)
+mul(3,4)mul(do()(3jmul(3,5)3

tests/test_day_3.cxx

@@ -6,17 +6,52 @@
 #include <sstream>
 #include <utility>
 #include <vector>
+#include <numeric>
 
 #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)};
+    const std::string line("Gmul(4,5)L3£9mul(34,)&3yMul(3,4)?");
+    bool do_state{true};
+    const std::vector<std::pair<int,int>> parsed{AdventOfCode24::Day3::parse_line(line, false, do_state)};
 
     ASSERT_EQ(parsed.size(), 1);
 
     ASSERT_EQ(parsed[0].first, 4);
     ASSERT_EQ(parsed[0].second, 5);
+}
+
+TEST(TestAOC, TestDay3pt1) {
+  spdlog::set_level(spdlog::level::debug);
+  const std::filesystem::path input_file = std::filesystem::path(ADVENT_OF_CODE_DATA) / "day_3_1.txt";
+  const std::vector<int> line_totals{AdventOfCode24::Day3::calculate_file_lines(input_file, false)};
+
+  const int overall_total = std::accumulate(line_totals.begin(), line_totals.end(), 0);
+
+  ASSERT_EQ(line_totals.size(), 1);
+  ASSERT_EQ(overall_total, 161);
+}
+
+TEST(TestAOC, TestDay3pt2) {
+  spdlog::set_level(spdlog::level::debug);
+  const std::filesystem::path input_file = std::filesystem::path(ADVENT_OF_CODE_DATA) / "day_3_2.txt";
+  const std::vector<int> line_totals{AdventOfCode24::Day3::calculate_file_lines(input_file, true)};
+
+  const int overall_total = std::accumulate(line_totals.begin(), line_totals.end(), 0);
+
+  ASSERT_EQ(line_totals.size(), 1);
+  ASSERT_EQ(overall_total, 48);
+}
+
+TEST(TestAOC, TestDay3pt2_scenario_1) {
+  spdlog::set_level(spdlog::level::debug);
+  const std::filesystem::path input_file = std::filesystem::path(ADVENT_OF_CODE_DATA) / "day_3_3.txt";
+  const std::vector<int> line_totals{AdventOfCode24::Day3::calculate_file_lines(input_file, true)};
+
+  const int overall_total = std::accumulate(line_totals.begin(), line_totals.end(), 0);
+
+  ASSERT_EQ(line_totals.size(), 2);
+  ASSERT_EQ(overall_total, 17);
 }