Completely reworked for Date struct

Author: Marcel Weikum

exercises/practice/baffling-birthdays/.meta/example.cpp

@@ -1,45 +1,55 @@
 #include <chrono>
-#include <iomanip>
 #include <random>
-#include <sstream>
-#include <unordered_set>
 
 #include "baffling_birthdays.h"
 
 namespace baffling_birthdays {
 
-bool shared_birthday(const std::vector<std::string>& birthdates) {
-    std::unordered_set<std::string> seen;
-    for (auto const& date : birthdates) {
-        if (date.size() < 10) continue;
-        std::string month_day = date.substr(5, 2) + "-" + date.substr(8, 2);
-        if (seen.count(month_day)) {
-            return true;
-        }
-        seen.insert(month_day);
+Date parse_date(const std::string& iso) {
+    Date d{0, 0, 0};
+    if (iso.size() < 10) return d;
+    try {
+        d.year = std::stoi(iso.substr(0, 4));
+        d.month = std::stoi(iso.substr(5, 2));
+        d.day = std::stoi(iso.substr(8, 2));
+    } catch (...) {
+        d = {0, 0, 0};
+    }
+    return d;
+}
+
+std::string to_string(const Date& d) {
+    std::ostringstream oss;
+    oss << std::setw(4) << std::setfill('0') << d.year << '-' << std::setw(2)
+        << std::setfill('0') << d.month << '-' << std::setw(2)
+        << std::setfill('0') << d.day;
+    return oss.str();
+}
+
+bool shared_birthday(const std::vector<Date>& dates) {
+    std::unordered_set<int> seen_md;
+    seen_md.reserve(dates.size());
+    for (auto const& d : dates) {
+        if (d.month < 1 || d.month > 12 || d.day < 1 || d.day > 31) continue;
+        int key = d.month * 100 + d.day;
+        if (seen_md.count(key)) return true;
+        seen_md.insert(key);
     }
     return false;
 }
 
-std::vector<std::string> random_birthdates(std::size_t group_size) {
+std::vector<Date> random_birthdates_dates(std::size_t group_size) {
     static std::mt19937_64 gen(
         std::chrono::system_clock::now().time_since_epoch().count());
     std::uniform_int_distribution<int> month_dist(1, 12);
     const int days_in_month[12] = {31, 28, 31, 30, 31, 30,
                                    31, 31, 30, 31, 30, 31};
-
-    std::vector<std::string> dates;
+    std::vector<Date> dates;
     dates.reserve(group_size);
     for (std::size_t i = 0; i < group_size; ++i) {
-        int month = month_dist(gen);
-        std::uniform_int_distribution<int> day_dist(1,
-                                                    days_in_month[month - 1]);
-        int day = day_dist(gen);
-        int year = 2001;
-        std::ostringstream oss;
-        oss << year << "-" << std::setw(2) << std::setfill('0') << month << "-"
-            << std::setw(2) << std::setfill('0') << day;
-        dates.push_back(oss.str());
+        int m = month_dist(gen);
+        std::uniform_int_distribution<int> day_dist(1, days_in_month[m - 1]);
+        dates.push_back(Date{2001, m, day_dist(gen)});
     }
     return dates;
 }
@@ -51,8 +61,7 @@ double estimated_probability_of_shared_birthday(std::size_t group_size) {
     for (std::size_t i = 0; i < group_size; ++i) {
         unique_prob *= (365.0 - static_cast<double>(i)) / 365.0;
     }
-    double shared_prob = (1.0 - unique_prob) * 100.0;
-    return shared_prob;
+    return (1.0 - unique_prob) * 100.0;
 }
 
 }  // namespace baffling_birthdays

exercises/practice/baffling-birthdays/.meta/example.h

@@ -1,14 +1,43 @@
 #pragma once
 
+#include <iomanip>
+#include <sstream>
 #include <string>
+#include <unordered_set>
 #include <vector>
 
 namespace baffling_birthdays {
 
-bool shared_birthday(const std::vector<std::string>& birthdates);
+struct Date {
+    int year;
+    int month;
+    int day;
+};
 
-std::vector<std::string> random_birthdates(std::size_t group_size);
+Date parse_date(const std::string& iso);
+
+std::string to_string(const Date& d);
+
+bool shared_birthday(const std::vector<Date>& dates);
+std::vector<Date> random_birthdates_dates(std::size_t group_size);
 
 double estimated_probability_of_shared_birthday(std::size_t group_size);
 
+inline bool shared_birthday(const std::vector<std::string>& birthdates) {
+    std::vector<Date> dates;
+    dates.reserve(birthdates.size());
+    for (auto const& s : birthdates) {
+        dates.push_back(parse_date(s));
+    }
+    return shared_birthday(dates);
+}
+
+inline std::vector<std::string> random_birthdates(std::size_t group_size) {
+    auto dates = random_birthdates_dates(group_size);
+    std::vector<std::string> out;
+    out.reserve(group_size);
+    for (auto const& d : dates) out.push_back(to_string(d));
+    return out;
+}
+
 }  // namespace baffling_birthdays