day 19

Author: bt

CMakeLists.txt

@@ -7,6 +7,7 @@ add_compile_options(-Wall -Wextra -Wpedantic -O2)
 function(add_challenge name)
     add_executable(${name} ${CMAKE_CURRENT_SOURCE_DIR}/src/${name}.cpp)
     target_include_directories(${name} PRIVATE ${CMAKE_SOURCE_DIR}/include)
+    set_property(TARGET ${name} PROPERTY CXX_STANDARD 20)
 endfunction(add_challenge)
 
 add_challenge(day1)
@@ -23,6 +24,11 @@ add_challenge(day11)
 add_challenge(day12)
 add_challenge(day13)
 add_challenge(day14)
+add_challenge(day15)
+add_challenge(day16)
+add_challenge(day17)
+add_challenge(day18)
+add_challenge(day19)
 
 add_custom_command(TARGET day1
     COMMAND ${CMAKE_COMMAND} -E create_symlink "${CMAKE_CURRENT_SOURCE_DIR}/data" "./data"

include/Cursor.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+// #include <space
+
+class Cursor final
+{
+public:
+    enum class Direction{Up = 0, Right = 1, Down = 2, Left=3, Sentinel=4};
+
+    Cursor() = default;
+    
+    explicit constexpr Cursor(Direction initDirection, int initX, int initY)
+    : m_direction{initDirection}
+    , m_x{initX}
+    , m_y{initY}
+    {}
+
+    [[nodiscard]] constexpr int x() const noexcept {
+        return m_x;
+    }
+
+    [[nodiscard]] constexpr int y() const noexcept {
+        return m_y;
+    }
+
+    [[nodiscard]] constexpr Direction direction() const noexcept {
+        return m_direction;
+    }
+
+    constexpr void stepUp() noexcept {
+        --m_x;
+    }
+
+    constexpr void stepDown() noexcept {
+        ++m_x;
+    }
+
+    constexpr void stepLeft() noexcept {
+        --m_y;
+    }
+
+    constexpr void stepRight() noexcept {
+        ++m_y;
+    }
+
+
+    constexpr void move() noexcept {
+        switch (m_direction)
+        {
+        case Direction::Up:
+            stepUp();
+            break;
+        case Direction::Down:
+            stepDown();
+            break;
+        case Direction::Left:
+            stepLeft();
+            break;
+        case Direction::Right:
+            stepRight();
+            break;
+        }
+    }
+
+    constexpr void stepBack() noexcept {
+        switch (m_direction)
+        {
+        case Direction::Up:
+            stepDown();
+            break;
+        case Direction::Left:
+            stepRight();
+            break;
+        case Direction::Down:
+            stepUp();
+            break;
+        case Direction::Right:
+            stepLeft();
+            break;
+        }
+    }
+
+    constexpr void turnRight() noexcept {
+       constexpr auto sentinelInt = static_cast<int>(Direction::Sentinel);
+       m_direction = static_cast<Direction>((static_cast<int>(m_direction) + 1) % sentinelInt);
+    }
+
+    constexpr void setDirection(Direction dir) noexcept {
+        m_direction = dir;
+    }
+
+    [[nodiscard]] constexpr bool operator==(const Cursor&) const = default;
+
+    [[nodiscard]] constexpr bool operator!=(const Cursor&) const = default;
+
+private:
+    Direction m_direction{Direction::Up};
+    int m_x{}, m_y{};
+};

src/day19.cpp

@@ -0,0 +1,123 @@
+#include "common_headers.hpp"
+
+#include <sstream>
+#include <unordered_set>
+
+[[nodiscard]] size_t solveFirstPart(const std::unordered_set<std::string> &patterns, const std::vector<std::string>& designs)
+{
+    size_t count{};
+    std::string search;
+    std::vector<int> match;
+    for(const auto& design : designs) {
+        match.clear();
+        match.resize(design.size() + 1, 0);
+        match[0] = 1;
+
+        for(size_t i = 0; i < design.size(); ++i) {
+            search.clear();
+            for(int j = i; j >= 0 && match[i + 1] == 0; --j) {
+                const auto substr =  design.substr(j, i - j + 1);
+                match[i + 1] = match[j] && (patterns.count(substr) > 0);
+            }
+        }
+        count += (match.back() == 1);
+    }
+    std::cerr << "\n";
+    return count;
+}
+
+[[nodiscard]] size_t solveSecondPart(const std::unordered_set<std::string> &patterns, const std::vector<std::string>& designs)
+{
+    size_t count{};
+    std::string search;
+    std::vector<size_t> match;
+    for(const auto& design : designs) {
+        match.clear();
+        match.resize(design.size() + 1, 0);
+        match[0] = 1;
+
+        for(size_t i = 0; i < design.size(); ++i) {
+            search.clear();
+            for(int j = i; j >= 0; --j) {
+                const auto substr =  design.substr(j, i - j + 1);
+                if(match[j] != 0 && (patterns.count(substr) > 0)) {
+                    match[i + 1] += match[j];
+                }
+            }
+        }
+
+        count += match.back();
+    }
+    std::cerr << "\n";
+    return count;
+}
+
+
+
+
+[[nodiscard]] std::unordered_set<std::string> parsePatterns(const std::string& pattern)
+{
+    std::unordered_set<std::string> patterns;
+
+    std::stringstream ss{pattern};
+    std::string line;
+    while((ss >> line)) {
+        if(line.back() == ',') {
+            line.pop_back();
+        }
+        patterns.emplace(line);
+    }
+    return patterns;
+}
+
+[[nodiscard]] std::pair<std::unordered_set<std::string>, std::vector<std::string>> parseInput(const std::vector<std::string>& inputVec)
+{
+    auto patterns = parsePatterns(inputVec.at(0));
+    std::vector<std::string> designs(std::next(inputVec.begin(), 2), inputVec.end());
+    return {std::move(patterns), std::move(designs)};
+}
+
+void printHelp()
+{
+    std::cerr << "\nUsage:\n"
+    << "The program requires 2 args: (part1, part2) and the path to the file."
+    << "\nFor example, ./day7 part1 data/day7.txt";
+}
+
+int main(int argc, char* argv[])
+{
+    if(argc != 3) {
+        printHelp();
+        return 1;
+    }
+
+    std::string_view task{argv[1]};
+    if(task != "part1" && task != "part2") {
+        std::cerr << "\nfirst arg can be either `part1` or `part2`\n";
+        printHelp();
+        return 1;
+    }
+    
+    std::vector<std::string> inputVec;
+    readInput(argv[2], std::back_inserter(inputVec));
+
+
+    auto [patterns, designs] = parseInput(inputVec);
+
+    // for(auto p : patterns) {
+    //     std::cerr << "\np `" << p <<"`";
+    // }
+
+    // for(auto s : designs) {
+        // std::cerr << "\n" << s;
+    // }
+
+    if(task == "part1") {
+        std::cout << solveFirstPart(patterns, designs);
+    }
+    else {
+        std::cout << solveSecondPart(patterns, designs);
+    }
+
+    return 0;
+}