DEV Community: Rob van der Leek

Advent of Code 2025 - December 10th

Rob van der Leek — Tue, 16 Dec 2025 08:27:12 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 10th

The puzzle of day 10 was fun for part one, and very disappointing for part two. Part two requires much more time than what I have available, and perhaps also a third-party library. I only completed part one for this day 😢

My pitfall for this puzzle: Although the code for part two works for the sample input, it does not terminate for the puzzle input. From what I've peeked at solutions for this day on Reddit, most people apply Gaussian Elimination, and most use a library for it.

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <sstream>

typedef std::vector<std::vector<int>> Wiring;

struct Machine {
    Wiring wiring;
    std::string startLights;
    std::string endLights;
    std::vector<int> startJoltage;
    std::vector<int> endJoltage;
};

std::vector<Machine> loadInput(const std::string &filename) {
    std::vector<Machine> result;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        auto rSquareIndex = line.find(']');
        std::string endLights = line.substr(1, rSquareIndex - 1);
        bool inWiring = false;
        bool injoltage = false;
        std::string numberBuffer;
        Wiring wiring;
        std::vector<int> currentWiring;
        std::vector<int> endJoltage;
        for (auto i = rSquareIndex + 1; i < line.length(); ++i) {
            if (line[i] == ')') {
                inWiring = false;
                currentWiring.push_back(std::stoi(numberBuffer));
                numberBuffer.clear();
                wiring.push_back(currentWiring);
            } else if (line[i] == '(') {
                inWiring = true;
                currentWiring.clear();
            } else if (inWiring) {
                if (line[i] == ',') {
                    currentWiring.push_back(std::stoi(numberBuffer));
                    numberBuffer.clear();
                } else {
                    numberBuffer += line[i];
                }
            } else if (line[i] == '{') {
                injoltage = true;
            } else if (line[i] == '}') {
                injoltage = false;
                endJoltage.push_back(std::stoi(numberBuffer));
                numberBuffer.clear();
            } else if (injoltage) {
                if (line[i] == ',') {
                    endJoltage.push_back(std::stoi(numberBuffer));
                    numberBuffer.clear();
                } else {
                    numberBuffer += line[i];
                }
            }
        }
        result.emplace_back(Machine{wiring, std::string(endLights.length(), '.'), endLights,
                                    std::vector<int>(endJoltage.size(), 0), endJoltage});
    }
    return result;
}

std::string doMove(const std::string &current, const std::vector<int> &move) {
    std::string next = current;
    for (int i : move) {
        next[i] = current[i] == '.' ? '#' : '.';
    }
    return next;
}

int calcSteps(const Machine &m) {
    std::vector<std::string> states;
    states.push_back(m.startLights);
    int step = 1;
    while (true) {
        std::vector<std::string> nextStates;
        for (const auto &state : states) {
            for (const auto &move : m.wiring) {
                auto nextState = doMove(state, move);
                if (nextState == m.endLights) {
                    return step;
                }
                nextStates.push_back(nextState);
            }
        }
        step++;
        states = nextStates;
    }
}

std::vector<int> doMovePartTwo(const std::vector<int> &current, const std::vector<int> &move) {
    std::vector<int> next = current;
    for (int i : move) {
        next[i] = current[i] - 1;
    }
    return next;
}

std::vector<int> minElementIndices(const std::vector<int> &v) {
    std::vector<int> result;
    auto minElement = 0;
    for (int i : v) {
        if (minElement == 0) {
            minElement = i;
        } else if (i > 0 && i < minElement) {
            minElement = i;
        }
    }
    for (int i = 0; i < v.size(); ++i) {
        if (v[i] == minElement) {
            result.push_back(i);
        }
    }
    return result;
}

bool contains(const std::vector<int> &v, std::vector<int> values) {
    for (auto value : values) {
        if (std::find(v.begin(), v.end(), value) != v.end()) {
            return true;
        }
    }
    return false;
}

int calcStepsPartTwo(const Machine &m) {
    std::vector<std::vector<int>> states;
    states.push_back(m.endJoltage);
    int step = 1;
    while (true) {
        std::vector<std::vector<int>> nextStates;
        for (const auto &s : states) {
            auto indices = minElementIndices(s);
            for (const auto &w : m.wiring) {
                if (!contains(w, indices)) {
                    continue;
                }
                auto nextState = doMovePartTwo(s, w);
                if (nextState == m.startJoltage) {
                    return step;
                }
                if (*std::min_element(nextState.begin(), nextState.end()) < 0) {
                    continue;
                }
                if (std::find(nextStates.begin(), nextStates.end(), nextState) == nextStates.end()) {
                    nextStates.push_back(nextState);
                }
            }
        }
        step++;
        states = nextStates;
    }
}

