aocpp/2022/06.cpp

#include <algorithm>
#include <array>
#include <cstdint>
#include <iostream>
#include <stdexcept>
#include <string>
#include <limits>

#include <doctest.h>

#include <aocpp/Startup.hpp>

namespace {

auto Solve(std::string const& input, std::size_t n) -> std::size_t
{
  std::array<std::size_t, 256> counts {};
  std::size_t uniques {0};

  auto const inc = [&](char c) {
    uniques += 1 == ++counts[static_cast<std::uint8_t>(c)];
  };

  auto const dec = [&](char c) {
    uniques -= 0 == --counts[static_cast<std::uint8_t>(c)];
  };

  for (std::size_t i = 0; i < n; ++i) {
    inc(input[i]);
  }

  for (std::size_t i = n; i < input.size(); ++i) {
    dec(input[i-n]);
    inc(input[i]);
    if (uniques == n) { return i+1; }
  }

  throw std::runtime_error{"bad input"};
}

} // namespace

TEST_SUITE("2022-06 examples") {
  TEST_CASE("examples") {
    CHECK(Solve("bvwbjplbgvbhsrlpgdmjqwftvncz", 4) == 5);
    CHECK(Solve("nppdvjthqldpwncqszvftbrmjlhg", 4) == 6);
    CHECK(Solve("nznrnfrfntjfmvfwmzdfjlvtqnbhcprsg", 4) == 10);
    CHECK(Solve("zcfzfwzzqfrljwzlrfnpqdbhtmscgvjw", 4) == 11);

    CHECK(Solve("mjqjpqmgbljsphdztnvjfqwrcgsmlb", 14) == 19);
    CHECK(Solve("bvwbjplbgvbhsrlpgdmjqwftvncz", 14) == 23);
    CHECK(Solve("nppdvjthqldpwncqszvftbrmjlhg", 14) == 23);
    CHECK(Solve("nznrnfrfntjfmvfwmzdfjlvtqnbhcprsg", 14) == 29);
    CHECK(Solve("zcfzfwzzqfrljwzlrfnpqdbhtmscgvjw", 14) == 26);
  }
}

auto main(int argc, char** argv) -> int {
  std::string input;
  std::getline(*aocpp::Startup(argc, argv), input);
  std::cout << "Part 1: " << Solve(input, 4) << std::endl;
  std::cout << "Part 2: " << Solve(input, 14) << std::endl;
}