Compiler Explorer

Source code

#include <chrono>
#include <ctime>
#include <iostream>
#include <cmath>
#include <iomanip>

//grok 3 on twitter
namespace grok
{
int getWeekNumber(std::chrono::system_clock::time_point tp) {
    // Convert time_point to time_t
    std::time_t tt = std::chrono::system_clock::to_time_t(tp);
    
    // Convert to tm structure for calendar calculations
    std::tm* tm = std::gmtime(&tt);
    
    // Get day of year (0-365)
    int yday = tm->tm_yday;
    
    // Get day of week (0=Sunday, 6=Saturday)
    int wday = tm->tm_wday;
    
    // Adjust wday to make Monday=0
    wday = (wday + 6) % 7;
    
    // Calculate ISO week number
    int week = (yday + 11 - wday) / 7;
    
    // Handle edge cases at year boundaries
    if (week == 0) {
        // Check if it's the last week of previous year
        std::tm tm_prev = *tm;
        tm_prev.tm_mday = 1;
        tm_prev.tm_mon = 0;
        std::mktime(&tm_prev);
        int prev_yday = 365 + (tm_prev.tm_year % 4 == 0 && (tm_prev.tm_year % 100 != 0 || tm_prev.tm_year % 400 == 0));
        int prev_wday = (tm_prev.tm_wday + 6) % 7;
        return (prev_yday + 11 - prev_wday) / 7;
    }
    else if (week == 53) {
        // Check if it's actually week 1 of next year
        std::tm tm_next = *tm;
        tm_next.tm_mday = 1;
        tm_next.tm_mon = 0;
        tm_next.tm_year += 1;
        std::mktime(&tm_next);
        if (tm_next.tm_yday > 3) {
            return 1;
        }
    }
    return week;
}

int getWeekNumber2(std::chrono::system_clock::time_point tp) {
    // Convert to time_t and tm
    std::time_t tt = std::chrono::system_clock::to_time_t(tp);
    std::tm tm = *std::gmtime(&tt);
    // Store original year
    int year = tm.tm_year + 1900;
    // Get day of year (0-365) and day of week (0=Sunday, 6=Saturday)
    int yday = tm.tm_yday;
    int wday = (tm.tm_wday + 6) % 7; // Adjust to Monday=0
    // Calculate ISO week number
    int week = (yday - wday + 11 + 7 * (wday != 0)) / 7;
    // Handle edge cases
    if (week == 0) {
        // Date belongs to last week of previous year
        tm.tm_year -= 1;
        tm.tm_mon = 11; // December
        tm.tm_mday = 31; // Last day
        std::mktime(&tm);
        yday = tm.tm_yday;
        wday = (tm.tm_wday + 6) % 7;
        return (yday - wday + 11 + 7 * (wday != 0)) / 7;
    }
    
    // Check if week 53 or late week belongs to next year
    if (week >= 52) {
        // Find January 4th of current year
        std::tm tm_jan4 = {};
        tm_jan4.tm_year = tm.tm_year;
        tm_jan4.tm_mon = 0;
        tm_jan4.tm_mday = 4;
        std::mktime(&tm_jan4);
        int jan4_wday = (tm_jan4.tm_wday + 6) % 7;
        int week_of_jan4 = (3 - jan4_wday + 11 + 7 * (jan4_wday != 0)) / 7;
        
        // If date is after Jan 4th's week, it may belong to next year
        if (week > week_of_jan4 || (week == week_of_jan4 && yday >= tm_jan4.tm_yday + (4 - jan4_wday))) {
            // Check if date is in week 1 of next year
            std::tm tm_next = tm;
            tm_next.tm_year += 1;
            tm_next.tm_mon = 0;
            tm_next.tm_mday = 1;
            std::mktime(&tm_next);
            int next_yday = yday - tm_jan4.tm_yday + 3; // Approximate offset
            if (next_yday <= 3) { // If close to Jan 1
                return 1;
            }
        }
    }
    return week;
}

void test(std::chrono::year_month_day ymd,int week)
{
    int weekn = getWeekNumber2(std::chrono::sys_days{ymd});
    std::cout << "grok: "<< ymd.day() << "." << ymd.month() << "."<< ymd.year() <<" Weeknumber: " 
      << weekn << " correct: " << week << " compare: ";
    if(weekn == week)
      std::cout << " pass\n";
    else
      std::cout << " fail\n";
}
}