void partOne() {
    const auto machines = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/10/input.txt");
    long result = 0;
    for (const auto &m : machines) {
        result += calcSteps(m);
    }
    std::cout << result << std::endl;
    assert(result == 558);
}

void partTwo() {
    const auto machines = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/10/input-small.txt");
    long result = 0;
    for (int i = 0; i < machines.size(); ++i) {
        std::cout << "Processing machine " << i + 1 << " of " << machines.size() << std::endl;
        result += calcStepsPartTwo(machines[i]);
    }
    std::cout << result << std::endl;
    assert(result == 0);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 11th

Rob van der Leek — Sat, 13 Dec 2025 22:13:02 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 11th

The puzzle of day 11 was fun and not so hard as the days before. I've completed this day before part two of December 9 and both parts of December 10.

My pitfall for this puzzle: Admittedly, I was stuck on the second part with some complex bookkeeping code. A small hint on Reddit was needed to successfully complete part two.

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <map>
#include <set>
#include <sstream>

struct Edge {
    const std::string from, to;
};

struct Graph {
    std::vector<std::string> nodes;
    std::vector<Edge> edges;
};

Graph loadInput(const std::string &filename) {
    Graph result;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        auto colonIndex = line.find(':');
        std::string fromName = line.substr(0, colonIndex);
        result.nodes.push_back(fromName);
        for (unsigned int i = colonIndex + 2; i < line.length(); i = i + 4) {
            std::string toName = line.substr(i, 3);
            result.nodes.push_back(toName);
            result.edges.push_back(Edge{fromName, toName});
        }
    }
    return result;
}

long walk(const Graph &g, const std::string &startNode, const std::string &endNode, std::set<std::string> visited,
          std::map<std::string, long> &lookupMap) {
    std::vector<std::string> next;
    for (const auto &[from, to] : g.edges) {
        if (from == startNode) {
            next.push_back(to);
        }
    }
    visited.insert(startNode);
    long result = 0;
    for (const auto &nextNode : next) {
        if (nextNode == endNode) {
            return 1;
        }
        if (visited.find(nextNode) == visited.end()) {
            if (lookupMap.find(nextNode) != lookupMap.end()) {
                result += lookupMap.at(nextNode);
            } else {
                auto count = walk(g, nextNode, endNode, visited, lookupMap);
                lookupMap.insert({nextNode, count});
                result += count;
            }
        }
    }
    return result;
}

long traces(const Graph &g, const std::string &startNode, const std::string &endNode) {
    std::map<std::string, long> lookupMap;
    return walk(g, startNode, endNode, std::set<std::string>(), lookupMap);
}

void partOne() {
    const auto graph = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/11/input.txt");
    auto result = traces(graph, "you", "out");
    std::cout << result << std::endl;
    assert(result == 662);
}

void partTwo() {
    const auto graph = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/11/input.txt");
    std::map<std::string, long> lookupMap;
    long a1 = traces(graph, "svr", "dac");
    long a2 = traces(graph, "dac", "fft");
    long a3 = traces(graph, "fft", "out");
    long b1 = traces(graph, "svr", "fft");
    long b2 = traces(graph, "fft", "dac");
    long b3 = traces(graph, "dac", "out");
    long result = a1 * a2 * a3 + b1 * b2 * b3;
    std::cout << result << std::endl;
    assert(result == 662);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 9th

Rob van der Leek — Tue, 09 Dec 2025 22:31:15 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 9th

The puzzle of day 9 was again a hairpuller. And again, I missed the deadline of completing the puzzle on the same day it was released, as I've only done part one so far.

My pitfall for this puzzle: Part two does not give the correct result for the puzzle input (it does work for the sample input). I probably miss a corner case while checking the intersection of line segments, but as I've spent already so much time on this puzzle, a fix for that is left as an exercise for the reader 😉

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <sstream>

struct Point {
    int x;
    int y;
};

std::vector<Point> loadInput(const std::string &filename) {
    std::vector<Point> result;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        auto comma = line.find(',');
        int x = std::stoi(line.substr(0, comma));
        int y = std::stoi(line.substr(comma + 1));
        result.push_back({x, y});
    }
    return result;
}

void partOne() {
    const auto points = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/09/input.txt");
    unsigned long long result = 0;
    for (int i = 0; i < points.size(); ++i) {
        for (int j = i + 1; j < points.size(); ++j) {
            auto p1 = points[i];
            auto p2 = points[j];
            long length = (p1.x > p2.x ? p1.x - p2.x : p2.x - p1.x) + 1;
            long height = (p1.y > p2.y ? p1.y - p2.y : p2.y - p1.y) + 1;
            long area = length * height;
            if (area > result) {
                result = area;
            }
        }
    }
    std::cout << result << std::endl;
    assert(result == 4729332959);
}

