warrence
/
AdventOfCode2024
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add proper CMake setup and update project structure

This commit is contained in:
Stefan Müller 2024-12-06 20:16:01 +01:00
parent fdfdca84e4
commit 38bca1e549
56 changed files with 282 additions and 681 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
.gitattributes vendored Normal file
View File

@ -0,0 +1,37 @@
# Sources
*.c text diff=cpp
*.cc text diff=cpp
*.cxx text diff=cpp
*.cpp text diff=cpp
*.cpi text diff=cpp
*.c++ text diff=cpp
*.hpp text diff=cpp
*.h text diff=cpp
*.h++ text diff=cpp
*.hh text diff=cpp
# Compiled Object files
*.slo binary
*.lo binary
*.o binary
*.obj binary
# Precompiled Headers
*.gch binary
*.pch binary
# Compiled Dynamic libraries
*.so binary
*.dylib binary
*.dll binary
# Compiled Static libraries
*.lai binary
*.la binary
*.a binary
*.lib binary
# Executables
*.exe binary
*.out binary
*.app binary

2
.gitignore vendored
View File

@ -35,5 +35,5 @@
# VS and Output # VS and Output
.vs .vs
Debug/ Debug/
out/
*.vcxproj.user *.vcxproj.user
build/

4
AdventOfCode2024/AdventOfCode2024.cpp → AdventOfCode2024.cpp
View File

