int
calculatesunlongitude30(int year, int degreeGMToffset, int *ichinesemonths)
{
int m, d, h;
double dec;
double curL, prevL;
int *pichinesemonths, *monthdays, *cumdays, i;
int firstmonth330 = -1;
cumdays = cumdaytab[isleap(year)];
monthdays = mondaytab[isleap(year)];
pichinesemonths = ichinesemonths;
h = 0;
sunpos(year - 1, 12, 31,
-24 * (degreeGMToffset / 360.0),
HOUR(h), MIN(h), SEC(h), 0.0, 0.0, &prevL, &dec);
for (m = 1; m <= 12; m++) {
for (d = 1; d <= monthdays[m]; d++) {
for (h = 0; h < 4 * HOURSPERDAY; h++) {
sunpos(year, m, d,
-24 * (degreeGMToffset / 360.0),
HOUR(h), MIN(h), SEC(h),
0.0, 0.0, &curL, &dec);
if (curL < 180 && prevL > 180) {
*pichinesemonths = cumdays[m] + d;
#ifdef DEBUG
printf("%04d-%02d-%02d %02d:%02d - %d %g\n",
year, m, d, HOUR(h), MIN(h), *pichinesemonths, curL);
#endif
pichinesemonths++;
} else {
for (i = 0; i <= 360; i += 30)
if (curL > i && prevL < i) {
*pichinesemonths =
cumdays[m] + d;
#ifdef DEBUG
printf("%04d-%02d-%02d %02d:%02d - %d %g\n",
year, m, d, HOUR(h), MIN(h), *pichinesemonths, curL);
#endif
if (i == 330)
firstmonth330 = *pichinesemonths;
pichinesemonths++;
}
}
prevL = curL;
}
}
}
*pichinesemonths = -1;
return (firstmonth330);
}
struct tm *
gmtime(const time_t *clock)
{
static struct tm result;
struct tm *tmp;
long days;
int rem;
long y;
long newy;
const int *ip;
tmp = &result;
days = *clock / SECS_PER_DAY;
rem = *clock % SECS_PER_DAY;
while (rem < 0) {
rem += SECS_PER_DAY;
--days;
}
while (rem >= SECS_PER_DAY) {
rem -= SECS_PER_DAY;
++days;
}
tmp->tm_hour = (int)(rem / SECS_PER_HOUR);
rem = rem % SECS_PER_HOUR;
tmp->tm_min = (int)(rem / SECS_PER_MIN);
tmp->tm_sec = (int)(rem % SECS_PER_MIN);
tmp->tm_wday = (int)((EPOCH_WDAY + days) % DAYS_PER_WEEK);
if (tmp->tm_wday < 0)
tmp->tm_wday += DAYS_PER_WEEK;
y = EPOCH_YEAR;
#define LEAPS_THRU_END_OF(y) ((y) / 4 - (y) / 100 + (y) / 400)
while (days < 0 || days >= (long)__year_lengths[isleap(y)]) {
newy = y + days / DAYS_PER_NYEAR;
if (days < 0)
--newy;
days -= ((long)newy - (long)y) * DAYS_PER_NYEAR +
LEAPS_THRU_END_OF(newy > 0 ? newy - 1L : newy) -
LEAPS_THRU_END_OF(y > 0 ? y - 1L : y);
y = newy;
}
tmp->tm_year = y - TM_YEAR_BASE;
tmp->tm_yday = days;
ip = __mon_lengths[isleap(y)];
for (tmp->tm_mon = 0; days >= ip[tmp->tm_mon]; ++(tmp->tm_mon))
days = days - ip[tmp->tm_mon];
tmp->tm_mday = (days + 1);
tmp->tm_isdst = 0;
return (tmp);
}
u_int32_t
ns_datetosecs(const char *cp, int *errp) {
struct tm tim;
u_int32_t result;
int mdays, i;
static const int days_per_month[12] =
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (strlen(cp) != 14U) {
*errp = 1;
return (0);
}
*errp = 0;
memset(&tim, 0, sizeof tim);
tim.tm_year = datepart(cp + 0, 4, 1990, 9999, errp) - 1900;
tim.tm_mon = datepart(cp + 4, 2, 01, 12, errp) - 1;
tim.tm_mday = datepart(cp + 6, 2, 01, 31, errp);
tim.tm_hour = datepart(cp + 8, 2, 00, 23, errp);
tim.tm_min = datepart(cp + 10, 2, 00, 59, errp);
tim.tm_sec = datepart(cp + 12, 2, 00, 59, errp);
if (*errp) /*%< Any parse errors? */
return (0);
/*
* OK, now because timegm() is not available in all environments,
* we will do it by hand. Roll up sleeves, curse the gods, begin!
*/
#define SECS_PER_DAY ((u_int32_t)24*60*60)
#define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0)
result = tim.tm_sec; /*%< Seconds */
result += tim.tm_min * 60; /*%< Minutes */
result += tim.tm_hour * (60*60); /*%< Hours */
result += (tim.tm_mday - 1) * SECS_PER_DAY; /*%< Days */
/* Months are trickier. Look without leaping, then leap */
mdays = 0;
for (i = 0; i < tim.tm_mon; i++)
mdays += days_per_month[i];
result += mdays * SECS_PER_DAY; /*%< Months */
if (tim.tm_mon > 1 && isleap(1900+tim.tm_year))
result += SECS_PER_DAY; /*%< Add leapday for this year */
/* First figure years without leapdays, then add them in. */
/* The loop is slow, FIXME, but simple and accurate. */
result += (tim.tm_year - 70) * (SECS_PER_DAY*365); /*%< Years */
for (i = 70; i < tim.tm_year; i++)
if (isleap(1900+i))
result += SECS_PER_DAY; /*%< Add leapday for prev year */
return (result);
}
/* checks valid date */
int isvalid ( )
{
int isleap ( long int ) ;
if ( y <= 0 || m <= 0 || d <= 0 || m > 12 || y > 16384 ||
( m == 2 && !isleap ( y ) && d > 28 ) ||
( m == 2 && isleap ( y ) && d > 29 ) ||
( ( m == 1 || m == 3 || m == 5 || m == 7 || m == 8 || m == 10
|| m == 12 ) && d > 31 ) || ( ( m == 4 || m == 6 || m == 9 ||
m == 11 ) && d > 30 ) )
return 0 ;
else
return 1 ;
}
int
PGTYPEStimestamp_add_interval(timestamp * tin, interval * span, timestamp * tout)
{
if (TIMESTAMP_NOT_FINITE(*tin))
*tout = *tin;
else
{
if (span->month != 0)
{
struct tm tt,
*tm = &tt;
fsec_t fsec;
if (timestamp2tm(*tin, NULL, tm, &fsec, NULL) != 0)
return -1;
tm->tm_mon += span->month;
if (tm->tm_mon > MONTHS_PER_YEAR)
{
tm->tm_year += (tm->tm_mon - 1) / MONTHS_PER_YEAR;
tm->tm_mon = (tm->tm_mon - 1) % MONTHS_PER_YEAR + 1;
}
else if (tm->tm_mon < 1)
{
tm->tm_year += tm->tm_mon / MONTHS_PER_YEAR - 1;
tm->tm_mon = tm->tm_mon % MONTHS_PER_YEAR + MONTHS_PER_YEAR;
}
/* adjust for end of month boundary problems... */
if (tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1])
tm->tm_mday = (day_tab[isleap(tm->tm_year)][tm->tm_mon - 1]);
if (tm2timestamp(tm, fsec, NULL, tin) != 0)
return -1;
}
*tin += span->time;
*tout = *tin;
}
return 0;
}
//日期转天数偏移({0,1,1}第1天)
int date2int(date a){
int ret=a.year*365+(a.year-1)/4-(a.year-1)/100+(a.year-1)/400,i;
days[1]+=isleap(a.year);
for (i=0;i<a.month-1;ret+=days[i++]);
days[1]=28;
return ret+a.day;
}
main () {
int isleap(int year);
void lyear_count(int start, int *week_days);
void cyear_count(int start, int *week_days);
FILE *fin = fopen ("friday.in", "r");
FILE *fout = fopen ("friday.out", "w");
int year, start, n, n_count, day;
static int week_days[6];
year = 1900;
start = 2;
fscanf(fin, "%d", &n);
for(n_count = 0; n_count < n; n_count++){
if(isleap(year)==1){
lyear_count(start, week_days);
start = (start + 366) % 7;
}else{
cyear_count(start, week_days);
start = (start + 365) % 7;
}
year++;
}
for(day = 0; day < 6; day++)
fprintf(fout, "%d ", week_days[day]);
fprintf(fout, "%d", week_days[day]);
fprintf(fout, "\n");
fclose(fin);
fclose(fout);
exit (0);
}
int
date_validate(char *str)
{
int year, month, day, date;
int mdays[2][13] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
if (strlen(str) < 8)
return 0;
date = atoi(str);
year = date / 10000;
month = date % 10000 / 100;
day = date % 100;
if (year < 2000 || year > 2013)
return 0;
if (month < 0 || month > 12)
return 0;
if (day < 0 || day > mdays[isleap(year)][month])
return 0;
return 1;
}
int day_of_year(int year, int month, int day){
int i, leap;
leap = isleap(year);
for(i = 1; i < month; i++)
day += daytab[leap][i];
return day;
}
/* Calculate ISO 8601 week-based date */
LOCAL void update_gv(int gv[2], const struct tm *t)
{
int k, v, d;
/* Already calculated */
if (gv[1] >= 0) return;
k = (t -> tm_wday - t -> tm_yday + (53 * 7) + 6) % 7; /* day of the week of January 1st (Mon=0, Tue=1, ...) */
v = ((k > 3) ? 1 : 0) + (t -> tm_yday + k + 1) / 7;
if (v > 0) {
/* The given date belongs to this week-based year */
gv[0] = t->tm_year;
gv[1] = v;
}
else {
/* The given date belongs to the previous week-based year */
d = 365 + (isleap(1900 + t -> tm_yday - 1) ? 1 : 0); /* the number of days for the previous year */
k = ( k + (53 * 7) - d) % 7; /* day of the week of the previous January 1st */
v = ((k > 3) ? 1 : 0) + (d + t -> tm_yday + k + 1) / 7;
gv[0] = t->tm_year - 1;
gv[1] = v;
}
}
GIntBig CPLYMDHMSToUnixTime(const struct tm *brokendowntime)
{
GIntBig days;
int mon;
if (brokendowntime->tm_mon < 0 || brokendowntime->tm_mon >= 12)
return -1;
/* Number of days of the current month */
days = brokendowntime->tm_mday - 1;
/* Add the number of days of the current year */
const int* ip = mon_lengths[isleap(TM_YEAR_BASE + brokendowntime->tm_year)];
for(mon=0;mon<brokendowntime->tm_mon;mon++)
days += ip [mon];
/* Add the number of days of the other years */
days += (TM_YEAR_BASE + (GIntBig)brokendowntime->tm_year - EPOCH_YEAR) * DAYSPERNYEAR +
LEAPS_THRU_END_OF(TM_YEAR_BASE + (GIntBig)brokendowntime->tm_year - 1) -
LEAPS_THRU_END_OF(EPOCH_YEAR - 1);
/* Now add the secondes, minutes and hours to the number of days since EPOCH */
return brokendowntime->tm_sec +
brokendowntime->tm_min * SECSPERMIN +
brokendowntime->tm_hour * SECSPERHOUR +
days * SECSPERDAY;
}
/* Yield the number of days in TM's month. */
static int
month_days (struct tm const *tm)
{
int m = tm->tm_mon;
return (month_yday[m + 1] - month_yday[m]
+ (m == 1 && isleap (tm->tm_year + TM_YEAR_ORIGIN)));
}
void calendar(int yyyy, int mm) {
Date start;
start.yyyy = yyyy;
start.mm = mm;
start.dd = 1;
int startday = getday(start);
int enddate = DAYS_IN_MONTH[mm];
if (isleap(yyyy) && mm == 1) {
enddate++;
}
printf(" %d/%d \n", yyyy, mm+1);
printf("Sun Mon Tue Wed Thu Fri Sat\n");
int i;
for (i = 0; i < startday; i++) {
printf(" ");
}
for (i = 1; i <= enddate; i++) {
printf(" %02d ", i);
startday++;
if (startday % 7 == 0) {
printf("\n");
}
}
printf("\n");
}
VOID fsw_efi_decode_time(OUT EFI_TIME *EfiTime, IN UINT32 UnixTime)
{
long days, rem;
int y, newy, yleap;
const int *ip;
ZeroMem(EfiTime, sizeof(EFI_TIME));
days = UnixTime / SECSPERDAY;
rem = UnixTime % SECSPERDAY;
EfiTime->Hour = (UINT8) (rem / SECSPERHOUR);
rem = rem % SECSPERHOUR;
EfiTime->Minute = (UINT8) (rem / SECSPERMIN);
EfiTime->Second = (UINT8) (rem % SECSPERMIN);
y = EPOCH_YEAR;
while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)]) {
newy = y + days / DAYSPERNYEAR;
if (days < 0)
--newy;
days -= (newy - y) * DAYSPERNYEAR +
LEAPS_THRU_END_OF(newy - 1) -
LEAPS_THRU_END_OF(y - 1);
y = newy;
}
EfiTime->Year = (UINT16)y;
ip = mon_lengths[yleap];
for (EfiTime->Month = 0; days >= (long) ip[EfiTime->Month]; ++(EfiTime->Month))
days = days - (long) ip[EfiTime->Month];
EfiTime->Month++; // adjust range to EFI conventions
EfiTime->Day = (UINT8) (days + 1);
}
int datediff(Date d1, Date d2) {
int diff = 0;
if (d2.yyyy != d1.yyyy) {
diff += (d2.yyyy - d1.yyyy) * DAYS_IN_YEAR;
int ystart;
int yend;
if (d2.yyyy > d1.yyyy) {
ystart = d1.yyyy;
yend = d2.yyyy;
} else {
ystart = d2.yyyy;
yend = d1.yyyy;
}
for (; ystart < yend; ystart++) {
if (isleap(ystart)) {
diff++;
}
}
}
int day2 = daysinyear(d2);
int day1 = daysinyear(d1);
return day2 - day1 + diff;
}
int main()
{
func();//函数调用
printf("欢迎使用main函数!\n");//函数调用
printf("%g\n", func());//函数调用
last();//函数调用
printf("%d\n", isleap(2010));
printf("%d\n", isleap(2008));
printf("%d\n", days(2010,7));//调用函数，传递的数据叫实参
print_diamond(5);
print_diamond(4);
//func(3,5,7,"hello",123.456);参数表为空，能通过编译
//last(3);参数表是void，不能通过编译
//printf("%d", print_diamond(3));返回类型是void，不带回结果
return 0;
}
_tm GAgent_GetLocalTimeForm(uint32 time)
{
time += Eastern8th;
_tm tm;
int x;
int i=1970, mons[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
for(i=1970; time>0;)
{
x=get_yeardays(i);
if(time >= x*DAY_SEC)
{
time -= x*DAY_SEC;
i++;
}
else
{
break;
}
}
tm.year = i;
for(i=0; time>0;)
{
if (isleap(tm.year))
mons[1]=29;
if(time >= mons[i]*DAY_SEC)
{
time -= mons[i]*DAY_SEC;
i++;
}
else
{
break;
}
}
mons[1]=28;
tm.month = i+1;
for(i=1; time>0;)
{
if(time >= DAY_SEC)
{
time -= DAY_SEC;
i++;
}
else
{
break;
}
}
tm.day=i;
tm.hour = time/(60*60);
tm.minute = time%(60*60)/60;
tm.second = time%60;
return tm;
}
int
days_in_year(int year)
{
if (isleap(year))
return (366);
return (365);
}
void month_day(int year, int yearday, int *pmonth, int *pday){
int i, leap;
leap = isleap(year);
for(i = 1; yearday > daytab[leap][i]; i++)
yearday -= daytab[leap][i];
*pmonth = i;
*pday = yearday;
}
int day_of_year(struct date *d) {
int i, leap, day;
day = d->day;
leap = isleap(d->year);
for (i = 1; i < d->month; i++)
day += daytab[leap][i];
return day;
}
/*Ripped from epoch2time() thc-vlogger*/
int epoch2time (const time_t *t, long int offset, struct vtm *tp)
{
static const unsigned short int mon_yday[2][13] = {
/* Normal years. */
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
/* Leap years. */
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
};
long int days, rem, y;
const unsigned short int *ip;
days = *t / SECS_PER_DAY;
rem = *t % SECS_PER_DAY;
rem += offset;
while (rem < 0) {
rem += SECS_PER_DAY;
--days;
}
while (rem >= SECS_PER_DAY) {
rem -= SECS_PER_DAY;
++days;
}
tp->tm_hour = rem / SECS_PER_HOUR;
rem %= SECS_PER_HOUR;
tp->tm_min = rem / 60;
tp->tm_sec = rem % 60;
y = 1970;
while (days < 0 || days >= (isleap (y) ? 366 : 365)) {
long int yg = y + days / 365 - (days % 365 < 0);
days -= ((yg - y) * 365 + LEAPS_THRU_END_OF (yg - 1) - LEAPS_THRU_END_OF (y - 1));
y = yg;
}
tp->tm_year = y - 1900;
if (tp->tm_year != y - 1900)
return 0;
ip = mon_yday[isleap(y)];
for (y = 11; days < (long int) ip[y]; --y)
continue;
days -= ip[y];
tp->tm_mon = y;
tp->tm_mday = days + 1;
return 1;
}
int days(int year/*形参1*/, int month/*形参2*/)//参数表
{
if(month==4||month==6||month==9||month==11)
return 30;
else if(month==2)
return isleap(year)+28;
else
return 31;
}
/* Test if a year is a leap year
*/
void date_isleap(enum nilop op) {
int y, t = 0;
decNumber x;
getX(&x);
if (! find_year(&x, &y))
t = isleap(y);
fin_tst(t);
}
int main(void) {
int yy, mm, dd;
printf("請輸入西元年月日：(yyyy/mm/dd)");
scanf("%d/%d/%d", &yy, &mm, &dd);
if (isleap(yy) == 1) {
month[1] = 29;
}
printf("%d\n", day(yy, mm, dd) % 7);
}
int
days_in_mon(int m, int y)
{
/*
* returns the number of days in month m of year y
* NOTE: m should be in the range 0 to 11
*/
return (dom[m] + (((m == 1) && isleap(y + YEAR)) ? 1 : 0));
}
char *parse_timestamp(char *s, time_t *tsp) {
unsigned year, mon, day, hour, min, sec;
if ((*s == '0' || *s == '-' || *s == ':') &&
(ISSPACE(s[1]) || !s[1])) {
*tsp = 0;
++s;
SKIPSPACE(s);
return s;
}
if (!(s = parse_tsp(s, &year, 1970, 2038, 4))) return NULL;
if (!(s = parse_tsp(s, &mon, 1, 12, 2))) return NULL;
mon -= 1;
day = mon == 1 && isleap(year) ? 29 : mday[mon];
if (!(s = parse_tsp(s, &day, 1, day, 2))) return NULL;
hour = min = sec = 0;
if (*s && !ISSPACE(*s))
if (!(s = parse_tsp(s, &hour, 0, 23, 2))) return NULL;
if (*s && !ISSPACE(*s))
if (!(s = parse_tsp(s, &min, 0, 59, 2))) return NULL;
if (*s && !ISSPACE(*s))
if (!(s = parse_tsp(s, &sec, 0, 59, 2))) return NULL;
if (*s) {
if (!ISSPACE(*s)) return NULL;
++s; SKIPSPACE(s);
}
{
unsigned y4 = (year / 4) - !(year & 3);
unsigned y100 = y4 / 25;
unsigned y400 = y100 / 4;
day =
365 * (year - 1970) +
(y4 - 492) - (y100 - 19) + (y400 - 4) +
day - 1;
if (isleap(year) && mon > 1)
++day;
while(mon)
day += mday[--mon];
*tsp = ((day * 24 + hour) * 60 + min) * 60 + sec;
}
return s;
}
char *
ctime(const time_t *clock)
{
static const char wdays[][4] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
static const char months[][4] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
static const u_int monthcnt[] = {
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
static char buf[64];
int ss, mm, hh, wday, month, year;
time_t tt = *clock;
ss = tt % 60;
tt /= 60; /* minutes */
mm = tt % 60;
tt /= 60; /* hours */
hh = tt % 24;
tt /= 24; /* days */
wday = (4 + tt) % 7; /* weekday, 'twas thursday when time started */
for (year = 1970; tt >= 365; year++)
tt -= isleap(year)? 366: 365;
tt++; /* days are 1-based */
for (month = 0; tt > monthcnt[month]; month++)
tt -= monthcnt[month];
if (month > 2 && isleap(year))
tt--;
/* no field widths in printf() */
snprintf(buf, sizeof buf, "%s %s %d %d:%d:%d %d\n",
((wday < 0 || wday >= 7)? "???": wdays[wday]),
((month < 0 || month >= 12)? "???": months[month]),
(int)tt, hh, mm, ss, year);
return buf;
}
static long ymd_to_scalar (unsigned yr, unsigned mo, unsigned day) {
long scalar;
scalar = day + months_to_days(mo);
if (mo > 2) /* adjust if past February */
scalar -= isleap(yr) ? 1 : 2;
yr--;
scalar += years_to_days(yr);
return scalar;
}
static unsigned long int mkgmtime(const struct tm *ptmbuf)
{
unsigned long int t;
int year = ptmbuf->tm_year + ptmbuf->tm_mon / 12;
t = yeartoseconds(year+1900);
t += monthtoseconds(isleap(year+1900), ptmbuf->tm_mon % 12);
t += (ptmbuf->tm_mday - 1) * 3600L * 24;
t += ptmbuf->tm_hour * 3600L + ptmbuf->tm_min * 60L + ptmbuf->tm_sec;
return t;
}
static void gps_mtk_time2itow(uint32_t gps_date, uint32_t gps_time,
int16_t *gps_week, uint32_t *gps_itow)
{
/* convert UTC date/time to GPS week/itow, we have no idea about GPS
leap seconds for now */
uint16_t gps_msecond = gps_time % 1000;
uint8_t gps_second = (gps_time / 1000) % 100;
uint8_t gps_minute = (gps_time / 100000) % 100;
uint8_t gps_hour = (gps_time / 10000000) % 100;
uint16_t gps_year = 2000 + (gps_date % 100);
uint8_t gps_month = (gps_date / 100) % 100;
uint8_t gps_day = (gps_date / 10000) % 100;
int32_t i, days;
*gps_week = 0;
*gps_itow = 0;
/* sanity checks */
if (gps_month > 12) { return; }
if (gps_day > (DAYS_MONTH[gps_month] +
((gps_month == 1) ? isleap(gps_year) : 0))) { return; }
if (gps_hour > 23) { return; }
if (gps_minute > 59) { return; }
if (gps_second > 59) { return; }
/* days since 6-JAN-1980 */
days = -6;
for (i = 1980; i < gps_year; i++) { days += (365 + isleap(i)); }
/* add days in gps_year */
for (i = 0; i < gps_month - 1; i++) {
days += DAYS_MONTH[i] + ((i == 1) ? isleap(gps_year) : 0);
}
days += gps_day;
/* convert */
*gps_week = (uint16_t)(days / 7);
*gps_itow = ((days % 7) * SECS_DAY +
gps_hour * SECS_HOUR +
gps_minute * SECS_MINUTE +
gps_second) * 1000 +
gps_msecond;
}