bool intersect(Point pA, Point pB, Point pC, Point pD) {
    auto line1Horizontal = (pA.y == pB.y);
    auto line2Horizontal = (pC.y == pD.y);
    if ((line1Horizontal && line2Horizontal) || (!line1Horizontal && !line2Horizontal)) {
        return false;
    }
    if (line1Horizontal) {
        return pC.x >= (pA.x < pB.x ? pA.x : pB.x) && pC.x <= (pA.x > pB.x ? pA.x : pB.x) &&
               pA.y > (pC.y < pD.y ? pC.y : pD.y) && pA.y < (pC.y > pD.y ? pC.y : pD.y);
    }
    return pA.x >= (pC.x < pD.x ? pC.x : pD.x) && pA.x <= (pC.x > pD.x ? pC.x : pD.x) &&
           pC.y > (pA.y < pB.y ? pA.y : pB.y) && pC.y < (pA.y > pB.y ? pA.y : pB.y);
}

bool rectIntersects(const Point p1, const Point p2, const Point p3, const Point p4, const std::vector<Point> &points) {
    for (int k = 0; k < points.size(); ++k) {
        auto p = points[k];
        auto q = (k == points.size() - 1 ? points[0] : points[k + 1]);
        if (intersect(p1, p4, p, q) || intersect(p4, p2, p, q) || intersect(p2, p3, p, q) || intersect(p3, p1, p, q)) {
            return true;
        }
    }
    return false;
}

void partTwo() {
    const auto points = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/09/input.txt");
    unsigned long long result = 0;
    for (int i = 0; i < points.size(); ++i) {
        for (int j = i + 1; j < points.size(); ++j) {
            auto p1 = points[i];
            auto p2 = points[j];
            long length = (p1.x > p2.x ? p1.x - p2.x : p2.x - p1.x) + 1;
            long height = (p1.y > p2.y ? p1.y - p2.y : p2.y - p1.y) + 1;
            long area = length * height;
            if (area > result) {
                auto p3 = Point{p1.x, p2.y};
                auto p4 = Point{p2.x, p1.y};
                if (rectIntersects(p1, p2, p3, p4, points))
                    continue;
                result = area;
            }
        }
    }
    std::cout << result << std::endl;
    assert(result == 24);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 8th

Rob van der Leek — Tue, 09 Dec 2025 12:11:55 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 8th

The puzzle of day 8 was brutal, no exaggeration. I missed the deadline of completing the puzzle on the same day it was released.

My pitfall for this puzzle: A graph approach was the only way I could think of for this puzzle, but graph code tends to be verbose (at least how I write it), and that pushed me again well over the 100 lines. Also, for part two I did a manual binary search 😳

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <set>
#include <sstream>

struct Node {
    int x, y, z;

    bool operator==(const Node &other) const {
        return x == other.x && y == other.y && z == other.z;
    }

    bool operator<(const Node &other) const {
        return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
    }
};

struct Edge {
    const Node *from, *to;
    double length;
};

struct Graph {
    std::vector<Node> nodes;
    std::vector<Edge> edges;
};

double distance(const Node &a, const Node &b) {
    return std::sqrt(std::pow(a.x - b.x, 2) + std::pow(a.y - b.y, 2) + std::pow(a.z - b.z, 2));
}

Graph loadInput(const std::string &filename) {
    Graph graph;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        auto firstComma = line.find(',');
        auto secondComma = line.find(',', firstComma + 1);
        int x = std::stoi(line.substr(0, firstComma));
        int y = std::stoi(line.substr(firstComma + 1, secondComma - firstComma - 1));
        int z = std::stoi(line.substr(secondComma + 1));
        graph.nodes.push_back(Node{x, y, z});
    }
    for (int i = 0; i < graph.nodes.size(); ++i) {
        for (int j = i + 1; j < graph.nodes.size(); ++j) {
            auto d = distance(graph.nodes[i], graph.nodes[j]);
            graph.edges.push_back(Edge{&graph.nodes[i], &graph.nodes[j], d});
        }
    }
    std::sort(graph.edges.begin(), graph.edges.end(), [](const Edge &a, const Edge &b) {
        return a.length < b.length;
    });
    return graph;
}

