C语言根据天数计算周数的实现方法与代码示例

#include <time.h>
 
// 主要时间类型
time_t;        // 日历时间，通常是从1970年1月1日00:00:00 UTC开始的秒数
struct tm;     // 分解时间，包含年、月、日、时、分、秒等详细信息
clock_t;       // 处理器时间，用于性能测量

struct tm {
    int tm_sec;   // 秒 (0-61，允许闰秒)
    int tm_min;   // 分 (0-59)
    int tm_hour;  // 时 (0-23)
    int tm_mday;  // 月中的天 (1-31)
    int tm_mon;   // 月 (0-11，0表示1月)
    int tm_year;  // 年 (从1900开始的年数)
    int tm_wday;  // 星期几 (0-6，0表示星期日)
    int tm_yday;  // 年中的天 (0-365)
    int tm_isdst; // 夏令时标志
};

周数 = (天数差值 + 起始偏移) / 7
余数 = (天数差值 + 起始偏移) % 7

#include <stdio.h>
 
/**
 * 基础周数计算 - 简单除法
 * @param days 总天数
 * @return 周数（向下取整）
 */
int calculate_weeks_basic(int days) {
    if (days < 0) {
        return -1; // 错误处理
    }
    return days / 7;  // 整数除法自动向下取整
}
 
/**
 * 基础周数计算 - 包含余数
 * @param days 总天数
 * @param remaining_days 剩余天数（输出参数）
 * @return 完整周数
 */
int calculate_weeks_with_remainder(int days, int *remaining_days) {
    if (days < 0 || remaining_days == NULL) {
        return -1;
    }
    *remaining_days = days % 7;
    return days / 7;
}
 
int main() {
    int days = 30;
    int remaining;
    int weeks = calculate_weeks_with_remainder(days, &remaining);
    
    printf("%d天 = %d周 余 %d天\n", days, weeks, remaining);
    return 0;
}

#include <stdio.h>
#include <time.h>
 
/**
 * 计算两个日期之间的周数差
 * @param start_tm 开始日期
 * @param end_tm 结束日期
 * @return 周数差值（-1表示错误）
 */
int calculate_weeks_between_dates(struct tm *start_tm, struct tm *end_tm) {
    if (!start_tm || !end_tm) {
        return -1;
    }
    
    // 转换为time_t进行计算
    time_t start_time = mktime(start_tm);
    time_t end_time = mktime(end_tm);
    
    if (start_time == -1 || end_time == -1) {
        return -1;
    }
    
    // 计算秒数差值
    double seconds_diff = difftime(end_time, start_time);
    
    // 转换为天数
    int days_diff = (int)(seconds_diff / (24 * 3600));
    
    // 计算周数
    return days_diff / 7;
}
 
/**
 * 获取指定日期是该年的第几周（ISO 8601标准）
 * @param year 年份
 * @param month 月份 (1-12)
 * @param day 日期 (1-31)
 * @return 周数（1-53），错误返回-1
 */
