Recursion

My latest programming effort involves a card guessing game. I was
motivated by my favorite cartoonist Bill Amend's latest strip (FoxTrot).

The language I use most frequently (TinyC) does not support what is called
"floating point" arithmetic. It supports "integer" arithmetic. I wanted
to add a feature to un-psychic.tc that would show the average number of guesses
it took to discover the "secret card" in the game. If it took 6 guesses
in game #1 and 7 guesses in game #2 the average would be 6.5. This is a
"floating point" number. A function I wrote called dpf (display proper
fraction) was used to get around the integer arithmetic limitation of
TinyC.

Computer programs use what are called functions. Functions usually need
to be fed what are called arguments. Functions are often housed in
libraries (like books). Functions have names. For example the function
dpf takes 3 arguments: numerator, denominator, precision.

dpf 3, 7, 4

would cause the decimal number

.4285

to display on a terminal

because .4285 is the 4 decimal digit precision value of the fraction 3/7.

If you play the card guessing game 7 times and it takes you a total of
38 guesses to identify the secret card your average number of guesses
per game would be 38/7 which is 5.4285 (to 4 decimal digits precision).
The whole number part of 38/7 is 5. The fractional part is 3/7.

Here's the code for dpf

// display proper fraction
dpf int n, d, p [
	if p > 0 [
		pn 10 * n / d
		dpf 10 * n % d, d, p - 1
		]
	]

Notice how the definition of this function uses itself (thus it is recursive).

If you manually try to figure out what 3/7 is by dividing 7 into 3
(remember long division?) you see that it involves multiplying the
numerator by 10, putting the whole number part of the quotient up top
and then repeating the process with the remainder part of the quotient.


     .4285
   ________
7 | 3.0000
   -2 8
    ---
      20
     -14
      ---
       60
      -56
      ---
       40
      -35
       ---
       etc.


The / operation gives you the whole number part of a division. The %
operation gives you the remainder part of a division.

Each "call" or "use" of the function tests the precision to see if it's
still positive (if p>0) and if so, does its thing with new arguments (p
is reduced by 1 each time so it'll eventually not be positive).



Here is another example of recursion:

minarr.tc

The above translated to C and QB64: 

minarr.c
minarr.bas