@ -1,4 +1,4 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "AdventOfCode2024.h" #include <aoc/Program.h>
int main() int main()
{ {

82
AdventOfCode2024/.editorconfig
View File

@ -1,82 +0,0 @@
# Visual Studio generated .editorconfig file with C++ settings.
root = true
[*.{c++,cc,cpp,cppm,cxx,h,h++,hh,hpp,hxx,inl,ipp,ixx,tlh,tli}]
# Visual C++ Code Style settings
cpp_generate_documentation_comments = xml
# Visual C++ Formatting settings
cpp_indent_braces = false
cpp_indent_multi_line_relative_to = innermost_parenthesis
cpp_indent_within_parentheses = indent
cpp_indent_preserve_within_parentheses = true
cpp_indent_case_contents = true
cpp_indent_case_labels = true
cpp_indent_case_contents_when_block = false
cpp_indent_lambda_braces_when_parameter = true
cpp_indent_goto_labels = one_left
cpp_indent_preprocessor = leftmost_column
cpp_indent_access_specifiers = false
cpp_indent_namespace_contents = true
cpp_indent_preserve_comments = false
cpp_new_line_before_open_brace_namespace = ignore
cpp_new_line_before_open_brace_type = ignore
cpp_new_line_before_open_brace_function = ignore
cpp_new_line_before_open_brace_block = ignore
cpp_new_line_before_open_brace_lambda = ignore
cpp_new_line_scope_braces_on_separate_lines = false
cpp_new_line_close_brace_same_line_empty_type = false
cpp_new_line_close_brace_same_line_empty_function = false
cpp_new_line_before_catch = true
cpp_new_line_before_else = true
cpp_new_line_before_while_in_do_while = false
cpp_space_before_function_open_parenthesis = remove
cpp_space_within_parameter_list_parentheses = false
cpp_space_between_empty_parameter_list_parentheses = false
cpp_space_after_keywords_in_control_flow_statements = true
cpp_space_within_control_flow_statement_parentheses = false
cpp_space_before_lambda_open_parenthesis = false
cpp_space_within_cast_parentheses = false
cpp_space_after_cast_close_parenthesis = false
cpp_space_within_expression_parentheses = false
cpp_space_before_block_open_brace = true
cpp_space_between_empty_braces = false
cpp_space_before_initializer_list_open_brace = false
cpp_space_within_initializer_list_braces = true
cpp_space_preserve_in_initializer_list = true
cpp_space_before_open_square_bracket = false
cpp_space_within_square_brackets = false
cpp_space_before_empty_square_brackets = false
cpp_space_between_empty_square_brackets = false
cpp_space_group_square_brackets = true
cpp_space_within_lambda_brackets = false
cpp_space_between_empty_lambda_brackets = false
cpp_space_before_comma = false
cpp_space_after_comma = true
cpp_space_remove_around_member_operators = true
cpp_space_before_inheritance_colon = true
cpp_space_before_constructor_colon = true
cpp_space_remove_before_semicolon = true
cpp_space_after_semicolon = true
cpp_space_remove_around_unary_operator = true
cpp_space_around_binary_operator = insert
cpp_space_around_assignment_operator = insert
cpp_space_pointer_reference_alignment = left
cpp_space_around_ternary_operator = insert
cpp_use_unreal_engine_macro_formatting = true
cpp_wrap_preserve_blocks = one_liners
# Visual C++ Inlcude Cleanup settings
cpp_include_cleanup_add_missing_error_tag_type = suggestion
cpp_include_cleanup_remove_unused_error_tag_type = dimmed
cpp_include_cleanup_optimize_unused_error_tag_type = suggestion
cpp_include_cleanup_sort_after_edits = false
cpp_sort_includes_error_tag_type = none
cpp_sort_includes_priority_case_sensitive = false
cpp_sort_includes_priority_style = quoted
cpp_includes_style = default
cpp_includes_use_forward_slash = true

18
AdventOfCode2024/AdventOfCode2024.h
View File

@ -1,18 +0,0 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "Program.h"

21
AdventOfCode2024/CMakeLists.txt
View File

@ -1,21 +0,0 @@
# CMakeList.txt : CMake project for AdventOfCode2024, include source and define
# project specific logic here.
#
cmake_minimum_required (VERSION 3.8)
# Enable Hot Reload for MSVC compilers if supported.
if (POLICY CMP0141)
cmake_policy(SET CMP0141 NEW)
set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<IF:$<AND:$<C_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:MSVC>>,$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>,$<$<CONFIG:Debug,RelWithDebInfo>:ProgramDatabase>>")
endif()
project ("AdventOfCode2024")
# Add source to this project's executable.
add_executable (AdventOfCode2024 "AdventOfCode2024.cpp" "AdventOfCode2024.h")
if (CMAKE_VERSION VERSION_GREATER 3.12)
set_property(TARGET AdventOfCode2024 PROPERTY CXX_STANDARD 20)
endif()
# TODO: Add tests and install targets if needed.

61
AdventOfCode2024/CMakePresets.json
View File

@ -1,61 +0,0 @@
{
"version": 3,
"configurePresets": [
{
"name": "windows-base",
"hidden": true,
"generator": "Ninja",
"binaryDir": "${sourceDir}/out/build/${presetName}",
"installDir": "${sourceDir}/out/install/${presetName}",
"cacheVariables": {
"CMAKE_C_COMPILER": "cl.exe",
"CMAKE_CXX_COMPILER": "cl.exe"
},
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Windows"
}
},
{
"name": "x64-debug",
"displayName": "x64 Debug",
"inherits": "windows-base",
"architecture": {
"value": "x64",
"strategy": "external"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug"
}
},
{
"name": "x64-release",
"displayName": "x64 Release",
"inherits": "x64-debug",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release"
}
},
{
"name": "x86-debug",
"displayName": "x86 Debug",
"inherits": "windows-base",
"architecture": {
"value": "x86",
"strategy": "external"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug"
}
},
{
"name": "x86-release",
"displayName": "x86 Release",
"inherits": "x86-debug",
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release"
}
}
]
}

80
AdventOfCode2024/CeresSearch.cpp
View File

@ -1,80 +0,0 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#include "CeresSearch.h"
std::string CeresSearch::getPuzzleName() const
{
return "Day 4: Ceres Search";
}
std::string CeresSearch::getInputFileName() const
{
return "ceres_search.txt";
}
void CeresSearch::finish()
{
for (int j = 0; j < lines.size(); j++)
{
for (int i = 0; i < lines[j].size(); i++)
{
if (lines[j][i] == xmas[0])
{
Point2 start{ i, j };
computeXmasCount(start);
}
else if (lines[j][i] == xmas[2])
{
Point2 start{ i, j };
computeX_MasCount(start);
}
}
}
}
void CeresSearch::computeXmasCount(const Point2& start)
{
for (auto d : Point2::directions)
{
auto p{ start + d };
auto i{ 1 };
while (i < 4 && isInBounds(p) && xmas[i] == getPosition(p))
{
p += d;
i++;
}
if (i == 4)
{
part1++;
}
}
}
void CeresSearch::computeX_MasCount(const Point2& start)
{
auto pUL{ start + Point2::upLeft };
auto pDR{ start + Point2::downRight };
auto pUR{ start + Point2::upRight };
auto pDL{ start + Point2::downLeft };
if (isInBounds(pUL) && isInBounds(pDR)
&& ((getPosition(pUL) == xmas[1] && getPosition(pDR) == xmas[3])
|| (getPosition(pUL) == xmas[3] && getPosition(pDR) == xmas[1]))
&& ((getPosition(pUR) == xmas[1] && getPosition(pDL) == xmas[3])
|| (getPosition(pUR) == xmas[3] && getPosition(pDL) == xmas[1])))
{
part2++;
}
}