int get_iso_week_number(int year, int month, int day) {
    struct tm date = {0};
    date.tm_year = year - 1900;  // tm_year是从1900开始的年数
    date.tm_mon = month - 1;      // tm_mon是0-11
    date.tm_mday = day;
    date.tm_hour = 12;           // 设置为中午，避免DST影响
    date.tm_min = 0;
    date.tm_sec = 0;
    
    // 标准化日期结构
    time_t time_val = mktime(&date);
    if (time_val == -1) {
        return -1;
    }
    
    // 重新获取标准化后的日期
    struct tm *normalized = localtime(&time_val);
    if (!normalized) {
        return -1;
    }
    
    // 计算该年的第一天
    struct tm year_start = {0};
    year_start.tm_year = year - 1900;
    year_start.tm_mon = 0;
    year_start.tm_mday = 1;
    year_start.tm_hour = 12;
    
    time_t year_start_time = mktime(&year_start);
    if (year_start_time == -1) {
        return -1;
    }
    
    struct tm *year_start_tm = localtime(&year_start_time);
    if (!year_start_tm) {
        return -1;
    }
    
    // 计算从年初开始的天数
    int days_from_year_start = normalized->tm_yday;
    
    // 计算第一周的偏移（ISO 8601：第一周包含第一个周四）
    int first_week_offset = (year_start_tm->tm_wday + 6) % 7; // 转换为周一为0
    
    // 调整天数计算
    int adjusted_days = days_from_year_start - (6 - first_week_offset);
    
    if (adjusted_days < 0) {
        // 日期在上一年度的最后一周
        return 1;
    }
    
    return (adjusted_days / 7) + 1;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
/**
 * 判断是否为闰年
 * @param year 年份
 * @return 1表示闰年，0表示平年
 */
int is_leap_year(int year) {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
 
/**
 * 获取指定月份的天数
 * @param year 年份
 * @param month 月份 (1-12)
 * @return 天数，错误返回-1
 */
int get_days_in_month(int year, int month) {
    if (month < 1 || month > 12) {
        return -1;
    }
    
    static const int days_in_month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    
    int days = days_in_month[month - 1];
    
    // 2月份特殊处理闰年
    if (month == 2 && is_leap_year(year)) {
        days = 29;
    }
    
    return days;
}
 
/**
 * 计算从公元1年1月1日到指定日期的总天数
 * @param year 年份
 * @param month 月份
 * @param day 日期
 * @return 总天数，错误返回-1
 */
long long calculate_total_days(int year, int month, int day) {
    if (year < 1 || month < 1 || month > 12 || day < 1) {
        return -1;
    }
    
    // 检查日期有效性
    int max_days = get_days_in_month(year, month);
    if (day > max_days) {
        return -1;
    }
    
    long long total_days = 0;
    
    // 计算完整年份的天数
    for (int y = 1; y < year; y++) {
        total_days += is_leap_year(y) ? 366 : 365;
    }
    
    // 计算当前年份中完整月份的天数
    for (int m = 1; m < month; m++) {
        total_days += get_days_in_month(year, m);
    }
    
    // 加上当前月份的天数
    total_days += day - 1;
    
    return total_days;
}
 
/**
 * 计算两个日期之间的精确周数
 * @param start_year 开始年份
 * @param start_month 开始月份
 * @param start_day 开始日期
 * @param end_year 结束年份
 * @param end_month 结束月份
 * @param end_day 结束日期
 * @param include_partial_week 是否计算不足一周的部分
 * @return 周数，错误返回-1.0
 */
double calculate_precise_weeks(int start_year, int start_month, int start_day,
                              int end_year, int end_month, int end_day,
                              int include_partial_week) {
    
    long long start_days = calculate_total_days(start_year, start_month, start_day);
    long long end_days = calculate_total_days(end_year, end_month, end_day);
    
    if (start_days == -1 || end_days == -1 || start_days > end_days) {
        return -1.0;
    }
    
    long long days_diff = end_days - start_days;
    
    if (include_partial_week) {
        return (double)days_diff / 7.0;
    } else {
        return (double)(days_diff / 7);
    }
}

#include <stdio.h>
#include <limits.h>
#include <errno.h>
 
/**
 * 增强的错误处理版本
 */
typedef enum {
    DATE_OK = 0,
    DATE_INVALID_INPUT = -1,
    DATE_OUT_OF_RANGE = -2,
    DATE_INVALID_FORMAT = -3,
    DATE_SYSTEM_ERROR = -4
} DateError;
 
/**
 * 安全的周数计算器
 * @param days 天数
 * @param weeks 输出参数：周数
 * @param remaining 输出参数：剩余天数
 * @return 错误代码
 */
DateError safe_calculate_weeks(int days, int *weeks, int *remaining) {
    // 输入验证
    if (!weeks || !remaining) {
        return DATE_INVALID_INPUT;
    }
    
    // 范围检查
    if (days < 0 || days > INT_MAX / 7) {
        return DATE_OUT_OF_RANGE;
    }
    
    // 计算周数和余数
    *weeks = days / 7;
    *remaining = days % 7;
    
    return DATE_OK;
}
 
/**
 * 错误信息获取函数
 */
const char* get_date_error_message(DateError error) {
    switch (error) {
        case DATE_OK:
            return "Success";
        case DATE_INVALID_INPUT:
            return "Invalid input parameters";
        case DATE_OUT_OF_RANGE:
            return "Date value out of valid range";
        case DATE_INVALID_FORMAT:
            return "Invalid date format";
        case DATE_SYSTEM_ERROR:
            return "System error occurred";
        default:
            return "Unknown error";
    }
}

/**
 * 动态内存分配的安全处理
 */
char* format_weeks_result(int weeks, int remaining) {
    // 计算所需缓冲区大小
    size_t buffer_size = snprintf(NULL, 0, "%d周 %d天", weeks, remaining) + 1;
    
    // 分配内存
    char *result = (char*)malloc(buffer_size);
    if (!result) {
        return NULL;
    }
    
    // 格式化字符串
    snprintf(result, buffer_size, "%d周 %d天", weeks, remaining);
    
    return result;
}
 
/**
 * 使用示例和内存管理
 */
void demonstrate_safe_usage() {
    int days = 45;
    int weeks, remaining;
    
    DateError error = safe_calculate_weeks(days, &weeks, &remaining);
    
    if (error == DATE_OK) {
        char *formatted = format_weeks_result(weeks, remaining);
        if (formatted) {
            printf("结果: %s\n", formatted);
            free(formatted);  // 记得释放内存
        } else {
            printf("内存分配失败\n");
        }
    } else {
        printf("计算失败: %s\n", get_date_error_message(error));
    }
}

#include <stdio.h>
#include <time.h>
 
/**
 * 预计算优化版本
 * 使用查找表避免重复计算
 */
#define MAX_YEAR 2100
#define MIN_YEAR 1900
 
static int days_before_month[2][13] = {
    // 平年
    {0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
    // 闰年
    {0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
};
 
/**
 * 优化的周数计算
 * 使用预计算表提高性能
 */
int fast_weeks_between_dates(int year1, int month1, int day1,
                            int year2, int month2, int day2) {
    
    // 快速路径：同一年内的计算
    if (year1 == year2) {
        int leap = is_leap_year(year1);
        int days1 = days_before_month[leap][month1] + day1 - 1;
        int days2 = days_before_month[leap][month2] + day2 - 1;
        return (days2 - days1) / 7;
    }
    
    // 跨年度计算（简化版本）
    int total_days = 0;
    
    // 第一年剩余天数
    int leap = is_leap_year(year1);
    int days_in_year1 = is_leap_year(year1) ? 366 : 365;
    int days1 = days_before_month[leap][month1] + day1 - 1;
    total_days += days_in_year1 - days1;
    
    // 中间完整年份
    for (int year = year1 + 1; year < year2; year++) {
        total_days += is_leap_year(year) ? 366 : 365;
    }
    
    // 最后一年已过天数
    leap = is_leap_year(year2);
    int days2 = days_before_month[leap][month2] + day2 - 1;
    total_days += days2;
    
    return total_days / 7;
}

#include <pthread.h>
#include <stdio.h>
 
typedef struct {
    int start_year;
    int end_year;
    long long total_days;
} YearRange;
 
/**
 * 线程函数：计算指定年份范围内的总天数
 */
void* calculate_years_days(void* arg) {
    YearRange* range = (YearRange*)arg;
    range->total_days = 0;
    
    for (int year = range->start_year; year <= range->end_year; year++) {
        range->total_days += is_leap_year(year) ? 366 : 365;
    }
    
    return NULL;
}
 
/**
 * 多线程优化的周数计算
 */
int parallel_weeks_calculation(int start_year, int end_year) {
    const int num_threads = 4;
    pthread_t threads[num_threads];
    YearRange ranges[num_threads];
    
    int years_per_thread = (end_year - start_year + 1) / num_threads;
    
    // 创建线程
    for (int i = 0; i < num_threads; i++) {
        ranges[i].start_year = start_year + i * years_per_thread;
        ranges[i].end_year = (i == num_threads - 1) ? end_year : 
                            ranges[i].start_year + years_per_thread - 1;
        
        pthread_create(&threads[i], NULL, calculate_years_days, &ranges[i]);
    }
    
    // 等待所有线程完成
    long long total_days = 0;
    for (int i = 0; i < num_threads; i++) {
        pthread_join(threads[i], NULL);
        total_days += ranges[i].total_days;
    }
    
    return total_days / 7;
}

#include <stdio.h>
#include <time.h>
 
/**
 * 项目进度跟踪器
 * 计算项目已进行周数和剩余周数
 */
typedef struct {
    char name[100];
    struct tm start_date;
    struct tm end_date;
    int total_weeks;
    int elapsed_weeks;
} Project;
 
/**
 * 初始化项目信息
 */
void init_project(Project* project, const char* name, 
                 int start_year, int start_month, int start_day,
                 int end_year, int end_month, int end_day) {
    
    strncpy(project->name, name, sizeof(project->name) - 1);
    project->name[sizeof(project->name) - 1] = '\0';
    
    // 设置开始日期
    project->start_date.tm_year = start_year - 1900;
    project->start_date.tm_mon = start_month - 1;
    project->start_date.tm_mday = start_day;
    project->start_date.tm_hour = 12;
    project->start_date.tm_min = 0;
    project->start_date.tm_sec = 0;
    
    // 设置结束日期
    project->end_date.tm_year = end_year - 1900;
    project->end_date.tm_mon = end_month - 1;
    project->end_date.tm_mday = end_day;
    project->end_date.tm_hour = 12;
    project->end_date.tm_min = 0;
    project->end_date.tm_sec = 0;
    
    // 标准化日期
    mktime(&project->start_date);
    mktime(&project->end_date);
    
    // 计算总周数
    time_t start_time = mktime(&project->start_date);
    time_t end_time = mktime(&project->end_date);
    int days_diff = (int)(difftime(end_time, start_time) / (24 * 3600));
    project->total_weeks = days_diff / 7;
}
 
/**
 * 更新项目进度
 */
void update_project_progress(Project* project) {
    time_t current_time;
    time(&current_time);
    
    time_t start_time = mktime(&project->start_date);
    int days_elapsed = (int)(difftime(current_time, start_time) / (24 * 3600));
    project->elapsed_weeks = days_elapsed / 7;
}
 
/**
 * 显示项目进度
 */
void display_project_status(const Project* project) {
    update_project_progress((Project*)project);
    
    int remaining_weeks = project->total_weeks - project->elapsed_weeks;
    double progress_percentage = (double)project->elapsed_weeks / project->total_weeks * 100.0;
    
    printf("\n=== 项目进度报告 ===\n");
    printf("项目名称: %s\n", project->name);
    printf("总周数: %d周\n", project->total_weeks);
    printf("已进行: %d周\n", project->elapsed_weeks);
    printf("剩余: %d周\n", remaining_weeks);
    printf("完成进度: %.1f%%\n", progress_percentage);
    
    // 简单的进度条
    printf("进度: [");
    int progress_bar_length = 50;
    int filled = (int)(progress_percentage / 100.0 * progress_bar_length);
    
    for (int i = 0; i < filled; i++) {
        printf("=");
    }
    for (int i = filled; i < progress_bar_length; i++) {
        printf(" ");
    }
    printf("]\n");
}

#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
    int week_number;
    double value;
    int count;
} WeeklyData;
 
/**
 * 按周聚合数据
 * 将日常数据聚合为周度数据
 */
WeeklyData* aggregate_by_week(const double* daily_data, int total_days, int* num_weeks) {
    *num_weeks = (total_days + 6) / 7;  // 向上取整
    
    WeeklyData* weekly_data = (WeeklyData*)calloc(*num_weeks, sizeof(WeeklyData));
    if (!weekly_data) {
        return NULL;
    }
    
    for (int i = 0; i < total_days; i++) {
        int week_index = i / 7;
        weekly_data[week_index].week_number = week_index + 1;
        weekly_data[week_index].value += daily_data[i];
        weekly_data[week_index].count++;
    }
    
    // 计算平均值
    for (int i = 0; i < *num_weeks; i++) {
        if (weekly_data[i].count > 0) {
            weekly_data[i].value /= weekly_data[i].count;
        }
    }
    
    return weekly_data;
}

#include <stdio.h>
#include <assert.h>
#include <string.h>
 
/**
 * 简单的测试框架
 */
#define TEST_ASSERT(condition, message) \
    do { \
        if (!(condition)) { \
            printf("测试失败: %s\n", message); \
            printf("  文件: %s\n", __FILE__); \
            printf("  行号: %d\n", __LINE__); \
            return 0; \
        } \
    } while(0)
 
/**
 * 测试基础周数计算
 */
int test_basic_weeks_calculation() {
    printf("测试基础周数计算...\n");
    
    // 测试正常情况
    TEST_ASSERT(calculate_weeks_basic(7) == 1, "7天应该等于1周");
    TEST_ASSERT(calculate_weeks_basic(14) == 2, "14天应该等于2周");
    TEST_ASSERT(calculate_weeks_basic(30) == 4, "30天应该等于4周");
    
    // 测试边界情况
    TEST_ASSERT(calculate_weeks_basic(0) == 0, "0天应该等于0周");
    TEST_ASSERT(calculate_weeks_basic(6) == 0, "6天应该等于0周");
    
    // 测试错误情况
    TEST_ASSERT(calculate_weeks_basic(-1) == -1, "负数天数应该返回错误");
    
    printf("基础周数计算测试通过!\n");
    return 1;
}
 
/**
 * 测试日期差值计算
 */
int test_date_difference() {
    printf("测试日期差值计算...\n");
    
    struct tm date1 = {0};
    struct tm date2 = {0};
    
    // 设置测试日期
    date1.tm_year = 2024 - 1900;
    date1.tm_mon = 0;  // 1月
    date1.tm_mday = 1;
    date1.tm_hour = 12;
    
    date2.tm_year = 2024 - 1900;
    date2.tm_mon = 0;  // 1月
    date2.tm_mday = 15;  // 14天后
    date2.tm_hour = 12;
    
    mktime(&date1);
    mktime(&date2);
    
    int weeks = calculate_weeks_between_dates(&date1, &date2);
    TEST_ASSERT(weeks == 2, "1月1日到1月15日应该是2周");
    
    printf("日期差值计算测试通过!\n");
    return 1;
}
 
/**
 * 运行所有测试
 */
void run_all_tests() {
    printf("=== 运行所有测试 ===\n\n");
    
    int passed = 0;
    int total = 0;
    
    // 运行测试并统计结果
    total++;
    if (test_basic_weeks_calculation()) passed++;
    
    total++;
    if (test_date_difference()) passed++;
    
    printf("\n=== 测试结果 ===\n");
    printf("通过: %d/%d\n", passed, total);
    printf("成功率: %.1f%%\n", (double)passed / total * 100.0);
}

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
 
/**
 * 性能基准测试
 */
void benchmark_weeks_calculation() {
    printf("=== 性能基准测试 ===\n");
    
    const int iterations = 1000000;
    clock_t start, end;
    double cpu_time_used;
    
    // 测试简单除法
    start = clock();
    for (int i = 0; i < iterations; i++) {
        volatile int result = calculate_weeks_basic(i % 365);
    }
    end = clock();
    cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("简单除法: %.3f秒 (%d次迭代)\n", cpu_time_used, iterations);
    
    // 测试带余数的计算
    int remaining;
    start = clock();
    for (int i = 0; i < iterations; i++) {
        volatile int result = calculate_weeks_with_remainder(i % 365, &remaining);
    }
    end = clock();
    cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("带余数计算: %.3f秒 (%d次迭代)\n", cpu_time_used, iterations);
    
    printf("\n性能测试完成!\n");
}