Hints

• This exercise is concerned exclusively with the idea of recursive functions. It is essential that, before attempting it, you are sure you understand the concept of a function. So, before coming in for this session ensure that you have thoroughly studied Chapter 2 of Illustrating C, and the accompanying sections of the on-line notes.

• Before even bothering to test the HCF() function, make sure that you understand what it is trying to do (calculate the "highest common factor" of two numbers) and how it is trying to do it. Please include in your report a short explanation (two or three sentences), in your own words, of why Euclid's method of calculating the highest common factor works.

• Note carefully the introduction of a new operator in the HCF() function - the remainder operator, denoted in C with the symbol %. Thus, in dealing with integer arithmetic, we have essentially two different kinds of division operator: the quotient operator (denoted by /) and the remainder operator denoted by %. This distinction does not arise in floating point arithmetic, where only the quotient operator is required (why?).

• To test the function HCF() you must first provide a main() function in order to form a complete program (remember: every complete C program file must contain the definition of a function called main()). In this particular case, the main() function needs to do just whatever is required to allow you to decide whether the HCF() function is working correctly or not. Minimally this means that it must call the HCF() function with some particular arguments, and should then print out the result which is return'ed by HCF(). But, of course, to properly test HCF() you will need to test it with a range of different arguments. One option is to simply edit the main() function, and rebuild (compile and link) the program before running each test. This is simple and perfectly satisfactory. But if you have the time, and wish to be a little more adventurous, you might try to write a main() function which would prompt the user to type in test arguments, and then feed them into HCF(): this would allow a whole range of tests to be done simply by re-running the program (i.e. without having to rebuild each time).

• In the second part of the exercise you are required to develop a variant on a function you were originally supposed to have developed in the previous lab session. It is therefore vital that you actually complete that previous exercise before coming in for this lab session!

• You are required to use recursion to implement the repetition required in reverse_print_array(). The essential idea of recursion is that a function actually calls or invokes (a copy of) itself.

  The way that can be used in this particular exercise is as follows: suppose that a single call to reverse_print_array() just prints the last element of the array it is given (assuming the array is not of zero length), and then calls itself (i.e. another copy of reverse_print_array()) to print the rest of the array (i.e. passing on the same array it was given, except "minus" the last element). And if reverse_print_array() is called with a zero array length argument, it should simply return immediately - that allows the recursion to "unwind" with all the copies of the function then exiting in turn, until we finally get back to the main() function. Of course, the idea of passing on the array "minus" the last element can be achieved simply by passing on a array length argument which is one less that the argument which has been passed in - the array "itself" does not actually have to be modified.