int walk(const std::vector<Edge> &edges, const Node &node, std::set<Node> &visited) {
    if (visited.find(node) != visited.end()) {
        return 0;
    }
    visited.insert(node);
    int count = 1;
    for (const auto &edge : edges) {
        if (*edge.from == node && visited.find(*edge.to) == visited.end()) {
            visited.insert(*edge.from);
            count += walk(edges, *edge.to, visited);
        } else if (*edge.to == node && visited.find(*edge.from) == visited.end()) {
            visited.insert(*edge.to);
            count += walk(edges, *edge.from, visited);
        }
    }
    return count;
}

void partOne() {
    auto distanceGraph = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/08/input.txt");
    constexpr int numberOfConnections = 1000;
    std::vector<Edge> edges;
    edges.reserve(numberOfConnections);
    for (int i = 0; i < numberOfConnections; ++i) {
        edges.push_back(distanceGraph.edges[i]);
    }
    std::set<Node> visited;
    std::vector<int> circuits;
    for (const auto &node : distanceGraph.nodes) {
        auto count = walk(edges, node, visited);
        if (count > 0)
            circuits.push_back(count);

    }
    sort(circuits.begin(), circuits.end(), [](int a, int b) {
        return a > b;
    });
    unsigned long result = 1;
    for (int i = 0; i < 3; ++i) {
        result *= circuits[i];
    }
    std::cout << result << std::endl;
    assert(result == 83520);
}

void partTwo() {
    const auto distanceGraph = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/08/input.txt");
    std::vector<Edge> edges;
    edges.reserve(5601);
    for (int i = 0; i < 5601; ++i) {
        edges.push_back(distanceGraph.edges[i]);
    }
    std::set<Node> visited;
    assert(walk(edges, distanceGraph.nodes[0], visited) == 1000);
    Edge edge = edges[edges.size() - 1];
    long result = edge.from->x * edge.to->x;
    std::cout << result << std::endl;
    assert(result == 1131823407);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 7th

Rob van der Leek — Sun, 07 Dec 2025 20:46:27 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 7th

The puzzle of day 7 was not that hard. My solution for part one was totally unusable for part two, but it was quite straightforward to come up with a new approach.

My pitfall for this puzzle: Maybe there is a way to solve both parts with the same approach but I did not manage to do that.

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <set>
#include <map>
#include <sstream>


std::vector<std::string> loadInput(const std::string &filename) {
    std::vector<std::string> result;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        result.push_back(line);
    }
    return result;
}

void partOne() {
    const auto lines = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/07/input.txt");
    std::set<int> beams;
    long result = 0;
    for (const auto &line : lines) {
        for (int i = 0; i < line.length(); ++i) {
            char c = line[i];
            if (c == 'S') {
                beams.insert(i);
            } else if (c == '^' && beams.count(i)) {
                result++;
                beams.erase(i);
                beams.insert(i - 1);
                beams.insert(i + 1);
            }
        }
    }
    std::cout << result << std::endl;
    assert(result == 1507);
}

long trackBeam(std::vector<std::string> lines, int i, int j, std::map<std::pair<int, int>, long> &p) {
    if (i == lines.size() - 1) {
        return 1;
    }
    if (lines[i][j] == '^') {
        if (p.count({i, j})) {
            return p.at({i, j});
        }
        long traces = trackBeam(lines, i + 1, j - 1, p) + trackBeam(lines, i + 1, j + 1, p);
        p[{i, j}] = traces;
        return traces;
    }
    return trackBeam(lines, i + 1, j, p);
}

void partTwo() {
    const auto lines = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/07/input.txt");
    std::map<std::pair<int, int>, long> p;
    long result = 0;
    for (int j = 0; j < lines[0].length(); ++j) {
        char c = lines[0][j];
        if (c == 'S') {
            result = trackBeam(lines, 0, j, p);
            break;
        }
    }
    std::cout << result << std::endl;
    assert(result == 1537373473728);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 6th

Rob van der Leek — Sat, 06 Dec 2025 22:59:32 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 6th

I underestimated The puzzle of day 6 completely. Just finished in time.

My pitfall for this puzzle: Could not get the solutions for both parts to fit in 100 lines 😞

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <numeric>
#include <regex>
#include <sstream>

std::vector<std::string> loadInput(const std::string &filename) {
    std::vector<std::string> result;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        result.push_back(line);
    }
    return result;
}

std::vector<std::vector<long>> loadNumbersPartOne(const std::vector<std::string> &lines) {
    std::vector<std::vector<long>> result;
    for (int i = 0; i < lines.size() - 1; ++i) {
        std::vector<long> row;
        std::regex del("\\s+");
        std::sregex_token_iterator iter(lines[i].begin(), lines[i].end(), del, -1);
        std::sregex_token_iterator end;
        while (iter != end) {
            auto value = iter->str();
            if (!value.empty()) {
                row.push_back(std::stol(value));
            }
            ++iter;
        }
        result.push_back(row);
    }
    return result;
}

