<think>
题目要求：输入年月日，输出星期几。已知公元1年1月1日是星期一。
算法步骤：
1. 计算从公元1年到输入年份的前一年末（即year-1年12月31日）的总天数。
注意：闰年有366天，平年365天。闰年规则：能被4整除但不能被100整除，或者能被400整除。
2. 计算输入年份的1月1日到输入月份的前一个月的最后一天的天数（即输入月份之前几个月的天数之和），再加上输入的日数。
注意：输入年份是否为闰年（影响2月天数）。
3. 将两部分天数相加，然后对7取余。已知公元1年1月1日是星期一，那么余数0代表星期日？但题目中1月1日是星期一，所以余数0应该对应星期日？但按照题目，第一天是星期一，所以我们可以这样对应：
总天数对7取余，得到0~6，分别对应星期一到星期日？不对，因为第一天（总天数0）是星期一，那么：
总天数 % 7 = 0 -> 星期一
1 -> 星期二
...
6 -> 星期日
但是注意：我们计算的总天数是从公元1年1月1日到输入日期的前一天？还是包括当天？题目中计算的是到前一年末和当年的到7月10日，注意题目描述：
第一部分：到2005年末（即2005-12-31）
第二部分：2006年1月1日到2006年7月10日（这里包括7月10日吗？注意题目没有明确，但按照常规，应该是包括7月10日当天的，但是第一部分却没有包括2006年1月1日，所以第二部分应该包括2006年1月1日到7月10日，即7月10日结束。
然而，我们通常计算两个日期之间的天数，如果包括起始日和结束日，那么从A到B的天数就是B-A+1？但这里题目没有这样算。实际上，题目第一部分计算的是从0001-01-01到2005-12-31，然后第二部分从2006-01-01到2006-07-10。注意：从0001-01-01到2005-12-31刚好是整年，而2006-01-01是下一天，所以这样加起来就是从0001-01-01到2006-07-10的总天数（包括2006-07-10）。
但是，公元1年1月1日（星期一）那天是第一天，所以总天数=1时是星期二。因此，我们的总天数（从公元1年1月1日到输入日期的天数）应该是包括输入日期的。
然而，按照题目的算法：
总天数 = （从公元1年1月1日到2005-12-31的天数） + （从2006-1-1到2006-7-10的天数）
实际上，从公元1年1月1日到2005-12-31的天数，这个天数是不包括2006-1-1的，然后加上从2006-1-1到2006-7-10的天数（这里包括2006-1-1和2006-7-10）。所以整个总天数就是从公元1年1月1日到2006-7-10的天数（包括这两天之间的所有天数，包括2006-7-10，但不包括公元1年1月1日？）不对，这里需要明确：
通常，计算两个日期之间的天数，如果从A到B（A和B都是日期），那么天数可以理解为B-A（即从A开始经过多少天到达B）。例如，从1月1日到1月2日，经过1天。那么，如果我们从公元1年1月1日（设为第0天）开始，那么到2005-12-31就是第（总天数-1）天？这样不对。
实际上，我们可以这样考虑：
从公元1年1月1日到2005年12月31日，一共是2005年整，那么就是2005年的总天数（注意闰年）。
然后，2006年1月1日到2006年7月10日，这是2006年的第几天？注意，1月1日是第1天，7月10日是第191天（如果是平年，1月31天，2月28天，3月31，4月30，5月31，6月30，7月10天：31+28+31+30+31+30+10=191天）。所以，整个总天数 = 2005年的总天数（即从1年到2005年的每年天数之和） + 191。
那么，这个总天数实际上就是：从公元1年1月1日到2006年7月10日所经过的天数（不包括起始日，包括结束日）？因为2005年12月31日再加上1天就是2006年1月1日，所以2005年12月31日那一天是总天数的最后一天，然后2006年1月1日就是下一天（总天数+1），直到7月10日（总天数+191）。因此，总天数为：
total_days = (从公元1年到2005年的所有年份天数之和) + (2006年1月1日到2006年7月10日的天数)
而公元1年1月1日是星期一，那么经过total_days天后，应该是星期几？注意，经过0天还是星期一，经过1天是星期二，...，经过6天是星期日，经过7天又是星期一。
所以，我们可以用 total_days % 7 来确定星期几：
余数0 -> 星期一
余数1 -> 星期二
...
余数6 -> 星期日
但是注意：公元1年1月1日那天，我们还没有经过任何天数，所以那天是第0天（余数0对应星期一），那么输入日期是经过total_days天后的那天，所以应该是余数(total_days) % 7。
然而，我们的总天数计算是从公元1年1月1日到输入日期的天数（包括输入日期，但不包括起始日？）。实际上，如果我们计算从公元1年1月1日到输入日期（假设为2006-7-10）的总天数，那么：
第0天：公元1年1月1日（星期一）
第1天：公元1年1月2日（星期二）
...
第total_days-1天：输入日期。
但是，题目中计算了两部分，第一部分是到2005-12-31，第二部分是从2006-1-1到2006-7-10。那么第一部分的天数是多少？就是公元1年1月1日到2005-12-31，这个天数等于2005*365 + 闰年个数（注意闰年规则）？但是注意，公元1年1月1日到2005-12-31，实际上包括了公元1年1月1日到2005年12月31日，一共2005年，但是注意这2005年是从1年到2005年（注意：没有公元0年）。
因此，我们需要计算从1年到year-1年（即2005年）的每一年的天数，然后求和。
然后第二部分，计算输入年份（2006）的1月1日到输入月份（7）的输入日（10）的天数。注意，这里包括1月1日吗？题目说“2006年1月1日到2006年7月10日”，通常我们计算这个区间的天数，如果包括1月1日，那么到7月10日就是191天（因为1月1日到1月31日是31天，但是1月1日算一天，所以到1月31日是31天，同理到7月10日就是191天）。但是，这里我们不需要加1，因为1月1日就是第一天。
所以，整个总天数 = 第一部分（1~2005年总天数） + 第二部分（2006年1月1日到7月10日的天数） = 2005年总天数 + 191。
那么，这个总天数的含义是：从公元1年1月1日（星期一）开始，经过这么多天后，到达2006年7月10日。所以，2006年7月10日这一天是星期几？就是 (总天数) % 7，对应关系如下：
0 -> 星期一
1 -> 星期二
2 -> 星期三
3 -> 星期四
4 -> 星期五
5 -> 星期六
6 -> 星期日
但是，我们验证一下样例输入：
输入：1 1 1（公元1年1月1日）
第一部分：0（因为年份是1，所以前一年是0年？但是题目没有公元0年，所以前一年没有，第一部分天数为0）
第二部分：从1月1日到1月1日，应该是1天？但是按照我们的计算，应该是1天（1月1日这一天）。
总天数=0+1=1，那么1%7=1，对应星期二？但题目要求输出Monday。
这里出现矛盾。所以我们需要调整：实际上，公元1年1月1日那天，我们不应该经过任何天数。所以，我们计算总天数时，应该不包含起始日（即公元1年1月1日）。也就是说，从公元1年1月1日到公元1年1月1日，经过0天。
因此，对于输入1年1月1日：
第一部分：从1年1月1日到0年？没有，所以第一部分为0。
第二部分：从1月1日到1月1日，应该是0天？还是1天？
如果我们改变思路：总天数 = 从公元1年1月1日到输入日期的前一天的总天数。那么，输入1年1月1日，总天数为0，对应星期一。这样就能解释。
但是题目中的算法是：
（1）先计算从公元1年1月1日到2005年末（2005-12-31）共多少天。注意，这个天数包括2005-12-31，但不包括2006-1-1。
（2）然后再计算2006年1月1日到2006年7月10有多少天。这个天数包括2006-1-1和2006-7-10吗？题目没有明确，但通常计算区间，如果说是从A到B，那么一般包括A和B？但这样就会重复一天（2006-1-1）？不对，因为第一部分结束于2005-12-31，第二部分从2006-1-1开始，所以不会重复。
实际上，第一部分的天数：从公元1年1月1日到2005-12-31（包括2005-12-31）的天数，我们记为A。
第二部分：从2006-1-1到2006-7-10，我们记为B（包括2006-1-1和2006-7-10）。
那么，总天数 = A + B。但是，这样计算，公元1年1月1日到2006-7-10的总天数就是A+B，但是注意，从公元1年1月1日到2005-12-31是A天，那么2006-1-1应该是第A+1天，2006-1-2是A+2天，...，2006-7-10就是A+B天？不对，因为B是从2006-1-1到2006-7-10的天数（包括这两天），那么B=191（因为2006年1月1日到7月10日有191天？实际上，1月1日到1月1日是1天，1月1日到1月2日是2天，...，1月1日到7月10日就是191天（因为7月10日是2006年的第191天，而1月1日是第1天，所以从1月1日到7月10日就是191-1=190天？不对，应该是包括1月1日，然后加上后面的天数，所以就是191天？）
我们重新考虑：2006年1月1日是第1天，2006年1月2日是第2天，...，2006年7月10日是第191天（因为1月31天，2月28天，3月31天，4月30天，5月31天，6月30天，7月10天：31+28+31+30+31+30+10=191，所以7月10日是第191天）。那么，从1月1日到7月10日，一共是191天（包括1月1日和7月10日）？不对，因为1月1日到1月2日只有1天（经过1天），所以从1月1日到7月10日，实际上只经过了190天（因为7月10日减去1月1日等于190天）。但是，如果我们说“从1月1日到7月10日”这个时间段内有多少天，包括起止日，那就是191天。
然而，在日期差计算中，我们通常计算的是两个日期之间相差的天数（即间隔天数），不包括起始日，包括结束日？或者都不包括？这需要统一。
为了避免混淆，我们采用以下方法：
总天数 = （从公元1年1月1日到输入日期的天数） - 1
这样，公元1年1月1日就是第0天（总天数0），那么输入日期就是第（总天数）天，然后模7。
或者，我们计算总天数时，不包括公元1年1月1日，那么：
第一部分：从公元1年1月2日到2005年12月31日（这样就是2005年整年减去1天？）这样很麻烦。
实际上，更通用的方法：
我们计算从公元1年1月1日到输入日期的总天数（包括输入日期，但不包括起始日？）或者包括起始日？我们需要重新定义。
标准做法：将总天数定义为从公元1年1月1日到输入日期（包括输入日期）所经过的天数（注意：公元1年1月1日是第1天）。那么，1年1月1日就是1，模7=1，对应星期一（因为1%7=1，而1对应星期一，2对应星期二，...，7对应星期日，8对应星期一）。这样，我们计算总天数，然后模7，如果结果是0，那么就是星期日（因为7%7=0，而7对应星期日），1对应星期一，...，6对应星期六。
但是，题目已知公元1年1月1日是星期一，所以如果我们把总天数1对应星期一，总天数2对应星期二，那么总天数7对应星期日（7%7=0，所以0对应星期日），总天数8对应星期一（8%7=1，对应星期一）。这样，我们可以用：
weekday = total_days % 7
0 -> 星期日
1 -> 星期一
...
6 -> 星期六
但是，这样就和我们的样例1（1年1月1日）对应：总天数=1，1%7=1，那么就是星期一，正确。
那么，如何计算总天数？
总天数 = 从公元1年1月1日到输入日期的天数（包括输入日期）
计算：
第一部分：从公元1年1月1日到2005年12月31日，这段时间包括2005年整年，但不包括2006年。那么，这段时间的天数就是2005年的最后一天是这一年的第几天？不，我们换一种方式：将总天数分成两部分：
(1) 从公元1年到year-1年的整年天数（即1~2005年）
(2) 输入年份（2006）从1月1日到输入月份和日期的天数（包括输入日期）
那么，总天数 = (1) + (2)
注意：公元1年1月1日，如果我们按照整年算，那么第一年（公元1年）我们只计算了1月1日这一天？不对，因为整年部分我们只计算到year-1年（即2005年），那么2006年1月1日到输入日期的天数，我们单独计算（包括输入日期），这样整个总天数就包括：
- 从公元1年1月1日到2005年12月31日（包括这些天）？不，我们计算整年时，我们计算的是从公元1年1月1日到2005年12月31日吗？不对，我们计算整年时，只计算每年的天数，然后求和，这样实际上是包括这些年的每一天，包括公元1年1月1日吗？不包括，因为整年计算我们是从公元1年1月1日开始的，所以整年部分应该从公元1年1月1日算到2005年12月31日，那么整年部分的天数就是公元1年1月1日到2005年12月31日的总天数（包括这两天之间的所有天，包括起止日？），这样就会重复计算公元1年1月1日？不对，因为我们计算整年时，公元1年这一整年（包括1月1日）已经算进去了，但是注意，我们计算整年部分时，我们计算的是从1年到2005年，每一年的天数之和（包括公元1年的365或366天，那么公元1年1月1日就已经被计算在内了）。然后第二部分，我们计算2006年1月1日到输入日期的天数（包括输入日期），那么这里2006年1月1日也被计算了。但是，2005年12月31日和2006年1月1日是连续的两天，所以这样计算是连续的。
但是，这样计算整年部分时，公元1年1月1日已经被算作整年部分（公元1年）的第一天。那么，总天数就是：
total_days = (从公元1年到2005年的每一年的天数之和) + (2006年1月1日到输入日期的天数)
注意，2006年1月1日到输入日期的天数，包括2006年1月1日这一天吗？如果包括，那么2006年1月1日就是这一部分的第一天，而整年部分已经包括了2005年12月31日（整年部分的最后一天），所以整个总天数就是连续的。
然而，对于输入1年1月1日：
整年部分：没有（因为前一年是0年，不存在），所以整年部分=0。
第二部分：从1年1月1日到1月1日，我们算1天（包括1月1日）。
总天数=0+1=1 -> 1%7=1 -> 星期一（正确）。
对于1年1月2日：
整年部分=0
第二部分：从1月1日到1月2日，算2天（包括1月1日和1月2日）？不对，因为输入日期是1月2日，我们要求计算到1月2日，所以第二部分应该是1年1月1日到1月2日，包括1月1日和1月2日，所以是2天。
总天数=0+2=2 -> 2%7=2 -> 星期二（正确）。
但是，我们计算第二部分时，输入年份的1月1日到输入月份和输入日期的天数，实际上应该是输入日期在当年是第几天（即这一年的第几天）。例如，2006年7月10日是2006年的第191天（因为1月31天，2月28天，...，7月10天，总共191天）。所以，第二部分就是这一年的第几天（即输入日期在当年的天数）。
因此，总天数 = 从公元1年到year-1年的整年天数之和 + 输入日期在当年的天数（即这一年的第几天）
注意：整年天数之和：对于每一年，如果是闰年就是366天，否则365天。
所以，算法步骤：
1. 计算从公元1年到year-1年的整年天数之和（注意，包括公元1年）。
for (int y=1; y<year; y++) {
if (isLeap(y)) {
total_days += 366;
} else {
total_days += 365;
}
}
2. 计算输入日期在当年是第几天（即从1月1日到输入日期的天数，包括输入日期）。
int daysInYear = 0;
int months[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (isLeap(year)) {
months[2] = 29;
} else {
months[2] = 28;
}
for (int m=1; m<month; m++) {
daysInYear += months[m];
}
daysInYear += day; // 因为1月1日是第1天，所以加上day（例如1月1日：0+1=1）
3. total_days += daysInYear;
4. 计算星期：week = total_days % 7
0 -> 星期日
1 -> 星期一
2 -> 星期二
3 -> 星期三
4 -> 星期四
5 -> 星期五
6 -> 星期六
但是，注意：公元1年1月1日，按照这个算法：
total_days = 0（整年部分：year-1=0，没有年份） + daysInYear（1月1日：1） = 1 -> 1%7=1 -> 星期一（正确）。
样例输入2：2 1 1（公元2年1月1日）
整年部分：只有公元1年（1年），是平年（365天？注意：1年能被4整除，但能被100整除吗？不能，所以是闰年？不对，公元1年：1除以4余1，所以不是闰年？闰年规则：能被4整除但不能被100整除，或者能被400整除。1不能被4整除（4*0=0，4*1=4>1），所以是平年。所以整年部分=365。
第二部分：2年1月1日，所以daysInYear=1。
total_days=365+1=366 -> 366 % 7 = 366/7=52周余2，所以余2 -> 星期二。样例输出是Tuesday（正确）。
样例输入3：2006 7 10
整年部分：2005年之前的所有年（1~2005）的天数。
闰年个数：能被4整除的年份数（2005/4=501）减去能被100整除的年份数（20）再加上能被400整除的年份数（5，因为2000是400的倍数，而400、800、1200、1600、2000）？不对，注意年份范围是1~2005。
闰年：4的倍数，但是整百的必须是400的倍数。
所以，闰年个数 = (2005/4) - (2005/100) + (2005/400) （取整数除法？不对，这样计算会多算？）
实际上，我们可以循环计算1~2005年，但这样效率低。我们可以用公式：
闰年数 = (year-1)/4 - (year-1)/100 + (year-1)/400
但是注意：从1年到n-1年，闰年个数 = (n-1)/4 - (n-1)/100 + (n-1)/400 （这里除法取整）
所以，对于2005年：闰年个数 = 2004/4 - 2004/100 + 2004/400 = 501 - 20 + 5 = 486。
总年数：2005年，所以整年天数 = 2005*365 + 486
然后计算2006年7月10日是2006年的第几天：
2006年：平年（2006不能被4整除），所以2月28天。
1月31，2月28，3月31，4月30，5月31，6月30，7月10 -> 31+28+31+30+31+30+10 = 191
总天数 = 2005*365+486 + 191
然后模7：我们不需要计算整个数，可以分步模7。
但是，我们写程序时，可以不用公式计算闰年个数，而是用循环（因为年份可能很大，但题目没有给范围，我们假设年份在1~9999，用循环可能效率不高，但也可以接受，或者用公式计算）。
为了清晰，我们可以用循环计算整年部分，但注意年份1~year-1。
但是，注意：公元1年1月1日到2005年12月31日，总共的年数：2005年（包括1年、2年、...、2005年）。
所以，我们可以这样：
long total_days = 0;
// 计算整年部分：从1年到year-1年
for (int y = 1; y < year; y++) {
if (isLeap(y)) {
total_days += 366;
} else {
total_days += 365;
}
}
然后计算当年天数（输入日期在当年的第几天）。
最后，总天数模7，然后用一个数组映射到星期：
char* weekdays[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
但是注意：我们的模结果是：
total_days % 7 = 0 -> 星期日（因为总天数1对应星期一，总天数2对应星期二，总天数7对应星期日（7%7=0），总天数8对应星期一（8%7=1））
所以：
0 -> Sunday
1 -> Monday
2 -> Tuesday
3 -> Wednesday
4 -> Thursday
5 -> Friday
6 -> Saturday
但是，我们的样例输出是：
1 1 1 -> Monday
2 1 1 -> Tuesday
2006 7 10 -> Monday
按照我们的算法：
1 1 1: total_days=1 -> 1%7=1 -> 对应Monday（正确）
2 1 1: 整年部分：y=1（平年，365），然后2006年1月1日：1 -> total_days=365+1=366 -> 366%7=366/7=52*7=364，余2 -> 对应Tuesday（正确）
2006 7 10:
整年部分：y=1~2005，需要计算闰年个数。我们写程序用循环计算。
所以，我们写程序如下：
注意：闰年判断函数：
int isLeap(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
计算当年天数（输入日期在当年的第几天）：
注意：如果是闰年，2月29天，否则28天。
另外，注意输入的年月日，月份是1~12，日是1~31（根据月份不同）。
代码步骤：
1. 读入年月日：year, month, day。
2. 验证输入（题目没有说非法输入，但假设输入合法）。
3. 计算整年部分（1~year-1）的总天数。
4. 计算输入日期在当年的天数（第几天）。
5. 总天数 = 整年部分 + 当年的天数。
6. 总天数 % 7，然后根据余数输出星期。
注意：总天数可能很大，使用long类型。
最后，注意样例输出：Monday（首字母大写，后面小写）
我们按照这个思路写代码。
但是，注意：题目输入是一组测试数据，但我们不知道有多少组，所以需要循环读取输入，直到文件结束。
样例输入有三组，所以我们可以用：
while (scanf("%d %d %d", &year, &month, &day) == 3) {
// 计算并输出
}
输出星期几的字符串（首字母大写，后面小写，如Monday）。
代码实现：
注意：月份数组，0索引不用，1~12月。
计算当年天数时，注意：前几个月（1~month-1）的天数，加上day。
例如，1月1日：前0个月的天数0，加上1 -> 1。
1月2日：0+2=2。
2月1日：31（1月）+1=32。
我们用一个数组存储每个月的天数，如果是闰年，2月改为29天。
代码：
</think># 计算给定日期是星期几的程序
以下是一个C语言程序，用于计算输入日期对应的星期几，根据题目要求实现：
```c
#include <stdio.h>
#include <stdbool.h>
// 判断是否为闰年
bool isLeap(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
int main() {
int year, month, day;
// 存储星期名称的数组
const char* weekdays[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
// 每月的天数（非闰年）
int monthDays[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
while (scanf("%d %d %d", &year, &month, &day) == 3) {
long totalDays = 0;
// 1. 计算从公元1年到year-1年的总天数
for (int y = 1; y < year; y++) {
totalDays += isLeap(y) ? 366 : 365;
}
// 2. 计算当年1月1日到输入日期的天数
// 如果是闰年，设置2月为29天
if (isLeap(year)) {
monthDays[2] = 29;
} else {
monthDays[2] = 28;
}
int daysInYear = 0;
// 累加前month-1个月的天数
for (int m = 1; m < month; m++) {
daysInYear += monthDays[m];
}
// 加上当前月的天数
daysInYear += day;
totalDays += daysInYear;
// 3. 计算星期几（模7运算）
// 公元1年1月1日是星期一，对应模7结果为1
int weekday = totalDays % 7;
// 4. 输出结果
printf("%s\n", weekdays[weekday]);
}
return 0;
}
```
## 程序详细解释
### 1. 闰年判断函数
```c
bool isLeap(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
```
- 根据题目要求：能被4整除但不能被100整除，或者能被400整除的年份是闰年
- 返回`true`表示闰年，`false`表示平年
### 2. 主程序逻辑
#### (1) 输入处理
```c
while (scanf("%d %d %d", &year, &month, &day) == 3)
```
- 循环读取输入的年、月、日三个整数
- 当成功读取三个整数时继续处理
#### (2) 计算总天数
```c
// 计算从公元1年到year-1年的总天数
for (int y = 1; y < year; y++) {
totalDays += isLeap(y) ? 366 : 365;
}
```
- 遍历从公元1年到输入年份的前一年
- 闰年加366天，平年加365天
```c
// 计算当年1月1日到输入日期的天数
if (isLeap(year)) {
monthDays[2] = 29; // 闰年2月29天
} else {
monthDays[2] = 28; // 平年2月28天
}
int daysInYear = 0;
for (int m = 1; m < month; m++) {
daysInYear += monthDays[m]; // 累加前month-1个月的天数
}
daysInYear += day; // 加上当前月的天数
totalDays += daysInYear; // 两部分天数相加
```
- 根据输入年份调整2月的天数
- 计算输入日期在当年是第几天
- 将当年天数加到总天数中
#### (3) 计算星期几
```c
int weekday = totalDays % 7;
```
- 总天数对7取模，得到0-6的值
- 根据已知条件：公元1年1月1日是星期一（总天数1对应周一）
#### (4) 输出结果
```c
const char* weekdays[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
printf("%s\n", weekdays[weekday]);
```
- 使用字符串数组映射数字到星期名称
- 直接输出对应的星期名称
### 3. 日期与星期的映射关系
总天数模7的结果对应的星期：
- 0 → Sunday
- 1 → Monday
- 2 → Tuesday
- 3 → Wednesday
- 4 → Thursday
- 5 → Friday
- 6 → Saturday
## 测试样例验证
### 样例1: 输入 `1 1 1`
- 总天数 = 1 (1月1日)
- 1 % 7 = 1 → Monday (正确)
### 样例2: 输入 `2 1 1`
- 公元1年: 365天 (平年)
- 公元2年1月1日: 第1天
- 总天数 = 365 + 1 = 366
- 366 % 7 = 366 - 364 = 2 → Tuesday (正确)
### 样例3: 输入 `2006 7 10`
1. 计算2005年及之前的总天数:
- 2005年之前的闰年数: 2004/4 - 2004/100 + 2004/400 = 501 - 20 + 5 = 486
- 总天数 = 2005×365 + 486 = 731,625 + 486 = 732,111
2. 计算2006年7月10日是当年第191天:
- 1月:31 + 2月:28 + 3月:31 + 4月:30 + 5月:31 + 6月:30 + 7月:10 = 191
3. 总天数 = 732,111 + 191 = 732,302
4. 732,302 % 7 = 732,302 ÷ 7 = 104,614×7=732,298 → 余4
5. 余数4 → Thursday (但题目预期是Monday)
**修正说明**：样例输出应该是Monday，但计算得到Thursday。这是因为我们的映射关系需要调整。根据公元1年1月1日是星期一，总天数1对应星期一，总天数7对应星期日（余0），总天数8对应星期一（余1）。因此正确的映射关系是：
- 余数0 → Sunday
- 余数1 → Monday
- 余数2 → Tuesday
- ...
- 余数6 → Saturday
修正代码：
```c
// 修改星期数组顺序
const char* weekdays[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
// 计算模7结果后直接使用
printf("%s\n", weekdays[totalDays % 7]);
```
修正后：
- 732,302 % 7 = 4 → Thursday（但应为Monday）
经过重新计算，发现闰年计算有误。2000年是闰年（被400整除），但1900年不是闰年（被100整除但不被400整除）。正确计算2005年前的闰年数：
- 从公元1年到2005年：2005/4 = 501，2005/100 = 20，2005/400 = 5
- 闰年数 = 501 - 20 + 5 = 486（正确）
- 总天数 = 2005×365 + 486 = 731,625 + 486 = 732,111
- 2006年7月10日：191天
- 总计：732,111 + 191 = 732,302
- 732,302 ÷ 7 = 104,614×7=732,298，余4 →
本文探讨了UML及设计模式的基础理论，强调了UML在软件开发中的重要性，并介绍了面向对象程序设计中类型与接口的概念。理解类如何定义具有共同特性的对象集合及其行为。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
