117 lines
3.4 KiB
C++
117 lines
3.4 KiB
C++
#include <algorithm>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <set>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <vector>
|
|
|
|
#include "common.hpp"
|
|
|
|
using Position = std::tuple<int, int, int>;
|
|
using Board = std::map<Position, CellState>;
|
|
|
|
std::vector<std::string> readInput(const std::string &filename) {
|
|
std::vector<std::string> input;
|
|
std::string line;
|
|
std::ifstream file(filename);
|
|
while (std::getline(file, line)) {
|
|
input.push_back(line);
|
|
}
|
|
|
|
return input;
|
|
}
|
|
|
|
Board parseBoard(const std::vector<std::string> &input) {
|
|
Board board;
|
|
int rowCursor = 0;
|
|
for (auto rowIterator = input.cbegin(); rowIterator != input.cend(); (rowCursor++, ++rowIterator)) {
|
|
auto &line = *rowIterator;
|
|
int colCursor = 0;
|
|
for (auto colIterator = line.cbegin(); colIterator != line.cend(); (colCursor++, ++colIterator)) {
|
|
CellState state = *colIterator == ALIVE_CHAR ? ALIVE : DEAD;
|
|
Position position(rowCursor, colCursor, 0);
|
|
board.emplace(std::move(position), std::move(state));
|
|
}
|
|
}
|
|
|
|
return board;
|
|
}
|
|
|
|
int getNumAdjacentLiveNeighbors(const Board &board, int row, int col, int depth) {
|
|
int count = 0;
|
|
for (int dRow = -1; dRow <= 1; dRow++) {
|
|
for (int dCol = -1; dCol <= 1; dCol++) {
|
|
for (int dDepth = -1; dDepth <= 1; dDepth++) {
|
|
if (dRow == 0 && dCol == 0 && dDepth == 0) {
|
|
continue;
|
|
}
|
|
|
|
Position position(row + dRow, col + dCol, depth + dDepth);
|
|
if (board.find(position) == board.end()) {
|
|
continue;
|
|
}
|
|
|
|
count += (board.at(position) == ALIVE);
|
|
}
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* Get the range alive positions of each component
|
|
* @param board The board to check
|
|
* @return std::pair<Position, Position> The min and max of each component on the board
|
|
*/
|
|
std::pair<Position, Position> getRangeOnEachAxis(const Board &board) {
|
|
std::pair<int, int> rowRange = getMinMaxAlivePositionsForComponent<Position, 0>(board);
|
|
std::pair<int, int> colRange = getMinMaxAlivePositionsForComponent<Position, 1>(board);
|
|
std::pair<int, int> depthRange = getMinMaxAlivePositionsForComponent<Position, 2>(board);
|
|
|
|
return std::pair<Position, Position>(
|
|
Position(rowRange.first, colRange.first, depthRange.first),
|
|
Position(rowRange.second, colRange.second, depthRange.second));
|
|
}
|
|
|
|
int run(const std::vector<std::string> &input) {
|
|
Board board = parseBoard(input);
|
|
Board nextBoard = board;
|
|
for (int i = 0; i < CYCLE_COUNT; i++) {
|
|
auto ranges = getRangeOnEachAxis(board);
|
|
for (int row = std::get<0>(ranges.first) - 1; row <= std::get<0>(ranges.second) + 1; row++) {
|
|
for (int col = std::get<1>(ranges.first) - 1; col <= std::get<1>(ranges.second) + 1; col++) {
|
|
for (int depth = std::get<2>(ranges.first) - 1; depth <= std::get<2>(ranges.second) + 1; depth++) {
|
|
int aliveNeighbors = getNumAdjacentLiveNeighbors(board, row, col, depth);
|
|
Position position(row, col, depth);
|
|
CellState state = getOrDefault(board, DEAD, position);
|
|
if (aliveNeighbors != 2 && aliveNeighbors != 3) {
|
|
state = DEAD;
|
|
} else if (state == DEAD && aliveNeighbors == 3) {
|
|
state = ALIVE;
|
|
}
|
|
|
|
nextBoard[position] = state;
|
|
}
|
|
}
|
|
}
|
|
std::swap(nextBoard, board);
|
|
}
|
|
|
|
return std::count_if(
|
|
board.cbegin(), board.cend(), [](const std::pair<Position, CellState> &item) { return item.second == ALIVE; });
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
if (argc != 2) {
|
|
std::cerr << argv[0] << " <input_file>" << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
auto input = readInput(argv[1]);
|
|
|
|
std::cout << run(input) << std::endl;
|
|
}
|