CS 1102: Lab 3

Lab Motivation and Goals

• programming with trees
• developing and using iterators over data structures

Exercises

For these exercises, we will work with the following data definition for binary trees:

```   ;; A bintree[alpha] is either
;;  - false, or
;;  - (make-node alpha bintree bintree)

;; the data definition for node appears above in that for bintree
(define-struct node (item left right))
```
1. Write the template for programs over bintrees. You can check for false using boolean?

2. Write a program `sign-tree` that consumes a bintree[number] (i.e., a bintree where the items at each node are numbers) and returns a bintree[symbol] with the same structure as the input tree, but with each number replaced with one of the symbols 'positive, 'negative, or 'zero, as appropriate.

3. Write a program `flip-tree` that consumes a bintree[posn] and returns a bintree[posn]. The returned tree should have the same structure as the input tree, but each posn should have its x- and y-coordinates flipped [i.e., (make-posn 3 4) would become (make-posn 4 3)].

Recall that (define-struct posn (x y)) is built-in to DrScheme.

4. The programs `sign-tree` and `flip-tree` have a similar structure. Write a function `tree-map` that takes a bintree and a function and applies the function to each node in the tree. Show how to implement `sign-tree` and `flip-tree` using `tree-map`. Be sure to include a correct contract for `tree-map`.

Everybody should be able to finish up to this point

5. Write a program `tree-andmap` that consumes a function of type (alpha -> boolean) and a bintree[alpha] and returns a boolean indicating whether the given function returned true at every node. Can you implement `tree-andmap` using a simple call to `tree-map`? By "a simple call", I mean can you just fill in the ... in the code below to implement this function? If not, why not?

```(define (tree-andmap func abt)
(tree-map ...))
```

Note: to check whether a value is false, you can use

`(and (boolean? value) (not value))`

Using `tree-andmap`, implement `pos-tree?` that consumes a bintree[number] and determines whether all numbers in the tree are positive.

6. A tennis tournament consists of a series of elimination matches: after each match, the player who wins advances to the next round and the player who loses is out of the tournament. Assume the number of initial players is a power of two. One possible player match-up would look like:

```  player1 \
player2
player2 /        \
-- player 2
player3 \        /
player3
player4 /
```

For each match, we need to store the names of the two players and the match score. In tennis, a match score is given as a series of scores for units of play (sets, if you know tennis lingo). A sample score might look like:

```  player1 : 6 7 3 6
player2 : 4 6 6 2
```

Where each column (pair) of numbers is one set.

Develop a data model for individual matches.

7. Write a program `player-wins` that consumes a player's name and a tournment tree (a bintree[match]) and returns a number indicating how many matches that player won in the tournament. Assume that the tournament properly advances the winning player to the next round (i.e., you shouldn't have to check the numeric scores for this problem).

Many students should be able to finish up to this point

8. A score is valid under the following conditions:

• it contains at most 5 sets
• one player won exactly three sets
• the two numbers in a set are either 7 and 6, or 6 and some number less than 6.

Write a program `scores-valid?` that consumes a tournament and returns a boolean indicating whether all of the scores in the tree meet these restrictions.

9. (More difficult) Write a program `player-earnings` that consumes a tournament, an earnings function, and a player's name and returns a number indicating how much the player won in the tournament. The earnings function takes the number of a round and one of the symbols 'win or 'lose and returns a number indicating how much the winner/loser earned for that round.

An example earning function might give the winner \$10,000 in each of the first two rounds and \$25,000 in any subsequent rounds, with the loser getting half as much as the winner in each round.