std::vector<std::vector<long>> loadNumbersPartTwo(const std::vector<std::string> &lines) {
    std::vector<std::vector<long>> result;
    std::vector<std::string> rotated(lines.size(), "");
    std::vector<long> v;
    for (int j = 0; j < lines[0].length() + 3; ++j) {
        std::stringstream ss;
        for (int k = 0; k < lines.size() - 1; ++k) {
            if (j >= lines[k].length()) {
                continue;
            }
            auto c = lines[k][j];
            if (c != ' ') {
                ss << lines[k][j];
            }
        }
        auto col = ss.str();
        if (col.empty()) {
            if (!v.empty()) {
                result.push_back(v);
                v = std::vector<long>();
            }
        } else {
            v.push_back(stol(col));
        }
    }
    return result;
}

std::vector<char> loadOperators(const std::string &line) {
    std::vector<char> result;
    std::regex del("\\s+");
    std::sregex_token_iterator iter(line.begin(), line.end(), del, -1);
    std::sregex_token_iterator end;
    while (iter != end) {
        auto value = iter->str();
        if (!value.empty()) {
            result.push_back(value[0]);
        }
        ++iter;
    }
    return result;
}

void partOne() {
    const auto input = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/06/input.txt");
    const auto numbers = loadNumbersPartOne(input);
    const auto operators = loadOperators(input[input.size() - 1]);
    std::vector<long> totals(numbers[0].size(), 0);
    for (const auto &row : numbers) {
        for (int j = 0; j < row.size(); ++j) {
            if (totals[j] == 0) {
                totals[j] = row[j];
            } else if (operators[j] == '+') {
                totals[j] = totals[j] + row[j];
            } else if (operators[j] == '*') {
                totals[j] = totals[j] * row[j];
            }
        }
    }
    long result = std::reduce(totals.begin(), totals.end());
    std::cout << result << std::endl;
    assert(result == 7229350537438);
}

void partTwo() {
    const auto input = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/06/input.txt");
    const auto columns = loadNumbersPartTwo(input);
    const auto operators = loadOperators(input[input.size() - 1]);
    std::vector<long> totals(columns.size(), 0);
    for (int j = 0; j < columns.size(); ++j) {
        if (operators[j] == '+') {
            totals[j] = std::reduce(columns[j].begin(), columns[j].end(), 0L);
        } else if (operators[j] == '*') {
            totals[j] = std::reduce(columns[j].begin(), columns[j].end(), 1L, std::multiplies{});
        }
    }
    long result = std::reduce(totals.begin(), totals.end());
    std::cout << result << std::endl;
    assert(result == 7229350537438);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 5th

Rob van der Leek — Fri, 05 Dec 2025 09:28:07 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 5th

The puzzle of day 5 took me about 30 minutes. The numbers for the puzzle input are big (much bigger than the example), but still fit a long so no need to have custom code for that.

My pitfall for this puzzle: My solution is simplistic and long (just below 100 lines). It wasn't a very satisfying puzzle today, to be honest.

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <sstream>

std::vector<std::pair<long, long>> loadRanges(const std::string &filename) {
    std::vector<std::pair<long, long>> result;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        if (line.empty()) {
            break;
        }
        long start = std::stol(line.substr(0, line.find('-')));
        long end = std::stol(line.substr(line.find('-') + 1));
        result.emplace_back(start, end);
    }
    std::sort(result.begin(), result.end(), [](const auto &a, const auto &b) {
        return a.first < b.first;
    });
    return result;
}

std::vector<long> loadIds(const std::string &filename) {
    std::vector<long> result;
    std::ifstream file(filename);
    std::string line;
    bool parseIds = false;
    while (std::getline(file, line)) {
        if (line.empty()) {
            parseIds = true;
            continue;
        }
        if (parseIds) {
            long id = std::stol(line);
            result.push_back(id);
        }
    }
    return result;
}

void partOne() {
    std::string filename("/Users/rob/projects/robvanderleek/adventofcode/2025/05/input.txt");
    const auto ids = loadIds(filename);
    const auto ranges = loadRanges(filename);
    long result = 0;
    for (const auto &id : ids) {
        for (const auto &[start, end] : ranges) {
            if (id >= start && id <= end) {
                result++;
                break;
            }
        }
    }
    std::cout << result << std::endl;
    assert(result == 558);
}

