// This program expects a single input line with // a day of the week (1+ chars) and a year (1970 // to 2100). Optionally, you can turn on debugging // that outputs a few special test cases as the // 3rd argument (1, T, t). Inspired by Shubhamendra // Chongder's question here: // https://www.sololearn.com/Discuss/793363/?ref=app // C++ program to calculate the number of Sundays // in a year . // The program has to calculate the no. of times a // particular day (eg. Sunday/Monday/Tuesday) occurs // in a given year. // Given it is probably a school assignment, I // described how to do this program, without writing // it. However, it was something I decided to write. // As you can see, I went a little overboard creating // a class. #include #include #include #include // ******************** Time ******************** // // The class to convert C time into C++ class. // This class still needs some future updates // to finish the complete functionality. class Time { //================== Private ================== // Private data and methods. private: // C time structure with second, minute, hour, // day of the month, month, year, day of the // week, day of the year, and daylight // savings time. struct tm tim; // Names of the days of the week. static const std::string days[7]; // Names of the months of the year. static const std::string months[12]; // Zero the C time structure. void zeroTime(struct tm *tp); // Method to initialize data during constructor. void init(int month, int day, int year); //================== Public ================== // Public types and methods. public: // Days of the week as an enumeration. enum Days {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday}; // Months of the year as an enumeration. enum Months {January, February, March, April, May, June, July, August, September, October, November, December}; // Constructor making an object with the current // time. Time(); // Constructor making an object for a specified // date at midnight (month as integer.) Time(int month, int day, int year); // Constructor making an object for a specified // date at midnight (month as enumeration.) Time(Months month, int day, int year); // Constructor making an object offset days from // the specified object. Time(Time timeS, int days); // Change the time of the object. void setTime(int hours, int minutes, int seconds); // Get the year of the object. int getYear(); // Return a string of the date (month day, year.) std::string getDate(); // Return a string of the time (hour:minute: // second.) std::string getTime(); // Return a string of the weekday. std::string getWDay(); // Return the enumeration of the weekday. Days getWDayN(); // Return the number of the day in the year. int getYDay(); // True, when the year is a leap year. bool isLeapYear(); // True, when the name is valid (matches what // characters exist) and day is updated. static bool lookupDay(Days *day, std::string name); // Return the string for the specified day. static std::string lookupDay(Days day); // True, when the name is valid (matches what // characters exist) and month is updated. static bool lookupMonth(Months *month, std::string name); // Return the string for the specified day. static std::string lookupMonth(Months month); }; // class Time // ******************** Const ******************** // // Initialize the private static constant strings // for the days of the week and months of the year. const std::string Time::days[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; const std::string Time::months[12] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; // ******************** zeroTime ******************** // // Private member to zero the C time structure. // The system can change this structure order // so access each field of the structure. // // Arguments // tp is the address of the structure to be // zeroed. // // Returns // Nothing. void Time::zeroTime(struct tm *tp) { tp->tm_sec = 0; // Seconds since minute started. tp->tm_min = 0; // Minutes since hour started. tp->tm_hour = 0; // Hours since day started. tp->tm_mday = 0; // Day number of month. tp->tm_mon = 0; // Months since year started. tp->tm_year = 0; // Years since 1900. tp->tm_wday = 0; // Day of the week. tp->tm_yday = 0; // Days since the year started. tp->tm_isdst = 0; // 1 during daylight savings. } // zeroTime // ******************** init ******************** // // Private method called to initialize the object // to a specified date by the two constructors // for that purpose. If the date fails to come // back, it wasn't valid so use the current date // and time. // // Arguments // month is the month number (1 to 12.) // day is the day number (1 to 31.) // year is the year (1900 to ?.) // // Returns // Nothing. void Time::init(int month, int day, int year) { // Fill in the C structure. struct tm ts; zeroTime(&ts); ts.tm_mon = month-1; ts.tm_mday = day; ts.tm_year = year-1900; // Get the time in seconds from Epoch for our // structure and get the new structure. time_t t = mktime(&ts); struct tm *tp = localtime(&t); // If the new structure date fails to match the // specified one, the specified one is invalid // (e.g. 2/31/2017) so default to the current // time. Get the current time in seconds and // get it's structure. if (tp->tm_mon+1 != month || tp->tm_mday != day || tp->tm_year+1900 != year) { t = time(NULL); tp = localtime(&t); } // if // Copy the structure into our object. tim = *tp; } // init // ******************** Time ******************** // // Constructor making an object with the current // time. Get the current time, convert it to // the structure, and copy it into the object. // // Arguments // Nothing. // // Returns // Nothing. Time::Time() { time_t t = time(NULL); struct tm *tp = localtime(&t); tim = *tp; } // Time // ******************** Time ******************** // // Constructor making an object for a specified // date at midnight. Call the common init // method to do the actual work. // // Arguments // month is the month number (1 to 12.) // day is the day number (1 to 31.) // year is the year (1900 to ?.) // // Returns // Nothing. Time::Time(int month, int day, int year) { init(month, day, year); } // Time // ******************** Time ******************** // // Constructor making an object for a specified // date at midnight. Call the common init // method to do the actual work. The enumeration // starts at 0 so adjust to 1 to 12 by adding one. // // Arguments // month is the month enumeration. // day is the day number (1 to 31.) // year is the year (1900 to ?.) // // Returns // Nothing. Time::Time(Months month, int day, int year) { init((int)month+1, day, year); } // Time // ******************** Time ******************** // // Constructor making an object offset days from // the specified object. // // Arguments // timeS is the object to use as a starting // point. // days is the number of days to add. // // Returns // Nothing. Time::Time(Time timeS, int days) { // Copy the starting point's time structure, // add in the days to the day of the month, // convert the structure to seconds (making // use of the fact that the function will // do what we want despite it not being a // valid date,) get the updated structure, // and store it in our object. struct tm ts = timeS.tim; ts.tm_mday += days; time_t t = mktime(&ts); struct tm *tp = localtime(&t); tim = *tp; } // Time // ******************** setTime ******************** // // Method to change the time of the object. // // Arguments // hours is the hour part of the time. // minutes is the minute part of the time. // seconds is the seconds part of the time. // // Returns // Nothing. void Time::setTime(int hours, int minutes, int seconds) { // If the hours are valid, update the object's // hour as specified. if (hours >= 0 && hours <= 23) tim.tm_hour = hours; // If the minutes are valid, update the object's // minutes as specified. if (minutes >= 0 && minutes <= 59) tim.tm_min = minutes; // If the seconds are valid, update the object's // seconds as specified. if (seconds >= 0 && seconds <= 59) tim.tm_sec = seconds; } // setTime // ******************* getYear ******************* // // This method gets the year of the object. // // Arguments // Nothing. // // Returns // The object's year. int Time::getYear() { return tim.tm_year+1900; } // getYear // ******************** getDate ******************** // // Method to return a string of the object's // date (e.g. November 1, 2017.) Use stringstream // to create the string and return it. // // Arguments // Nothing. // // Returns // String of the object's date. std::string Time::getDate() { std::stringstream s; s << months[tim.tm_mon] << " " << tim.tm_mday << ", " << tim.tm_year+1900; return s.str(); } // getDate // ******************** getTime ******************** // // Method to return a string of the time (e.g. // 01:01:01.) Use stringstream to create the // string and return it. // // Arguments // Nothing. // // Returns // String of the object's time. std::string Time::getTime() { std::stringstream s; s << tim.tm_hour/10 << tim.tm_hour%10 << ":" << tim.tm_min/10 << tim.tm_min%10 << ":" << tim.tm_sec/10 << tim.tm_sec%10; return s.str(); } // getTime // ******************** getWDay ******************** // // Method to return a string of the weekday (e.g. // Sunday.) Lookup the string for the structure's // weekday and return it. // // Arguments // Nothing. // // Returns // String of the object's day of the week. std::string Time::getWDay() { return days[tim.tm_wday]; } // getWDay // ******************** getWDayN ******************** // // Method to return the enumeration of the weekday // (e.g. Time::Sunday.) Convert the structure's // weekday and return the corresponding enumeration. // // Arguments // Nothing. // // Returns // Enumeration of the object's day of the week. Time::Days Time::getWDayN() { return (Days)tim.tm_wday; } // getWDayN // ******************** getYDay ******************** // // Method to return the object's number of the day // in the year (1 to 366.) January 1st is day 1 and // December 31 is 365 (366 on leap year.) The // structure's version starts at zero so add one // to return it. // // Arguments // Nothing. // // Returns // Number of the day in the year. int Time::getYDay() { return tim.tm_yday+1; } // getYDay // ******************* isLeapYear ******************* // // This method returns true, when the year is a // leap year. Fill in the C structure for December // 31 of this object's year, get the time in // seconds from Epoch for our structure, get the // new structure, and see if there are 366 days // in the year. // // Arguments // Nothing. // // Returns // True for leap year. bool Time::isLeapYear() { struct tm ts; zeroTime(&ts); ts.tm_mon = 11; ts.tm_mday = 31; ts.tm_year = tim.tm_year; time_t t = mktime(&ts); struct tm *tp = localtime(&t); return (bool)(tp->tm_yday == 365); } // isLeapYear // ******************** lookupDay ******************** // // This method returns true, when the name is valid // and day is updated. Note: this method will allow // a single character match so 'S' matches "Sunday" // and 'T' matches "Tuesday". Saturday and Thursday // require two characters to match. // // Arguments // day is the address for the weekday. If true // is return, the weekday will be updated // to the one found. // name is the string to lookup. // // Returns // True for a valid weekday. bool Time::lookupDay(Days *day, std::string name) { // Default the result to false and allocate the // string. For each array element, compare the // strings, until a match is found. bool r = false; std::string d; for (int i = 0; i < 7 && !r; i++) { // Make a copy of the current element for the // number of characters in the name we are // checking. This allows a single letter match. // If the strings match, update the result to // true and the day to the one found. d = days[i].substr(0, name.length()); if (name.compare(d) == 0) { r = true; *day = (Days)i; } // if } // for // Return the result of the match. return r; } // lookupDay // ******************** lookupDay ******************** // // This method return the string for the specified // day. // // Arguments // day is the weekday to look up. // // Returns // The corresponding string for the weekday. std::string Time::lookupDay(Days day) { return days[(int)day]; } // lookupDay // ******************* lookupMonth ******************* // // This method returns true, when the name is valid // and month is updated. Note: this method will allow // a single character match so 'A' matches "April", // 'J' matches "January", and 'M' matches "March". // August, June, and May require two characters to // match. July requires three. // // Arguments // month is the address for the month. If true // is return, the month will be updated to // the one found. // name is the string to lookup. // // Returns // True for a valid month. bool Time::lookupMonth(Months *month, std::string name) { // Default the result to false and allocate the // string. For each array element, compare the // strings, until a match is found. bool r = false; std::string m; for (int i = 0; i < 12 && !r; i++) { // Make a copy of the current element for the // number of characters in the name we are // checking. This allows a single letter match. // If the strings match, update the result to // true and the month to the one found. m = months[i].substr(0, name.length()); if (name.compare(m) == 0) { r = true; *month = (Months)i; } // if } // for // Return the result of the match. return r; } // lookupMonth // ******************* lookupMonth ******************* // // This method return the string for the specified // month. // // Arguments // month to look up. // // Returns // The corresponding string for the month. std::string Time::lookupMonth(Months month) { return months[(int)month]; } // lookupMonth //===================== End Time ===================== // ******************* processYear ******************* // // This function outputs how many times the weekday // occurs in the year and lists them all. // // Arguments // day is the weekday we are interested in. // year is the year we are interested in. // // Returns // Nothing. void processYear(Time::Days day, int year) { // Default number of weekday occurences in the // year to 52. It might end up being 53, if it // is the first or second day in the new year. // Normal years end on the same weekday they // start. Leap years end on the following // day (e.g. 2012 is a leap year that starts on // Sunday and ends on Monday; 2013 starts and // ends on Tuesday.) Get the last day of the // year and it's weekday (0 to 7.) If the // weekday is the one we are interested in or // the year is a leap year and it is the // following one (e.g. Monday 2012 or Sunday // 2012 was specified,) set the occurences // to 53. int days = 52; Time t1(Time::December, 31, year); Time::Days d = t1.getWDayN(); if (day == d | (t1.isLeapYear() && (Time::Days)(((int)day+1)%7) == d)) days = 53; // Lookup the string for the weekday. Output how // many occurences were found (e.g. // '2012 has 53 Sundays.'.) std::string s = Time::lookupDay(day); std::cout << year << " has " << days << " " << s << "s." << std::endl; // Get the first day of the year and it's // weekday. Time t2(Time::January, 1, year); d = t2.getWDayN(); // Get the first weekday we are looking for. // repeat until we have outputted all of the // occurences, output the current date and // get the next one. Time t3(t2, (7+((int)day-(int)d))%7); do { std::cout << t3.getDate() << std::endl; Time t4(t3, 7); t3 = t4; } while (--days); } // processYear // ******************** test ******************** // // This function performs testing of the Time class. // // Arguments // Nothing. // // Returns // Nothing. void test() { // Test 1 ------ Using the first constructor, // create an instance with the current time // and output the information. Time t1; std::cout << t1.getDate() << " " << t1.getWDay() << " " << t1.getTime() << std::endl; // Test 2 ------ Using the second constructor, // create an instance for January 1 of the // current year, set the time to 1:9:0 AM, // and output the information. Time t2(1, 1, t1.getYear()); t2.setTime(1, 9, 0); std::cout << t2.getDate() << " " << t2.getWDay() << " " << t2.getTime() << std::endl; // Test 3 ------ Using the third constructor, // create an instance for December 31, 2016, // verify it is a leap year & output it is, // and output the information. Time t3(Time::December, 31, 2016); if (t3.isLeapYear()) std::cout << "Leap year "; std::cout << t3.getDate() << " " << t3.getWDay() << " " << t3.getTime() << std::endl; // Test 4 ------ Using the fourth constructor, // create an instance based on the second // object offset the days returned for the // first. The date should end up being today // with the 1:9:0 AM time. Output the information. Time t4(t2, t1.getYDay()-1); std::cout << t4.getDate() << " " << t4.getWDay() << " " << t4.getTime() << std::endl; // Test 5 ------ Process Sundays of 2012 getting // 53 days. processYear(Time::Sunday, 2012); // Test 6 ------ Process Mondays of 2012 also // getting 53 days. All other weekdays yield 52 // days. processYear(Time::Monday, 2012); } // test // ******************** getInput ******************** // // Prompt for and read the day of the week, year, and // optionally debug. Note: arguments contents is // updated even when the input is invalid. // // Arguments // day is the address to store the weekday. // year is the address to store the year. // debug is the address to store the debug option. // // Returns // True, when everything is good. bool getInput(Time::Days *day, int *year, bool *debug) { // Create the various data needed: the input line, // weekday argument, argument state, index to the // line, current character from line, locale, and // result valid. std::string input; std::string wDay; int state = 0; int i; char c; std::locale loc; bool valid; // Prompt for and read the line. For each character // in the line while the arguments are valid, // process the character. std::cout << "Enter a weekday and year: "; getline(std::cin, input); for (valid = !input.empty(), i = 0; valid && i < input.length(); i++) { // Lowercase the current character and process // the current state as needed. c = tolower(input[i], loc); switch (state) { // Looking for the start of the first // argument: If the current character is a // space, skip it. If it is alphabetic, we // found the start so store the uppercase // version into the weekday and proceed to // the next state. Otherwise, it must be // invalid so abort. case 0: if (c == ' ') { } else if (isalpha(c)) { wDay = toupper(c); state++; } else { valid = false; } // if break; // Looking for the end of the first argument: // If the current character is a space, // we found the end so verify the weekday // is valid and if so proceed to the next state. // If the character is alphabetic, tack it // onto the weekday. Otherwise, it must be // invalid so abort. case 1: if (c == ' ') { valid = Time::lookupDay(day, wDay); if (valid) { state++; } } else if (isalpha(c)) { wDay += c; } else { valid = false; } // if break; // Looking for the start of the second // argument: If the current character is // a space, skip it. If it is numeric, we // found the start so store the digit into // the year and proceed to the next state. // Otherwise, it must be invalid so abort. case 2: if (c == ' ') { } else if (isdigit(c)) { *year = (int)c-(int)'0'; state++; } else { valid = false; } // if break; // Looking for the end of the second argument: // If the current character is a space, // we found the end so proceed to the next // state. If the character is numeric, shift // the year and add the new digit. Otherwise, // it must be invalid so abort. case 3: if (c == ' ') { state++; } else if (isdigit(c)) { *year = *year*10+(int)c-(int)'0'; } else { valid = false; } // if break; // Looking for the optional debug state: If // the current character is a space, skip it. // Otherwise, we found the debug state so // update debug based on finding a '1' or 't' // and proceed to the next state ignoring // the rest of the line. case 4: if (c == ' ') { } else { *debug = c == '1' || c == 't'; state++; } // if break; } // switch } // for // If we didn't get a valid first argument, complain // and abort. if (state < 1 || (state == 1 && !valid)) { std::cout << std::endl << "Invalid weekday!" << std::endl; valid = false; // If we didn't get a valid second argument or the // year is out of range, complain and abort. } else if (state < 3 || *year < 1970 || *year > 2100) { std::cout << std::endl << "Invalid year!" << std::endl; valid = false; } // if // Return whether the arguments are valid. return valid; } // getInput // ******************** main ******************** // // This is the main entry point for the program. // It prompts for the weekday and year. If the // input is valid, process the year and, if // debug requested, output the various tests. // // Arguments // Nothing. // // Returns // A zero. int main() { Time::Days day; int year; bool debug = false; if (getInput(&day, &year, &debug)) { processYear(day, year); if (debug) test(); } // if return 0; } // main

Shubhamendra Chongder date og