day[01]: optimized the solutions, improved code quality

src/01/solution.cxx

···
 #include <algorithm>
 #include <cstdlib>
 #include <filesystem>
+#include <format>
 #include <fstream>
 #include <print>
-#include <ranges>
 #include <string>
 #include <string_view>
 
···
   int value = 50;
 };
 
+struct RotationResult {
+  int new_value;
+  int crossed_0;
+};
+
 // @return how many times the rotary crossed 0, but *not* the times it stopped
 // at 0
-int rotate(Rotary &rotary, int value) {
+RotationResult rotate(const Rotary &rotary, const int value) {
   int result = rotary.value + value;
-  int crossed_0 = 0;
+
+  int begin = std::min(result, rotary.value);
+  int end = std::max(result, rotary.value);
 
-  int begin = std::min(result, rotary.value); // looks modern, but it's really
-  int end = std::max(result, rotary.value);   // hideous
-  auto range = std::ranges::views::iota(begin + 1, end) |
-               std::ranges::views::filter([](int x) { return x % 100 == 0; });
+  auto begin_norm = 0;
+  if (begin % 100 != 0) {
+    if (begin >= 0) {
+      begin_norm = begin - (begin % 100);
+    } else {
+      begin_norm = (begin - 100) / 100 * 100;
+    }
+  } else {
+    begin_norm = begin;
+  }
 
-  for (int _ : range) { // Kotlin .forEach would have looked so much better
-    crossed_0 += 1;
+  auto end_norm = 0;
+  if (end % 100 != 0) {
+    end_norm = end + (100 - end % 100);
+  } else {
+    end_norm = end;
   }
 
-  while (result < 0) {
-    result += 100;
+  auto crossed_0 = (end_norm - begin_norm) / 100 - 1;
+
+  if (result < 0) {
+    result += std::abs(result / 100 * 100) + 100;
   }
-  while (result > 99) {
-    result -= 100;
+  if (result > 99) {
+    result %= 100;
   }
-  rotary.value = result;
 
-  return crossed_0;
+  return RotationResult{.new_value = result, .crossed_0 = crossed_0};
 }
 
 int main() {
···
   // horrendous code below
 
   for (std::string line; std::getline(input, line);) {
+    // parser is okay-ish, I trust AoC inputs
     std::string_view rotation = std::string_view(line.data(), 1);
     std::string_view number_sv = std::string_view(line.data() + 1);
 
     auto number = std::stoi(number_sv.data());
-
     if (rotation == "L") {
       number = -number;
     }
 
-    // ridiculous - a function has both side effect and a return value
-    // this shit reminds me of out parameter convention so much...
-    times_crossed_0 += rotate(rotary, number);
-
+    auto result = rotate(rotary, number);
+    times_crossed_0 += result.crossed_0;
+    rotary.value = result.new_value;
     if (rotary.value == 0) {
       password_part_1 += 1;
     }
···
 
   std::println("Eureka! {} / {}", password_part_1, password_part_2);
 
-  input.close();
   return 0;
 }