std::vector<std::pair<long, long>> mergeRanges(const std::vector<std::pair<long, long>> &ranges) {
    std::vector<std::pair<long, long>> result;
    auto [start, end] = ranges[0];
    for (int i = 1; i < ranges.size(); ++i) {
        auto [nextStart, nextEnd] = ranges[i];
        if (nextStart > end) {
            result.emplace_back(start, end);
            start = nextStart;
            end = nextEnd;
        } else if (nextEnd > end) {
            end = nextEnd;
        }
    }
    result.emplace_back(start, end);
    return result;
}

void partTwo() {
    auto ranges = loadRanges("/Users/rob/projects/robvanderleek/adventofcode/2025/05/input.txt");
    auto mergedRanges = mergeRanges(ranges);
    long result = 0;
    for (auto [first, end] : mergedRanges) {
        result += end - first + 1;
    }
    std::cout << result << std::endl;
    assert(result == 344813017450467);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 4th

Rob van der Leek — Thu, 04 Dec 2025 17:06:24 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 4th

The puzzle of day 4 was pretty straightforward. I guess it's possible to use a single pass, instead of an iterative approach, but I did not have the time to look into that.

My pitfall for this puzzle: The C++ std::string::substr method takes a start and length argument. Who would have known?! I expected a start and non-inclusive end argument. That took me some debug headaches 🤯

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <sstream>


std::vector<std::string> loadInput(const std::string &filename) {
    std::vector<std::string> result;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        result.push_back(line);
    }
    return result;
}

bool canAccess(const std::vector<std::string> &grid, int row, int col) {
    int rolls = 0;
    std::stringstream ss;
    if (row > 0) {
        const std::string &topRow = grid[row - 1];
        ss << topRow.substr(std::max(0, col - 1), col == 0 ? 2 : 3);
    }
    ss << grid[row].substr(std::max(0, col - 1), col == 0 ? 2 : 3);
    if (row < grid.size() - 1) {
        const std::string &bottomRow = grid[row + 1];
        ss << bottomRow.substr(std::max(0, col - 1), col == 0 ? 2 : 3);
    }
    const std::string neighborsStr = ss.str();
    for (const char c : neighborsStr) {
        if (c == '@') {
            rolls++;
        }
    }
    return rolls - 1 /* self */ < 4;
}

std::vector<std::string> processGrid(std::vector<std::string> &grid) {
    std::vector<std::string> result;
    for (int rowIdx = 0; rowIdx < grid.size(); ++rowIdx) {
        std::string row = grid[rowIdx];
        std::string nextRow = row;
        for (int colIdx = 0; colIdx < row.length(); ++colIdx) {
            auto element = row[colIdx];
            if (element == '@' && canAccess(grid, rowIdx, colIdx)) {
                nextRow[colIdx] = '.';
                grid[rowIdx] = row;
            }
        }
        result.push_back(nextRow);
    }
    return result;
}

int countGrid(std::vector<std::string> &grid) {
    int result = 0;
    for (int rowIdx = 0; rowIdx < grid.size(); ++rowIdx) {
        for (int colIdx = 0; colIdx < grid[rowIdx].length(); ++colIdx) {
            if (grid[rowIdx][colIdx] == '@') {
                ;
                result++;
            }
        }
    }
    return result;
}

void partOne() {
    auto grid = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/04/input.txt");
    auto startCount = countGrid(grid);
    auto nextGrid = processGrid(grid);
    auto nextCount = countGrid(nextGrid);
    int result = startCount - nextCount;
    std::cout << result << std::endl;
    assert(result == 1495);
}

void partTwo() {
    auto grid = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/04/input.txt");
    auto startCount = countGrid(grid);
    auto nextGrid = processGrid(grid);
    auto previousCount = startCount;
    auto nextCount = countGrid(nextGrid);
    while (nextCount < previousCount) {
        previousCount = nextCount;
        nextGrid = processGrid(nextGrid);
        nextCount = countGrid(nextGrid);
    }
    long result = startCount - nextCount;
    std::cout << result << std::endl;
    assert(result == 8768);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 3rd

Rob van der Leek — Wed, 03 Dec 2025 16:19:52 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 3rd

The puzzle of day 3 was a nice challenge. Of course, my simplistic solution for part one failed miserably when faced with the requirements of part two. Luckily, in the end I could solve both parts with a single function, which is always satisfying.

My pitfall for this puzzle: Some stupid C++ mistakes. At some moment, I also began to doubt equality logic for std::pair, but a bit of debugging showed the error was in a different part of the code.

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <map>
#include <sstream>


std::vector<std::string> loadInput(const std::string &filename) {
    std::vector<std::string> result;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        result.push_back(line);
    }
    return result;
}

