Holy shit I think that is the most complicated code I have ever written without a single bug in one go

advent_of_code/d8/main.cpp

@@ -30,7 +30,7 @@ pair<array<string, 10>, array<string, 4>> parse_line(const string &s){
     return result;
 }
 
-map<int, string> identify_digits(const array<string, 10> &digits){
+map<string, int> identify_digits(const array<string, 10> &digits){
     map<int, string> digit_strings;
 
     vector<string> size_fives;
@@ -54,8 +54,88 @@ map<int, string> identify_digits(const array<string, 10> &digits){
         }
     }
 
+    vector<set<char>> size_fives_sets(3);
+    for(int i = 0; i < 3; ++i){
+        for(char &c : size_fives[i]){
+            size_fives_sets[i].insert(c);
+        }
 
-    return digit_strings;
+        // We know that 2 is the only digit that combines with 4 to be 8
+        for(char &c : digit_strings[4]){
+            size_fives_sets[i].insert(c);
+        }
+
+        if(size_fives_sets[i].size() == 7){
+            digit_strings[2] = size_fives[i];
+            size_fives.erase(size_fives.begin() + i);
+            break;
+        }
+    }
+
+    // Now do kind of the same thing but for 5 and 3, combined with 7
+    set<char> three_or_five;
+    for(char &c : size_fives[0]){
+        three_or_five.insert(c);
+    }
+
+    for(char &c : digit_strings[7]){
+        three_or_five.insert(c);
+    }
+
+    // So in the case that it not of size 5, which means it is the number 5
+    if(three_or_five.size() != 5){
+        swap(size_fives[0], size_fives[1]);
+    }
+
+    digit_strings[3] = size_fives[0];
+    digit_strings[5] = size_fives[1];
+
+    vector<set<char>> size_six_sets(3);
+    for(int i = 0; i < 3; ++i){
+        for(char &c : size_six[i]){
+            size_six_sets[i].insert(c);
+        }
+
+        // Only 6 and 7 together form 8 from all the six sized digits
+        for(char &c : digit_strings[7]){
+            size_six_sets[i].insert(c);
+        }
+
+        if(size_six_sets[i].size() == 7){
+            digit_strings[6] = size_six[i];
+            size_six.erase(size_six.begin() + i);
+            break;
+        }
+    }
+
+    // Now we only need 9 and 0, which can be distinguished by combining with 4
+    set<char> nine_or_zero;
+    for(char &c : size_six[0]){
+        nine_or_zero.insert(c);
+    }
+
+    for(char &c : digit_strings[4]){
+        nine_or_zero.insert(c);
+    }
+
+    // In the case that the size is 7, which means it combines to an eight
+    if(nine_or_zero.size() != 7){
+        swap(size_six[0], size_six[1]);
+    }
+
+    digit_strings[0] = size_six[0];
+    digit_strings[9] = size_six[1];
+
+    for(auto &s : digit_strings){
+        sort(s.second.begin(), s.second.end());
+    }
+
+    map<string, int> result;
+    for(auto &d : digit_strings){
+        result[d.second] = d.first;
+    }
+
+    return result;
 }
 
 int main(){
@@ -106,8 +186,23 @@ int main(){
 
     cout << result << endl;
 
+    result = 0;
+    for(auto &line : input_text){
+        auto digit_map = identify_digits(line.first);
 
+        int acc = 0;
+        for(int i = 0; i < 4; ++i){
+            string s = line.second[i];
+            sort(s.begin(), s.end());
 
+            acc *= 10;
+            acc += digit_map[s];
+        }
+
+        result += acc;
+    }
+
+    cout << result << endl;
 
     cout << flush;