154 lines
3.8 KiB
C++
154 lines
3.8 KiB
C++
#include <span>
|
|
#include <algorithm>
|
|
#include <ranges>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <set>
|
|
|
|
#include "fmt/std.h"
|
|
|
|
#include "aoc/types.hpp"
|
|
#include "aoc/utils.hpp"
|
|
|
|
using namespace std::string_view_literals;
|
|
using namespace aoc::types;
|
|
|
|
// starts at 50
|
|
[[maybe_unused]]constexpr auto raw_str = R"(
|
|
3-5
|
|
10-14
|
|
16-20
|
|
12-18
|
|
|
|
1
|
|
5
|
|
8
|
|
11
|
|
17
|
|
32
|
|
)";
|
|
|
|
static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
|
|
// std::string str{raw_str};
|
|
auto str = aoc::read_text("./input.txt").value_or("");
|
|
str = aoc::trim(str);
|
|
|
|
auto id_spec = str | std::views::split("\r\n\r\n"sv) | std::views::transform([](auto const& str) {
|
|
return aoc::trim({std::begin(str), std::end(str)});
|
|
}) | std::ranges::to<std::vector>();
|
|
|
|
if (id_spec.size() < 2) throw std::runtime_error("ID specification is not valid");
|
|
|
|
auto id_range = id_spec[0] | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
|
|
return std::ranges::fold_left(str | std::views::split("-"sv), std::vector<f64>{}, [](auto a, auto const& v) {
|
|
a.push_back(std::stod(std::string({std::begin(v), std::end(v)})));
|
|
return a;
|
|
});
|
|
}) | std::ranges::to<std::vector>();
|
|
|
|
auto ids = id_spec[1] | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
|
|
return std::stod(std::string{std::begin(str), std::end(str)});
|
|
}) | std::ranges::to<std::vector>();
|
|
|
|
struct range {
|
|
f64 start;
|
|
f64 end;
|
|
};
|
|
|
|
// f64 sum = 0;
|
|
|
|
// for (usize i = 0; i < ids.size(); ++i) {
|
|
// auto const id = ids[i];
|
|
// bool is_valid = false;
|
|
// for (usize j = 0; j < id_range.size(); ++j) {
|
|
// auto const a = id_range[j][0];
|
|
// auto const b = id_range[j][1];
|
|
//
|
|
// if (id >= a && id <= b) {
|
|
// is_valid = true;
|
|
// break;
|
|
// }
|
|
// }
|
|
//
|
|
// fmt::print("id: {} is {}\n", id, is_valid ? "valid" : "not valid");
|
|
//
|
|
// if (is_valid) ++sum;
|
|
// }
|
|
|
|
std::vector<range> range_vec{};
|
|
for (usize i = 0; i < id_range.size(); ++i) {
|
|
auto const a = id_range[i][0];
|
|
auto const b = id_range[i][1];
|
|
range_vec.push_back({a, b});
|
|
}
|
|
|
|
std::ranges::sort(range_vec, [](auto a, auto b) {
|
|
return a.start < b.start;
|
|
});
|
|
fmt::print("----------\n");
|
|
|
|
// for (auto const& r : range_vec) {
|
|
// fmt::print("{}-{}\n", r.start, r.end);
|
|
// }
|
|
//
|
|
// fmt::print("----------\n");
|
|
|
|
std::vector<range> ranges{};
|
|
for (usize i = 0; i < range_vec.size(); i += 1) {
|
|
auto const& r = range_vec[i];
|
|
if (ranges.empty()) {
|
|
ranges.push_back(r);
|
|
continue;
|
|
}
|
|
|
|
if (ranges.back().start <= r.start && ranges.back().end >= r.end) {
|
|
continue;
|
|
}
|
|
|
|
if (ranges.back().end >= r.start) {
|
|
ranges.back().end = r.end;
|
|
continue;
|
|
}
|
|
|
|
ranges.push_back(r);
|
|
}
|
|
|
|
fmt::print("\n");
|
|
|
|
f64 sum = 0.0;
|
|
for (auto const& r : ranges) {
|
|
// fmt::print("{}-{} ", r.start, r.end);
|
|
auto const d = (r.end - r.start) + 1;
|
|
fmt::print("{}\n", d);
|
|
sum += d;
|
|
}
|
|
|
|
fmt::print("res: {}\n", sum);
|
|
|
|
//
|
|
// std::vector<f64> ranges{};
|
|
// for (auto const& value : set) ranges.push_back(value);
|
|
// set = {};
|
|
// std::ranges::sort(ranges);
|
|
//
|
|
//
|
|
// // for (auto const& id : valid_ids) {
|
|
// // fmt::print("{} ", id);
|
|
// // }
|
|
// fmt::print("\n");
|
|
//
|
|
// fmt::print("res: {}\n", sum);
|
|
}
|
|
|
|
auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
|
|
try {
|
|
entry({argv, std::next(argv, argc)});
|
|
} catch (std::exception const& e) {
|
|
fmt::print(stderr, "{}\n", e.what());
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|