Advent of Code 2018

#include <cstdio>
#include <unordered_set>

int main()
{
	typedef int num_t;

	num_t freq = 0;
	int inp = 0;

	std::unordered_set<num_t> freqs;

	FILE* f = fopen("advent_1_2.txt", "r");

	while (1)
	{
		while(fscanf(f, "%d", &inp) == 1)
		{
			freq += inp;

			if (freqs.find(freq) != freqs.end())
			{
				printf("freq is %d\n", freq);
				return 0;
			}

			freqs.emplace(freq);
		}

		rewind(f);
	}

	return 1;
}

#include <iostream>
#include <iterator>
#include <numeric>

int main(int argc, char *argv[])
{
    std::istream_iterator<int> is(std::cin);
    std::istream_iterator<int> eos;
    int result = accumulate(is, eos, 0);
    std::cout << result << std::endl;
    return 0;
}

#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <unordered_set>
#include <vector>


int main(int argc, char *argv[])
{
    std::istream_iterator<int> is(std::cin);
    std::istream_iterator<int> eos;
    std::vector<int> v;
    copy(is, eos, std::back_inserter(v));

    int s = 0;
    std::unordered_set<int> m;
    while (true) {
        for (const int x : v) {
            if (!m.insert(s).second) {
                std::cout << s << std::endl;
                return 0;
            }
            s += x;
        }
    }
    return 0;
}

#include <iostream>
#include <string>
#include <unordered_map>

int main(int argc, char *argv[])
{
    std::string line;
    int twice = 0;
    int thrice = 0;
    while (std::getline(std::cin, line)) {
        std::unordered_map<char, int> m;
        bool b_twice = false;
        bool b_thrice = false;
        for (char &c : line) {
            auto it = m.find(c);
            if (it != m.end()) {
                (it->second)++;
            } else {
                m.insert({c, 1});
            }
        }
        for (auto &kv : m) {
            if (kv.second == 2 && !b_twice) {
                twice++;
                b_twice = true;
            }
            if (kv.second == 3 && !b_thrice) {
                thrice++;
                b_thrice = true;
            }
        }
    }
    std::cout << twice * thrice << std::endl;
    return 0;
}

#include <iostream>
#include <iterator>
#include <string>
#include <vector>

int main(int argc, char *argv[])
{
    std::istream_iterator<std::string> is(std::cin);
    std::istream_iterator<std::string> eos;
    std::vector<std::string> v;
    copy(is, eos, std::back_inserter(v));
    for (auto it1 = v.begin(); it1 != v.end(); ++it1) {
        for (auto it2 = it1 + 1; it2 != v.end(); ++it2) {
            std::string s1 = *it1;
            std::string s2 = *it2;
            if (s1.length() != s2.length()) {
                continue;
            }
            int diff = -1;
            for (int i = 0; i < s1.size(); ++i) {
                if (s1[i] != s2[i]) {
                    if (diff != -1) {
                        diff = -1;
                        break;
                    }
                    diff = i;
                }
            }
            if (diff != -1) {
                std::cout << s1.substr(0, diff) <<
                    s1.substr(diff + 1, s1.size()) <<
                    std::endl;
                return 0;
            }
        }
    }
    return 0;
}

#include <iostream>
#include <iterator>
#include <regex>
#include <set>
#include <string>
#include <vector>

int main(int argc, char *argv[])
{
    std::vector<std::vector<std::pair<int, int>>> v;
    std::vector<int> ids;
    std::set<int> non_overlapped;
    std::set<std::pair<int, int>> intersections;
    std::string line;
    std::regex re("^#\\s*(\\d+)\\s*@\\s*(\\d+),(\\d+):\\s*(\\d+)x(\\d+)$");
    std::smatch match;
    while (std::getline(std::cin, line)) {
        std::regex_match(line, match, re);
        int id = std::stoi(match[1]);
        ids.push_back(id);
        non_overlapped.insert(id);
        std::vector<std::pair<int, int>> s;
        for (int i = std::stoi(match[2]); i < std::stoi(match[2]) + std::stoi(match[4]); ++i) {
            for (int j = std::stoi(match[3]); j < std::stoi(match[3]) + std::stoi(match[5]); ++j) {
                s.emplace_back(i, j);
            }
        }
        int j = 0;
        for (const auto &s2 : v) {
            std::vector<std::pair<int, int>> intersection;
            std::set_intersection(s.begin(), s.end(),
                                  s2.begin(), s2.end(),
                                  std::back_inserter(intersection));
            intersections.insert(intersection.begin(), intersection.end());
            if (!intersection.empty()) {
                non_overlapped.erase(id);
                non_overlapped.erase(ids[j]);
            }
            ++j;
        }
        v.push_back(s);
    }
    std::cout << intersections.size() << std::endl;
    if (!non_overlapped.empty()) {
        std::cout << *non_overlapped.begin() << std::endl;
    }
    return 0;
}