33
AdventOfCode2024/CeresSearch.h
View File

@ -1,33 +0,0 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <vector>
#include "LinesSolver.h"
class CeresSearch :
public LinesSolver
{
public:
std::string getPuzzleName() const override;
std::string getInputFileName() const override;
void finish() override;
private:
char xmas[4] = { 'X', 'M', 'A', 'S' };
void computeXmasCount(const Point2& start);
void computeX_MasCount(const Point2& start);
};

32
AdventOfCode2024/LinesSolver.cpp
View File

@ -1,32 +0,0 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#include "LinesSolver.h"
void LinesSolver::processDataLine(const std::string& line)
{
lines.push_back(line);
}
bool LinesSolver::isInBounds(const Point2& point)
{
return 0 <= point.y && point.y < lines.size()
&& 0 <= point.x && point.x < lines[point.y].size();
}
char LinesSolver::getPosition(const Point2& point)
{
return lines[point.y][point.x];
}

32
AdventOfCode2024/LinesSolver.h
View File

@ -1,32 +0,0 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <vector>
#include "Solver.h"
#include "Point2.h"
class LinesSolver :
public Solver
{
public:
void processDataLine(const std::string& line) override;
protected:
std::vector<std::string> lines{};
bool isInBounds(const Point2& point);
char getPosition(const Point2& point);
};

81
AdventOfCode2024/Point2.cpp
View File

@ -1,81 +0,0 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#include "Point2.h"
Point2::Point2()
: Point2{ 0, 0 } {}
Point2::Point2(const int x, const int y)
: x{ x }, y{ y } {}
bool Point2::operator==(const Point2& rhs) const
{
return x == rhs.x && y == rhs.y;
}
bool Point2::operator!=(const Point2& rhs) const
{
return !(x == y);
}
Point2 Point2::operator+(const Point2& rhs) const
{
return Point2(x + rhs.x, y + rhs.y);
}
Point2 Point2::operator-(const Point2& rhs) const
{
return Point2(x - rhs.x, y - rhs.y);
}
Point2 Point2::operator*(const int rhs) const
{
return Point2(x * rhs, y * rhs);
}
Point2 Point2::operator-() const
{
return Point2(-x, -y);
}
Point2& Point2::operator+=(const Point2& rhs)
{
*this = *this + rhs;
return *this;
}
Point2& Point2::operator-=(const Point2& rhs)
{
*this = *this - rhs;
return *this;
}
Point2& Point2::operator*=(const int rhs)
{
*this = *this * rhs;
return *this;
}
const Point2 Point2::left{ -1, 0 };
const Point2 Point2::right{ 1, 0 };
const Point2 Point2::up{ 0, -1 };
const Point2 Point2::down{ 0, 1 };
const Point2 Point2::upLeft{ -1, -1 };
const Point2 Point2::upRight{ 1, -1 };
const Point2 Point2::downLeft{ -1, 1 };
const Point2 Point2::downRight{ 1, 1 };
const Point2 Point2::directions[] = { Point2::left, Point2::right, Point2::up, Point2::down,
Point2::upLeft, Point2::upRight, Point2::downLeft, Point2::downRight };

36
AdventOfCode2024/Point2.h
View File

@ -1,36 +0,0 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
class Point2
{
public:
int x, y;
Point2();
Point2(const int x, const int y);
bool operator==(const Point2& rhs) const;
bool operator!=(const Point2& rhs) const;
Point2 operator+(const Point2& rhs) const;
Point2 operator-(const Point2& rhs) const;
Point2 operator*(const int rhs) const;
Point2 operator-() const;
Point2& operator+=(const Point2& rhs);
Point2& operator-=(const Point2& rhs);
Point2& operator*=(const int rhs);
static const Point2 left, right, up, down;
static const Point2 upLeft, upRight, downLeft, downRight;
static const Point2 directions[8];
};

