I'm trying to calculate the day of week from a seconds since epoch timestamp. From time.h I can use gmtime(), but this increases the program with 1.3kB, probably because gmtime() also calculates the date.
So, I'm wondering what would be wrong about using something like:
(timestamp / (24*3600)) % 7
The only thing I could think of is leap seconds, such that something like 00:00:02 could be classified as the wrong day.
edit
This is for embedded programming, 1.3kB is a substantial part of the 64kB program/firmware. Furthermore, I'm not expecting to do anything with timezones or dates after this.
what would be wrong about using something like: (?)
(timestamp / (24*3600)) % 7
Not much wrong with the above except you have not specified the day of the week the epoch began (e.g. Thursday) nor the day of the week the week begins on (e.g. Monday). See 8601 for a deeper discusison on the first day of the week. Also watch out for computations like 24*3600 that with 16-bit int/unsigned lead to troubles.
Example: Let us say the epoch began on day-of-the-week number 3 (Monday:0. Thursday:3). This takes care of 2 issues at once: day of the week of the epoch and the first day of the week as only the positive difference needs to be coded.
#define EPOCH_DOW 3
#define SECS_PER_DAY 86400
dow = ((timestamp / SECS_PER_DAY) + EPOCH_DOW) % 7;
If timestamp is a signed type, append the following to insure a result in the [0...6] range.
dow = (dow + 7) % 7;
// or
if (dow < 0) dow += 7;
I doubt leap seconds are used in your application. If they are, the task is far more complicated as code then needs to deal with not only with a more complex calculation, but how to receive updates of the next scheduled leap-seconds - they occur irregularly.
You're off by 4, since January 1, 1970 was a Thursday, and you may compute an incorrect result for dates before the epoch depending on the behavior of % on negative operands. (The simplest fix is to check whether the result is negative, and if so add 7.) But other than this, your algorithm is correct; it's the same as used by glibc internal function __offtime, which gmtime ultimately ends up calling. (You can't call it yourself, as it's an internal implementation detail).
There's no need to worry about leap seconds; Unix time ignores them.
I would recommend encapsulating the code in a (possibly inline) function, with the gmtime implementation as a comment of #if 0 block, so that you can easily switch to it if you start needing to compute months/years as well.
i'm trying to use the Datediff function to give me the years off a user but this is more complicated than i thought.
SELECT DATEDIFF( DD,'1963-07-22','2016-07-23')
This will give me 19360 Days i think that is because 2016 have a Leap Year and that is fine.
what i would like to do is get the YEAR and not the days.
if i change the interval from DD to YY(YYYY) it only calculates the year.
In my experience it does work best to use the number of days between the two dates and then divide that amount by 365.25 to be exact, then round off to even years. This would give you the most precise age in years I think.
The correct answer to calculate someone's age, or the difference in truncated years between two dates is
year(#today)-year(#birthDate)+floor((month(#today)-month(#birthdate)+floor((day(#today)-day(#birthdate))/31))/12);
This will work regardless of leap years. And correct for whether the person was born on a later month or even a later day in the same month. This will also ignore hours and minutes, as should be when calculating someone's age.
When using "yyyy" in DateDiff only the year parts of the dates are used to calculate the difference. The month and day are omitted. This will produce results that are sometimes correct and sometimes incorrect by one year.
Try using this instead.
SELECT Int((#2016-07-23#-#1963-07-22#)/365.25);
I am trying to write an algorithm that takes an input of a date ("2000-01-01") and also "y|m|d", where y is the number of years to add to the original date and m and d are the months and days. This algorithm needs to take into account leap years as well. Sorry I haven't posted any code, I haven't really got anything working yet.
The algorithm also needs to work like this: if you add three months to 30th November, you would get 28th February the next year, or 29th if it is a leap year. So if the month you are coming from as a length higher than the final resultant month, the last day of the final resultant month will be taken.
Could someone please give me some pointers on how to write it or link to any useful resources?
I hope that this makes sense, any questions let me know. Thanks.
You seem to have the problem quite well figured out. Here is the algorithm for finding a leap year:
if year is not divisible by 4 then common year
else if year is not divisible by 100 then leap year
else if year is not divisible by 400 then common year
else leap year
Most, if not all of what you need can be found in the <ctime> library (http://www.cplusplus.com/reference/ctime/).
In particular look up the time_t and struct tm types and how to convert between the two (localtime(), gmttime(), ...). Note that you can add days, hours, months, etc to the fields in a struct tm and they are handled properly, e.g., the "32nd of January" becomes "Feb. 1st".
The <ctime> library also handles leap years.
Your way of adding 3 months seems non conventinal, so you might have to check this by hand. Still easy enough by using <ctime>.
EDIT: Before somebody complains that <ctime> is c++, in plain c this library is in <time.h>.
I'm trying go calculate difference between two dates, for homework.
Only problem is we can't use anything outside of for while if loops.. which is driving me crazy. I tried writing the sudocode for it and it seems simple enough but when I start sitting down and coding I get lost when the months start coming in.(excluding leap years)
Say the start dates is July 3 2015 going to March 5 2016.
I was originaly going to add days until the current month is finish and pretty much calculate everything from days. But I get kinda lost when I start including different days for each month.
An idea to work out how far you can go in that month might be
for(day=1;day<=days_in_month(month);day++){
counter++;
}
Then have a days_in_month function, that returns, using a few if statements. If you have a bit of google I remember seeing a few good statements to efficiently work this out - if you need to include leap years you'll obviously need to pass the year to the days_in_month function.
Oviously you'll need the above loop nested some other ones.
Hope this helps, good luck.
Step 1: Write a function to convert a date into a "day number since epoc", which takes into account things like leap years, etc. The epoc could probably be "1/1/1970". It'd be easy to just use lookup tables - one for "days in previous years" that includes a leap year flag and one for "days in previous months" for non-leap years (where if the leap year flag from the previous table is set and the month is after February, you add a day). Then you'd add "days in previous years", "days in previous months" and the day of the month to get "day number since epoc".
Step 2: Convert both dates into "day number since epoc" integers and subtract.
Note: The lecturer might expect you to use calculations rather than using lookup tables. In this case, use lookup tables to get it working, then replace the lookup tables one at a time.
I am stuck on the following problem from my C programming class:
Write a program that prompts the user to input a year, and then outputs the calendar(for the entire year).
I have no idea how to approach this problem. I can usually start my homework problems (this is an optional challenge problem), but I am really lost. We've worked through chapters 1-10 of Deitel & Deitel (loops, arrays, pointers, I/O, etc), but I don't know how to approach this at all. Any hints or suggestions would be appreciated.
It might help you to understand the mathematics of the calendar. If the fabulous book Calendrical Calculations is not in your university library, they may be able to get you a reprint of the article by the same authors in Software—Practice & Experience. And ask your prof to request the book for the library.
In general, when you have a big problem like this one, you want to break it down into little problems that are easier to solve.
Here's one possible little problem to start with: if you know how many days there are in a month, and what weekday the first of the month falls on, could you output a calendar for that month?
The hardest part is determining which day of the week the year starts on.
http://en.wikipedia.org/wiki/Calculating_the_day_of_the_week
But even without that knowledge, when I first implemented this, I used a reference date (for example, you know that today, January 11, 2010 is a Monday) and counted days from there. (Just keep in mind that leap years have an extra day, and that leap years are every 4 years except every 100 years except every 400 years.)
http://en.wikipedia.org/wiki/Leap_year
Does this code qualify? :-)
char command[]="cal 2010";
sprintf(command,"cal %d",argv[1]);
system(command);
It assumes a Unix machine with cal in the path.
you need to find out first the day on 1st of january
and then print the dates.
GO to https://sourceforge.net/projects/c-cpp-calender/
go through the code and you will understand it
A good start may be the localtime(3) and mktime(3) functions. Alternatively, you can implement the relevant date arithmetic from scratch. Then, simply, generate the first line of the calendar (find the weekday that corresponds to January 1st, then print taht in the right place, followed by the rest of the week), then print all but the last lines, then print the last line.
Depending on if you want a calendar paginated by month or not, this MAY be better done ona per-month instead of a per-year basis.
Well, first figure out the algorithmic part of your problem - given a year, find what day Jan 1st is.
After this, just note the number of days in each month (store it in an array, say num_days[]), and the note the number of months in a year and an array of strings for the months.
For e.g. the outermost loop iterates over the months. Say, iterate for(i=0;i<NumMonths;++i). Then, for each month, print the string, e.g. month[i], then a newline.
Then, with simple tabs, print Sun Mon Tue ..., and another newline.
Then using the day Jan 1st corresponds to (call it FirstDay), insert spaces, and start with that day. Keep printing the dates and newlines till you hit max_month[i] which is 31 (for January). Store the name of day of the last day of the previous month and just reiterate treating that day as FirstDay.
You need a couple pieces to start. First, you need a formula that computes the day of the week for January 1 of whatever year is entered. You'll also need a formula to determine if the year is a leap year. Both of these formulae are easily found with a simple Google search. The third item you need is a simple array containing the number of days in each of the 12 months for a non-leap year.
Once you have these things, its trivial to determine the week day for each month of the year. Make sure to account for February 29 in a leap year. From there, you just need to create a function that primts out the monthly calendar in a form that looks similar to the calendar hanging on the wall. Try sketching out the desired layout on paper first and use that as a template for creating the appropriate format statements.
Might check out the doomsday algorithm. This would get you certain "dooms days" like Jan 31 is a doomsday, for 2008, that was a saturday. You can work backwords from there
Basically, there are two approaches:
The easy / pragmatical way: Solve the task, and forget about everything else. Here you may check documentation for mktime() (you'll find an example based on mktime below..).
The scientific / engineering way: Learn to know how it works! You can start at the great wikipedia article about the gregorian calendar. Read it, understand it, and write code that implements the underlying algorithms (which are known, no rocket science, it is possible). This will improve your skills a lot (in fact, you really should do such a thing, maybe not the calender but another topic, it will give you a big leap in understanding all things).
Now some pragmatic code to start with. mktime() has a great feature: it knows the calender details, and it accepts e.g. a date "2010-01-60" and will convert it into February 29th, 2010. But, this will only work for dates after 1970. It will not work for earlier dates (though I am not 100% sure, but it shouldn't work, because unix time starts at January 1st, 1970, but try with other dates, maybe mktime() is not restricted to unix time).
Pseudo-Code, this prints each day on a single line (YYYY-MM-DD):
void print_cal( int year ) {
static char weekdays[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
struct tm tm;
for( int day=0; day<365; ++day ) {
memset( &tm, 0, sizeof(tm) );
tm.tm_year = year - 1900;
tm.tm_mday = day;
mktime( &tm ); // modifies tm
printf( "%04d-%02d-%02d, %s\n", tm.tm_year, tm.tm_mon+1, tm.tm_mday, weekdays[tm.tm_wday] );
}
}
This code ignores leap years. You still have to adjust it to be correct for leap years! Also the result is not very pretty yet, just one line per day.
EDIT: added output of weekdays.