Solution for Day 14.

As it turns out I should have updated Day 12 to use disjoint sets in the
first place...

Added new utility header for functions/classes used across solutions.
For now it contains disjoint sets and the knot hash function. Also
updated solutions of Day 10 and Day 12 to make use of this header.

Author: thorstel

CMakeLists.txt

@@ -14,8 +14,10 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 include_directories(inc)
 
 add_executable(aoc17
+    inc/aoc_utility.hpp
     inc/default_includes.hpp
     inc/solution.hpp
+    src/aoc_utility.cpp
     src/day01.cpp
     src/day02.cpp
     src/day03.cpp

inc/aoc_utility.hpp

@@ -0,0 +1,80 @@
+#ifndef AOC_UTILITY_H_
+#define AOC_UTILITY_H_
+
+#include <array>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace aoc
+{
+/**********************************************************************
+ *                             KNOT HASH                              *
+ **********************************************************************/
+
+std::array<unsigned int, 16> knot_hash(const std::string& input);
+
+void knot_hash_round(
+        std::array<unsigned int, 256>&   array,
+        const std::vector<unsigned int>& inputs,
+        unsigned int&                    pos,
+        unsigned int&                    skip);
+
+/**********************************************************************
+ *                     DISJOINT SETS / UNION FIND                     *
+ **********************************************************************/
+
+template<typename T>
+class disjoint_sets
+{
+    struct set { T id; size_t size{0u}; };
+
+    std::unordered_map<T, set> table;
+    size_t                     num_sets{0u};
+
+public:
+    T find(const T& t) { return find_rec(t).id; }
+
+    void make_union(const T& t1, const T& t2)
+    {
+        auto& s1 = find_rec(t1);
+        auto& s2 = find_rec(t2);
+
+        if (s1.id != s2.id)
+        {
+            --num_sets;
+            s2.id    = s1.id;
+            s1.size += s2.size;
+        }
+    }
+
+    bool contains(const T& t) const { return table.find(t) != table.end(); }
+
+    size_t size_of_set(const T& t) { return find_rec(t).size; }
+
+    size_t set_count() const { return num_sets; }
+
+private:
+    set& find_rec(const T& t)
+    {
+        auto& s = table[t];
+        if (s.size == 0u)
+        {
+            ++num_sets;
+            s.id   = t;
+            s.size = 1u;
+            return s;
+        }
+        else if (s.id == t) { return s; }
+        else
+        {
+            auto& p = find_rec(s.id);
+            s.id    = p.id;
+            return p;
+        }
+    }
+};
+
+}
+#endif  // AOC_UTILITY_H_
+

inputs/Day14.txt

@@ -0,0 +1 @@
+ffayrhll

instructions/Day14.txt

@@ -0,0 +1,83 @@
+--- Day 14: Disk Defragmentation ---
+
+Suddenly, a scheduled job activates the system's disk defragmenter. Were
+the situation different, you might sit and watch it for a while, but
+today, you just don't have that kind of time. It's soaking up valuable
+system resources that are needed elsewhere, and so the only option is to
+help it finish its task as soon as possible.
+
+The disk in question consists of a 128x128 grid; each square of the grid
+is either free or used. On this disk, the state of the grid is tracked
+by the bits in a sequence of knot hashes.
+
+A total of 128 knot hashes are calculated, each corresponding to a
+single row in the grid; each hash contains 128 bits which correspond to
+individual grid squares. Each bit of a hash indicates whether that
+square is free (0) or used (1).
+
+The hash inputs are a key string (your puzzle input), a dash, and a
+number from 0 to 127 corresponding to the row. For example, if your key
+string were flqrgnkx, then the first row would be given by the bits of
+the knot hash of flqrgnkx-0, the second row from the bits of the knot
+hash of flqrgnkx-1, and so on until the last row, flqrgnkx-127.
+
+The output of a knot hash is traditionally represented by 32 hexadecimal
+digits; each of these digits correspond to 4 bits, for a total of 4 * 32
+= 128 bits. To convert to bits, turn each hexadecimal digit to its
+equivalent binary value, high-bit first: 0 becomes 0000, 1 becomes 0001,
+e becomes 1110, f becomes 1111, and so on; a hash that begins with
+a0c2017... in hexadecimal would begin with
+10100000110000100000000101110000... in binary.
+
+Continuing this process, the first 8 rows and columns for key flqrgnkx
+appear as follows, using # to denote used squares, and . to denote free
+ones:
+
+##.#.#..-->
+.#.#.#.#
+....#.#.
+#.#.##.#
+.##.#...
+##..#..#
+.#...#..
+##.#.##.-->
+|      |
+V      V
+
+In this example, 8108 squares are used across the entire 128x128 grid.
+
+Given your actual key string, how many squares are used?
+
+Your puzzle answer was 8190.
+
+--- Part Two ---
+
+Now, all the defragmenter needs to know is the number of regions. A
+region is a group of used squares that are all adjacent, not including
+diagonals. Every used square is in exactly one region: lone used squares
+form their own isolated regions, while several adjacent squares all
+count as a single region.
+
+In the example above, the following nine regions are visible, each
+marked with a distinct digit:
+
+11.2.3..-->
+.1.2.3.4
+....5.6.
+7.8.55.9
+.88.5...
+88..5..8
+.8...8..
+88.8.88.-->
+|      |
+V      V
+
+Of particular interest is the region marked 8; while it does not appear
+contiguous in this small view, all of the squares marked 8 are connected
+when considering the whole 128x128 grid. In total, in this example, 1242
+regions are present.
+
+How many regions are present given your key string?
+
+Your puzzle answer was 1134.
+

src/aoc_utility.cpp

@@ -0,0 +1,54 @@
+#include "aoc_utility.hpp"
+#include "default_includes.hpp"
+
+/**********************************************************************
+ *                             KNOT HASH                              *
+ **********************************************************************/
+
+std::array<unsigned int, 16> aoc::knot_hash(const std::string& input)
+{
+    static std::array<unsigned int, 256> array;
+    std::iota(array.begin(), array.end(), 0u);
+
+    std::vector<unsigned int> inputs;
+    std::for_each(input.begin(), input.end(),
+            [&](auto c) {
+                inputs.push_back(static_cast<unsigned int>(c));
+            });
+    for (auto i : {17u, 31u, 73u, 47u, 23u}) { inputs.push_back(i); }
+
+    unsigned int pos{0u}, skip{0u};
+    for (auto i{0}; i < 64; ++i) { knot_hash_round(array, inputs, pos, skip); }
+
+    std::array<unsigned int, 16> hash;
+    auto hh = hash.begin();
+    for (auto it = array.begin(); it != array.end(); std::advance(it, 16))
+    {
+        *(hh++) = std::accumulate(it, (it + 16), 0u, std::bit_xor<void>());
+    }
+
+    return hash;
+}
+
+void aoc::knot_hash_round(
+        std::array<unsigned int, 256>&   array,
+        const std::vector<unsigned int>& inputs,
+        unsigned int&                    pos,
+        unsigned int&                    skip)
+{
+    for (auto len : inputs)
+    {
+        unsigned int start_pos{pos};
+        unsigned int end_pos = ((pos + len) - 1u) % array.size();
+
+        for (auto i{0u}; i < (len / 2u); ++i)
+        {
+            std::swap(array[start_pos], array[end_pos]);
+            start_pos = (start_pos + 1u) % array.size();
+            end_pos   = (end_pos > 0u) ? (end_pos - 1u) : (array.size() - 1u);
+        }
+
+        pos = (pos + (len + skip++)) % array.size();
+    }
+}
+

src/day10.cpp

@@ -1,76 +1,35 @@
+#include "aoc_utility.hpp"
 #include "default_includes.hpp"
 #include "solution.hpp"
 
-static inline void hash_round(
-        std::array<int,256>&    list,
-        const std::vector<int>& inputs,
-        int&                    pos,
-        int&                    skip_size)
-{
-    for (int len : inputs)
-    {
-        int start_pos = pos;
-        int end_pos   = ((pos + len) - 1) % list.size();
-
-        for (int i = 0; i < (len / 2); ++i)
-        {
-            std::swap(list[start_pos], list[end_pos]);
-            start_pos = (start_pos + 1) % list.size();
-            end_pos   = (end_pos > 0) ? (end_pos - 1) : (list.size() - 1);
-        }
-
-        pos = (pos + (len + skip_size++)) % list.size();
-    }
-}
-
 template<>
 void solve<Day10>(std::istream& ins, std::ostream& outs)
 {
-    std::array<int,256> list;
-    std::iota(list.begin(), list.end(), 0);
+    std::array<unsigned int, 256> list;
+    std::iota(list.begin(), list.end(), 0u);
 
     std::string input;
     ins >> input;
 
     // Part 1
-    std::istringstream iss{input};
-    std::vector<int>   inputs_p1;
+    std::istringstream        iss{input};
+    std::vector<unsigned int> inputs;
     for (std::string s; std::getline(iss, s, ',');)
     {
-        inputs_p1.push_back(std::stoi(s));
+        inputs.push_back(std::stoi(s));
     }
 
-    int pos{0}, skip_size{0};
-    hash_round(list, inputs_p1, pos, skip_size);
+    unsigned int pos{0u}, skip_size{0u};
+    aoc::knot_hash_round(list, inputs, pos, skip_size);
     outs << "(Part 1) Result = " << (list[0] * list[1]) << std::endl;
 
     // Part 2
-    std::iota(list.begin(), list.end(), 0);
-    std::vector<int> inputs_p2;
-    std::for_each(
-            input.begin(),
-            input.end(),
-            [&](auto c) { inputs_p2.push_back(static_cast<int>(c)); });
-    for (int i : {17, 31, 73, 47, 23}) { inputs_p2.push_back(i); }
-
-    pos       = 0;
-    skip_size = 0;
-    for (auto i = 0; i < 64; ++i)
-    {
-        hash_round(list, inputs_p2, pos, skip_size);
-    }
-
     // setup hex output formatting
     auto format = outs.flags();
     outs << std::setfill('0') << std::hex;
 
     outs << "(Part 2) Hash   = ";
-    for (auto it = list.begin(); it < list.end(); std::advance(it, 16))
-    {
-        outs << std::setw(2)
-             << std::accumulate(it, (it + 16), 0, std::bit_xor<void>());
-    }
-
+    for (auto b : aoc::knot_hash(input)) { outs << std::setw(2) << b; }
     outs << std::endl;
 
     // reset output formatting

src/day12.cpp

@@ -1,53 +1,24 @@
+#include "aoc_utility.hpp"
 #include "default_includes.hpp"
 #include "solution.hpp"
 
 template<>
 void solve<Day12>(std::istream& ins, std::ostream& outs)
 {
-    std::unordered_map<int, int>                     group_map;
-    std::unordered_map<int, std::unordered_set<int>> groups;
-
-    int group_id_counter{0};
+    aoc::disjoint_sets<int> groups;
     for (std::string line; std::getline(ins, line);)
     {
         std::istringstream iss{line};
         std::string        word;
         std::vector<int>   group;
 
         iss >> word;
-        group.emplace_back(std::stoi(word));
+        auto set = groups.find(stoi(word));
         iss >> word; // skip the <->
-        while (iss >> word) { group.emplace_back(std::stoi(word)); }
-
-        std::unordered_set<int> to_merge;
-        for (int elem : group)
-        {
-            auto it = group_map.find(elem);
-            if (it != group_map.end()) { to_merge.insert(it->second); }
-        }
-
-        int group_id = (to_merge.size() > 0)
-            ? *(to_merge.begin())
-            : group_id_counter++;
-        if (to_merge.size() > 1)
-        {
-            std::for_each(
-                    std::next(to_merge.begin()),
-                    to_merge.end(),
-                    [&](int gid)
-                    {
-                        groups[group_id].insert(
-                                groups[gid].begin(),
-                                groups[gid].end());
-                        groups.erase(gid);
-                    });
-        }
-
-        groups[group_id].insert(group.begin(), group.end());
-        for (int elem : groups[group_id]) { group_map[elem] = group_id; }
+        while (iss >> word) { groups.make_union(set, stoi(word)); }
     }
 
-    outs << "Group size of '0' = " << groups[group_map[0]].size() << std::endl
-         << "Number of groups  = " << groups.size() << std::endl;
+    outs << "Group size of '0' = " << groups.size_of_set(0) << std::endl
+         << "Number of groups  = " << groups.set_count() << std::endl;
 }