1
AdventOfCode2024/StringState.cpp
View File

@ -1 +0,0 @@
#include "StringState.h"

82
AdventOfCode2024/UnitTests/UnitTests.cpp
View File

@ -1,82 +0,0 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#include "pch.h"
#include "CppUnitTest.h"
#include "Part1TestContext.h"
#include "Part2TestContext.h"
#include "../Solver.h"
#include "../SolverEngine.h"
#include "../HistorianHysteria.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace UnitTests
{
TEST_CLASS(HistorianHysteriaTests)
{
public:
TEST_METHOD(FullData1)
{
runTest(*std::make_unique<HistorianHysteria>(), 2176849, part1TestContext_);
}
TEST_METHOD(FullData2)
{
runTest(*std::make_unique<HistorianHysteria>(), 23384288, part2TestContext_);
}
TEST_METHOD(ExampleData1)
{
runTest(*std::make_unique<HistorianHysteria>(), 11, part1ExampleTestContext_);
}
TEST_METHOD(ExampleData2)
{
runTest(*std::make_unique<HistorianHysteria>(), 31, part2ExampleTestContext_);
}
private:
Part1TestContext part1TestContext_{ getInputPaths() };
Part2TestContext part2TestContext_{ getInputPaths() };
Part1TestContext part1ExampleTestContext_{ getExampleInputPaths() };
Part2TestContext part2ExampleTestContext_{ getExampleInputPaths() };
void runTest(Solver& solver, const long long int expected, const TestContext& context)
{
SolverEngine solverEngine{ context.getInputPaths() };
solverEngine.run(solver);
assertAreEqual(expected, context.getResult(solver));
}
std::vector<std::string> getInputPaths() const
{
return std::vector<std::string>{ "../../data", "../../../../data" };
}
std::vector<std::string> getExampleInputPaths() const
{
return std::vector<std::string>{ "../../data/examples", "../../../../data/examples" };
}
void assertAreEqual(const long long int expected, const long long int actual) const
{
std::wstring message = L"Expected: <" + std::to_wstring(expected) + L"> Actual: <" + std::to_wstring(actual) + L">";
Assert::IsTrue(expected == actual, message.c_str());
}
};
}

57
CMakeLists.txt Normal file
View File

@ -0,0 +1,57 @@
cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
Include(FetchContent)
set(CMAKE_CXX_STANDARD 23) # latest c++
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
# prepare out unit test framework
FetchContent_Declare(
Catch2
GIT_REPOSITORY https://github.com/catchorg/Catch2.git
GIT_TAG v3.4.0 # or a later release
)
FetchContent_MakeAvailable(Catch2)
# Versioning
project ("AdventOfCode2024" VERSION 0.0.1 DESCRIPTION "" LANGUAGES CXX)
# ---
# Grab source files
file(GLOB_RECURSE AdventOfCode2024Sources
"include/*.h"
"include/*.hpp"
"src/*.c"
"src/*.cpp"
)
file(GLOB_RECURSE AdventOfCode2024Tests
"tests/include/*.h"
"tests/include/*.hpp"
"tests/src/*.c"
"tests/src/*.cpp"
)
# Project setup
set(output_target AdventOfCode2024)
# This is split in 2 because catch2 generates its own main() functions
# and we don't want to recompile everything twice, so we reuse the lib object.
# lib
# / \
# main exe catch2
# Library to contain logic/code
add_library(${output_target}-lib ${AdventOfCode2024Sources})
target_include_directories(${output_target}-lib PUBLIC "include")
# Executable that links to the lib containing the code
add_executable(${output_target} "AdventOfCode2024.cpp")
target_link_libraries(${output_target} PRIVATE ${output_target}-lib)
# Catch2 linked with the lib.
add_executable(${output_target}-tests ${AdventOfCode2024Tests})
target_include_directories(${output_target}-tests PRIVATE "tests/include")
target_link_libraries(${output_target}-tests PRIVATE
${output_target}-lib
Catch2::Catch2WithMain
)

