Chapter Seven
Random Numbers
KeyWords: RND, RANDOMIZE, TIMER

Here are three programs that will solve the problems at the end of chapter six. Keep in mind that your label and variable names will be different, and some of you more ingenious people may have found a more efficient method of doing them. The programs listed here work, but they use the simplest logic available, except for the Prime Number program, which has one little improvement. The reversal programs can be written with fewer variables. To test your programs, just run them and make sure they give you the correct answers. Here is the program that reverses a three-digit number:

GETNUM:

PRINT "Input a Three-Digit Number";

INPUT NUM

IF NUM - INT(NUM) <> 0 THEN GOTO GETNUM

IF NUM < 100 THEN GOTO GETNUM

IF NUM > 999 THEN GOTO GETNUM

LET QUOTIENT = NUM / 100

LET DIG3 = FIX(QUOTIENT)

LET NUM = NUM - 100 * DIG3

LET QUOTIENT = NUM / 10

LET DIG2 = FIX(QUOTIENT)

LET NUM = NUM - 10 * DIG2

PRINT NUM; DIG2; DIG3

PRINT DIG3 + 10 * DIG2 + 100 * NUM

END

Notice that we used a method that allows us to print out the answer in both methods suggested in the problem for the leading zero case. To turn it into a 4-digit program, we simply expand on the 3-digit algorithm (set of instructions) to handle one more digit, and adjust the input checking accordingly. Here is our program:

GETNUM:

PRINT "Input a Four-Digit Number";

INPUT NUM

IF NUM - INT(NUM) <> 0 THEN GOTO GETNUM

IF NUM < 1000 THEN GOTO GETNUM

IF NUM > 9999 THEN GOTO GETNUM

LET QUOTIENT = NUM / 1000

LET DIG4 = FIX(QUOTIENT)

LET NUM = NUM - 1000 * DIG4

LET QUOTIENT = NUM / 100

LET DIG3 = FIX(QUOTIENT)

LET NUM = NUM - 100 * DIG3

LET QUOTIENT = NUM / 10

LET DIG2 = FIX(QUOTIENT)

LET NUM = NUM - 10 * DIG2

PRINT NUM; DIG2; DIG3; DIG4

PRINT DIG4 + 10 * DIG3 + 100 * DIG2 + 1000 * NUM

END

Notice how the two programs are very similar? You may trace through the program listings yourself to discover the logic that we used. Chances are it is very close to the way you did it, although it is possible to do it backwards. Not easy, but possible. Instead of working with the quotient, you work with the remainder when you divide.

Let's move on to the Prime Number program. To find out if a number is prime, all we have to do is divide it by every integer between 2 and (itself-1). If we get an integer as an answer (no remainder), we have found a factor, and the number is not prime. However, to speed up the program a little bit, you will notice that factors always come in pairs, and the largest factor can never be more than half of the number. So to double the speed of the program, you only have to divide the number by every integer from 2 to 1/2 of the number. Here is the program (Notice how we test that the number is an integer in lines 5 and 10):

GETNUM:

PRINT "Enter an Integer between 2 and 20,000 and"

PRINT "I will tell you if it is a Prime Number"

INPUT NUM

IF NUM - INT(NUM) <> 0 THEN GOTO GETNUM

IF NUM < 2 THEN GOTO GETNUM

IF NUM > 20000 THEN GOTO GETNUM

PRIME = 0

FOR TRY = 2 TO NUM / 2

    IF NUM / TRY <> INT(NUM / TRY) THEN GOTO TRYMORE

    PRINT "Factor Found:"; TRY

    PRIME = 1

TRYMORE:

NEXT TRY

IF PRIME = 1 THEN GOTO NOTPRIME

PRINT "Number is Prime!"

GOTO DONE

NOTPRIME:

PRINT "Sorry, Number is not prime."

DONE:

END

There is one "trick" in this program, and you may have noticed it in the variable PRIME. This is what is called a FLAG variable. At the beginning of the program, this flag is set to zero, which in our case means we have not yet found a factor. We then divide the number by the first integer (2). If it does not turn out to be a factor, it jumps down to the NEXT command, and tries the next integer. On the other hand, if 2 is a factor, then the variable PRIME is assigned the value of 1, indicating we have found a factor, so we run it up the flag pole and see if anyone salutes. Got it? When the FOR...NEXT loop has finished, we drop down to line 15. If the entire loop has gone without finding a factor, then lines 11 and 12 would never have been executed, and PRIME would still be zero. We then drop down to line 16 and print out that the number is prime. If PRIME is 1, then line 15 is true, and the program branches to line 18, stating to the user that the number isn't prime. Notice also that line 11 prints out the factors as it finds them.

Let's get into some new material. We'll start out with the easier of the two ideas, random numbers. Random numbers are just that. You don't know what the next one will be. The function to generate a random number is RND. Type in this cute little program:

FOR X = 1 TO 5

    PRINT RND

NEXT X

END

Now go ahead and run the program. RND always returns a number between (but not including) zero and one. Also, you may be interested to know that these are not really random numbers. Run the program three or four more times. Notice anything? Yes! You get the same sequence of numbers every time!! We'll show you how to get around that later. RND can also be used with an argument, like such: RND(x). Different values of x will produce different results. If x is positive, you will get the next number in the sequence. If x is negative, you will start the sequence all over again. If x is zero, RND repeats the last number generated.

How do we get a different number each time we run our program? QBASIC has included a function that allows us to seed or initialize the random number generator. It is the RANDOMIZE function. Add this line to the top of our program:

RANDOMIZE

That's all there is to it. Now run the program. When the computer sees the RANDOMIZE function, it prints out a prompt:

Random number seed (-32768 to 32767)?_

and waits for you to enter an integer within the specified range. That allows you 65,536 different random sequences, which should be more than enough. Notice, however, that when you enter the same seed number, you get the same sequence of random numbers. Also, we probably don't want our user to have to come up with a number off the top of their head. How do we get around that? RANDOMIZE will also allow us to use an argument. QBASIC also has a function that returns a different number all the time, and only returns the same number once per day. It is the TIMER function, and all it does is tell you how many seconds it has been since midnight. It operates off of the DOS clock, so if you set the date and time correctly, the count will be pretty accurate. Let's see how many seconds have passed since midnight. Type in (in the immediate window)

PRINT TIMER 

and press Enter. If it is in the morning, you will get a pretty small number. In the afternoon, you will get a good sized number, and late at night, you will get an absolutely huge number. Incidently, there are 86,400 seconds in a day. The only problem is, our random number seed can only be up to about 33,000. How do we fix that? Easy enough. Just divide TIMER by three, and the largest you will get is 28,800. That is easily within range, and you will get a new seed every time. Once the random number is seeded in a program, there is no need to keep on reseeding it. Let's fix up our top line to read:

RANDOMIZE TIMER/3

RANDOMIZE TIMER / 3

FOR COUNT = 1 TO 20

    LET NUM = RND

    LET NUM = INT(20 * NUM) + 1

    PRINT NUM

NEXT COUNT

END

READ A,B,C,D,E,F,G,H,I,J

LET X = (A+B+C+D+E+F+G+H+I+J)/2

PRINT X

DATA ...

END

READ A,B,C,D,E,F,G,H,I,J

LET X = (A+B+C+D+E+F+G+H+I+J) / 10

PRINT A,A-X

PRINT B,B-X

PRINT C,C-X

PRINT D,D-X

PRINT E,E-X

PRINT F,F-X

PRINT G,G-X

PRINT H,H-X

PRINT I,I-X

PRINT J,J-X

DATA ...

END