123 lines
2.7 KiB
C++
123 lines
2.7 KiB
C++
#include <array>
|
|
#include <cassert>
|
|
#include <iostream>
|
|
#include <regex>
|
|
#include <string>
|
|
|
|
using Int = long;
|
|
|
|
struct Vector
|
|
{
|
|
Vector(Int x, Int y, Int z)
|
|
: x_(x), y_(y), z_(z)
|
|
{
|
|
}
|
|
|
|
Int x() const noexcept { return x_; }
|
|
Int y() const noexcept { return y_; }
|
|
Int z() const noexcept { return z_; }
|
|
|
|
auto operator+=(Vector const& rhs) noexcept
|
|
{
|
|
x_ += rhs.x();
|
|
y_ += rhs.y();
|
|
z_ += rhs.z();
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
Int x_;
|
|
Int y_;
|
|
Int z_;
|
|
};
|
|
|
|
auto operator<(Vector const& lhs, Vector const& rhs) -> bool
|
|
{
|
|
if (lhs.x() < rhs.x()) {
|
|
return true;
|
|
}
|
|
if (lhs.x() == rhs.x() && lhs.y() < rhs.y()) {
|
|
return true;
|
|
}
|
|
if (lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() < rhs.z()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
auto operator==(Vector const& lhs, Vector const& rhs) -> bool
|
|
{
|
|
return lhs.x() == rhs.x() && lhs.y() == rhs.y() && lhs.z() == rhs.z();
|
|
}
|
|
|
|
struct NodeState
|
|
{
|
|
NodeState(Vector const& pos, Vector const& velocity, Vector const& accel)
|
|
: pos_(pos), velocity_(velocity), accel_(accel)
|
|
{
|
|
}
|
|
|
|
void update_position()
|
|
{
|
|
velocity_ += accel_;
|
|
pos_ += velocity_;
|
|
}
|
|
|
|
auto position() const noexcept -> Vector const& { return pos_; }
|
|
|
|
private:
|
|
Vector pos_;
|
|
Vector velocity_;
|
|
Vector accel_;
|
|
};
|
|
|
|
auto operator==(NodeState const& lhs, NodeState const& rhs) -> bool
|
|
{
|
|
return lhs.position() == rhs.position();
|
|
}
|
|
|
|
auto operator<(NodeState const& lhs, NodeState const& rhs) -> bool
|
|
{
|
|
return lhs.position() < rhs.position();
|
|
}
|
|
|
|
auto main() -> int
|
|
{
|
|
static std::regex re{
|
|
R"(p=<(-?\d+),(-?\d+),(-?\d+)>, v=<(-?\d+),(-?\d+),(-?\d+)>, a=<(-?\d+),(-?\d+),(-?\d+)>)"};
|
|
std::vector<NodeState> nodes;
|
|
std::string line;
|
|
while (std::getline(std::cin, line) && !line.empty()) {
|
|
std::smatch m;
|
|
if (!std::regex_search(line, m, re)) {
|
|
std::cerr << "Unable to interpret: " << line << '\n';
|
|
return 1;
|
|
}
|
|
Vector pos{std::stol(m.str(1)), std::stol(m.str(2)), std::stol(m.str(3))};
|
|
Vector velocity{std::stol(m.str(4)), std::stol(m.str(5)), std::stol(m.str(6))};
|
|
Vector accel{std::stol(m.str(7)), std::stol(m.str(8)), std::stol(m.str(9))};
|
|
nodes.push_back(NodeState{pos, velocity, accel});
|
|
}
|
|
|
|
for (unsigned i{0}; i < 1000; ++i) {
|
|
std::sort(nodes.begin(), nodes.end());
|
|
for (auto it{nodes.begin()}; it != nodes.end();) {
|
|
auto it2{it};
|
|
while (it2 != nodes.end() && *it == *it2) {
|
|
++it2;
|
|
}
|
|
if (std::distance(it, it2) > 1) {
|
|
it = nodes.erase(it, it2);
|
|
}
|
|
else {
|
|
assert(std::distance(it, it2) == 1);
|
|
it = it2;
|
|
}
|
|
}
|
|
|
|
std::for_each(nodes.begin(), nodes.end(), [](auto& node) { node.update_position(); });
|
|
}
|
|
|
|
std::cout << "Number of nodes left: " << nodes.size() << '\n';
|
|
}
|