#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <numeric>
#include <tuple>
#include <vector>

namespace bad {

struct result {
	int chosen;
	unsigned tudc;
};

unsigned get_tudc(int in) {
	unsigned x = static_cast<unsigned>((in > 0) ? in : -in);
	unsigned digits{};
	do {
		digits |= 1u << (x % 10);
	} while (x /= 10);
	do {
		x += digits & 1u;
	} while (digits >>= 1u);
	return x;
}

result getSmallestIntegerWithSmallestTUDC(const int* arr, std::size_t size) {
	result ret{2147483647, -1u}; // {signed max, unsigned max}
	result* values = new result[size];
	std::cout << "  For individual values -\n";
	for (std::size_t i = 0; i < size; ++i) {
		values[i] = {arr[i], get_tudc(arr[i])};
		std::cout << "    " << values[i].chosen << " has " << values[i].tudc
		          << " unique digit(s).\n";
		if (values[i].tudc < ret.tudc) {
			ret.tudc = values[i].tudc;
		}
	}
	std::cout << '\n';

	for (std::size_t i = 0; i < size; ++i) {
		if (values[i].tudc == ret.tudc) {
			if (values[i].chosen < ret.chosen) {
				ret.chosen = values[i].chosen;
			}
		}
	}

	delete[] values;
	return ret;
}

int tudc_main(int, char**) {
	std::cout << "blah blah...\n";
	while (true) {
		int choice{};
		std::cout << "\
**********************************************\n\
*                MENU – Hw #2                *\n\
* 1. Calling getSIWSmallestTUDC()            *\n\
* 2. Quit                                    *\n\
**********************************************\n\
Select an option (use integer value only): ";
		std::cin >> choice;
		if (choice == 1) {
			std::size_t count{};
			std::cout << "What is the size of the array? ";
			std::cin >> count;
			std::cout << '\n';
			if (count > 0) {
				int* arr = new int[count];
				result r{};
				for (std::size_t i = 0; i < count; ++i) {
					std::cout << "  Value #" << i << ": ";
					std::cin >> arr[i];
				}
				std::cout << "\nThe working array has 3 values of\n";
				for (std::size_t i = 0; i < count; ++i) {
					std::cout << "  " << arr[i] << '\n';
				}
				std::cout << "\nCalling "
				             "getSmallestIntegerWithSmallestTUDCYourName() with\n"
				             "arguments of\n"
				             "    1. The array of {"
				          << arr[0];
				for (std::size_t i = 1; i < count; ++i) {
					std::cout << ", " << arr[i];
				}
				std::cout << "}; and\n"
				             "    2. The array size of "
				          << count << "\n\n";
				r = getSmallestIntegerWithSmallestTUDC(arr, count);
				std::cout << "After the function call was completed and a value "
				             "was returned.\n\n"
				             "  (1) The smallest TUD is "
				          << r.tudc << "; and\n  (2) " << r.chosen
				          << " is the smallest integer with smallest TUD of "
				          << r.tudc << ".\n\n";
				delete[] arr;
			}
		} else if (choice == 2) {
			std::cout << "\n  Having Fun!...\n";
			break;
		} else if (std::cin) {
			std::cout << "\nYou are very funny here!\n\n";
		} else {
			std::cout << '\n';
			break;
		}
	}
	return 0;
}
} // namespace bad

namespace good {
struct result {
	int chosen;
	unsigned tudc;
};

unsigned get_tudc(int in) {
	auto x = static_cast<unsigned>((in > 0) ? in : -in);
	auto digits = std::bitset<10>{};
	do {
		digits.set(x % 10);
	} while (x /= 10);
	return static_cast<unsigned>(digits.count());
}

template <typename ForwardIt>
result get_smallest_tudc(ForwardIt begin, ForwardIt end) {
	if (begin == end) {
		throw std::invalid_argument("get_smallest_tudc: Empty range not valid");
	} else {
		return std::accumulate(
		    std::next(begin), end, result{*begin, get_tudc(*begin)},
		    [](const result a, const int b) {
			    auto t = get_tudc(b);
			    return (std::tie(a.tudc, a.chosen) < std::tie(t, b))
			               ? a
			               : result{b, t};
		    });
	}
}

int tudc_main(int argc, char** argv) {
	auto display = [](result r) {
		std::cout << "The smallest TUDC is " << r.tudc
		          << " and the smallest input with that TUDC is " << r.chosen
		          << ".\n";
	};
	if (argc > 1) {
		std::vector<int> arr;
		for (int i = 1; i < argc; ++i) {
			arr.push_back(std::stoi(argv[i]));
		}
		display(get_smallest_tudc(arr.begin(), arr.end()));
	} else {
		do {
			std::cout << "Please enter some numbers:\n";
			try {
				display(get_smallest_tudc(std::istream_iterator<int>{std::cin},
				                          std::istream_iterator<int>{}));
				if (std::cin) {
					std::cout << "cin is good\n";
				} else {
					//					std::cout << "cin is: " << (std::cin.bad() ? 'b' :
					//'_')
					//					          << (std::cin.fail() ? 'f' : '_')
					//					          << (std::cin.eof() ? 'e' : '_') << '\n';
					std::cin.clear();
					std::string ignore;
					std::cin >> ignore;
				}
			} catch (std::invalid_argument&) {
				break;
			}
		} while (std::cin);
		if (std::cin.eof()) {
			std::cout << '\n';
		} else if (not std::cin) {
			std::cerr << "Input error.\n";
		}
	}
	return 0;
}
} // namespace good