#include <algorithm>
#include <iostream>
#include <map>
#include <regex>
#include <string>
#include <unordered_map>
#include <vector>

int main(int argc, char *argv[])
{
    std::vector<std::string> v;
    std::string line;
    while (std::getline(std::cin, line)) {
        v.push_back(line);
    }
    std::sort(v.begin(), v.end());
    std::unordered_map<int, std::vector<int>> minutes_asleep;
    std::regex re("^\\[(\\d+)-(\\d+)-(\\d+)\\s+(\\d+):(\\d+)\\]\\s+Guard #(\\d+) begins shift$");
    std::regex re2("^\\[(\\d+)-(\\d+)-(\\d+)\\s+(\\d+):(\\d+)\\].*$");
    std::smatch match;
    int id;
    int minute = -1;
    for (const std::string &line : v) {
        std::regex_match(line, match, re);
        if (!match.empty()) {
            id = std::stoi(match[6]);
        } else {
            std::regex_match(line, match, re2);
            int m = std::stoi(match[5]);
            if (minute == -1) {
                minute = m;
            } else {
                auto x = minutes_asleep.insert({id, std::vector<int>()});
                for (int i = minute; i < m; ++i) {
                    x.first->second.push_back(i);
                }
                minute = -1;
            }
        }
    }
    auto max = std::max_element(minutes_asleep.begin(), minutes_asleep.end(),
                                [](std::pair<int, std::vector<int>> a,
                                   std::pair<int, std::vector<int>> b) {
                                    return a.second.size() < b.second.size();
                                });
    std::unordered_map<int, int> m;
    for (int x : max->second) {
        auto y = m.insert({x, 0});
        y.first->second++;
    }
    int max_minute = std::max_element(m.begin(), m.end(),
                                      [](std::pair<int, int> a,
                                         std::pair<int, int> b) {
                                          return a.second < b.second;
                                      })->first;
    std::cout << max->first * max_minute << std::endl;
    std::map<std::pair<int, int>, int> m2;
    for (const auto &x : minutes_asleep) {
        for (int y : x.second) {
            auto z = m2.insert({{x.first, y}, 0});
            z.first->second++;
        }
    }
    auto max_id_minute = std::max_element(m2.begin(), m2.end(),
                                          [](std::pair<std::pair<int, int>, int> a,
                                             std::pair<std::pair<int, int>, int> b) {
                                              return a.second < b.second;
                                          })->first;
    std::cout << max_id_minute.first * max_id_minute.second << std::endl;
    return 0;
}

#include <cctype>
#include <stack>
#include <string>
#include <iostream>
#include <iterator>

template<class iterator_type>
int f(iterator_type begin, iterator_type end, char skip = 0)
{
    std::stack<char> s;
    for (auto it = begin; it != end; ++it) {
        if (skip == std::tolower(*it)) {
            continue;
        }
        if (!s.empty() && *it != s.top() && std::toupper(*it) == std::toupper(s.top())) {
            s.pop();
        } else {
            s.push(*it);
        }
    }
    return s.size();
}

int main(int argc, char *argv[])
{
    std::string s;
    std::cin >> s;
    std::cout << f(s.begin(), s.end()) << std::endl;
    int min = s.size();
    for (char c = 'a'; c <= 'z'; ++c) {
        min = std::min(min, f(s.begin(), s.end(), c));
    }
    std::cout << min << std::endl;
    return 0;
}