//chat bot on the website
namespace chatgpt{
    int get_week_number(const std::chrono::system_clock::time_point& time_point) {
     std::time_t t = std::chrono::system_clock::to_time_t(time_point);

// Use std::localtime to convert the time_t to a tm struct
    std::tm tm = *std::localtime(&t);

// Adjust the tm struct to ensure weeks start on Monday
    // tm.tm_wday: Sunday = 0, Monday = 1, ..., Saturday = 6
    // If tm.tm_wday is 0 (Sunday), we want to move it to the previous Monday.
    int weekday = tm.tm_wday == 0 ? 6 : tm.tm_wday - 1;

// The first day of the year (January 1st) is used to determine the week number
    std::tm start_of_year = tm;
    start_of_year.tm_mday = 1;  // Set to January 1st
    start_of_year.tm_hour = start_of_year.tm_min = start_of_year.tm_sec = 0;
    std::mktime(&start_of_year);  // Normalize the tm structure

// Get the day of the year (1-based)
    int day_of_year = tm.tm_yday + 1;

// Determine the week number: day_of_year is 1-based, so subtract the weekday
    // and divide by 7 to get the correct week
    int week_number = (day_of_year + 6 - weekday) / 7;

return week_number;
}

int get_iso_week_number(const std::chrono::system_clock::time_point& time_point) {
    // Convert time_point to system time (std::time_t)
    std::time_t t = std::chrono::system_clock::to_time_t(time_point);

// Use std::localtime to convert the time_t to a tm struct
    std::tm tm = *std::localtime(&t);

// Get the year and month
    int year = tm.tm_year + 1900;  // tm.tm_year is years since 1900
    int month = tm.tm_mon + 1;      // tm.tm_mon is 0-based (0 = January)
    int day = tm.tm_mday;

// Calculate the day of the year (1-based)
    std::tm start_of_year = tm;
    start_of_year.tm_mday = 1;  // Set to January 1st
    std::mktime(&start_of_year);  // Normalize the tm structure
    int day_of_year = tm.tm_yday + 1;

// Determine the day of the week (1-based, Monday=1, Sunday=7)
    int weekday = tm.tm_wday == 0 ? 7 : tm.tm_wday;  // Adjust so Monday = 1, Sunday = 7
    if (weekday == 1) weekday = 0;  // Monday becomes the start of the week.

// Compute the first Thursday of the year to determine ISO week 1
    std::tm first_thursday = start_of_year;
    first_thursday.tm_mday = 4; // ISO week 1 starts on the week containing January 4th
    std::mktime(&first_thursday);  // Normalize the tm structure

// Calculate the difference in days between the first Thursday and the current date
    int days_from_first_thursday = day_of_year - first_thursday.tm_yday;

// Calculate the week number
    int week_number = (days_from_first_thursday + 6 - weekday) / 7 + 1;

return week_number;
}

void test(std::chrono::year_month_day ymd,int week)
{
    int weekn = get_iso_week_number(std::chrono::sys_days{ymd});
    std::cout << "chatgpt: "<< ymd.day() << "." << ymd.month() << "."<< ymd.year() <<" Weeknumber: " << weekn << " correct: " << week << " compare: ";
    if(weekn == week)
      std::cout << " pass\n";
    else
      std::cout << " fail\n";
}
}