long largestJoltage(const std::string &bank, int length,
                    std::map<std::pair<std::string, int>, long> &lookupMap) {
    if (lookupMap.count(std::make_pair(bank, length))) {
        return lookupMap[std::make_pair(bank, length)]; // return cached result
    }
    long result = 0;
    for (int i = 0; i < bank.length(); ++i) {
        long prefix = static_cast<long>((bank[i] - '0') * pow(10, length - 1));
        long candidate = prefix;
        if (bank.length() - i < length) {
            continue;
        }
        if (length > 1) {
            long suffix = largestJoltage(bank.substr(i + 1), length - 1, lookupMap);
            candidate += suffix;
        }
        if (candidate > result) {
            result = candidate;
        }
    }
    lookupMap[std::make_pair(bank, length)] = result;
    return result;
}


void partOne() {
    const auto banks = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/03/input.txt");
    long result = 0;
    for (const auto &bank : banks) {
        std::map<std::pair<std::string, int>, long> lookupMap = {};
        result += largestJoltage(bank, 2, lookupMap);
    }
    std::cout << result << std::endl;
    assert(result == 17087);
}

void partTwo() {
    const auto banks = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/03/input.txt");
    long result = 0;
    for (const auto &bank : banks) {
        std::map<std::pair<std::string, int>, long> lookupMap = {};
        result += largestJoltage(bank, 12, lookupMap);
    }
    std::cout << result << std::endl;
    assert(result == 169019504359949);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 2nd

Rob van der Leek — Tue, 02 Dec 2025 20:08:36 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

Check the first post for a short intro to this series.

You can also follow my progress on GitHub.

December 2nd

The puzzle of day 2 was not that hard. I feared my simplistic solution for part one would not cut it for part two, but it was actually pretty easy to create a new isInvalidId function for part two, and retrofit that to part one 😅

My pitfall for this puzzle: Had to look a couple of C++ tips & tricks, but nothing major.

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>
#include <sstream>


void extractRange(const std::string &range, std::vector<std::string> &result) {
    const auto from = std::stol(range.substr(0, range.find('-')));
    const auto to = std::stol(range.substr(range.find('-') + 1));
    for (auto i = from; i <= to; ++i) {
        result.push_back(std::to_string(i));
    }
}

std::vector<std::string> loadInput(const std::string &filename) {
    std::vector<std::string> result;
    std::ifstream file(filename);
    std::string line;
    std::getline(file, line);
    size_t pos = 0;
    while ((pos = line.find(',')) != std::string::npos) {
        auto range = line.substr(0, pos);
        extractRange(range, result);
        line.erase(0, pos + 1);
    }
    extractRange(line, result);
    return result;
}


bool isInvalidId(const std::string &id, const size_t maxParts = 2) {
    for (int i = 2; i <= maxParts; ++i) {
        if (id.length() % i == 0) {
            auto s = std::string();
            auto part = id.substr(0, id.length() / i);
            std::ostringstream os;
            for (int j = 0; j < i; j++) {
                os << part;
            }
            if (id == os.str()) {
                return true;
            }
        }
    }
    return false;
}

void partOne() {
    const auto ids = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/02/input.txt");
    long result = 0;
    for (const auto &id : ids) {
        if (isInvalidId(id)) {
            result += std::stol(id);
        }
    }
    std::cout << result << std::endl;
    assert(result == 5398419778);
}

void partTwo() {
    const auto ids = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/02/input.txt");
    long long result = 0;
    for (const auto &id : ids) {
        if (isInvalidId(id, id.length())) {
            result += std::stol(id);
        }
    }
    std::cout << result << std::endl;
    assert(result == 15704845910);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

Advent of Code 2025 - December 1st

Rob van der Leek — Mon, 01 Dec 2025 15:37:10 +0000

In this series, I'll share my progress with the 2025 version of Advent of Code.

I'll try to post my solution to the puzzle on the day it's unlocked on the website. Let's see how far I get this year. The previous year I did not participate, and in 2023 I did make it to the end, but well after December 25...
Good for me this year: only 12 days of puzzles, so I really plan on finishing before x-mas.

My solutions are not the most sophisticated, or the smallest, or the fastest, etc. I only have an hour or so each day to work on the puzzles. Still, I hope you like reading along with my coding adventures, and perhaps compare your solutions with mine, let me know in the comments below!

You can also follow my progress on GitHub.

A bit on my setup

This year, I'll be using C++. The main reason to pick C++ is that I want to catch up with language features that have been introduced in the last 5 10 15 20 years.

Rules I try to adhere to:

I write all the code in a single file (main.cpp) using the JetBrains CLion IDE (an IDE because I really need the autocomplete/linter support for my rusty C++ skills)
A solution should be less than 100 lines, if it's bigger I try to refactor/be smarter
I only use code from the standard C++ library, no third-party libraries
I only use Google/StackOverflow/Claude for basic C++ language stuff, no complete solutions 😇

December 1st

The puzzle of day 1 did not take me that long. Quite a soft landing this year 😄

My pitfall for this puzzle: I wanted to use a more elegant Dequeue implementation, but in the end stuck with the ugly if-then-else solution.

Solution here, do not click if you want to solve the puzzle first yourself

#include <cassert>
#include <fstream>
#include <iostream>

std::vector<std::pair<char, int>> loadInput(const std::string &filename) {
    std::vector<std::pair<char, int>> instructions;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        char direction = line[0];
        int distance = std::stoi(line.substr(1));
        instructions.emplace_back(direction, distance);
    }
    return instructions;
}

int calculateZeros(const std::vector<std::pair<char, int>> &instructions, const bool countPassZero = false) {
    int dial = 50;
    int zeros = 0;
    for (auto i : instructions) {
        auto [direction, count] = i;
        if (count >= 100) {
            if (countPassZero) {
                zeros += count / 100;
            }
            count = count % 100;
        }
        if (direction == 'L') {
            int nextDial = dial - count;
            if (nextDial < 0) {
                if (countPassZero && dial > 0) {
                    zeros++;
                }
                nextDial = 100 + nextDial;
            }
            dial = nextDial;
        } else {
            int nextDial = dial + count;
            if (nextDial >= 100) {
                if (countPassZero && nextDial != 100) {
                    zeros++;
                }
                nextDial = nextDial % 100;
            }
            dial = nextDial;
        }
        if (dial == 0) {
            zeros++;
        }
    }
    return zeros;
}

void partOne() {
    auto instructions = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/01/input.txt");
    auto result = calculateZeros(instructions);
    std::cout << result << std::endl;
    assert(result == 1064);
}

void partTwo() {
    const auto instructions = loadInput("/Users/rob/projects/robvanderleek/adventofcode/2025/01/input.txt");
    const auto result = calculateZeros(instructions, true);
    std::cout << result << std::endl;
    assert(result == 6122);
}

int main() {
    partOne();
    partTwo();
    return 0;
}

That's it! See you again tomorrow!

GitHub CLI Extension for Conventional Commits

Rob van der Leek — Fri, 25 Oct 2024 12:19:18 +0000

A new GitHub CLI extension called gh-cc makes it easy to turn all your commits into conventional commits.
Read below about the advantages of using conventional commits, or skip ahead to the installation section.

Improving your commit history

Conventional Commits is a guideline to improve the readability of commit messages. For example, if a commit fixes a bug in the code, a normal commit message looks like this:

Do not crash on empty index field

The same commit message, but now in a conventional style, looks like this:

fix: 🐛 Do not crash on empty index field

The prefix helps both humans and machines to better understand the main intent of the commit.

Improved readability for humans

Compare the git histories (git log --oneline) below, which one is easier to grasp?

Normal commit log:

36d23b5 Add filter for new matches
d5d96ee Do not crash on empty index field
4f0f722 Keep less data in memory
70fcb38 Update dependencies
b5432ee Bump version to 0.15.0
b69b9c4 Update FAQ section

Conventional commit log:

36d23b5 feat: ✨ Add filter for new matches
d5d96ee fix: 🐛 Do not crash on empty index field
4f0f722 perf: ⚡️ Keep less data in memory
70fcb38 build: ⬆️ Update dependencies
b5432ee build: 🔖 Bump version to 0.15.0
b69b9c4 docs: 📝 Update FAQ section

Improved readability for machines

Because conventional commits add a consistent prefix to your commit messages, automated tools can parse this prefix and use it for other nice things. One of these things is making your project follow the Semantic Versioning specification by automatically creating semantic releases. The screenshot below shows how pretty your generated release documentation becomes by using conventional commmits:

Installation

If you have the GitHub CLI up and running, installing the extension is as simple as:

gh ext install robvanderleek/gh-cc

Usage

Type the following inside any cloned repository:

gh cc -am "commit message here"

This extension passes all arguments on to git commit, so to save typing you can add the following alias to your shell configuration: alias gc="gh cc". The command above then becomes:

gc -am "commit message here"

That's it!

Request for feedback

This GH CLI extension implements the Angular convention for commit types, combined with gitmojis. It does not support scopes, or message bodies. For feedback, suggestions and bug reports, please open an issue.

Examples of more advanced tools for conventional commits can be found here.

Cover image by BRRT from Pixabay