banan-os/userspace/aoc2023/day19/main.cpp

291 lines
6.5 KiB
C++
Raw Normal View History

#include <BAN/Array.h>
2023-12-23 18:47:44 +02:00
#include <BAN/HashMap.h>
#include <BAN/HashSet.h>
#include <BAN/Sort.h>
2023-12-23 18:47:44 +02:00
#include <BAN/String.h>
#include <BAN/Vector.h>
#include <sys/time.h>
2023-12-23 18:47:44 +02:00
#include <ctype.h>
#include <inttypes.h>
#include <stdio.h>
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
enum Variable { x, m, a, s };
enum class Comparison { Less, Greater, Always };
struct Rule
{
Variable operand1;
i64 operand2;
Comparison comparison;
BAN::String target;
};
using Workflows = BAN::HashMap<BAN::String, BAN::Vector<Rule>>;
2023-12-23 18:47:44 +02:00
struct Item
{
i64 values[4];
bool operator==(const Item& other) const
{
return memcmp(values, other.values, sizeof(values)) == 0;
}
};
struct ItemHash
{
BAN::hash_t operator()(const Item& item) const
{
return BAN::hash<u64>()(item.values[0]) ^
BAN::hash<u64>()(item.values[1]) ^
BAN::hash<u64>()(item.values[2]) ^
BAN::hash<u64>()(item.values[3]);
};
};
i64 parse_i64(BAN::StringView str)
{
i64 result = 0;
for (size_t i = 0; i < str.size() && isdigit(str[i]); i++)
result = (result * 10) + (str[i] - '0');
return result;
}
bool get_line(FILE* fp, BAN::String& out)
{
out.clear();
bool success = false;
char buffer[128];
while (fgets(buffer, sizeof(buffer), fp))
{
success = true;
MUST(out.append(buffer));
if (out.back() == '\n')
{
out.pop_back();
break;
}
}
return success;
}
Workflows parse_workflows(FILE* fp)
{
Workflows workflows;
BAN::String line;
while (get_line(fp, line) && !line.empty())
{
auto name = line.sv().substring(0, *line.sv().find('{'));
MUST(workflows.emplace(name));
auto rule_str = line.sv().substring(*line.sv().find('{') + 1);
rule_str = rule_str.substring(0, rule_str.size() - 1);
auto rules_str = MUST(rule_str.split(','));
for (size_t i = 0; i < rules_str.size() - 1; i++)
{
Rule rule;
rule.operand1 = (rules_str[i][0] == 'x') ? Variable::x :
(rules_str[i][0] == 'm') ? Variable::m :
(rules_str[i][0] == 'a') ? Variable::a :
Variable::s;
rule.operand2 = parse_i64(rules_str[i].substring(2));
rule.comparison = (rules_str[i][1] == '<') ? Comparison::Less : Comparison::Greater;
rule.target = rules_str[i].substring(*rules_str[i].find(':') + 1);
MUST(workflows[name].push_back(BAN::move(rule)));
}
MUST(workflows[name].emplace_back(Variable::x, 0, Comparison::Always, rules_str.back()));
}
return workflows;
}
BAN::Vector<Item> parse_items(FILE* fp)
{
BAN::Vector<Item> items;
BAN::String line;
while (get_line(fp, line) && !line.empty())
{
auto values = MUST(line.sv().substring(1, line.size() - 2).split(','));
ASSERT(values.size() == 4);
ASSERT(values[0][0] == 'x');
ASSERT(values[1][0] == 'm');
ASSERT(values[2][0] == 'a');
ASSERT(values[3][0] == 's');
Item item;
item.values[0] = parse_i64(values[0].substring(2));
item.values[1] = parse_i64(values[1].substring(2));
item.values[2] = parse_i64(values[2].substring(2));
item.values[3] = parse_i64(values[3].substring(2));
2023-12-23 18:47:44 +02:00
MUST(items.push_back(item));
}
return items;
}
bool satifies_rule(const Item& item, const Rule& rule)
{
switch (rule.comparison)
{
case Comparison::Always:
return true;
case Comparison::Less:
return item.values[rule.operand1] < rule.operand2;
case Comparison::Greater:
return item.values[rule.operand1] > rule.operand2;
}
ASSERT_NOT_REACHED();
}
bool is_accepted(const Item& item, const BAN::String& name, const Workflows& workflows)
{
const auto& workflow = workflows[name];
for (const auto& rule : workflow)
{
if (!satifies_rule(item, rule))
continue;
if (rule.target == "A"_sv)
2023-12-23 18:47:44 +02:00
return true;
if (rule.target == "R"_sv)
2023-12-23 18:47:44 +02:00
return false;
return is_accepted(item, rule.target, workflows);
}
ASSERT_NOT_REACHED();
}
i64 puzzle1(FILE* fp)
{
auto workflows = parse_workflows(fp);
auto items = parse_items(fp);
BAN::Vector<Item> accepted;
for (const auto& item : items)
if (is_accepted(item, "in"_sv, workflows))
2023-12-23 18:47:44 +02:00
MUST(accepted.push_back(item));
i64 result = 0;
for (const auto& item : accepted)
result += item.values[0] + item.values[1] + item.values[2] + item.values[3];
return result;
}
i64 puzzle2(FILE* fp)
{
auto workflows = parse_workflows(fp);
BAN::Array<BAN::HashSet<i64>, 4> values;
for (const auto& workflow : workflows)
{
for (const auto& rule : workflow.value)
{
if (rule.comparison != Comparison::Always)
{
MUST(values[rule.operand1].insert(rule.operand2));
MUST(values[rule.operand1].insert(rule.operand2 + 1));
}
}
}
for (i64 i = 0; i < 4; i++)
{
MUST(values[i].insert(1));
MUST(values[i].insert(4001));
}
BAN::Array<BAN::Vector<i64>, 4> values_sorted;
for (i64 i = 0; i < 4; i++)
{
MUST(values_sorted[i].reserve(values[i].size()));
for (i64 value : values[i])
MUST(values_sorted[i].push_back(value));
BAN::sort::sort(values_sorted[i].begin(), values_sorted[i].end());
}
i64 result = 0;
for (u64 xi = 0; xi < values_sorted[0].size() - 1; xi++)
{
timespec time_start;
clock_gettime(CLOCK_MONOTONIC, &time_start);
for (u64 mi = 0; mi < values_sorted[1].size() - 1; mi++)
{
for (u64 ai = 0; ai < values_sorted[2].size() - 1; ai++)
{
for (u64 si = 0; si < values_sorted[3].size() - 1; si++)
{
Item item {{
values_sorted[0][xi],
values_sorted[1][mi],
values_sorted[2][ai],
values_sorted[3][si]
}};
if (!is_accepted(item, "in"_sv, workflows))
continue;
i64 x_count = values_sorted[0][xi + 1] - values_sorted[0][xi];
i64 m_count = values_sorted[1][mi + 1] - values_sorted[1][mi];
i64 a_count = values_sorted[2][ai + 1] - values_sorted[2][ai];
i64 s_count = values_sorted[3][si + 1] - values_sorted[3][si];
result += x_count * m_count * a_count * s_count;
}
}
}
timespec time_stop;
clock_gettime(CLOCK_MONOTONIC, &time_stop);
u64 duration_us = (time_stop.tv_sec * 1'000'000 + time_stop.tv_nsec / 1'000) - (time_start.tv_sec * 1'000'000 + time_start.tv_nsec / 1'000);
printf("step took %" PRIu64 ".%03" PRIu64 " ms, estimate %" PRIu64 " s\n", duration_us / 1000, duration_us % 1000, (values_sorted[0].size() - xi - 2) * duration_us / 1'000'000);
}
return result;
2023-12-23 18:47:44 +02:00
}
int main(int argc, char** argv)
{
const char* file_path = "/usr/share/aoc2023/day19_input.txt";
if (argc >= 2)
file_path = argv[1];
FILE* fp = fopen(file_path, "r");
if (fp == nullptr)
{
perror("fopen");
return 1;
}
printf("puzzle1: %" PRId64 "\n", puzzle1(fp));
fseek(fp, 0, SEEK_SET);
printf("puzzle2: %" PRId64 "\n", puzzle2(fp));
fclose(fp);
}