namespace claude_chatbot
{
// Returns the ISO week number (1-53) for a given time point
template <typename Clock = std::chrono::system_clock>
int get_week_number(const std::chrono::time_point<Clock>& time_point) {
    // Convert to time_t
    auto time_t_value = Clock::to_time_t(time_point);
    
    // Convert to tm struct
    std::tm tm_value = {};
    
    #if defined(_WIN32) || defined(_WIN64)
    localtime_s(&tm_value, &time_t_value);
    #else
    localtime_r(&time_t_value, &tm_value);
    #endif
    
    // Use the %V format which gives ISO 8601 week number (1-53)
    char buffer[4];
    std::strftime(buffer, sizeof(buffer), "%V", &tm_value);
    
    return std::stoi(buffer);
}

template <typename Clock = std::chrono::system_clock>
int get_week_number_fc(const std::chrono::time_point<Clock>& time_point) {
    int val = -1;
    // Convert to time_t
    auto time_t_value = Clock::to_time_t(time_point);
    
    // Convert to tm struct
    std::tm tm_value= {};
    
    #if defined(_WIN32) || defined(_WIN64)
    localtime_s(&tm_value, &time_t_value);
    #else
    gmtime_r(&time_t_value,&tm_value);
    #endif
    
    // Use the %V format which gives ISO 8601 week number (1-53)
    char buffer[4];
    std::strftime(buffer, sizeof(buffer), "%V", &tm_value);
    
    if(std::from_chars(buffer, buffer+4,val).ec == std::errc{})
        return val;
    return std::stoi(buffer);
}

template <typename Clock = std::chrono::system_clock>
int get_week_number2(const std::chrono::time_point<Clock>& time_point) {
    // Convert to time_t
    auto time_t_value = Clock::to_time_t(time_point);
    // Convert to tm struct
    std::tm tm_value = {};
    #if defined(_WIN32) || defined(_WIN64)
    localtime_s(&tm_value, &time_t_value);
    #else
    localtime_r(&time_t_value, &tm_value);
    #endif
    // Get day of year (0-365)
    int day_of_year = tm_value.tm_yday;
    // Get day of week (0-6, where 0 is Sunday)
    int day_of_week = tm_value.tm_wday;
    // Convert to ISO day of week (1-7, where 1 is Monday)
    int iso_day_of_week = (day_of_week == 0) ? 7 : day_of_week;
    // Get the date of the first day of the year
    std::tm first_day = tm_value;
    first_day.tm_mday = 1;
    first_day.tm_mon = 0;
    // Find the day of week for January 1st
    time_t first_day_time = std::mktime(&first_day);
    std::tm* first_day_tm = std::localtime(&first_day_time);
    int first_day_wday = first_day_tm->tm_wday;
    int iso_first_day = (first_day_wday == 0) ? 7 : first_day_wday;
    
    // Calculate week number according to ISO 8601
    int week = (day_of_year + 7 - iso_day_of_week + iso_first_day) / 7;
    
    // Adjust for special cases
    if (iso_first_day > 4) {
        week--;  // First week of the year doesn't include January 1st
    }
    
    // Special case: last days of December might belong to week 1 of next year
    if (tm_value.tm_mon == 11 && tm_value.tm_mday >= 29) {
        // Check if it's week 1 of next year
        if ((tm_value.tm_mday - tm_value.tm_wday) > 31 - 4) {
            return 1;
        }
    }
    // Special case: first days of January might belong to last week of previous year
    if (week == 0) {
        // Get the last week of the previous year
        std::tm last_day_prev_year = tm_value;
        last_day_prev_year.tm_year--;
        last_day_prev_year.tm_mon = 11;
        last_day_prev_year.tm_mday = 31;
        time_t last_day_prev_time = std::mktime(&last_day_prev_year);
        
        std::tm* last_day_prev_tm = std::localtime(&last_day_prev_time);
        auto prev_year_end = Clock::from_time_t(last_day_prev_time);
        return get_week_number(prev_year_end);
    }
    return week;
}

//C++20
template <typename Clock = std::chrono::system_clock>
int get_week_number3(const std::chrono::time_point<Clock>& time_point) {
    // Convert to year/month/day
    auto days = std::chrono::time_point_cast<std::chrono::days>(time_point);
    auto ymd = std::chrono::year_month_day{days};
    
    // Convert to year/month/weekday
    auto weekday = std::chrono::weekday{days};
    
    // Use year/month/weekday to get week number
    auto ywwd = std::chrono::year_month_weekday{ymd};
    return static_cast<unsigned>(ywwd.weekday_indexed().index());
}
/*
#else // C++17 or earlier

template <typename Clock = std::chrono::system_clock>
int get_iso_week_number(const std::chrono::time_point<Clock>& time_point) {
    // Convert to time_t
    auto time_t_value = Clock::to_time_t(time_point);
    
    // Convert to tm struct
    std::tm tm_value = {};
    
    #if defined(_WIN32) || defined(_WIN64)
    localtime_s(&tm_value, &time_t_value);
    #else
    localtime_r(&time_t_value, &tm_value);
    #endif
    
    // Get the date of Thursday in the current week
    // (since ISO weeks start with Monday and the first week has 4+ days)
    std::tm thursday = tm_value;
    thursday.tm_mday += (3 - ((tm_value.tm_wday + 6) % 7)); // Adjust to Thursday
    std::mktime(&thursday); // Normalize the date
    
    // January 4th is always in week 1 per ISO 8601
    std::tm first_week = thursday;
    first_week.tm_mon = 0;  // January
    first_week.tm_mday = 4; // 4th
    std::mktime(&first_week);
    
    // Count days since first Thursday of the year
    int days = 1 + (thursday.tm_yday - first_week.tm_yday);
    
    // Calculate week number
    return (days / 7) + (days % 7 > 0 ? 1 : 0);
}
#endif*/

//last version as output
template <typename Clock = std::chrono::system_clock>
int get_week_number4(const std::chrono::time_point<Clock>& time_point) {
    // Convert to time_t
    auto time_t_value = Clock::to_time_t(time_point);
    // Convert to tm struct
    std::tm tm_value = {};
    #if defined(_WIN32) || defined(_WIN64)
    localtime_s(&tm_value, &time_t_value);
    #else
    localtime_r(&time_t_value, &tm_value);
    #endif
    // Calculate ISO 8601 week number
    // Shift to Thursday (ISO weeks are defined by Thursday)
    int wday = tm_value.tm_wday;
    if (wday == 0) wday = 7; // Convert Sunday from 0 to 7
    // Find Thursday of the current week
    int delta_to_thu = 4 - wday; // Days to Thursday (Mon=1, Thu=4)
    // Clone current time
    std::tm thursday = tm_value;
    thursday.tm_mday += delta_to_thu;
    std::mktime(&thursday); // Normalize the date
    // January 4th is always in week 1 per ISO 8601
    std::tm jan4 = {};
    jan4.tm_year = thursday.tm_year;
    jan4.tm_mon = 0;  // January
    jan4.tm_mday = 4; // 4th
    jan4.tm_hour = 12; // Noon (to avoid DST issues)
    std::mktime(&jan4);
    // Find the Thursday of week 1
    int jan4_wday = jan4.tm_wday;
    if (jan4_wday == 0) jan4_wday = 7; // Convert Sunday from 0 to 7
    std::tm thu_week1 = jan4;
    thu_week1.tm_mday += (4 - jan4_wday); // Adjust to Thursday
    std::mktime(&thu_week1);
    // Calculate days between Thursday of current week and Thursday of week 1
    int days_diff = thursday.tm_yday - thu_week1.tm_yday;
    // Calculate week number
    int week = (days_diff / 7) + 1;
    return week;
}

template <typename Clock = std::chrono::system_clock>
int get_week_number_improved(const std::chrono::time_point<Clock>& time_point) {
    // Convert to time_t
    auto time_t_value = Clock::to_time_t(time_point);
    // Convert to tm struct
    std::tm tm_value = {};
    #if defined(_WIN32) || defined(_WIN64)
    localtime_s(&tm_value, &time_t_value);
    #else
    localtime_r(&time_t_value, &tm_value);
    #endif
    // Calculate ISO 8601 week number
    // Shift to Thursday (ISO weeks are defined by Thursday)
    int wday = tm_value.tm_wday;
    if (wday == 0) wday = 7; // Convert Sunday from 0 to 7
    // Find Thursday of the current week
    int delta_to_thu = 4 - wday; // Days to Thursday (Mon=1, Thu=4)
    // Clone current time
    std::tm thursday = tm_value;
    thursday.tm_mday += delta_to_thu;
    std::mktime(&thursday); // Normalize the date
    // January 4th is always in week 1 per ISO 8601
    std::tm jan4 = {};
    jan4.tm_year = thursday.tm_year;
    jan4.tm_mon = 0;  // January
    jan4.tm_mday = 4; // 4th
    jan4.tm_hour = 12; // Noon (to avoid DST issues)
    std::mktime(&jan4);
    // Find the Thursday of week 1
    int jan4_wday = jan4.tm_wday;
    if (jan4_wday == 0) jan4_wday = 7; // Convert Sunday from 0 to 7
    std::tm thu_week1 = jan4;
    thu_week1.tm_mday += (4 - jan4_wday); // Adjust to Thursday
    std::mktime(&thu_week1);
    // Calculate days between Thursday of current week and Thursday of week 1
    int days_diff = thursday.tm_yday - thu_week1.tm_yday;
    // Calculate week number
    int week = (days_diff / 7) + 1;
    return week;
}

void test(std::chrono::year_month_day ymd,int week)
{
    int weekn = get_week_number_fc(std::chrono::sys_days{ymd});
    std::cout << "claude_chatbot: "<< ymd.day() << "." << ymd.month() << "."<< ymd.year() <<" Weeknumber: " << weekn << " correct: " << week << " compare: ";
    if(weekn == week)
      std::cout << " pass\n";
    else
      std::cout << " fail\n";
}
}

