feiko/aoc25
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Day5

Browse source
This commit is contained in:
Feiko Wielsma 2025-12-06 20:36:52 +00:00
parent 840f236c60
commit 43448aaeb6
9 changed files with 1434 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

12
.devcontainer/Dockerfile
View file

@ -13,8 +13,20 @@ RUN apt-get update \
python3 \
python3-pip \
ca-certificates \
curl \
wget \
tmux \
ripgrep \
fd-find \
unzip \
&& rm -rf /var/lib/apt/lists/*
RUN curl -LO https://github.com/neovim/neovim/releases/download/stable/nvim-linux-x86_64.tar.gz \
&& rm -rf /opt/nvim \
&& tar -C /opt -xzf nvim-linux-x86_64.tar.gz \
&& ln -sf /opt/nvim-linux-x86_64/bin/nvim /usr/local/bin/nvim \
&& rm nvim-linux-x86_64.tar.gz
# Create workspace folder (VS Code devcontainer convention)
ARG WORKSPACE_FOLDER=/workspaces/aoc25
RUN mkdir -p ${WORKSPACE_FOLDER} && chown -R root:root ${WORKSPACE_FOLDER}

2
.devcontainer/devcontainer.json
View file

@ -14,7 +14,7 @@
"ms-vscode.cpptools",
"ms-vscode.cmake-tools",
"llvm-vs-code-extensions.vscode-clangd",
"xaver.clang-format"
"vadimcn.vscode-lldb"
],
"postCreateCommand": "cmake -S . -B build || true"
}

1
CMakeLists.txt
View file

@ -38,4 +38,5 @@ add_subdirectory(day1)
add_subdirectory(day2)
add_subdirectory(day3)
add_subdirectory(day4)
add_subdirectory(day5)

160
day2/main.cpp
View file

@ -1,35 +1,32 @@
#include <iostream>
#include <fstream>
#include <string>
#include <string_view>
#include <vector>
#include <algorithm>
#include <expected>
#include <fstream>
#include <iostream>
#include <print>
#include <ranges>
#include <array>
#include <map>
#include <numeric>
#include <functional>
#include <algorithm>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
struct IDRange {
long leftRange;
long rightRange;
};
auto parseRanges(const std::string& filename) -> std::expected<std::vector<IDRange>, std::string> {
std::ifstream inputF {filename};
if (!inputF){
auto parseRanges(const std::string &filename) -> std::expected<std::vector<IDRange>, std::string> {
std::ifstream inputF{filename};
if (!inputF) {
return std::unexpected{"Some file open error.\n"};
}
std::vector<IDRange> idRanges{};
std::vector<IDRange> idRanges{};
std::string bigString{};
std::getline(inputF,bigString);
std::getline(inputF, bigString);
auto ranges = std::ranges::to<std::vector<std::string>>(std::views::split(bigString, ','));
for(const auto& range : ranges){
for (const auto &range : ranges) {
auto subParts = std::ranges::to<std::vector<std::string>>(std::views::split(range, '-'));
idRanges.emplace_back(std::stol(subParts[0]), std::stol(subParts[1]));
}
@ -39,115 +36,106 @@ auto parseRanges(const std::string& filename) -> std::expected<std::vector<IDRan
return std::move(idRanges);
}
auto countDoubles(const std::vector<IDRange>& idRanges) {
auto countDoubles(const std::vector<IDRange> &idRanges) {
long doubles{};
for(const auto& rng : idRanges){
//std::println("{}-{}", rng.leftRange, rng.rightRange);
for( long i = rng.leftRange; i <= rng.rightRange; i++){
auto str_version = std::to_string(i) ;
for (const auto &rng : idRanges) {
// std::println("{}-{}", rng.leftRange, rng.rightRange);
for (long i = rng.leftRange; i <= rng.rightRange; i++) {
auto str_version = std::to_string(i);
auto str_len = str_version.size();
//std::print("Checking {}. Length: {}", str_version, str_version.size());
// std::print("Checking {}. Length: {}", str_version, str_version.size());
if (str_len % 2 == 0) {
//std::print(" Divisible by two, splitting...");
std::string_view left_half = std::string_view(str_version).substr(0, str_len/2);
std::string_view right_half = std::string_view(str_version).substr(str_len/2, str_len);
//std::print("Halves: {}/{}",left_half, right_half);
if(left_half == right_half){
//std::print(" EQUAL!");
// std::print(" Divisible by two, splitting...");
std::string_view left_half = std::string_view(str_version).substr(0, str_len / 2);
std::string_view right_half = std::string_view(str_version).substr(str_len / 2, str_len);
// std::print("Halves: {}/{}",left_half, right_half);
if (left_half == right_half) {
// std::print(" EQUAL!");
doubles += i;
}
}
//std::println();
// std::println();
}
}
return doubles;
}
}
auto calculatePossibleSplits(int length) -> std::vector<int>{
//std::println("Possible ways to split a str of length {}: ", length);
auto calculatePossibleSplits(int length) -> std::vector<int> {
// std::println("Possible ways to split a str of length {}: ", length);
std::vector<int> returnVec{};
for(auto toCheck : std::views::iota(2, length+1)){
if(length % toCheck == 0)
{
//std::println("{}", toCheck);
for (auto toCheck : std::views::iota(2, length + 1)) {
if (length % toCheck == 0) {
// std::println("{}", toCheck);
returnVec.push_back(toCheck);
}
}
return std::move(returnVec);
}
std::unordered_map<int, std::vector<int>> splitMap{};
auto getPossibleSplits(int length) -> const std::vector<int>&{
if(!splitMap.contains(length)){
//std::println("Caching {}",length);
auto getPossibleSplits(int length) -> const std::vector<int> & {
if (!splitMap.contains(length)) {
// std::println("Caching {}",length);
splitMap[length] = calculatePossibleSplits(length);
}
return splitMap.at(length);
}
auto countRepeats(const std::vector<IDRange>& idRanges) {
auto countRepeats(const std::vector<IDRange> &idRanges) {
long doubles{};
for(const auto& rng : idRanges){
//std::println("{}-{}", rng.leftRange, rng.rightRange);
for( long i = rng.leftRange; i <= rng.rightRange; i++){
auto str_version = std::to_string(i) ;
for (const auto &rng : idRanges) {
// std::println("{}-{}", rng.leftRange, rng.rightRange);
for (long i = rng.leftRange; i <= rng.rightRange; i++) {
auto str_version = std::to_string(i);
auto str_len = str_version.size();
//std::print("Checking {}. Length: {} ", str_version, str_version.size());
// std::print("Checking {}. Length: {} ", str_version, str_version.size());
std::vector<int> numsToCheck = getPossibleSplits(str_len);
//std::println("Possible splits: {}", numsToCheck);
for (int checkNum : numsToCheck)
{
//std::print("Splitting in {}: ", checkNum);
std::vector<std::string_view> splits(checkNum);
for(auto toCheck : std::views::iota(0, checkNum)){
auto window = str_len/checkNum;
splits[toCheck] = std::string_view(str_version).substr(toCheck*window, window);
//std::print("[{}]: {} /{} ", toCheck, splits[toCheck], window);
const std::vector<int> &numsToCheck = getPossibleSplits(str_len);
// std::println("Possible splits: {}", numsToCheck);
for (int checkNum : numsToCheck) {
// std::print("Splitting in {}: ", checkNum);
std::vector<std::string_view> splits(checkNum);
for (auto toCheck : std::views::iota(0, checkNum)) {
auto window = str_len / checkNum;
splits[toCheck] = std::string_view(str_version).substr(toCheck * window, window);
// std::print("[{}]: {} /{} ", toCheck, splits[toCheck], window);
}
if(std::equal(splits.begin() + 1, splits.end(), splits.begin())){
//std::print(" EQUAL!");
if (std::equal(splits.begin() + 1, splits.end(), splits.begin())) {
// std::print(" EQUAL!");
doubles += i;
break;
}
//std::println();
// std::println();
}
//std::println();
// std::println();
}
//std::println();
// std::println();
}
return doubles;
}
}
auto main() -> int {
auto testCase = parseRanges("test_input");
if(testCase) {
auto testResult = countDoubles(*testCase);
auto testResultP2 = countRepeats(*testCase);
std::println("P1 Testcase result: {}", testResult);
std::println("P2 Testcase result: {}", testResultP2);
if (testCase) {
auto testResult = countDoubles(*testCase);
auto testResultP2 = countRepeats(*testCase);
std::println("P1 Testcase result: {}", testResult);
std::println("P2 Testcase result: {}", testResultP2);
} else {
std::print("{}\n", testCase.error());
}
else{
std::print("{}\n", testCase.error());
}
auto realRanges = parseRanges("puzzle_input");
if(realRanges) {
//auto realResult = countDoubles(*realRanges);
auto realResultP2 = countRepeats(*realRanges);
//std::println("P1 Real result: {}", realResult);
std::println("P2 Real result: {}", realResultP2);
if (realRanges) {
// auto realResult = countDoubles(*realRanges);
auto realResultP2 = countRepeats(*realRanges);
// std::println("P1 Real result: {}", realResult);
std::println("P2 Real result: {}", realResultP2);
} else {
std::print("{}\n", realRanges.error());
}
else{
std::print("{}\n", realRanges.error());
}
return 0;
}

3
day4/main.cpp
View file

@ -19,7 +19,6 @@ struct Diagram {
auto grid() { return GridView(data.data(), height, width); }
};
namespace {
auto printMap(Diagram &diagram) {
auto grid = diagram.grid();
for (auto row = 0UZ; row != grid.extent(0); row++) {
@ -137,7 +136,7 @@ auto moveMoveablePaper(Diagram &diagram) -> long {
return totalPaperRemoved;
}
} // namespace
auto main() -> int {
auto testCase = parseMap("test_input");
if (testCase) {

2
day5/CMakeLists.txt Normal file
View file

@ -0,0 +1,2 @@
# Use top-level helper to add the target and copy input files
aoc_add_day(day5 "${CMAKE_CURRENT_SOURCE_DIR}" main.cpp)

144
day5/main.cpp Normal file
View file

@ -0,0 +1,144 @@
#include <algorithm>
#include <array>
#include <cstddef>
#include <expected>
#include <fstream>
#include <iostream>
#include <list>
#include <mdspan>
#include <print>
#include <ranges>
#include <set>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
// struct FreshRange {
// long long left;
// long long right;
// };
using FreshRange = std::pair<long long, long long>;
struct PuzzleInput {
std::vector<FreshRange> freshRanges;
std::vector<long long> ingredients;
};
static auto parseInput(const std::string &filename) -> std::expected<PuzzleInput, std::string> {
std::ifstream inputF{filename};
if (!inputF) {
return std::unexpected{"Some file open error.\n"};
}
PuzzleInput puzzleInput{};
std::string puzzleLine{};
while (std::getline(inputF, puzzleLine)) {
if (puzzleLine.empty()) {
std::println("Empty string");
break;
}
auto subParts = std::ranges::to<std::vector<std::string>>(std::views::split(puzzleLine, '-'));
puzzleInput.freshRanges.emplace_back(std::stoll(subParts[0]), std::stoll(subParts[1]));
std::println("Range: {}", subParts);
}
while (std::getline(inputF, puzzleLine)) {
// std::println("Ingredient: {}", puzzleLine);
puzzleInput.ingredients.emplace_back(std::stoll(puzzleLine));
}
// std::println("Ranges: {}\nIngredients: {}", puzzleInput.ingredients, puzzleInput.ingredients);
return std::move(puzzleInput);
}
static auto countFreshIngredients(const PuzzleInput &puzzleInput) -> long long {
const auto &freshRanges = puzzleInput.freshRanges;
const auto &ingredients = puzzleInput.ingredients;
long long totalFresh{};
std::println("Ranges: {}\nIngredients: {}", ingredients, ingredients);
for (const auto ingredient : ingredients) {
std::println("Checking {}", ingredient);
for (const auto &range : freshRanges) {
if (ingredient >= range.first && ingredient <= range.second) {
std::println("{} fits in range: {}:{}", ingredient, range.first, range.second);
totalFresh += 1;
break;
}
}
}
return totalFresh;
}
static long long countAll(const std::ranges::range auto &ranges) {
std::println("Final count:\n\n");
long long bigNum{};
for (const auto &range : ranges) {
std::println("{}:{}", range.first, range.second);
if (range == FreshRange(-1, -1)) {
continue;
}
bigNum += range.second - range.first + 1;
}
return bigNum;
}
static auto countFreshIngredientsRange(std::vector<FreshRange> &ranges) -> long long {
std::ranges::sort(ranges);
std::list<FreshRange> rangeList;
rangeList.assign_range(ranges);
auto cur = rangeList.begin();
while (true) {
auto next = std::next(cur);
std::println("Starting with {}", *cur);
if (next == rangeList.end()) { // No need to compare against the end
break;
}
if (cur->second >= next->first) {
std::println("\t Merging! {}", *next);
cur->second = std::max(cur->second, next->second);
rangeList.erase(next);
} else {
cur++;
}
}
return countAll(rangeList);
}
auto main() -> int {
auto testCase = parseInput("test_input");
if (testCase) {
// auto testResult = countFreshIngredients(*testCase);
// std::println("P1 Testcase result: {}", testResult);
auto testResultP2 = countFreshIngredientsRange((*testCase).freshRanges);
std::println("P2 Testcase result: {}", testResultP2);
} else {
std::print("{}\n", testCase.error());
}
auto realPuzzle = parseInput("puzzle_input");
if (realPuzzle) {
// auto realResult = countFreshIngredients(*realPuzzle);
// std::println("P1 Real result: {}", realResult);
auto realResultP2 = countFreshIngredientsRange((*realPuzzle).freshRanges);
std::println("P2 Real result: {}", realResultP2);
} else {
std::print("{}\n", realPuzzle.error());
}
return 0;
}

1187
day5/puzzle_input Normal file
View file

File diff suppressed because it is too large Load diff

12
day5/test_input Normal file
View file

@ -0,0 +1,12 @@
3-5
10-14
10-13
16-20
12-18
1
5
8
11
17
32