Update some 2015 sources to .clang-tidy

2021-12-02 19:57:58 +00:00
parent 7ab7ecb00a
commit 9ecc3ff53d
27 changed files with 305 additions and 336 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -8,65 +8,69 @@
 # misc-no-recursion: We do not mind recursion (and we need to recurse)
 # readability-function-cognitive-complexity: Too many asserts trigger this one unnecessarily
 # cppcoreguidelines-pro-bounds-array-to-pointer-decay: Triggers on assert()
-Checks:          >-
- *,
- -abseil-*,
- -altera-*,
- -android-*,
- -fuchsia-*,
- -hicpp-*,
- -llvmlibc-*,
- -objc-*,
- -zircon-*,
- -cppcoreguidelines-owning-memory,
- -cppcoreguidelines-pro-type-vararg,
- -google-runtime-references,
- -llvm-header-guard,
- -misc-no-recursion,
- -readability-function-cognitive-complexity,
- -clang-diagnostic-ignored-optimization-argument,
- -cppcoreguidelines-pro-bounds-array-to-pointer-decay
+Checks: >-
+  *,
+  -abseil-*,
+  -altera-*,
+  -android-*,
+  -fuchsia-*,
+  -hicpp-*,
+  -llvmlibc-*,
+  -objc-*,
+  -zircon-*,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-pro-type-vararg,
+  -google-runtime-references,
+  -llvm-header-guard,
+  -misc-no-recursion,
+  -readability-function-cognitive-complexity,
+  -clang-diagnostic-ignored-optimization-argument,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -readability-identifier-length,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -readability-magic-numbers,
+  -misc-non-private-member-variables-in-classes
 WarningsAsErrors: '*,-clang-diagnostic-ignored-optimization-argument'
 HeaderFilterRegex: ''
 AnalyzeTemporaryDtors: false
-FormatStyle:     file
-User:            mgrettondann
+FormatStyle: file
+User: mgrettondann
 CheckOptions:
-  - key:             llvm-else-after-return.WarnOnConditionVariables
-    value:           '0'
-  - key:             modernize-loop-convert.MinConfidence
-    value:           reasonable
-  - key:             modernize-replace-auto-ptr.IncludeStyle
-    value:           llvm
-  - key:             cert-str34-c.DiagnoseSignedUnsignedCharComparisons
-    value:           '0'
-  - key:             google-readability-namespace-comments.ShortNamespaceLines
-    value:           '10'
-  - key:             cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
-    value:           '0'
-  - key:             cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
-    value:           '1'
-  - key:             cert-dcl16-c.NewSuffixes
-    value:           'L;LL;LU;LLU'
-  - key:             google-readability-braces-around-statements.ShortStatementLines
-    value:           '1'
-  - key:             modernize-pass-by-value.IncludeStyle
-    value:           llvm
-  - key:             google-readability-namespace-comments.SpacesBeforeComments
-    value:           '2'
-  - key:             modernize-loop-convert.MaxCopySize
-    value:           '16'
-  - key:             cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
-    value:           '1'
-  - key:             modernize-use-nullptr.NullMacros
-    value:           'NULL'
-  - key:             llvm-qualified-auto.AddConstToQualified
-    value:           '0'
-  - key:             modernize-loop-convert.NamingStyle
-    value:           CamelCase
-  - key:             llvm-else-after-return.WarnOnUnfixable
-    value:           '0'
-  - key:             google-readability-function-size.StatementThreshold
-    value:           '800'
+  - key: llvm-else-after-return.WarnOnConditionVariables
+    value: '0'
+  - key: modernize-loop-convert.MinConfidence
+    value: reasonable
+  - key: modernize-replace-auto-ptr.IncludeStyle
+    value: llvm
+  - key: cert-str34-c.DiagnoseSignedUnsignedCharComparisons
+    value: '0'
+  - key: google-readability-namespace-comments.ShortNamespaceLines
+    value: '10'
+  - key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+    value: '0'
+  - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value: '1'
+  - key: cert-dcl16-c.NewSuffixes
+    value: 'L;LL;LU;LLU'
+  - key: google-readability-braces-around-statements.ShortStatementLines
+    value: '1'
+  - key: modernize-pass-by-value.IncludeStyle
+    value: llvm
+  - key: google-readability-namespace-comments.SpacesBeforeComments
+    value: '2'
+  - key: modernize-loop-convert.MaxCopySize
+    value: '16'
+  - key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
+    value: '1'
+  - key: modernize-use-nullptr.NullMacros
+    value: 'NULL'
+  - key: llvm-qualified-auto.AddConstToQualified
+    value: '0'
+  - key: modernize-loop-convert.NamingStyle
+    value: CamelCase
+  - key: llvm-else-after-return.WarnOnUnfixable
+    value: '0'
+  - key: google-readability-function-size.StatementThreshold
+    value: '800'
 ...

--- a/2015/puzzle-01-01.cc
+++ b/2015/puzzle-01-01.cc
@@ -2,13 +2,14 @@
 #include <iostream>
 #include <string>

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    int floor = 0;
-    for (auto c : line) {
+    for (auto c : line) {  // NOLINT(readability-identifier-length)
      assert(c == '(' || c == ')');
-      floor += (c == '(') - (c == ')');
+      floor += (c == '(') ? 1 : 0;
+      floor -= (c == ')') ? 1 : 0;
    }
    std::cout << floor << "\n";
  }
--- a/2015/puzzle-01-02.cc
+++ b/2015/puzzle-01-02.cc
@@ -2,15 +2,16 @@
 #include <iostream>
 #include <string>

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    int floor = 0;
    std::string::size_type pos = 0;