8
AdventOfCode2024/HistorianHysteria.h → include/aoc/HistorianHysteria.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -17,10 +17,10 @@
#include <set> #include <set>
#include "Solver.h" #include <aoc/Solver.h>
class HistorianHysteria : class HistorianHysteria
public Solver : public Solver
{ {
public: public:
virtual std::string getPuzzleName() const override; virtual std::string getPuzzleName() const override;

8
AdventOfCode2024/MullCharState.h → include/aoc/MullCharState.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,10 +15,10 @@
#pragma once #pragma once
#include "StringState.h" #include <aoc/StringState.h>
class MullCharState : class MullCharState
public StringState : public StringState
{ {
public: public:
MullCharState(const char expected); MullCharState(const char expected);

2
AdventOfCode2024/MullData.h → include/aoc/MullData.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software

10
AdventOfCode2024/MullDataState.h → include/aoc/MullDataState.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,11 +15,11 @@
#pragma once #pragma once
#include "MullData.h" #include <aoc/MullData.h>
#include "StringState.h" #include <aoc/StringState.h>
class MullDataState : class MullDataState
public StringState : public StringState
{ {
public: public:
void setData(MullData& data); void setData(MullData& data);

8
AdventOfCode2024/MullDoOpenState.h → include/aoc/MullDoOpenState.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,10 +15,10 @@
#pragma once #pragma once
#include "MullDataState.h" #include <aoc/MullDataState.h>
class MullDoOpenState : class MullDoOpenState
public MullDataState : public MullDataState
{ {
public: public:
void enter(StringStateMachine* stateMachine) override {}; void enter(StringStateMachine* stateMachine) override {};

8
AdventOfCode2024/MullEntryState.h → include/aoc/MullEntryState.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,10 +15,10 @@
#pragma once #pragma once
#include "StringState.h" #include <aoc/StringState.h>
class MullEntryState : class MullEntryState
public StringState : public StringState
{ {
public: public:
void enter(StringStateMachine* stateMachine) override; void enter(StringStateMachine* stateMachine) override;

8
AdventOfCode2024/MullFactorState.h → include/aoc/MullFactorState.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,10 +15,10 @@
#pragma once #pragma once
#include "MullDataState.h" #include <aoc/MullDataState.h>
class MullFactorState : class MullFactorState
public MullDataState : public MullDataState
{ {
public: public:
MullFactorState(const char expected, const int index); MullFactorState(const char expected, const int index);

12
AdventOfCode2024/MullItOver.h → include/aoc/MullItOver.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,12 +15,12 @@
#pragma once #pragma once
#include "MullData.h" #include <aoc/MullData.h>
#include "MullStates.h" #include <aoc/MullStates.h>
#include "Solver.h" #include <aoc/Solver.h>
class MullItOver : class MullItOver
public Solver : public Solver
{ {
public: public:
MullItOver(); MullItOver();

12
AdventOfCode2024/MullStates.h → include/aoc/MullStates.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,11 +15,11 @@
#pragma once #pragma once
#include "MullCharState.h" #include <aoc/MullCharState.h>
#include "MullDoOpenState.h" #include <aoc/MullDoOpenState.h>
#include "MullEntryState.h" #include <aoc/MullEntryState.h>
#include "MullFactorState.h" #include <aoc/MullFactorState.h>
#include "MullToggleCloseState.h" #include <aoc/MullToggleCloseState.h>
class MullStates class MullStates
{ {

8
AdventOfCode2024/MullToggleCloseState.h → include/aoc/MullToggleCloseState.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,10 +15,10 @@
#pragma once #pragma once
#include "MullDataState.h" #include <aoc/MullDataState.h>
class MullToggleCloseState : class MullToggleCloseState
public MullDataState : public MullDataState
{ {
public: public:
MullToggleCloseState(const bool isEnabler); MullToggleCloseState(const bool isEnabler);

2
AdventOfCode2024/Program.h → include/aoc/Program.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software

4
AdventOfCode2024/RedNosedReportData.h → include/aoc/RedNosedReportData.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -17,7 +17,7 @@
#include<vector> #include<vector>
#include "Slope.h" #include <aoc/Slope.h>
class RedNosedReportData class RedNosedReportData
{ {

12
AdventOfCode2024/RedNosedReports.h → include/aoc/RedNosedReports.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,12 +15,12 @@
#pragma once #pragma once
#include "Slope.h" #include <aoc/Slope.h>
#include "Solver.h" #include <aoc/Solver.h>
#include "RedNosedReportData.h" #include <aoc/RedNosedReportData.h>
class RedNosedReports : class RedNosedReports
public Solver : public Solver
{ {
public: public:
std::string getPuzzleName() const override; std::string getPuzzleName() const override;

2
AdventOfCode2024/Slope.h → include/aoc/Slope.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software

2
AdventOfCode2024/Solver.h → include/aoc/Solver.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software

5
AdventOfCode2024/SolverEngine.h → include/aoc/SolverEngine.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -20,13 +20,14 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "Solver.h" #include <aoc/Solver.h>
class SolverEngine class SolverEngine
{ {
public: public:
SolverEngine(const std::vector<std::string>& inputPaths); SolverEngine(const std::vector<std::string>& inputPaths);
void run(Solver& solver); void run(Solver& solver);
private: private:
std::vector<std::string> inputPaths_; std::vector<std::string> inputPaths_;
std::filesystem::path tryGetValidFullInputFilePath(const std::string& inputFileName); std::filesystem::path tryGetValidFullInputFilePath(const std::string& inputFileName);

4
AdventOfCode2024/StringState.h → include/aoc/StringState.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -17,7 +17,7 @@
#include <vector> #include <vector>
#include "StringStateMachine.h" #include <aoc/StringStateMachine.h>
class StringStateMachine; class StringStateMachine;

4
AdventOfCode2024/StringStateMachine.h → include/aoc/StringStateMachine.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -17,7 +17,7 @@
#include <string> #include <string>
#include "StringState.h" #include <aoc/StringState.h>
class StringState; class StringState;

4
AdventOfCode2024/HistorianHysteria.cpp → src/HistorianHysteria.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,7 +15,7 @@
#include <iostream> #include <iostream>
#include "HistorianHysteria.h" #include <aoc/HistorianHysteria.h>
std::string HistorianHysteria::getPuzzleName() const std::string HistorianHysteria::getPuzzleName() const
{ {

4
AdventOfCode2024/MullCharState.cpp → src/MullCharState.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullCharState.h" #include <aoc/MullCharState.h>
MullCharState::MullCharState(const char expected) MullCharState::MullCharState(const char expected)
: expected_{ expected }, successState_{}, failState_{} {} : expected_{ expected }, successState_{}, failState_{} {}

4
AdventOfCode2024/MullData.cpp → src/MullData.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullData.h" #include <aoc/MullData.h>
MullData::MullData() MullData::MullData()
: isEnabled_{ true }, factor1_{ 0 }, factor2_{ 0 }, part1_{ 0 }, part2_{ 0 } {}; : isEnabled_{ true }, factor1_{ 0 }, factor2_{ 0 }, part1_{ 0 }, part2_{ 0 } {};

4
AdventOfCode2024/MullDataState.cpp → src/MullDataState.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullDataState.h" #include <aoc/MullDataState.h>
void MullDataState::setData(MullData& data) void MullDataState::setData(MullData& data)
{ {

4
AdventOfCode2024/MullDoOpenState.cpp → src/MullDoOpenState.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullDoOpenState.h" #include <aoc/MullDoOpenState.h>
void MullDoOpenState::next(StringStateMachine* stateMachine) void MullDoOpenState::next(StringStateMachine* stateMachine)
{ {

4
AdventOfCode2024/MullEntryState.cpp → src/MullEntryState.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullEntryState.h" #include <aoc/MullEntryState.h>
void MullEntryState::enter(StringStateMachine* stateMachine) void MullEntryState::enter(StringStateMachine* stateMachine)
{ {

4
AdventOfCode2024/MullFactorState.cpp → src/MullFactorState.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullFactorState.h" #include <aoc/MullFactorState.h>
MullFactorState::MullFactorState(const char expected, const int index) MullFactorState::MullFactorState(const char expected, const int index)
: expected_{ expected }, index_{ index }, successState_{}, failState_{} {} : expected_{ expected }, index_{ index }, successState_{}, failState_{} {}

6
AdventOfCode2024/MullItOver.cpp → src/MullItOver.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,8 +13,8 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullItOver.h" #include <aoc/MullItOver.h>
#include "StringStateMachine.h" #include <aoc/StringStateMachine.h>
MullItOver::MullItOver() MullItOver::MullItOver()
: Solver{}, data_{}, states_ { : Solver{}, data_{}, states_ {

4
AdventOfCode2024/MullStates.cpp → src/MullStates.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullStates.h" #include <aoc/MullStates.h>
MullStates::MullStates(MullData& data) MullStates::MullStates(MullData& data)
{ {

4
AdventOfCode2024/MullToggleCloseState.cpp → src/MullToggleCloseState.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "MullToggleCloseState.h" #include <aoc/MullToggleCloseState.h>
MullToggleCloseState::MullToggleCloseState(const bool isEnabler) MullToggleCloseState::MullToggleCloseState(const bool isEnabler)
: isEnabler_{ isEnabler }, successState_{} {} : isEnabler_{ isEnabler }, successState_{} {}

16
AdventOfCode2024/Program.cpp → src/Program.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -16,14 +16,13 @@
#include <iostream> #include <iostream>
#include <memory> #include <memory>
#include "Program.h" #include <aoc/Program.h>
#include "SolverEngine.h" #include <aoc/SolverEngine.h>
// Solver implementations in day order. // Solver implementations in day order.
#include "HistorianHysteria.h" #include <aoc/HistorianHysteria.h>
#include "RedNosedReports.h" #include <aoc/RedNosedReports.h>
#include "MullItOver.h" #include <aoc/MullItOver.h>
#include "CeresSearch.h"
void Program::run() void Program::run()
{ {
@ -37,10 +36,9 @@ void Program::runSolvers()
solverEngine.run(*std::make_unique<HistorianHysteria>()); solverEngine.run(*std::make_unique<HistorianHysteria>());
solverEngine.run(*std::make_unique<RedNosedReports>()); solverEngine.run(*std::make_unique<RedNosedReports>());
solverEngine.run(*std::make_unique<MullItOver>()); solverEngine.run(*std::make_unique<MullItOver>());
solverEngine.run(*std::make_unique<CeresSearch>());
} }
std::vector<std::string> Program::getInputPaths() const std::vector<std::string> Program::getInputPaths() const
{ {
return std::vector<std::string>{ "data", "../../data" }; return std::vector<std::string>{ "data", "../../../data", "../../../../data" };
} }

4
AdventOfCode2024/RedNosedReports.cpp → src/RedNosedReports.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -17,7 +17,7 @@
#include <sstream> #include <sstream>
#include <vector> #include <vector>
#include "RedNosedReports.h" #include <aoc/RedNosedReports.h>
std::string RedNosedReports::getPuzzleName() const std::string RedNosedReports::getPuzzleName() const
{ {

4
AdventOfCode2024/Solver.cpp → src/Solver.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "Solver.h" #include <aoc/Solver.h>
Solver::Solver() Solver::Solver()
: part1{ 0 }, part2{ 0 } {} : part1{ 0 }, part2{ 0 } {}

4
AdventOfCode2024/SolverEngine.cpp → src/SolverEngine.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -16,7 +16,7 @@
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include "SolverEngine.h" #include <aoc/SolverEngine.h>
SolverEngine::SolverEngine(const std::vector<std::string>& inputPaths) SolverEngine::SolverEngine(const std::vector<std::string>& inputPaths)
: inputPaths_{ inputPaths } {} : inputPaths_{ inputPaths } {}

4
AdventOfCode2024/StringStateMachine.cpp → src/StringStateMachine.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,7 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "StringStateMachine.h" #include <aoc/StringStateMachine.h>
StringStateMachine::StringStateMachine(const std::string& line, StringState& entryState) StringStateMachine::StringStateMachine(const std::string& line, StringState& entryState)
{ {

8
AdventOfCode2024/UnitTests/Part1TestContext.h → tests/include/aocTests/Part1TestContext.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,10 +15,10 @@
#pragma once #pragma once
#include "TestContext.h" #include <aocTests/TestContext.h>
class Part1TestContext : class Part1TestContext
public TestContext : public TestContext
{ {
public: public:
Part1TestContext(std::vector<std::string> inputPaths); Part1TestContext(std::vector<std::string> inputPaths);

8
AdventOfCode2024/UnitTests/Part2TestContext.h → tests/include/aocTests/Part2TestContext.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -15,10 +15,10 @@
#pragma once #pragma once
#include "TestContext.h" #include <aocTests/TestContext.h>
class Part2TestContext : class Part2TestContext
public TestContext : public TestContext
{ {
public: public:
Part2TestContext(std::vector<std::string> inputPaths); Part2TestContext(std::vector<std::string> inputPaths);

4
AdventOfCode2024/UnitTests/TestContext.h → tests/include/aocTests/TestContext.h
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -18,7 +18,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include <Solver.h> #include <aoc/Solver.h>
class TestContext class TestContext
{ {

5
AdventOfCode2024/UnitTests/Part1TestContext.cpp → tests/src/Part1TestContext.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,8 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "pch.h" #include <aocTests/Part1TestContext.h>
#include "Part1TestContext.h"
Part1TestContext::Part1TestContext(std::vector<std::string> inputPaths) Part1TestContext::Part1TestContext(std::vector<std::string> inputPaths)
: TestContext{ inputPaths } {} : TestContext{ inputPaths } {}

5
AdventOfCode2024/UnitTests/Part2TestContext.cpp → tests/src/Part2TestContext.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,8 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "pch.h" #include <aocTests/Part2TestContext.h>
#include "Part2TestContext.h"
Part2TestContext::Part2TestContext(std::vector<std::string> inputPaths) Part2TestContext::Part2TestContext(std::vector<std::string> inputPaths)
: TestContext{ inputPaths } {} : TestContext{ inputPaths } {}

70
tests/src/TestCases.cpp Normal file
View File

@ -0,0 +1,70 @@
// Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
#include <aocTests/Part1TestContext.h>
#include <aocTests/Part2TestContext.h>
#include <aoc/Solver.h>
#include <aoc/SolverEngine.h>
#include <aoc/HistorianHysteria.h>
#include <catch2/catch_test_macros.hpp>
#define REQUIRE_MESSAGE(cond, msg) if (!(cond)) { INFO(msg); REQUIRE(cond); }
class HistorianHysteriaTests
{
public:
Part1TestContext part1TestContext_{ getInputPaths() };
Part2TestContext part2TestContext_{ getInputPaths() };
Part1TestContext part1ExampleTestContext_{ getExampleInputPaths() };
Part2TestContext part2ExampleTestContext_{ getExampleInputPaths() };
void runTest(Solver &solver, const long long int expected, const TestContext &context)
{
SolverEngine solverEngine{context.getInputPaths()};
solverEngine.run(solver);
REQUIRE(expected == context.getResult(solver));
}
private:
std::vector<std::string> getInputPaths() const
{
return std::vector<std::string>{ "data", "../../../data", "../../../../data" };
}
std::vector<std::string> getExampleInputPaths() const
{
return std::vector<std::string>{ "data/examples", "../../../data/examples", "../../../../data/examples" };
}
};
TEST_CASE( "[HistorianHysteriaTests]" )
{
HistorianHysteriaTests tests;
SECTION( "FullData1" ) {
tests.runTest(*std::make_unique<HistorianHysteria>(), 2176849, tests.part1TestContext_);
}
SECTION( "FullData2" ) {
tests.runTest(*std::make_unique<HistorianHysteria>(), 23384288, tests.part2TestContext_);
}
SECTION( "ExampleData1" ) {
tests.runTest(*std::make_unique<HistorianHysteria>(), 11, tests.part1ExampleTestContext_);
}
SECTION( "ExampleData2" ) {
tests.runTest(*std::make_unique<HistorianHysteria>(), 31, tests.part2ExampleTestContext_);
}
}

5
AdventOfCode2024/UnitTests/TestContext.cpp → tests/src/TestContext.cpp
View File

@ -1,5 +1,5 @@
// Solutions to the Advent Of Code 2024. // Solutions to the Advent Of Code 2024.
// Copyright (C) 2024 Stefan Müller // Copyright (C) 2024 Stefan Müller
// //
// This program is free software: you can redistribute it and/or modify it under // This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software // the terms of the GNU General Public License as published by the Free Software
@ -13,8 +13,7 @@
// You should have received a copy of the GNU General Public License along with // You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>. // this program. If not, see <http://www.gnu.org/licenses/>.
#include "pch.h" #include <aocTests/TestContext.h>
#include "TestContext.h"
TestContext::TestContext(std::vector<std::string> inputPaths) TestContext::TestContext(std::vector<std::string> inputPaths)
: inputPaths_{ inputPaths } {} : inputPaths_{ inputPaths } {}