day2b.cpp

#include <string>
#include <vector>
#include <sstream>
#include <fstream>
#include <cassert>

namespace day2b
{
	// an invalid id has an even number of digits
	// the first half matches the second half
	// now you can split it up to n times, where n is the # of digits
	// so we need to find the factors of the # of digits
	// le epic brute force solution takes ~30 seconds

	int main()
	{
		std::string input0;
		//std::ifstream ifile("day2a_sample.txt");
		std::ifstream ifile("day2a.txt");
		if (ifile.is_open())
		{
			while (!ifile.eof())
			{
				std::string line;
				std::getline(ifile, line);
				input0 += line + '\n';
			}
			assert(input0.back() == '\n');
			input0.pop_back(); // no trailing newline character please
			//__debugbreak();
		}
		else
		{
			assert(0);
		}

		std::vector<std::string> values;
		std::string temp;
		for (char c : input0)
		{
			if (c == '-' || c == ',')
			{
				values.push_back(temp);
				temp = "";
				continue;
			}
			temp += c;
		}
		values.push_back(temp);

		std::vector<std::pair<uint64_t, uint64_t>> ranges;
		for (int i = 0; i < values.size(); i += 2)
		{
			ranges.emplace_back(
				std::stoull(values[i]),
				std::stoull(values[i + 1])
			);
		}

		std::vector<uint64_t> ranges2;
		for (auto& r : ranges)
		{
			for (uint64_t i = r.first; i <= r.second; i++)
			{
				ranges2.push_back(i);
			}
		}

		uint64_t accumulator = 0;
		for (auto v : ranges2)
		{
			std::vector<int> factors;
			int digits = std::floor(std::log10(v)) + 1;
			for (int i = 1; i < digits; i++)
			{
				if (digits % i == 0)
				{
					factors.push_back(i);
				}
			}
			for (int f : factors)
			{
				std::vector<uint64_t> parts;
				uint64_t v_temp = v;
				while (v_temp > 0)
				{
					uint64_t top = v_temp % static_cast<uint64_t>(std::powl(10, f));
					parts.push_back(top);
					v_temp = v_temp / static_cast<uint64_t>(std::powl(10, f));
				}

				bool all_equal = true;
				assert(parts.size());
				for (int i = 0; i < parts.size() - 1; i++) // when size is zero, then zero - 1 is an underflow... cute
				{
					if (parts[i] != parts[i + 1])
					{
						all_equal = false;
						break;
					}
				}

				if (all_equal)
				{
					accumulator += v;
					break;
				}
			}
		}

		__debugbreak();
		return 0;
	}

}