Facebook
Google
GitHub
Linkedin
C programming help beginner
- Thread starter iLEEZi
- Start date
Apologies, the way I worded my thread may have caused some misunderstanding, I wasn’t asking anyone to do my coursework for me. I asked for help on how to begin my code and additional guidance so I could understand what was wrong with my own code and learn how to fix it. Im not a school student, I'm a first year EEE student and I could hope you understand how much challenging university is compared to school. I’ve had other very time consuming modules to deal with, which is why I had to leave this for last minute, but that doesn’t mean I’m avoiding my own work. I also haven’t used or copied any code given in this thread since I’ve written my own and asked for help to get it working, in which these kind people actually assisted me. For learning from videos, that’s how a lot of beginners nowadays start, alongside tutorials and forums like this. This is a help forum, so if you don’t want to help then its fine.
While there is some room for legitimate criticism about the TS putting off working on the assignment until the deadline was approaching, that doesn't mean that it is ridiculous for others to try to help them learn. Let's also try to present such criticism in a more civil manner, though it's easy for something to come across as more harsh/rude than it was intended (something we've pretty much all been guilty of). Hopefully the TS recognizes the position they put themselves into because of not managing their time well, but learning those kinds of skills is all part of being a student and hopefully they will do a better job in the future.
I suspect this is a cultural terminology issue, but could you clarify what you mean by not being a school student but yet being a first year EEE student?
Here (i.e., on AAC), "homework" refers to ANY assignment that is being done for any kind of credit. We tend to use the same approach even with people that are doing assignment-like tasks even if it's purely on their own initiative, because the goal is not to solve the problem, but to learn how to solve comparable problems in the future.
Most students that ask questions here are university students. The majority are in their first two years of their program. We get some high school students (or whatever the comparable level where you are from are called) as well as some graduate students. We can usually estimate the level by the nature of the problem being worked, but that's not guaranteed, so it can be helpful to know what level the person is actually at.
Thank you very much for your help, using your idea I was able to get my code working as needed. I really appreciate guidiance.
Using your valuable knowledge, i was able to get my code working and I really appreciate it. I separated the functions inside main() which was the only reason why the code wasnt working earlier. I also tried to fix my indentation to make the code look more cleaner. I will use your idea of using global variables and fgets() in my future code as I advanced through my knowledge. I decided to keep things simple right now because it felt easier for me to understand and my prof will know that i made the code myself. However though, the information you told me about how fgets() is a better alternative to scanf() was really interesting, and once again i will definitely implement that in my future codes. About the int main(void) and the function below it, i have not really learnt about it yet, so i would not make sense for me to use it now. I really appreciate your guidance.
yes, you’re right that this is partly a cultural terminology difference. Here in the UK (and I believe across much of Europe as well), we usually use “school” to refer to pre-university education, while university is seen as a separate stage, which is why I said I’m not a school student but a first-year EEE student.
I also now understand and agree with your point about how assignments are treated here — the focus should be on learning how to solve problems rather than just getting the answer, and that’s exactly the approach I’ve been trying to take by working on my own code and asking for guidance where I’m stuck. Id like to apologise for any misunderstanding caused between other thread viewers due to my poor clarification.
Using fgets() to gets input requires some understanding of what is going on under the hood and is not something that beginners would find easy figuring out on their own, so unless your instructor or your text covers it, I'd put it on the back burner for now, but it is something you should look at down the road.
All the 'void' keyword does is tell the compiler that the function takes no arguments. This is implied by "int main()" and is how the original C language did it. The standards simply required it to be explicit. Most compilers won't complain about not having it unless you configure them to strictly enforce the standard. But you should get in the habit of writing standards-compliant code unless there's a good reason not to (and good reasons do exist).
Hi there,
If you are going to create a system for this from the ground up, you would have to study the making of the Gregorian calendar at the very least. This involves the 4, 100, 400 rule for leap years. Every 4 years there is a leap year, but every 100 years there is no leap year, but every 400 years there is still a leap year. That's kind of nutty, but it's all in order to make up for the imprecise calculations for the actual length of a solar year. That means if you study the solar year you'll get even better because you'll need yet another rule for every 4000 years. That makes it the 4, 100, 400, 4000 rule, but most people and programs leave out the 4000 rule which means the calendar is off by 1 day in 4000 years. You can also get the day of week from these rules also, and you also need the starting date of the calendar.
Before that there was the Julian, and before that the Roman calendar. There are other calendars also that are more accurate than the one we use today. Even the Julian can be updated to perform better. Some calendars are only off by 1 day in 100000 years. We could do that with ours too, but we'd have to add more rules. It's all because of the difference of our approximation of the length of a year versus what it actually is over many centuries.
From what I understand now, there have been at least 40 known calendars over the years, and actually even more than that. The earliest ones were based on the things they needed most back then such as for growing crops. Today we have a lot more needs so we need a better way of making a calendar.
The basic operation is the calendar has to discretize the year into days, but it also has to synchronize with the actual astronomy. It's like any digitizing process that has limited bit resolution and has to monitor a continuous physical process. Eventually it loses sync and has to be adjusted. We use the leap year day for this purpose. Because that's an entire day, that brings up another error, which then has to be corrected, but even that's not enough, so eventually yet another correction, etc., etc. It's kind of funny when you think about. It's almost like, "Whoops, we need an extra day", then "Whoops, we don't need an extra day this year", then "Whoops, ..." etc., etc. If the resolution of the discretization is limited, this kind of adjustment would have to go on forever. In addition, it's a complex physical process that is being monitored, so we have to include measurements as well. That means we can't pick a number like 365.242189 as the exact number of days in a year and expect it to work forever even with adjustments.
It's a complex phenomenon but we make approximations so we can deal with it on a year to year basis.
From what I understand the Persian calendar constantly syncs to the actual solar year, so there is no fixed number like 365.242189 because if the next year another measurement is made it could be maybe 365.243122 which could alter something.
@iLEEZi: Now that we are well past the presumed due date, I'll walk through one approach to solving the problem, showing the incremental steps in the development that you might consider. This will be an example of what is known as the "top-down" approach in which the high-level logic is implemented and the low-level details filled in later. This is accomplished by "stubbing out" low level functions so that they return something valid, regardless of whether it is correct or not.
The first step is to break the overall problem down into a sequence of smaller steps:
Code:
#include <stdio.h>
int main(void)
{
// Get the first date from the User
// Get the second date from the User
// Calculate the number of days from the first date to the second
// Print out the result
return 0;
}
Code:
#include <stdio.h>
void GetDate(int date[])
{
date[0] = 25;
date[1] = 9;
date[2] = 2007;
}
int DaysBetween(int date1[], int date2[])
{
return 42;
}
int main(void)
{
//
int date1[3], date2[3]; // Date[] = {dd, mm, yyyy}
int days;
// Get the first date from the User
GetDate(date1);
// Get the second date from the User
GetDate(date2);
// Calculate the number of days from the first date to the second
days = DaysBetween(date1, date2);
// Print out the result
printf("%02d/%02d/%04d is %d days after %02d/%02d/%04d.\n",
date2[0], date2[1], date2[2], days, date1[0], date1[1], date1[2]);
return 0;
}Also notice that our pseudocode now serves the purpose of documenting our code. The reader sees what the code is supposed to accomplish, followed the code that accomplishes it. The comments focus on the 'what' in the context of solving the problem, while the code details the 'how'.
The next thing I'm going to do is flesh out the GetDate() function just enough to be able to return two different dates (so that I can start testing the DaysBetween() function). In response to being asked for a date, the user will just enter a single number. If that number is 1, it will return one date, otherwise it will return another. This allows us to run tests very easily instead of having to type in two actual dates each time. If we want to use different dates, we can simply change the dates in this function or add additional dates (a switch() statement would be good if we want to do this).
At the same time, the DaysBetween() function will be given the ability to determine which date comes before the other, or if they are the same. It will then return +42, -42, or 0, accordingly.
Code:
#include <stdio.h>
void GetDate(int date[])
{
int temp;
printf("Enter a date: ");
scanf("%d", &temp);
if (1 == temp)
{
date[0] = 25;
date[1] = 9;
date[2] = 2007;
}
else
{
date[0] = 6;
date[1] = 3;
date[2] = 1974;
}
}
int CompareDates(int date1[], int date2[])
{
// IF Years are different
if (date2[2] != date1[2])
// IF year2 > year1, date2 > date1 ELSE data2 < date1
return (date2[2] > date1[2])? 1 : -1;
// IF Months are different
if (date2[1] != date1[1])
// IF month2 > month1, date2 > date1 ELSE data2 < date1
return (date2[1] > date1[1])? 1 : -1;
// IF Days are different
if (date2[0] != date1[0])
// IF day2 > day1, date2 > date1 ELSE data2 < date1
return (date2[0] > date1[0])? 1 : -1;
// Dates are equal
return 0;
}
int DaysBetween(int date1[], int date2[])
{
return 42 * CompareDates(date1, date2);
}
int main(void)
{
//
int date1[3], date2[3]; // Date[] = {dd, mm, yyyy}
int days;
// Get the first date from the User
GetDate(date1);
// Get the second date from the User
GetDate(date2);
// Calculate the number of days from the first date to the second
days = DaysBetween(date1, date2);
// Print out the result
printf("%02d/%02d/%04d is %d days after %02d/%02d/%04d.\n",
date2[0], date2[1], date2[2], days, date1[0], date1[1], date1[2]);
return 0;
}There are many ways to do this, but let's do the equivalent of counting on our fingers. It may sound stupid, however, if it's stupid but works, it ain't stupid.
Since now we are having to develop an algorithm, we'll start with the high-level pseudocode for it.
Code:
int DaysBetween(int date1[], int date2[])
{
// Make a copy of the first date
// Initialize day counter to zero
// WHILE the temp date isn't equal to the second date
// Adjust day counter
// Move temp date one day closer to second date
// Return the day counter
}
Code:
void AdjustDate(int date[], int plusMinus)
{
// IF plusMinus is positive
if (1 == plusMinus)
{
// Move the date forward one day
date[0]++;
}
// ELSE
else
{
// Move the date back one day
date[0]--;
}
}
Code:
void GetDate(int date[])
{
int temp;
printf("Enter a date: ");
scanf("%d", &temp);
if (1 == temp)
{
date[0] = 23;
date[1] = 11;
date[2] = 1987;
}
else
{
date[0] = 5;
date[1] = 11;
date[2] = 1987;
}
}
Code:
Enter a date: 1
Enter a date: 2
05/11/1987 is -18 days after 23/11/1987.
Enter a date: 2
Enter a date: 1
23/11/1987 is 18 days after 05/11/1987.
Enter a date: 1
Enter a date: 1
23/11/1987 is 0 days after 23/11/1987.
Code:
void AdjustDate(int date[], int plusMinus)
{
// IF plusMinus is positive
if (1 == plusMinus)
{
// Move the date forward one day
date[0]++;
// Move to start of following month if necessary
if (31 < date[0])
{
date[1]++;
date[0] = 1;
}
// Move to start of following year if necessary
if (12 < date[1])
{
date[2]++;
date[1] = 1;
}
}
// ELSE
else
{
// Move the date back one day
date[0]--;
// Move to end of prior month if necessary
if (1 > date[0])
{
date[1]--;
date[0] = 31;
}
// Move to end of prior year if necessary
if (1 > date[1])
{
date[2]--;
date[1] = 12;
}
}
}
Code:
Enter a date: 1
Enter a date: 2
23/11/1887 is -37200 days after 23/11/1987.
Enter a date: 2
Enter a date: 1
23/11/1987 is 37200 days after 23/11/1887.
Code:
Enter a date: 1
Enter a date: 2
31/12/9999 is 3719999 days after 01/01/0000.The next step is to make our AdjustDate() function aware of how many days are actually in a month, ignoring leap years.
Notice that this change is extremely minor at this level of abstraction, involving only replacing the hardcoded 31 (the prior days in a month) with a call to the function DaysInMonth() that is expected to return the actual number of days in a month.
Code:
void AdjustDate(int date[], int plusMinus)
{
// IF plusMinus is positive
if (1 == plusMinus)
{
// Move the date forward one day
date[0]++;
// Move to start of following month if necessary
if (DaysInMonth(date) < date[0])
{
date[1]++;
date[0] = 1;
}
// Move to start of following year if necessary
if (12 < date[1])
{
date[2]++;
date[1] = 1;
}
}
// ELSE
else
{
// Move the date back one day
date[0]--;
// Move to end of prior month if necessary
if (1 > date[0])
{
date[1]--;
date[0] = DaysInMonth(date);
}
// Move to end of prior year if necessary
if (1 > date[1])
{
date[2]--;
date[1] = 12;
}
}
}A subtle point here is that the date that we pass to DaysInMonth() has been modified by either incrementing it or decrementing it, which means that it could be 0 (or as high as 32). Also, when we call it to set the day to the last day of the prior month, the month has been decremented always, so it could be 0. We need to be sure that we allow and account for this.
Code:
int DaysInMonth(int date[])
{
static int daysInMonth[] = {31,28,31,30,31,30,31,31,30,31,30,31};
// Return the number of days in the month with wraparound
// (date[1]-1) accounts for array index being zero-based
// (date[1]-1)+12 moves negative months to positive for rem to be mod
// ((date[1]-1)+12)%12 maps values outside array bounds back in
return daysInMonth[((date[1]-1)+12)%12];
}The last thing we need to do (other than modifying GetDate() actually get and validate a date from the User) is to account for leap years.
The obvious place to do this is in the DaysInMonth() function. At this level of abstraction, we just need to know if the current year is a leap year and, if so, is the current month February. If so, we simply add 1 to the number of days that gets returned.
Code:
int DaysInMonth(int date[])
{
static int daysInMonth[] = {31,28,31,30,31,30,31,31,30,31,30,31};
// SET leapDay to 1 if the date is in February of a leap year (0 otherwise)
int leapDay = (2 == date[1]) && IsLeapYear(date));
// Return the number of days in the month with wraparound
// (date[1]-1) accounts for array index being zero-based
// (date[1]-1)+12 moves negative months to positive for rem to be mod
// ((date[1]-1)+12)%12 maps values outside array bounds back in
return daysInMonth[((date[1]-1)+12)%12] + leapDay;
}
Code:
int IsLeapYear(int date[])
{
int year = date[2];
// Years divisible by 400 ARE leap years
if (0 == year%400)
return 0;
// All other century years are NOT leap years
if (0 == year%100)
return 0;
// All other years divisible by 4 ARE leap years
return (0 == year%4);
}
[/QUOTE]
If all years divisible by four were leap years, we would expect this to add 2500 days to our extreme span. Since there are 100 century years, this would be reduced to 2400 by the century-year rule, but the 400-year rule would add back 25 of them. Hence, over 10,000 years, there should be 2425 leap days.
But, when I ran it, I got 3652399 days, which is an additional 2400 days. This implies that the issue is related to the 400-day rule. Sure enough, my IsLeapYear() function is returning 0 in this case when it should be returning 1.
This underscores the value in incremental development and testing. Implement small pieces of code and then perform a meaningful test on them -- don't just run them and call it good if it doesn't crash. If it doesn't produce the expected output, the most likely culprit is going to be the small amount of code you just implemented, which immediately allows you to focus your attention on the correctness of that small piece of code.
Finally, we can turn our attention to getting actual dates from the user and validating them.
First, we modify our GetDate() function as follows:
[CODE]
void GetDate(int date[])
{
int temp;
printf("Enter a date in the forma DD/MM/YYYY: ");
scanf("%d/%d/%d", &date[0], &date[1], &date[2]);
if (!IsValidDate(date))
{
printf("ABORT: Date Entered is not valid.\n");
exit(1);
}
}// Get a date from the User
// IF the date is not valid, abort the program
At this level, we don't care HOW we determine whether the date is valid. That's deeper in the weeds than we should be thinking at this level, so leave that task to another function.
Note that, to use the exit() function, we need to include <stdlib.h>.
After we are satisfied that we can accept valid dates successfully, we can implement our full IsValidDate() function very easily. Again, note that our code is not too far down in the weeds. We have a function that tells us how many days are in a month, so we use it. This did require me to move the DaysInMonth() and IsLeapYear() functions to the top of the file.
Code:
int IsValidDate(int date[])
{
// Year must be between 1 and 9999 (inclusive)
if ( !( (1 <= date[2]) && (date[2] <= 9999) ) )
return 0;
// Month must be between 1 and 12 (inclusive)
if ( !( (1 <= date[1]) && (date[1] <= 12) ) )
return 0;
// Day must be between 1 and 12 (inclusive)
if ( !( (1 <= date[0]) && (date[1] <= DaysInMonth(date)) ) )
return 0;
// If no tests above failed, the date is valid
return 1;
}For instance, from the time I sat down and opened a blank source code file until now, which includes all the time spent writing this post, was barely over two hours -- and the vast majority of that time was writing this post!
Thank you so much for taking your precious time and teaching me how to breakdown huge codes like this. I somehow managed to get my codes working through spending a huge load of time on trial and error, and i submitted it just a few days ago. I loved your idea of making psuedo codes and i will definitely give it a try for my next coursework. The way you wrote your code made sense to me. However, i do not get the difference between void functions and normal functions, i dont understand the use of return at the end of the function. From what i understand, i know that return 1 means true and return 0 means false, for example, in your code you used return 42 in the DaysBetween() function, and i dont understand what that does,i also know that return can be used to return a value from the function like you did in DaysInMonth() function. Additionally, function parameters is another concept i couldnt fully grasp. I know the complete basic example of function parameters where you can set a parameter in a function, then assign a value to that parameter when calling that function, but for a more difficult code i do not understand the parameters at all.
Trial and error has its uses, but the focus should be on taking a step back and figuring out exactly what you want to accomplish and what needs to happen to accomplish it. Most problems can be broken down into a relatively small handful of smaller problems that can be tackled more or less independently. Each of those problems can the be broken down further, as needed, until you get down to a point where you can say, "Yep, I know how to make that happen."
The only difference is that a void function is a function that doesn't return any value at all, while a non-void function is one that does. Don't make it any harder than it is.
In some programming languages, a subroutine that doesn't return a value is called a "procedure" while a subroutine that does is called a "function". There are some under-the-hood reasons why making a distinction makes sense, but mostly these are of relevance to the person writing the compiler. Today, from the perspective of the programmer, most languages lump them together and each one either returns something or it doesn't. The C language standard merely requires standards-compliant programs tell the compiler explicitly when a function isn't going to return a value by declaring the return type to be 'void'. This gives a useful heads up to the compiler so that it can leverage that knowledge to produce more efficient code or to give useful warnings to the programmer when their code either returns a value when they said it wouldn't, or doesn't return a value when it said it would. In essence, it establishes a contract between you and the compiler and enables the compiler to help you by letting you know when you are breaching the contract.
Similarly, if your function doesn't take any arguments, by telling it that the parameter list is void, you are explicitly telling the compiler that you are not going to pass any arguments to that function when you call it so that it can give you a warning if you ever do.
What the return value means depends entirely on what the programmer intends it to mean. If you call the sqrt() function, the return value is the square root of the value that was passed to it as an argument when it was called. If you call the strlen() function, the value that is returned is the number of characters in the string (NUL-terminated character array) that was passed to it. If you need your function to return a true/false result, the 0 is how we represent a FALSE in C, while ANY non-zero value is considered to be TRUE. But YOU decide what a function's return value means, and then you must be sure that you USE that value in a manner consistent with what you decided.
The value returned by DaysBetween represents the number of days by which the second date follows the first. But I wanted to be able to call the function before I tackled how to go about actually figuring out how many days separate two dates. So I "stubbed out" the function by hardcoding it to return a value that was valid, though almost certainly wrong. I just picked 42 out of a hat (well, not quite) as my temporary return value to use until I got around to doing something better.
I'm not at all sure what you do and don't understand on this point. You declare parameters for your function and when the function is called, you pass arguments that are used to set the values in those parameters. That's pretty much it. Don't make it harder than it is.
YESSSSS, the year 2000 was unusual because it was a multiple of 400! ! !
It created an interesting situation in that if you were totally naive of anything beyond the "divisible by 4 rule" (which is a very large fraction of people), you got it right, while people that were aware of the "divisible by 100" rule", but not the "divisible by 400" rule (which is a large fraction of the remaining people), you got it wrong. It was basically a case of, sometimes, two wrongs do make a right.
