Can somebody tell me why there's no semicolon required at the end of the #include line and/or the main function declaration??

Also, some sources include the first solo 'int', while others do not.

Some sources include the text found inside the main function parens, while others do not.

Why are there SPACES surrounding the minus sign, but not around the divisor?

In respect of http://radified.com/cgi-bin/yabb2/YaBB.pl?num=1266346028
Can somebody tell me why there's no semicolon required at the end of the #include line and/or the main function declaration??

There's no semicolon at the end of #include because there are really two languages in C; one operates at the level of text, and is called the C Preprocessor. All the lines in a program that begin with # are instructions for the preprocessor, which runs before the main C compiler proper. C's model is that conceptually, the C compiler is chewing on one big single file of text and the preprocessor does jobs like combining text files together as part of passing them on to the compiler.

This comes from the original UNIX where C developed, which as mentioned before was a 16-bit machine with 64k of data and program space per process. The preprocessor was actually a separate program (named "cpp") from the C compiler proper (which generally got called something like "cc1") and the two were connected by a UNIX pipe so that the text output of cpp was piped into the cc1 part - using a pipe for this allowed the two programs together to accomplish much more than an integrated one. Users typically newer ran the compiler parts themselves; that arrangement was then managed by a "front end" program which occupied the name "cc" and was what most people interacted with, and thus thought of as the C compiler (and that front end could also handle compiling multiple files, and then involve the linker program "ld" to create a final executable binary).

A semicolon only seems necessary at the end of the printf statement. Trying to understand the rules/logic/patterns

The rules for semicolons are a little arcane from the outside; they are required so that the language can tell one statement apart from the one that comes after it, as C considers all whitespace (newlines, spaces, and such like) as insignificant at the level of the grammar. All statements therefore need something to separate them from the next statement, and it's the semicolon which has that job (for statements that themselves that can contain another statement like "if" conditionals and "for" loops, curly braces will often do the same job).

By the way, remember that at the time, UNIX was unusual in having programs being "text files" and those files being nothing more than sequences of bytes ("bytes" being relatively new at the time too!). Older languages cared more about whitespace - things like column position - because they were input on physical *punchcards*, not typed into a terminal. The 80-column line width of terminals was considered ideal, incidentally because most punchcards were physically 80 characters long.

Also, some sources include the first solo 'int', while others do not.

The "solo int" thing reflects the history of the language, and these days it should be considered absolutely required; not having it is a throwback to the very first versions of C, where the only data types were "char", "int", and "long", pointers and arrays. In that early version of the C language, since most things were of type "int", it was made the *default* data type. So, if a declaration did not include an "int", the fact the data was an int was just assumed. This changed dramatically over the years, especially with the evolution of C++ out of C - it's still possible to omit "int" in a few places, but it's never a good idea and it's something you should avoid doing. Be explicit as possible.

Some sources include the text found inside the main function parens, while others do not.

The text inside the parentheses after "main" is largely another historical change; similarly to the case above with default "int", most function parameters were assumed to have a type of int and so there usually wasn't a need to declare their data types at all. Furthermore, although C generally required you to declare correctly declare at least the number of function arguments correctly, the "main" function is special in that it's where your program started, so it's the one function in all of C where *it didn't matter if you got the arguments wrong*; unlike any other function, nothing bad happened. So, people got lazy and often tended to leave everything out altogether.

This largely changed with the standardization of C during the 1980's; the usage with the data type declarations inside the parentheses comes from the ANSI Standard editions of C (the original C language put them elsewhere if they were present at all, which as noted above they weren't). This change allowed the compiler to do a much better job of type-checking the language to ensure that you called functions with the right number and type of arguments - prior to ANSI C, there was basically no checking at all of this, and almost any program would compile but would happily crash when you ran it. ANSI C tried to move as much as much of this kind of pre-checking as possible into the compiler instead of just letting programs crash, and then C++ built on that much much more and as a result some of the really error-prone old C style is not longer considered legal in C++.

So, although in a pure C program you can still sometimes get away with this kind of thing, a good C program should ideally also be a valid C++ program, by keeping to the subset of C which is also supported in C++. For that reason and for better type-checking, good style should *always* include proper data type declarations for function arguments in the parentheses.