int main()
{
    using namespace std;
    using namespace std::chrono;
    typedef duration<int, ratio_multiply<hours::period, ratio<24> >::type> days;
    std::chrono::year_month_day ymd(2010y,std::chrono::January,1d);
    system_clock::time_point now = system_clock::now();
    std::cout << "Weeknumber: " << grok::getWeekNumber(now) << "\n";
    /*grok::test({2025y,std::chrono::January,1d},1);
    grok::test({2025y,std::chrono::December,31d},1);
    grok::test({2009y,std::chrono::December,31d},53);
    grok::test({2010y,std::chrono::January,1d},53);
    grok::test({2010y,std::chrono::January,2d},53);
    grok::test({2010y,std::chrono::January,3d},53);
    grok::test({2005y,std::chrono::January,1d},53);
    grok::test({2006y,std::chrono::January,1d},52);//*/

chatgpt::test({2025y,std::chrono::January,1d},1);
    chatgpt::test({2025y,std::chrono::December,31d},1);
    chatgpt::test({2009y,std::chrono::December,31d},53);
    chatgpt::test({2010y,std::chrono::January,1d},53);
    chatgpt::test({2010y,std::chrono::January,2d},53);
    chatgpt::test({2010y,std::chrono::January,3d},53);
    chatgpt::test({2005y,std::chrono::January,1d},53);
    chatgpt::test({2006y,std::chrono::January,1d},52);

claude_chatbot::test({2025y,std::chrono::January,1d},1);
    claude_chatbot::test({2025y,std::chrono::December,31d},1);
    claude_chatbot::test({2009y,std::chrono::December,31d},53);
    claude_chatbot::test({2010y,std::chrono::January,1d},53);
    claude_chatbot::test({2010y,std::chrono::January,2d},53);
    claude_chatbot::test({2010y,std::chrono::January,3d},53);
    claude_chatbot::test({2005y,std::chrono::January,1d},53);
    claude_chatbot::test({2006y,std::chrono::January,1d},52);

std::cout << "\n\n\n";
}