-    for (auto c : line) {
+    for (auto c : line) {  // NOLINT(readability-identifier-length)
      ++pos;
      assert(c == '(' || c == ')');
-      floor += (c == '(') - (c == ')');
+      floor += (c == '(') ? 1 : 0;
+      floor -= (c == ')') ? 1 : 0;
      if (floor == -1) {
        break;
      }
--- a/2015/puzzle-02-01.cc
+++ b/2015/puzzle-02-01.cc
@@ -8,7 +8,7 @@ struct Box
  /** Construct box.
   *  \param s String representation of dimensions 'lxwxh'
   */
-  Box(std::string const& s)
+  explicit Box(std::string const& s)
  {
    std::size_t pos = 0;
    l_ = std::stoul(s, &pos, 10);
@@ -22,22 +22,22 @@ struct Box
  }

  // How much paper does this box need?
-  unsigned long paper_needed() const
+  [[nodiscard]] auto paper_needed() const -> std::uint64_t
  {
-    unsigned long s1 = l_ * w_;
-    unsigned long s2 = w_ * h_;
-    unsigned long s3 = h_ * l_;
+    std::uint64_t s1 = l_ * w_;
+    std::uint64_t s2 = w_ * h_;
+    std::uint64_t s3 = h_ * l_;
    return 2 * (s1 + s2 + s3) + std::min({s1, s2, s3});
  }

-  unsigned long l_;
-  unsigned long w_;
-  unsigned long h_;
+  std::uint64_t l_;
+  std::uint64_t w_;
+  std::uint64_t h_;
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
-  unsigned long total = 0;
+  std::uint64_t total = 0;
  for (std::string line; std::getline(std::cin, line);) {
    Box b(line);
    auto amount = b.paper_needed();
--- a/2015/puzzle-02-02.cc
+++ b/2015/puzzle-02-02.cc
@@ -6,9 +6,9 @@
 struct Box
 {
  /** Construct box.
-   *  \param s String representation of dimensions 'lxwxh'
+   *  \param s String representation of dimensions `lxwxh`
   */
-  Box(std::string const& s)
+  explicit Box(std::string const& s)
  {
    std::size_t pos = 0;
    l_ = std::stoul(s, &pos, 10);
@@ -22,33 +22,33 @@ struct Box
  }

  // How much paper does this box need?
-  unsigned long paper_needed() const
+  [[nodiscard]] auto paper_needed() const -> std::uint64_t
  {
-    unsigned long s1 = l_ * w_;
-    unsigned long s2 = w_ * h_;
-    unsigned long s3 = h_ * l_;
+    auto s1{l_ * w_};
+    auto s2{w_ * h_};
+    auto s3{h_ * l_};
    return 2 * (s1 + s2 + s3) + std::min({s1, s2, s3});
  }

  // How much ribbon do we need?
-  unsigned long ribbon_needed() const
+  [[nodiscard]] auto ribbon_needed() const -> std::uint64_t
  {
    // The various side perimeters - we want the min of these multiplied by
    // volume.
-    unsigned long p1 = 2 * (l_ + w_);
-    unsigned long p2 = 2 * (w_ + h_);
-    unsigned long p3 = 2 * (h_ + l_);
+    auto p1{2 * (l_ + w_)};
+    auto p2{2 * (w_ + h_)};
+    auto p3{2 * (h_ + l_)};
    return l_ * w_ * h_ + std::min({p1, p2, p3});
  }

-  unsigned long l_;
-  unsigned long w_;
-  unsigned long h_;
+  std::uint64_t l_;
+  std::uint64_t w_;
+  std::uint64_t h_;
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
-  unsigned long total = 0;
+  std::uint64_t total = 0;
  for (std::string line; std::getline(std::cin, line);) {
    Box b(line);
    auto amount = b.ribbon_needed();
--- a/2015/puzzle-03-01.cc
+++ b/2015/puzzle-03-01.cc
@@ -1,19 +1,17 @@
 #include <algorithm>
-#include <cassert>
 #include <iostream>
 #include <set>
-#include <string>

 struct Pos
 {
-  Pos(int x, int y) : x_(x), y_(y) {}
+  Pos(int x, int y) : x_(x), y_(y) {}  // NOLINT(bugprone-easily-swappable-parameters)

-  bool operator<(Pos const& rhs) const noexcept
+  auto operator<(Pos const& rhs) const noexcept -> bool
  {
    return x_ < rhs.x_ || (x_ == rhs.x_ && y_ < rhs.y_);
  }

-  bool operator==(Pos const& rhs) const noexcept { return x_ == rhs.x_ && y_ == rhs.y_; }
+  auto operator==(Pos const& rhs) const noexcept -> bool { return x_ == rhs.x_ && y_ == rhs.y_; }

  void move(char c)
  {
@@ -40,7 +38,7 @@ struct Pos
  int y_;
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    std::set<Pos> visited;
--- a/2015/puzzle-03-02.cc
+++ b/2015/puzzle-03-02.cc
@@ -1,19 +1,17 @@
 #include <algorithm>
-#include <cassert>
 #include <iostream>
 #include <set>
-#include <string>

 struct Pos
 {
-  Pos(int x, int y) : x_(x), y_(y) {}
+  Pos(int x, int y) : x_(x), y_(y) {}  // NOLINT(bugprone-easily-swappable-parameters)

-  bool operator<(Pos const& rhs) const noexcept
+  auto operator<(Pos const& rhs) const noexcept -> bool
  {
    return x_ < rhs.x_ || (x_ == rhs.x_ && y_ < rhs.y_);
  }

-  bool operator==(Pos const& rhs) const noexcept { return x_ == rhs.x_ && y_ == rhs.y_; }
+  auto operator==(Pos const& rhs) const noexcept -> bool { return x_ == rhs.x_ && y_ == rhs.y_; }

  void move(char c) noexcept
  {
@@ -40,25 +38,25 @@ struct Pos
  int y_;
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    std::set<Pos> visited;
    Pos santa(0, 0);
-    Pos robo_santa(0, 0);
+    Pos robot_santa(0, 0);
    visited.insert(santa);
-    visited.insert(robo_santa);
-    bool do_robo = false;
+    visited.insert(robot_santa);
+    bool do_robot = false;
    for (auto c : line) {
-      if (do_robo) {
-        robo_santa.move(c);
-        visited.insert(robo_santa);
+      if (do_robot) {
+        robot_santa.move(c);
+        visited.insert(robot_santa);
      }
      else {
        santa.move(c);
        visited.insert(santa);
      }
-      do_robo = !do_robo;
+      do_robot = !do_robot;
    }
    std::cout << "Houses visited = " << visited.size() << "\n";
  }
--- a/2015/puzzle-04-01.cc
+++ b/2015/puzzle-04-01.cc
@@ -1,27 +1,27 @@
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <iostream>
-#include <set>
 #include <string>

 #include <openssl/evp.h>

-using MD5Digest = unsigned char[EVP_MAX_MD_SIZE];
+using MD5Digest = std::array<unsigned char, EVP_MAX_MD_SIZE>;

-unsigned int md5(MD5Digest digest, std::string const& s)
+auto md5(MD5Digest& digest, std::string const& s) -> unsigned int
 {
  EVP_MD const* md{EVP_md5()};
-  unsigned int md_len;
+  unsigned int md_len{0};

-  EVP_MD_CTX* md_ctxt{EVP_MD_CTX_new()};
-  assert(md_ctxt != NULL);
-  EVP_DigestInit_ex2(md_ctxt, md, NULL);
-  EVP_DigestUpdate(md_ctxt, s.data(), s.length());
-  EVP_DigestFinal_ex(md_ctxt, digest, &md_len);
+  EVP_MD_CTX* md_context{EVP_MD_CTX_new()};
+  assert(md_context != nullptr);
+  EVP_DigestInit_ex2(md_context, md, nullptr);
+  EVP_DigestUpdate(md_context, s.data(), s.length());
+  EVP_DigestFinal_ex(md_context, digest.data(), &md_len);
  return md_len;
 }

-bool is_valid(std::string const& s)
+auto is_valid(std::string const& s) -> bool
 {
  MD5Digest digest;
  auto len = md5(digest, s);
@@ -29,7 +29,7 @@ bool is_valid(std::string const& s)
  return digest[0] == 0 && digest[1] == 0 && (digest[2] & 0xf0) == 0;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    unsigned i = 0;
--- a/2015/puzzle-04-02.cc
+++ b/2015/puzzle-04-02.cc
@@ -1,27 +1,27 @@
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <iostream>
-#include <set>
 #include <string>

 #include <openssl/evp.h>

-using MD5Digest = unsigned char[EVP_MAX_MD_SIZE];
+using MD5Digest = std::array<unsigned char, EVP_MAX_MD_SIZE>;

-unsigned int md5(MD5Digest digest, std::string const& s)
+auto md5(MD5Digest& digest, std::string const& s) -> unsigned int
 {
  EVP_MD const* md{EVP_md5()};
-  unsigned int md_len;
+  unsigned int md_len{0};

-  EVP_MD_CTX* md_ctxt{EVP_MD_CTX_new()};
-  assert(md_ctxt != NULL);
-  EVP_DigestInit_ex2(md_ctxt, md, NULL);
-  EVP_DigestUpdate(md_ctxt, s.data(), s.length());
-  EVP_DigestFinal_ex(md_ctxt, digest, &md_len);
+  EVP_MD_CTX* md_context{EVP_MD_CTX_new()};
+  assert(md_context != nullptr);
+  EVP_DigestInit_ex2(md_context, md, nullptr);
+  EVP_DigestUpdate(md_context, s.data(), s.length());
+  EVP_DigestFinal_ex(md_context, digest.data(), &md_len);
  return md_len;
 }

-bool is_valid(std::string const& s)
+auto is_valid(std::string const& s) -> bool
 {
  MD5Digest digest;
  auto len = md5(digest, s);
@@ -29,7 +29,7 @@ bool is_valid(std::string const& s)
  return digest[0] == 0 && digest[1] == 0 && digest[2] == 0;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    unsigned i = 0;
--- a/2015/puzzle-05-01.cc
+++ b/2015/puzzle-05-01.cc
@@ -1,7 +1,5 @@
 #include <algorithm>
-#include <cassert>
 #include <iostream>
-#include <set>
 #include <string>

 // Check if a string is nice:
@@ -9,7 +7,7 @@
 //  >=3 vowels
 //  At least one double letter
 //  No instances of 'ab', 'cd', 'pq', or 'xy'.
-bool is_nice(std::string const& s) noexcept
+auto is_nice(std::string const& s) noexcept -> bool
 {
  unsigned vowel_count = 0;
  bool repeated = false;
@@ -33,7 +31,7 @@ bool is_nice(std::string const& s) noexcept
  return repeated && vowel_count >= 3;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  unsigned nice_strings;
  for (std::string line; std::getline(std::cin, line);) {
--- a/2015/puzzle-05-02.cc
+++ b/2015/puzzle-05-02.cc
@@ -1,21 +1,19 @@
 #include <algorithm>
-#include <cassert>
 #include <iostream>
-#include <set>
 #include <string>

 // Check if a string is nice:
 // Nice strings have:
 //   repeated double letters - but not overlapping
 //   repeated letters separated by one other.
-bool is_nice(std::string const& s) noexcept
+auto is_nice(std::string const& s) noexcept -> bool
 {
  bool repeated_pair = false;
  bool repeated_sep = false;

  std::cout << s;
  for (std::string::size_type i = 0; i < s.length() - 2; ++i) {
-    // Find whether the two characters starting at i are repeated in the rest of
+    // Find whether the two characters starting at `i` are repeated in the rest of
    // the string.  We don't have to look backwards as we will already have
    // scanned it.
    if (s.substr(i + 2).find(s.substr(i, 2)) != std::string::npos) {
@@ -35,11 +33,11 @@ bool is_nice(std::string const& s) noexcept
  return repeated_pair && repeated_sep;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
-  unsigned nice_strings;
+  unsigned nice_strings{0};
  for (std::string line; std::getline(std::cin, line);) {
-    nice_strings += is_nice(line);
+    nice_strings += is_nice(line) ? 1 : 0;
  }
  std::cout << nice_strings << '\n';

--- a/2015/puzzle-06-01.cc
+++ b/2015/puzzle-06-01.cc
@@ -2,7 +2,6 @@
 #include <cassert>
 #include <iostream>
 #include <regex>
-#include <set>
 #include <string>

 enum class Action { TurnOn, Toggle, TurnOff };
@@ -12,9 +11,9 @@ using Point = std::pair<unsigned, unsigned>;
 /// A command
 struct Command
 {
-  Command(std::string const& s)
+  explicit Command(std::string const& s)
  {
-    const char* re = "(turn on|toggle|turn off)\\s(\\d+),(\\d+)\\sthrough\\s(\\d+),(\\d+)";
+    const char* re = R"((turn on|toggle|turn off)\s(\d+),(\d+)\sthrough\s(\d+),(\d+))";
    std::smatch m;
    if (!std::regex_search(s, m, std::regex(re))) {
      std::cerr << "Unable to interpret:" << s << "\n";
@@ -51,7 +50,7 @@ struct Array
  {
    for (unsigned i = 0; i < N; ++i) {
      for (unsigned j = 0; j < N; ++j) {
-        lights_[i][j] = false;
+        lights_[i][j] = false;  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
      }
    }
  }
@@ -68,13 +67,14 @@ struct Array
      for (unsigned j = command.bottom_left_.second; j <= command.top_right_.second; ++j) {
        switch (command.act_) {
        case Action::TurnOn:
-          lights_[i][j] = true;
+          lights_[i][j] = true;  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
          break;
        case Action::Toggle:
-          lights_[i][j] = !lights_[i][j];
+          lights_[i][j] =    // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+            !lights_[i][j];  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
          break;
        case Action::TurnOff:
-          lights_[i][j] = false;
+          lights_[i][j] = false;  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
          break;
        }
      }
@@ -82,12 +82,12 @@ struct Array
  }

  /// How many lights are on
-  unsigned num_on() const noexcept
+  [[nodiscard]] auto num_on() const noexcept -> unsigned
  {
    unsigned count = 0;
    for (unsigned i = 0; i < N; ++i) {
      for (unsigned j = 0; j < N; ++j) {
-        count += lights_[i][j];
+        count += lights_[i][j];  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
      }
    }

@@ -100,7 +100,9 @@ struct Array
    std::cout << "P1\n" << N << " " << N << "\n";
    for (unsigned i = 0; i < N; ++i) {
      for (unsigned j = 0; j < N; ++j) {
-        std::cout << (lights_[i][j] ? "1" : "0");
+        std::cout << (lights_[i][j]  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+                        ? "1"
+                        : "0");  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        if (j % 70 == 0) {
          std::cout << "\n";
        }
@@ -109,10 +111,10 @@ struct Array
    }
  }

-  bool lights_[N][N];
+  bool lights_[N][N]{};  // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
  Array<1000> arr;
  for (std::string line; std::getline(std::cin, line);) {
--- a/2015/puzzle-06-02.cc
+++ b/2015/puzzle-06-02.cc
@@ -2,16 +2,15 @@
 #include <cassert>
 #include <iostream>
 #include <regex>
-#include <set>
 #include <string>

 enum class Action { TurnOn, Toggle, TurnOff };
 using Point = std::pair<unsigned, unsigned>;
 struct Command
 {
-  Command(std::string const& s)
+  explicit Command(std::string const& s)
  {
-    const char* re = "(turn on|toggle|turn off)\\s(\\d+),(\\d+)\\sthrough\\s(\\d+),(\\d+)";
+    const char* re = R"((turn on|toggle|turn off)\s(\d+),(\d+)\sthrough\s(\d+),(\d+))";
    std::smatch m;
    if (!std::regex_search(s, m, std::regex(re))) {
      std::cerr << "Unable to interpret:" << s << "\n";
@@ -47,7 +46,7 @@ struct Array
  {
    for (unsigned i = 0; i < N; ++i) {
      for (unsigned j = 0; j < N; ++j) {
-        lights_[i][j] = 0;
+        lights_[i][j] = 0;  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
      }
    }
  }
@@ -63,14 +62,14 @@ struct Array
      for (unsigned j = command.bottom_left_.second; j <= command.top_right_.second; ++j) {
        switch (command.act_) {
        case Action::TurnOn:
-          ++lights_[i][j];
+          ++lights_[i][j];  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
          break;
        case Action::Toggle:
-          lights_[i][j] += 2;
+          lights_[i][j] += 2;  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
          break;
        case Action::TurnOff:
-          if (lights_[i][j] > 0) {
-            --lights_[i][j];
+          if (lights_[i][j] > 0) {  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+            --lights_[i][j];        // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
          }
          break;
        }
@@ -78,12 +77,12 @@ struct Array
    }
  }

-  unsigned brightness() const noexcept
+  [[nodiscard]] auto brightness() const noexcept -> unsigned
  {
    unsigned count = 0;
    for (unsigned i = 0; i < N; ++i) {
      for (unsigned j = 0; j < N; ++j) {
-        count += lights_[i][j];
+        count += lights_[i][j];  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
      }
    }
    return count;
@@ -95,23 +94,24 @@ struct Array
    unsigned max = 0;
    for (unsigned i = 0; i < N; ++i) {
      for (unsigned j = 0; j < N; ++j) {
-        if (lights_[i][j] > max) {
-          max = lights_[i][j];
+        if (lights_[i][j] > max) {  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+          max = lights_[i][j];      // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }
      }
    }
    std::cout << "P2\n" << N << " " << N << "\n" << max << "\n";
    for (unsigned i = 0; i < N; ++i) {
      for (unsigned j = 0; j < N; ++j) {
-        std::cout << lights_[i][j] << "\n";
+        std::cout << lights_[i][j]  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+                  << "\n";
      }
    }
  }

-  unsigned lights_[N][N];
+  unsigned lights_[N][N]{};  // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
  Array<1000> arr;
  for (std::string line; std::getline(std::cin, line);) {
--- a/2015/puzzle-07-01.cc
+++ b/2015/puzzle-07-01.cc
@@ -44,7 +44,7 @@ enum class Action {
 };

 /// Pretty-print action
-std::ostream& operator<<(std::ostream& os, Action act)
+auto operator<<(std::ostream& os, Action act) -> std::ostream&
 {
  switch (act) {
  case Action::Set:
@@ -74,7 +74,7 @@ using Wire = std::string;                  ///< Wire name (string)
 using Signal = std::variant<Value, Wire>;  ///< Either a wire or explicit value

 /// Outputter for a signal
-std::ostream& operator<<(std::ostream& os, Signal const& signal)
+auto operator<<(std::ostream& os, Signal const& signal) -> std::ostream&
 {
  return std::visit(
    [&os](auto&& arg) -> std::ostream& {
@@ -97,10 +97,10 @@ struct Instruction
   *    set    := signal '->' wire
   *    not    := 'NOT' set
   *    op     := 'AND' | 'OR' | 'LSHIFT' | 'RSHIFT'
-   *    binop  := signal op signal '->' wire
-   *    instr  := binop | not | set
+   *    bin-op  := signal op signal '->' wire
+   *    instr  := bin-op | not | set
   */
-  Instruction(std::string const& s)
+  explicit Instruction(std::string const& s)
  {
    if (parse_bin_op(s)) {
      return;
@@ -116,16 +116,16 @@ struct Instruction
  }

  /// Get action
-  Action action() const noexcept { return act_; }
+  [[nodiscard]] auto action() const noexcept -> Action { return act_; }

  /// Get the destination wire
-  Wire const& dest() const noexcept { return dest_; }
+  [[nodiscard]] auto dest() const noexcept -> Wire const& { return dest_; }

  /// Get the first (or only) source
-  Signal const& src1() const noexcept { return src1_; }
+  [[nodiscard]] auto src1() const noexcept -> Signal const& { return src1_; }

  /// Get the second source
-  Signal const& src2() const noexcept
+  [[nodiscard]] auto src2() const noexcept -> Signal const&
  {
    assert(act_ != Action::Set && act_ != Action::Not);
    return src2_;
@@ -133,7 +133,7 @@ struct Instruction

 private:
  /// Parse a <not> instruction.  Return true if successful.
-  bool parse_not(std::string const& s)
+  auto parse_not(std::string const& s) -> bool
  {
    if (s.substr(0, 4) == "NOT ") {
      std::string::size_type pos = 4;
@@ -146,7 +146,7 @@ private:
  }

  /// Parse a <bin_op> instruction.  Return true if successful.
-  bool parse_bin_op(std::string const& s)
+  auto parse_bin_op(std::string const& s) -> bool
  {
    static const std::regex re("^([[:lower:][:digit:]]+) ([[:upper:]]+) "
                               "([[:lower:][:digit:]]+) -> ([[:lower:]]+)");
@@ -181,7 +181,7 @@ private:
  ///
  /// Also used for the latter half of <not> parsing.  ACT tells you what is
  /// being parsed. Returns true if parsing successful.
-  bool parse_set(std::string const& s, Action act = Action::Set)
+  auto parse_set(std::string const& s, Action act = Action::Set) -> bool
  {
    static const std::regex re("^([[:lower:][:digit:]]+) -> ([[:lower:]]+)");
    std::smatch m;
@@ -196,25 +196,23 @@ private:
  }

  /// Make a Signal from a string.
-  Signal make_signal(std::string const& s)
+  static auto make_signal(std::string const& s) -> Signal
  {
-    if (std::isdigit(s[0])) {
+    if (std::isdigit(s[0]) == 1) {
      auto u = std::stoul(s, nullptr, 10);
      assert(u <= UINT16_MAX);
-      return Signal(static_cast<std::uint16_t>(u));
-    }
-    else {
-      return Signal(s);
+      return {static_cast<std::uint16_t>(u)};
    }
+    return {s};
  }

-  Action act_;          ///< Action
-  Wire dest_;           ///< Destination wire
-  Signal src1_, src2_;  ///< Source signals
+  Action act_{Action::Not};  ///< Action
+  Wire dest_;                ///< Destination wire
+  Signal src1_, src2_;       ///< Source signals
 };

 /// Outputter for an instruction.
-std::ostream& operator<<(std::ostream& os, Instruction const& instr)
+auto operator<<(std::ostream& os, Instruction const& instr) -> std::ostream&
 {
  os << instr.action() << " " << instr.dest() << ", " << instr.src1();
  if (instr.action() != Action::Set && instr.action() != Action::Not) {
@@ -230,27 +228,31 @@ using Instructions = std::vector<Instruction>;  ///< Instructions to execute
 struct VM
 {
  /// Add an instruction the the list we have
-  void add_instr(Instruction const& instr) { instrs_.push_back(instr); }
+  void add_instr(Instruction const& instr) { instructions_.push_back(instr); }

  /// Has this wire a known value?
-  bool has_value(Wire const& w) const noexcept { return values_.find(w) != values_.end(); }
+  [[nodiscard]] auto has_value(Wire const& w) const noexcept -> bool
+  {
+    return values_.find(w) != values_.end();
+  }

  /// Has this signal a known value?
-  bool has_value(Signal const& s) const noexcept
+  [[nodiscard]] auto has_value(Signal const& s) const noexcept -> bool
  {
-    return std::visit(
-      Overloaded{[](Value v) { return true; }, [&](Wire const& w) { return has_value(w); }}, s);
+    return std::visit(Overloaded{[]([[maybe_unused]] Value v) { return true; },
+                                 [&](Wire const& w) { return has_value(w); }},
+                      s);
  }

  /// Get the value on the wire
-  Value value(Wire const& w) const noexcept
+  [[nodiscard]] auto value(Wire const& w) const noexcept -> Value
  {
    assert(has_value(w));
    return values_.find(w)->second;
  }

  /// Get the value of a signal
-  Value value(Signal const& s) const noexcept
+  [[nodiscard]] auto value(Signal const& s) const noexcept -> Value
  {
    return std::visit(
      Overloaded{[](Value v) { return v; }, [&](Wire const& w) { return value(w); }}, s);
@@ -267,15 +269,17 @@ struct VM
  void value(Signal const& s, Value v)
  {
    std::visit(
-      Overloaded{[v](Value v2) { assert(v == v2); }, [&, v](Wire const& w) { value(w, v); }}, s);
+      Overloaded{[v](Value v2) { assert(v == v2); },       // NOLINT(bugprone-lambda-function-name)
+                 [&, v](Wire const& w) { value(w, v); }},  // NOLINT(bugprone-lambda-function-name)
+      s);                                                  // NOLINT(bugprone-lambda-function-name)
  }

  /// Execute the instructions.  Returns true if we have updated some wire
  /// values.
-  bool execute()
+  auto execute() -> bool
  {
    bool done_anything = false;
-    for (auto const& instr : instrs_) {
+    for (auto const& instr : instructions_) {
      done_anything |= execute_instr(instr);
    }

@@ -290,13 +294,13 @@ private:
   * An instruction may not be executed if the incoming signals have not been
   * set yet.
   */
-  bool execute_instr(Instruction const& instr)
+  auto execute_instr(Instruction const& instr) -> bool
  {
    std::cout << instr << " # ";

-    // First of all check there is something to do - i.e. that the destination
+    // First check there is something to do - i.e. that the destination
    // register has not been set already.
-    Wire dest = instr.dest();
+    auto const& dest{instr.dest()};
    if (has_value(dest)) {
      std::cout << "already has value: " << dest << " = " << value(dest) << "\n";
      return false;
@@ -325,10 +329,10 @@ private:
   *  \param  fn    How to modify the source value to the dest.
   *  \return       True if we executed the function.
   */
-  bool execute_single_src(Instruction const& instr, std::function<Value(Value)> fn)
+  auto execute_single_src(Instruction const& instr, const std::function<Value(Value)>& fn) -> bool
  {
-    Wire dest = instr.dest();
-    Signal src = instr.src1();
+    auto const& dest{instr.dest()};
+    Signal const& src{instr.src1()};
    if (has_value(src)) {
      value(dest, fn(value(src)));
      std::cout << "setting wire to: " << dest << " = " << value(dest) << "\n";
@@ -344,11 +348,12 @@ private:
   *  \param  fn    How to modify the source values to the dest.
   *  \return       True if we executed the function.
   */
-  bool execute_double_src(Instruction const& instr, std::function<Value(Value, Value)> fn)
+  auto execute_double_src(Instruction const& instr, const std::function<Value(Value, Value)>& fn)
+    -> bool
  {
-    Wire dest = instr.dest();
-    Signal src1 = instr.src1();
-    Signal src2 = instr.src2();
+    auto const& dest{instr.dest()};
+    auto const& src1{instr.src1()};
+    auto const& src2{instr.src2()};
    if (has_value(src1) && has_value(src2)) {
      value(dest, fn(value(src1), value(src2)));
      std::cout << "setting wire to: " << dest << " = " << value(dest) << "\n";
@@ -360,10 +365,10 @@ private:
  }

  ValueMap values_;
-  Instructions instrs_;
+  Instructions instructions_;
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
  VM vm;

--- a/2015/puzzle-07-02.cc
+++ b/2015/puzzle-07-02.cc
@@ -44,7 +44,7 @@ enum class Action {
 };

 /// Pretty-print action
-std::ostream& operator<<(std::ostream& os, Action act)
+auto operator<<(std::ostream& os, Action act) -> std::ostream&
 {
  switch (act) {
  case Action::Set:
@@ -74,7 +74,7 @@ using Wire = std::string;                  ///< Wire name (string)
 using Signal = std::variant<Value, Wire>;  ///< Either a wire or explicit value

 /// Outputter for a signal
-std::ostream& operator<<(std::ostream& os, Signal const& signal)
+auto operator<<(std::ostream& os, Signal const& signal) -> std::ostream&
 {
  return std::visit(
    [&os](auto&& arg) -> std::ostream& {
@@ -100,7 +100,7 @@ struct Instruction
   *    binop  := signal op signal '->' wire
   *    instr  := binop | not | set
   */
-  Instruction(std::string const& s)
+  explicit Instruction(std::string const& s)
  {
    if (parse_bin_op(s)) {
      return;
@@ -116,16 +116,16 @@ struct Instruction
  }

  /// Get action
-  Action action() const noexcept { return act_; }
+  [[nodiscard]] auto action() const noexcept -> Action { return act_; }

  /// Get the destination wire
-  Wire const& dest() const noexcept { return dest_; }
+  [[nodiscard]] auto dest() const noexcept -> Wire const& { return dest_; }

  /// Get the first (or only) source
-  Signal const& src1() const noexcept { return src1_; }
+  [[nodiscard]] auto src1() const noexcept -> Signal const& { return src1_; }

  /// Get the second source
-  Signal const& src2() const noexcept
+  [[nodiscard]] auto src2() const noexcept -> Signal const&
  {
    assert(act_ != Action::Set && act_ != Action::Not);
    return src2_;
@@ -133,7 +133,7 @@ struct Instruction

 private:
  /// Parse a <not> instruction.  Return true if successful.
-  bool parse_not(std::string const& s)
+  auto parse_not(std::string const& s) -> bool
  {
    if (s.substr(0, 4) == "NOT ") {
      std::string::size_type pos = 4;
@@ -146,7 +146,7 @@ private:
  }

  /// Parse a <bin_op> instruction.  Return true if successful.
-  bool parse_bin_op(std::string const& s)
+  auto parse_bin_op(std::string const& s) -> bool
  {
    static const std::regex re("^([[:lower:][:digit:]]+) ([[:upper:]]+) "
                               "([[:lower:][:digit:]]+) -> ([[:lower:]]+)");
@@ -181,7 +181,7 @@ private:
  ///
  /// Also used for the latter half of <not> parsing.  ACT tells you what is
  /// being parsed. Returns true if parsing successful.
-  bool parse_set(std::string const& s, Action act = Action::Set)
+  auto parse_set(std::string const& s, Action act = Action::Set) -> bool
  {
    static const std::regex re("^([[:lower:][:digit:]]+) -> ([[:lower:]]+)");
    std::smatch m;
@@ -196,25 +196,23 @@ private:
  }

  /// Make a Signal from a string.
-  Signal make_signal(std::string const& s)
+  static auto make_signal(std::string const& s) -> Signal
  {
-    if (std::isdigit(s[0])) {
+    if (std::isdigit(s[0]) == 1) {
      auto u = std::stoul(s, nullptr, 10);
      assert(u <= UINT16_MAX);
-      return Signal(static_cast<std::uint16_t>(u));
-    }
-    else {
-      return Signal(s);
+      return {static_cast<std::uint16_t>(u)};
    }
+    return {s};
  }

-  Action act_;          ///< Action
-  Wire dest_;           ///< Destination wire
-  Signal src1_, src2_;  ///< Source signals
+  Action act_{Action::Not};  ///< Action
+  Wire dest_;                ///< Destination wire
+  Signal src1_, src2_;       ///< Source signals
 };

 /// Outputter for an instruction.
-std::ostream& operator<<(std::ostream& os, Instruction const& instr)
+auto operator<<(std::ostream& os, Instruction const& instr) -> std::ostream&
 {
  os << instr.action() << " " << instr.dest() << ", " << instr.src1();
  if (instr.action() != Action::Set && instr.action() != Action::Not) {
@@ -230,27 +228,30 @@ using Instructions = std::vector<Instruction>;  ///< Instructions to execute
 struct VM
 {
  /// Add an instruction the the list we have
-  void add_instr(Instruction const& instr) { instrs_.push_back(instr); }
+  void add_instr(Instruction const& instr) { instructions_.push_back(instr); }

  /// Has this wire a known value?
-  bool has_value(Wire const& w) const noexcept { return values_.find(w) != values_.end(); }
+  [[nodiscard]] auto has_value(Wire const& w) const noexcept -> bool
+  {
+    return values_.find(w) != values_.end();
+  }

  /// Has this signal a known value?
-  bool has_value(Signal const& s) const noexcept
+  [[nodiscard]] auto has_value(Signal const& s) const noexcept -> bool
  {
    return std::visit(
-      Overloaded{[](Value v) { return true; }, [&](Wire const& w) { return has_value(w); }}, s);
+      Overloaded{[](Value /*v*/) { return true; }, [&](Wire const& w) { return has_value(w); }}, s);
  }

  /// Get the value on the wire
-  Value value(Wire const& w) const noexcept
+  [[nodiscard]] auto value(Wire const& w) const noexcept -> Value
  {
    assert(has_value(w));
    return values_.find(w)->second;
  }

  /// Get the value of a signal
-  Value value(Signal const& s) const noexcept
+  [[nodiscard]] auto value(Signal const& s) const noexcept -> Value
  {
    return std::visit(
      Overloaded{[](Value v) { return v; }, [&](Wire const& w) { return value(w); }}, s);
@@ -267,15 +268,17 @@ struct VM
  void value(Signal const& s, Value v)
  {
    std::visit(
-      Overloaded{[v](Value v2) { assert(v == v2); }, [&, v](Wire const& w) { value(w, v); }}, s);
+      Overloaded{[v](Value v2) { assert(v == v2); },
+                 [&, v](Wire const& w) { value(w, v); }},  // NOLINT(bugprone-lambda-function-name)
+      s);                                                  // NOLINT(bugprone-lambda-function-name)
  }

  /// Execute the instructions.  Returns true if we have updated some wire
  /// values.
-  bool execute()
+  auto execute() -> bool
  {
    bool done_anything = false;
-    for (auto const& instr : instrs_) {
+    for (auto const& instr : instructions_) {
      done_anything |= execute_instr(instr);
    }

@@ -290,13 +293,13 @@ private:
   * An instruction may not be executed if the incoming signals have not been
   * set yet.
   */
-  bool execute_instr(Instruction const& instr)
+  auto execute_instr(Instruction const& instr) -> bool
  {
    std::cout << instr << " # ";

    // First of all check there is something to do - i.e. that the destination
    // register has not been set already.
-    Wire dest = instr.dest();
+    auto const& dest = instr.dest();
    if (has_value(dest)) {
      std::cout << "already has value: " << dest << " = " << value(dest) << "\n";
      return false;
@@ -325,10 +328,10 @@ private:
   *  \param  fn    How to modify the source value to the dest.
   *  \return       True if we executed the function.
   */
-  bool execute_single_src(Instruction const& instr, std::function<Value(Value)> fn)
+  auto execute_single_src(Instruction const& instr, const std::function<Value(Value)>& fn) -> bool
  {
-    Wire dest = instr.dest();
-    Signal src = instr.src1();
+    const Wire& dest = instr.dest();
+    const Signal& src = instr.src1();
    if (has_value(src)) {
      value(dest, fn(value(src)));
      std::cout << "setting wire to: " << dest << " = " << value(dest) << "\n";
@@ -344,11 +347,12 @@ private:
   *  \param  fn    How to modify the source values to the dest.
   *  \return       True if we executed the function.
   */
-  bool execute_double_src(Instruction const& instr, std::function<Value(Value, Value)> fn)
+  auto execute_double_src(Instruction const& instr, const std::function<Value(Value, Value)>& fn)
+    -> bool
  {
-    Wire dest = instr.dest();
-    Signal src1 = instr.src1();
-    Signal src2 = instr.src2();
+    const Wire& dest = instr.dest();
+    const Signal& src1 = instr.src1();
+    const Signal& src2 = instr.src2();
    if (has_value(src1) && has_value(src2)) {
      value(dest, fn(value(src1), value(src2)));
      std::cout << "setting wire to: " << dest << " = " << value(dest) << "\n";
@@ -360,10 +364,10 @@ private:
  }

  ValueMap values_;
-  Instructions instrs_;
+  Instructions instructions_;
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
  VM vm;

--- a/2015/puzzle-08-01.cc
+++ b/2015/puzzle-08-01.cc
@@ -1,14 +1,11 @@
 #include <cassert>
 #include <functional>
 #include <iostream>
-#include <map>
-#include <regex>
 #include <string>
-#include <variant>

 enum class State { Begin, Normal, Escape, Hex1, Hex2, End };

-std::string unescape(std::string const& s)
+auto unescape(std::string const& s) -> std::string
 {
  std::string unescaped;
  static const std::string hex = "0123456789abcdef0123456789ABCDEF";
@@ -56,7 +53,7 @@ std::string unescape(std::string const& s)
      auto idx = hex.find(c);
      assert(idx != std::string::npos);
      byte = (byte << 4) + (idx & 0xf);
-      unescaped += (char)byte;
+      unescaped += static_cast<char>(byte);
      state = State::Normal;
      break;
    }
@@ -67,7 +64,7 @@ std::string unescape(std::string const& s)
  return unescaped;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  unsigned len = 0;

--- a/2015/puzzle-08-02.cc
+++ b/2015/puzzle-08-02.cc
@@ -1,12 +1,7 @@
-#include <cassert>
 #include <functional>
 #include <iostream>
-#include <map>
-#include <regex>
-#include <string>
-#include <variant>

-std::string escape(std::string const& s)
+auto escape(std::string const& s) -> std::string
 {
  std::string escaped;
  escaped += '"';
@@ -20,7 +15,7 @@ std::string escape(std::string const& s)
  return escaped;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  unsigned len = 0;

--- a/2015/puzzle-09-01.cc
+++ b/2015/puzzle-09-01.cc
@@ -21,8 +21,7 @@ struct Graph
    std::smatch m;
    if (!std::regex_search(s, m, re)) {
      std::cout << "Failed to match: " << s << "\n";
-      assert(false);
-      return;
+      abort();
    }
    auto n1 = m.str(1);
    auto n2 = m.str(2);
@@ -37,7 +36,7 @@ struct Graph
    std::cout << n1 << " <-> " << n2 << " weight: " << w << "\n";
  }

-  Weight solve_tsp() const
+  [[nodiscard]] auto solve_tsp() const -> Weight
  {
    Weight min_weight = ~0U;
    std::vector<Node> nodes(nodes_.begin(), nodes_.end());
@@ -67,7 +66,7 @@ struct Graph
  Edges weights_;
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
  Graph g;

--- a/2015/puzzle-09-02.cc
+++ b/2015/puzzle-09-02.cc
@@ -21,8 +21,7 @@ struct Graph
    std::smatch m;
    if (!std::regex_search(s, m, re)) {
      std::cout << "Failed to match: " << s << "\n";
-      assert(false);
-      return;
+      abort();
    }
    auto n1 = m.str(1);
    auto n2 = m.str(2);
@@ -37,7 +36,7 @@ struct Graph
    std::cout << n1 << " <-> " << n2 << " weight: " << w << "\n";
  }

-  Weight solve_tsp() const
+  [[nodiscard]] auto solve_tsp() const -> Weight
  {
    Weight min_weight = ~0U;
    visit_all_perms([&min_weight](Weight w) {
@@ -49,7 +48,7 @@ struct Graph
    return min_weight;
  }

-  Weight solve_max_tsp() const
+  [[nodiscard]] auto solve_max_tsp() const -> Weight
  {
    Weight max_weight = 0;
    visit_all_perms([&max_weight](Weight w) {
@@ -86,7 +85,7 @@ private:
  Edges weights_;
 };

-int main(int argc, char** argv)
+auto main() -> int
 {
  Graph g;

--- a/2015/puzzle-10-01.cc
+++ b/2015/puzzle-10-01.cc
@@ -1,13 +1,8 @@
-#include <cassert>
 #include <functional>
 #include <iostream>
-#include <map>
-#include <regex>
-#include <set>
 #include <string>
-#include <variant>

-std::string look_and_say(std::string const& s)
+auto look_and_say(std::string const& s) -> std::string
 {
  std::string result;
  for (std::string::size_type i = 0; i < s.length();) {
@@ -23,7 +18,7 @@ std::string look_and_say(std::string const& s)
  return result;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    std::cout << "Application 0, length = " << line.length() << ": " << line << "\n";
--- a/2015/puzzle-10-02.cc
+++ b/2015/puzzle-10-02.cc
@@ -1,13 +1,8 @@
-#include <cassert>
 #include <functional>
 #include <iostream>
-#include <map>
-#include <regex>
-#include <set>
 #include <string>
-#include <variant>

-std::string look_and_say(std::string const& s)
+auto look_and_say(std::string const& s) -> std::string
 {
  std::string result;
  for (std::string::size_type i = 0; i < s.length();) {
@@ -23,7 +18,7 @@ std::string look_and_say(std::string const& s)
  return result;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    std::cout << "Application 0, length = " << line.length() << ": " << line << "\n";
--- a/2015/puzzle-11-01.cc
+++ b/2015/puzzle-11-01.cc
@@ -1,13 +1,9 @@
 #include <cassert>
 #include <functional>
 #include <iostream>
-#include <map>
-#include <regex>
-#include <set>
 #include <string>
-#include <variant>

-bool illegal_char(char c) { return c == 'i' || c == 'l' || c == 'o'; }
+auto illegal_char(char c) -> bool { return c == 'i' || c == 'l' || c == 'o'; }

 void pre_advance_password(std::string& s)
 {
@@ -43,7 +39,7 @@ void advance_password(std::string& s)
  }
 }

-bool valid_password(std::string const& s)
+auto valid_password(std::string const& s) -> bool
 {
  unsigned double_count = 0;
  bool run = false;
@@ -63,7 +59,7 @@ bool valid_password(std::string const& s)
  return double_count >= 2 && run;
 }

-std::string next_password(std::string const& s)
+auto next_password(std::string const& s) -> std::string
 {
  std::string result = s;
  pre_advance_password(result);
@@ -73,7 +69,7 @@ std::string next_password(std::string const& s)
  return result;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    std::string next = next_password(line);
--- a/2015/puzzle-11-02.cc
+++ b/2015/puzzle-11-02.cc
@@ -1,13 +1,9 @@
 #include <cassert>
 #include <functional>
 #include <iostream>
-#include <map>
-#include <regex>
-#include <set>
 #include <string>
-#include <variant>

-bool illegal_char(char c) { return c == 'i' || c == 'l' || c == 'o'; }
+auto illegal_char(char c) -> bool { return c == 'i' || c == 'l' || c == 'o'; }

 void pre_advance_password(std::string& s)
 {
@@ -43,7 +39,7 @@ void advance_password(std::string& s)
  }
 }

-bool valid_password(std::string const& s)
+auto valid_password(std::string const& s) -> bool
 {
  unsigned double_count = 0;
  bool run = false;
@@ -63,7 +59,7 @@ bool valid_password(std::string const& s)
  return double_count >= 2 && run;
 }

-std::string next_password(std::string const& s)
+auto next_password(std::string const& s) -> std::string
 {
  std::string result = s;
  pre_advance_password(result);
@@ -73,7 +69,7 @@ std::string next_password(std::string const& s)
  return result;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  for (std::string line; std::getline(std::cin, line);) {
    std::string next = next_password(line);
--- a/2015/puzzle-12-01.cc
+++ b/2015/puzzle-12-01.cc
@@ -1,13 +1,9 @@
-#include <cassert>
 #include <functional>
 #include <iostream>
-#include <map>
 #include <regex>
-#include <set>
 #include <string>
-#include <variant>

-int parse_numbers(std::string const& s)
+auto parse_numbers(std::string const& s) -> int
 {
  static const std::regex re("-?\\d+");
  std::string left = s;
@@ -21,7 +17,7 @@ int parse_numbers(std::string const& s)
  return acc;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  int acc = 0;
  for (std::string line; std::getline(std::cin, line);) {
--- a/2015/puzzle-12-02.cc
+++ b/2015/puzzle-12-02.cc
@@ -2,23 +2,15 @@
 #include <cctype>
 #include <functional>
 #include <iostream>
-#include <map>
-#include <regex>
-#include <set>
 #include <string>
-#include <variant>

-int do_parse(std::string const& s, std::string::size_type& pos)
+auto do_parse(std::string const& s, std::string::size_type& pos) -> int
 {
  int result = 0;
  bool ignore = false;

  while (pos < s.size()) {
-    if (s[pos] == '{') {
-      ++pos;
-      result += do_parse(s, pos);
-    }
-    else if (s[pos] == '[') {
+    if (s[pos] == '{' || s[pos] == '[') {
      ++pos;
      result += do_parse(s, pos);
    }
@@ -40,7 +32,7 @@ int do_parse(std::string const& s, std::string::size_type& pos)
      }
      pos = e + 1;
    }
-    else if (std::isdigit(s[pos]) || s[pos] == '-') {
+    else if (std::isdigit(s[pos]) == 1 || s[pos] == '-') {
      std::size_t len = 0;
      result += std::stoi(s.substr(pos), &len);
      pos += len;
@@ -54,7 +46,7 @@ int do_parse(std::string const& s, std::string::size_type& pos)
  return result;
 }

-int parse_numbers(std::string const& s)
+auto parse_numbers(std::string const& s) -> int
 {
  std::string::size_type pos = 0;
  int result = do_parse(s, pos);
@@ -62,7 +54,7 @@ int parse_numbers(std::string const& s)
  return result;
 }

-int main(int argc, char** argv)
+auto main() -> int
 {
  int acc = 0;
  for (std::string line; std::getline(std::cin, line);) {
--- a/2020/puzzle-08-01.cc
+++ b/2020/puzzle-08-01.cc
@@ -89,16 +89,16 @@ struct VM
  void add_instruction(Instruction const& i)
  {
    std::cout << i << "\n";
-    instrs_.push_back(i);
+    instructions_.push_back(i);
  }

  void execute()
  {
-    std::vector<bool> seen(instrs_.size(), false);
+    std::vector<bool> seen(instructions_.size(), false);
    while (!seen[pc_]) {
-      assert(pc_ < instrs_.size());
+      assert(pc_ < instructions_.size());
      seen[pc_] = true;
-      execute(instrs_[pc_]);
+      execute(instructions_[pc_]);
      ++pc_;
    }
    std::cout << "PC seen before: " << pc_ << "\n";
@@ -127,7 +127,7 @@ private:
    std::cout << "\n";
  }

-  Instructions instrs_;
+  Instructions instructions_;
  std::size_t pc_;
  Value acc_;
 };
--- a/2020/puzzle-08-02.cc
+++ b/2020/puzzle-08-02.cc
@@ -104,20 +104,20 @@ struct VM
  void add_instruction(Instruction const& i)
  {
    std::cout << i << "\n";
-    instrs_.push_back(i);
+    instructions_.push_back(i);
  }

  bool execute()
  {
-    std::vector<bool> seen(instrs_.size(), false);
+    std::vector<bool> seen(instructions_.size(), false);
    acc_ = 0;
    pc_ = 0;
    while (!seen[pc_]) {
-      assert(pc_ < instrs_.size());
+      assert(pc_ < instructions_.size());
      seen[pc_] = true;
-      execute(instrs_[pc_]);
+      execute(instructions_[pc_]);
      ++pc_;
-      if (pc_ == instrs_.size()) {
+      if (pc_ == instructions_.size()) {
        std::cout << "Terminated\n";
        return true;
      }
@@ -128,13 +128,13 @@ struct VM

  void find_fix()
  {
-    for (std::size_t pos = 0; pos < instrs_.size(); ++pos) {
-      if (instrs_[pos].flip_jmp()) {
+    for (std::size_t pos = 0; pos < instructions_.size(); ++pos) {
+      if (instructions_[pos].flip_jmp()) {
        if (execute()) {
-          std::cout << "Success at instruction " << pos << ": " << instrs_[pos] << "\n";
+          std::cout << "Success at instruction " << pos << ": " << instructions_[pos] << "\n";
          return;
        }
-        instrs_[pos].flip_jmp();
+        instructions_[pos].flip_jmp();
      }
    }
  }
@@ -162,7 +162,7 @@ private:
    std::cout << "\n";
  }

-  Instructions instrs_;
+  Instructions instructions_;
  std::size_t pc_;
  Value acc_;
 };