1. Write a function whose job is to output some sequence of "interesting" #'s. The numbers should be separated from one another somehow so they don't all run together. This function may need to call another function, where the second function determines whether a number is interesting or not.

A. void outputA( unsigned lo, unsigned hi );

The args designate the range [lo, hi]. If lo > hi, then that designates the empty range (no numbers), in which case outputA returns without outputting any numbers. Otherwise, outputA outputs all the numbers in the range that are interesting.

For this problem (A), let's say all numbers are interesting, so we'll output all the numbers in the range.

For example, if main says

            outputA( 5, 10 );

then outputA will output

            5 6 7 8 9 10

For another example, if main says

            outputA( 10, 5 );

then outputA won't output any numbers at all.

B. void outputB( unsigned lo, unsigned hi );

Same idea, but this time only even #'s are interesting.

For example, if main says

            outputB( 5, 10 );

then outputB will output

            6 8 10

C. void outputC( unsigned lo, unsigned hi );

Same idea for odd #'s, but this time you need to have outputC call another function, odd, that returns whether a given number is odd:

            bool odd( unsigned n );

odd's job is to return whether n is odd.

For example,

            odd( 1234 )

returns false because 1234 isn't an odd number.

outputC's job is to take each number in the range [lo, hi], pass it to odd to see whether it's odd, and to use this return value to determine whether to output that number or not.

For example, if main says

            outputC( 5, 10 );

then outputC will call odd 6 times and output

            5 7 9

(Of course, testing whether a number is odd is so simple that in a serious program we might decide to have outputC test just test for oddness without calling another function, but for this question I want you to actually write and use the odd function.)

D.         void outputD( unsigned lo, unsigned hi );

Same idea for prime numbers. You'll write and call a function prime:

            bool prime( unsigned n ); // return whether n is a prime #

As you probably know, a prime number is a number greater than 1 that has no (positive) factors besides 1 and itself. The first 4 prime numbers are 2, 3, 5, 7.

Pseudocode for a decent way to test for primeness:

            //         is n a prime number?

            if n is less than 2, then no, it's not prime, we're done

            for fac = 2, 3, 4, 5, 6, 7, ... indefinitely{

                        if fac < n/fac, then yes, n is prime, we're done

                        if n is divisible by fac, then no, n is not prime, we're done

            }

(If you know another correct way to check for primeness, feel free to use it instead.)

For example, if main says

            outputD( 11, 30 )

then outputD will call prime a total of 20 times, and end up outputting 6 #:

            11 13 17 19 23 29

E.         void outputE( unsigned lo, unsigned howMany );

This function also relies on the prime function mentioned above, but outputD's job is to start at lo and to find and output howMany prime numbers.

For example, if main says

            outputE( 30, 5 );

then outputE will output

            31 37 41 43 47

F.         void outputF( unsignedhi );

outputF's job is to output each square number up to hi.

For instance, if main says

            outputF( 83 );

then outputF will output

            0 1 4 9 16 25 36 49 64 81