TEACH POPCOURSE7 - List processing using iteration

Contents

• Iteration using `for'
• Using `if' commands with `else' and `elseif'
• Iteration using `while'
• Exercises
• Quick reference
• Moving on

Iteration using `for'

A simple application of a `for' command is as follows.

vars n;
for n from 1 to 10 do
   n ==>
endfor;

** 1
** 2
** 3
** 4
** 5
** 6
** 7
** 8
** 9
** 10

In this example, there is only command between the `do' and `endfor' and this just prints the value of n. Hence we get all the numbers between 1 and 10 printed out on successive lines. Of course, we do not have to use `n'. We can use any variable we like. And we can also use any range of integers we like. Thus

vars bang;
for bang from 4 to 7 do
   bang ==>
endfor;
** 4
** 5
** 6
** 7

We can have one `for' command inside another. In fact we can put any combination of commands inside the loop. The following code for example uses two `for' loops---one inside the other---to print out lists containing all pairs of whole numbers between 1 and 3 that sum to more than 2.

for n from 1 to 3 do
   for m from 1 to 3 do
      if n + m > 2 then
         [^n ^m] ==>
      endif;
   endfor;
endfor;

The `for' command is particularly useful when used in conjunction with a list. If we want to do something to every element of a list, all we need is a `for' command whose loop variable steps through all the positions in the list. For example, imagine we set up a list as follows.

vars message;
[beam me up scottie] -> message;

for position from 1 to 4 do
   message(position) ==>
endfor;

** beam
** me
** up
** scottie

Experiment: construct a `for' command that prints out the `square' of every value in the list [3 46 87 32 0 2], where the square of a value is just the value multiplied by itself.

We can also use a `for' command to add up a list of numbers. To do this we first set up a variable (initialized to 0) that will serve as a place to store a `running total'. We then use a `for' command with a `position' variable to iterate over the list, adding in each element to our running total.

vars numbers, total;
0 -> total;
[345 1235 76 21 3] -> numbers;

for position from 1 to 5 do
   total + numbers(position) -> total;
endfor;

total ==>
**  1680

Using `if' commands with `else' and `elseif'

if 4 < 3 then
   1 ==>
elseif 5 = 6 then
   2 ==>
elseif 2 > 1 and 3 > 2 then
   3 ==>
else
   0 ==>
endif;

** 3

(For practice, write POP-11 code to assign the value of the expression `23 * 78 / 4 + 6' to a variable called `num'. Then write an `if' command that prints out 1, if the value of `num' is greater than 1000 or less than 100, or 2 if the value is greater than 750 or less than 250, or 3 otherwise. Mark all the code and load it. The value printed out should be 3.)

Iteration using `while'

vars n;
9999 -> n;

while n > 1 do
   n / 2 -> n;
   n ==>
endwhile;

** 4999.5
** 2499.75
** 1249.88
** 624.938
** 312.469
** 156.234
** 78.1172
** 39.0586
** 19.5293
** 9.76465
** 4.88232
** 2.44116
** 1.22058
** 0.610291

Experiment: write a `while' command that keeps doubling and printing out the value of `n' (initialized to 1) until its value is greater than 100.

Tip of the day

Exercises

1. Write a `for' command that uses square-brackets, hats, double-hats etc. to reconstruct in reverse order a list of four elements stored in the variable `words'. (Hint: you may find it helpful to have another variable `revwords' (initialized to the empty list) in which to build up the reversed list.)

2. Write a procedure called `spread' which takes a list and produces a copy of the list in which every element of the original list is followed by a 1. It should behave like this

   spread([foo bang ding dong]) ==>
   ** [foo 1 bang 1 ding 1 dong 1]
   

3. Write a procedure called `merge' that takes two lists of the same length and interleaves them. When called like this

   merge([a b c d], [1 2 3 4]) ==>
   

   the value printed should be

   ** [a 1 b 2 c 3 d 4]
   

4. Write a procedure, called `allbefore' that takes a list and a word and then constructs and returns a list of all the elements that precede the given word. When called like this

   allbefore([the man opened the door], "opened") ==>
   

   POP-11 should print

   ** [the man]
   

5. Write a procedure called `all_pairs' that produces a list of sublists such that each sublist contains a possible pairing from the two lists provided as argument. The value printed by

   all_pairs([1 2 3], [a b d]) ==>
   

   should be

   ** [[1 a] [1 b] [1 d] [2 a] [2 b] [2 d] [3 a] [3 b] [3 d]]
   

   Hint: try using two `for' commands, one nested inside the other.

   1. Write a procedure called `prune' which takes a list as argument and produces a list as its result. The new list should contain the same elements as the original one, but with all redundancies removed . Thus

      prune([A B 1 2 C 2 1 B A]) ==>

      should produce

      ** [A B 1 2 C].
      

   2. Use the built-in `member' procedure to write a procedure called `issubset' which takes two lists and returns <true> if every element of the first list is a member of the second, but <false> otherwise.

   3. Write a procedure called `larger' which takes two lists as arguments and produces the result <true> if the first has more distinct elements than the second, otherwise <false>, thus:

      larger([a a a],[b c])=> ** <false> larger([1 2 3],[a b a b])=> ** <true>

Quick reference

for    steps a variable through range, doing commands each time around
while  repeats some commands while an expression has value `<true>'

Moving on