Marketing Pitch and Impressions#

C++ was designed with systems programming and embedded, resource-constrained software and large systems in mind, with performance, efficiency, and flexibility of use as its design highlights. C++ has also been found useful in many other contexts, with key strengths being software infrastructure and resource-constrained applications, including desktop applications, video games, servers (e.g., e-commerce, web search, or databases), and performance-critical applications (e.g., telephone switches or space probes).

— wikipedia.org

C++ is a surprisingly long-lived language having been around for more than 40 years now. It’s core philosophy is to provide developers with maximum degree of control over system resources, including CPU and memory. Unsurprisingly, this level of control comes with significant complexity. One of the often heard maxims in the C++ world is “you only pay for what you use.”

Visual Studio Code support for C++ is excellent, as you might expect.

The Code#

I’ve written quite a bit of C++ code over the years, but I have not used it much recently. I was looking forward to putting the code together for this problem but as it turned out, this was one of the more fiddly problems to solve this year.

The solution makes use of std::ranges and std::views to form a processing pipeline. I’ve implemented a custom pipeline operator to apply the supply the applied operation to the provided numbers.

Both part 1 and part 2 are calculated in the same way, but differing orientations. For both parts, columnar boundaries are established. Then part 1 applies the supplied operator to horizontal substrings arranged in rows. Part 2 applies the same operator to vertical substrings arranged in columns.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#include <ranges>
#include <string>
#include <vector>
#include <fstream>
#include <numeric>
#include <iostream>
#include <algorithm>
#include <functional>

bool is_space(char c) { return c == ' '; }

struct calc {
    char op;
};

template <std::ranges::input_range R>
long long operator|(R&& r, calc c) {
    return (c.op == '+')
        ? std::ranges::fold_left(r, 0LL, std::plus<>{})
        : std::ranges::fold_left(r, 1LL, std::multiplies<>{});
}

std::vector<std::string> read_input(const char *filename) {
    std::vector<std::string> lines;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        lines.emplace_back(std::move(line));
    }
    return lines;
}

int main() {
    const auto lines { read_input("y25d06.txt") };
    const int rows = lines.size();
    const auto width = rows ? lines[0].size() : 0;

    long long part1 = 0;
    long long part2 = 0;

    auto column_blank = [&](size_t column) {
        return std::ranges::all_of(lines, is_space, [=](const std::string &s) {
            return s[column];
        });
    };

    for (size_t col = 0; col < width; ) {
        if (column_blank(col)) {
            col++;
            continue;
        }

        const auto start = col;
        while (col < width && !column_blank(col)) {
            col++;
        }
        const auto end = col;

        const auto c = calc{ lines.back()[start] };

        part1 += std::views::iota(0, rows - 1)
            | std::views::transform([&](int r) {
                return std::stoll(lines[r].substr(start, end - start));
            })
            | c;

        part2 += std::views::iota(start, end)
            | std::views::reverse
            | std::views::transform([&](size_t c) {
                std::string s;
                for (int r = 0; r < rows - 1; ++r) s += lines[r][c];
                return std::stoll(s);
            })
            | c;
    }

    std::cout << "Part1: " << part1 << std::endl;
    std::cout << "Part2: " << part2 << std::endl;
    return 0;
}

Install C++ and run#

You need a recent compiler to support the C++23 standard library features.

C++ doesn’t have a standard package manager, so we just compile and execute.

# You probably have this installed already

# Execute the code
g++ -Wall -Wpedantic -std=c++23 -O -o d06 d06.cpp && ./d06