Let's make arrays work for you
By PETER DAVIDSON
AN array is a way of storing several connected variables, whether
numeric or string. It is much easier to access an array element
(that is one variable within the array) than it is to access'
one variable out of several ordinary variables that have not been
connected in the form of an array.
To illustrate this, let us first consider a badly written program
(Program I) which is intended to print out a telephone number
when a person's name is typed into the computer:-
10 INPUT requiredname$
20 IF reguiredname$ = "FRED" THEN PRINT 545 27364 :GOTO
10
30 IF requiredname$ = "JANE" THEN PRINT 485 4849 :GOTO
10
40 IF reguiredname$ = "JIM" THEN PRINT 475 9398 :GOTO
10
50 IF requiredname$ = "JACK" THEN PRINT 455 9989 :GOTO
10
60 PRINT "NOT THERE" : GOTO 10
Program I
Although it works, it has several faults which we will now try
to improve.
• Line 10 will generate a question mark on the screen, with
no explanation as to what it is for.
• Lines 20 to 40 are very similar. It should be possible to
find a way to achieve the same result without the repetition (imagine
a program written like this containing 1,000 names!).
• Telephone numbers contain spaces. These cause problems in
the printout
when they are printed as shown in this program.
• There is no way to stop the program (except using ESCAPE or
BREAK).
• It is very difficult to add new names to the directory.
It must be realised that the use of a computer as a telephone
directory is not of practical use - it is quicker to use the book.
But it is an easy application to understand and illustrates the
use of arrays quite clearly.
Below is a flowchart showing some of the requirements of a better
directory program.
Rather than use several separate variables, this time we shall
use a one dimensional array. This means that we
use a single variable name followed by a subscript (which is
just a number in brackets).
For example, instead of using first-name$, secondname$, and
thirdname$ as variable names we can use name$(l), name$(2), and
name$(3). The advantage of this method is that all three can be
referred to as name$(N) and the required one accessed by setting
the variable N to the correct value.
Obviously it is much easier to go beyond three variables using
this method than by using a completely new name each time.
Let us start by looking at a procedure for setting up two one-dimensional
arrays, one of names and one of numbers as in Program II.
500 DEF PROCinput
510 count=0
520 REPEAT
530 count=count+1
540 READ name$(count).number$(count)
550 UNTIL name$(count)="EOF"
560 total=count-1
570 ENDPROC
Program II
The procedure uses a READ statement, so we will also require
DATA statements as in Program III.
1000 DATA FRED,545 27364,JANE,485 4849,JIM,475 9398,JACK,455
9969
5000 DATA EOF,EOF
Program III
It is possible to have as many DATA statements as required anywhere
in the program. In the above example they start at line 1000 and
the end of file is at line 5000. This means that more DATA statements
can be inserted if required using line numbers between these.
Two EOF markers are used as the program reads two items of data
each time it executes line 540.
Before running a program which contains an array it is necessary
to reserve memory for the array. This is done with a DIMension
statement. A program containing the above procedure would require
a statement such as:-
10 DIM name$(25),number$(25)
This reserves 26 memory locations for names - name$(0) to name$(25)
-and 26 locations for numbers. The procedure shown will not use
location 0 but swopping lines 530 and 540 could cure this. The
same effect can also be achieved if a variable is used in the
DIMension statement, such as:
5 N=25
10 DIM name$(N),number$(N)
The above procedure and DATA statements will set up the two
required arrays in the memory and also a variable (total) storing
how many names and numbers are in the arrays. The arrays can be
pictured as in Figure I.
|
name$(l)
|
FRED
|
number$(l)
|
545 27364
|
|
name$(2)
|
JANE
|
number$(2)
|
485 4849
|
|
name$(3)
|
JIM
|
number$(3)
|
475 9398
|
|
name$(4)
|
JACK
|
number$(4)
|
455 9989
|
|
name$(5)
|
EOF
|
number$(5)
|
EOF
|
Figure I
If we search through the array of names and find the required
one, the corresponding telephone number will have the same subscript
and can be accessed directly.
It should be noticed that a string array has been used to store
the numbers. This means that they will be printed as stored with
no corruption caused by the spaces as would be the case if a numeric
array was used.
Now look at a procedure to search through the array of names.
If the required one is found the corresponding number is output
(Program IV).
700 DEF PROCsearch
710 count=0
720 REPEAT
730 count=count+l
740 IF requiredname$ = name$(count) THEN FOUND=TRUE ELSE FOUND=FALSE
750 UNTIL FOUND OR count=total
760 IF FOUND THEN PRINT requiredname$"'s phone numder is
"number$(count) ELSE PRINT requiredname$" is not in
the list"
770 ENOPROC
Program IV
The two procedures (lines 500-570 and 700-770) together with
DATA statements (lines 1000-5000) can now be put together and
with a few extra lines (10-60, Program V) we have a far better
telephone directory program.
Several improvements can still be made to this program, one
simple one being a tidy up of the output. This is left as an exercise
for the reader (use CLS and TAB).
10 DIM name$(l00).number$(100)
20 PROCinput
30 REPEAT
40 INPUT "Whose number is required" ,requiredname$
50 PROCsearch
60 UNTIL requiredname$="STOP'
Program V
Of the five faults found in the first program, the latter program
corrects the first four and improves the last. The names are still
contained in the program, but are now in DATA statements and so
are quite easy to change. The cure for this is to store the data
on tape or disc.
The arrays we have looked at so far are one dimensional, but
it is possible to use more than one dimension.
In the above program we could replace the two one dimensional
arrays (nameS(X) and number$(X) by one two dimensional array,
which we could call info$(X,Y) where X will be the number of names
and phone numbers and Y will be a 1 or 2 (1 corresponding to a
name and 2 corresponding to a number).
The "picture" that you can use of a two-dimensional
array is shown in Figure II.
|
info$(l,l)
|
info$(l,2)
|
|
FRED
|
545 27364
|
|
info$(2,l)
|
info$(2,2)
|
|
JANE
|
485 4849
|
|
info$(3,l)
|
infoS(3,2)
|
|
JIM
|
475 9398
|
|
info$(4,l)
|
info$(4,2)
|
|
JACK
|
455 9989
|
|
info$(5,l)
|
info$(5,2)
|
|
EOF
|
EOF
|
Figure II
To use a two dimensional array in your program the following
changes are required (Program VI).
10 DIM info$(100,2)
540 FOR N=lT0 2 :READ info$(count,N) :NEXT
550 UNTIL info$(count,l)="EOF"
740 IF requiredname$ = info$(count ,1) THEN FOUND=TRUE ELSE FOUND=FALSE
760 IF FOUND THEN PRINT requiredname$"'s phone number is
"info$(count,2) ELSE PRINT requiredname$" is not in
the list"
Program VI
There are advantages to both methods. The two one dimensional
array method has the advantage that name$(20) obviously refers
to the twentieth name and number$(20) to the twentieth number.
This is much clearer than info$(20,l) and info$(20,2).
On the other hand a two dimensional array uses less memory,
and if more items are stored - for example, address, date of birth,
occupation - all that is required is to change the limits of the
FOR . . . NEXT loop in line 540 and use a loop in line 760.
All the relevant information about a person whose name is typed
in would then be printed out. But note that the DATA will also
need corresponding changes.
Finally we present a program which prints out sentences, missing
out a word (or group of words). Although the present data is nursery
rhymes, other data can easily be substituted. The program uses
three one dimensional arrays:
START$(NUMBER)
MISS$(NUMBER)
FIN$(NUMBER)
A random number is chosen and the corresponding elements of
the first and last array are printed out, together with stars
corresponding to each letter of the middle one.
If a word is typed in correctly, a congratulation message is
chosen at random from the three messages in the one dimensional
array CONGRAT$(NUMBER).
If an error is made the message is taken from the two dimensional
array ERRMSG$(NUMBER1,NUMBER2), where NUMBER1 corresponds to the
number of attempts at the question and NUMBER2 is chosen at random
so that one of three different messages is printed out at random,
making nine different messages possible.
To modify this program the following line numbers are easily
changed:
780 ... the number of sentences in the data.
800 ... the title.
1000 onwards ... the sentences. These are entered in three parts
with commas around the word(s) that you want missing out.
Note that if your sentence contains commas, quotes must be put
around that part of the sentence.
820 to 960 ... the messages. REM statements show which are error
and which are congratulations.
