## Homework Assignment 3

### Higher-Order Functions in Racket

#### Introduction

Template Source File
This assignment gives you your first chance to write and us higher-order functions in Racket. Download the file homework03.rkt and use it as a template for your submission. Please use the name homework03.rkt for your file!
Do Not Use...
To solve these problems, you do not need any Racket features beyond the things we have learned in class and the things discussed in this assignment.
• Do not use a let expression in any function.
• Do not use an internal define in any function.
• You may not use explicit recursion or looping for in any function. Your solutions to Problems 3, 4, and 5 should use higher-order functions such as map and apply to do their jobs.
You will find these Racket primitives useful on this assignment:
• string->number converts a string that contains a number into the equivalent number.

• exact->inexact converts an exact number (an integer or a fraction) into the equivalent floating-point number.

• You may pass a two-argument function to map. If you do, then you must pass two list arguments, not one. map will pass the corresponding items in each list to the function at the same time:
```    > (map + '(1 3) '(2 7))
'(3 10)
```

#### Problems

1. For Problem 4 of Homework 2, you wrote a candy-temperature function to implement a common conversion from The Joy of Cooking. However, programmers who makes candy in the same city most of the time are forced to send their city's elevation as an argument to the function every time. This is inconvenient.

Write a Racket function named candy-temperature-at that takes one number as an argument: elevation (in feet) of a given location. candy-temperature-at returns a function that takes one argument, a temperature (in degrees Fahrenheit) to use for a candy. The returned function returns as its value the temperature to use for that candy at the specified elevation. For example:
```     > ((candy-temperature-at 5280) 302)     ;; Denver
291.44

> (define temp-in-cf                    ;; Cedar Falls
(candy-temperature-at 959))

> (temp-in-cf 240)                      ;; Cedar Falls fudge!
238.082
```
I have provided check-= expressions for these examples. Write at least two more check-= expressions to test your solution.

2. For Problem 5 of Homework 2, you wrote a function named in-range? that tests to see if two values are within a specified tolerance. When we work in engineering settings with such tolerances, the *epsilon* value is often fixed for most of our tests. Passing *epsilon* to the function every time we call it is inconvenient, but making *epsilon* a global variable creates bigger problems.

Write a Racket function named in-range-of? that takes one number as an argument: the epsilon to use as a tolerance. in-range-of? returns as its value a function that takes two number arguments. The returned function returns true if the difference between its arguments is less than epsilon, and false otherwise. For example:
```     > ((in-range-of? 0.1) 4.95 5.0)
#t

> ((in-range-of? 0.1) 5.0 4.95)     ;; works both ways
#t

> (define within-0.01?
(in-range-of? 0.01))

> (within-0.01? 4.95 5.0)           ;; not anymore!
#f

> (within-0.01? 5.0 4.99)
#t
```
I have provided check-true and check-false expressions for these examples. You do not have to write any more tests for this problem.

3. Suppose that we have a list containing height/weight pairs for a group of people, in inches and pounds, respectively:
```     ( (76 . 195) (81 . 212) (79 . 225) (78 . 206) ... )
```
We would like to know the average height of the people in the group.

Use higher-order functions such as map and apply to define a Racket function named average-height. This function takes a list of height/weight pairs as its only argument and returns the the average height of the group. For example:
```     > (average-height '((79 . 225)))
79.0

> (average-height '((70 . 150) (62 . 100)))
66.0
```
Assume that we have already written a variable-arity function named average. It is defined in your template file. You may write other helper functions if you like, but you do not have to.

I have provided check-= expressions for these examples. Write at least two more check-= expressions to test your solution.

4. A buddy of mine wrote a program that predicts the results of college basketball games (pretty well, I might add). At the end of a week, he would like to know how far his program's predictions were from the actual results. His program has generated a list of predicted-difference/actual-difference pairs:
```     ( (2 -7) (-4 -20) (7 8) (-13 2) ... )
```
The first item in this list says that his program predicted Team 1 would win by 2 points, but it lost by 7 points (so, Team 2 won by 7). For that game, his program was off by abs(2 - (-7)) == abs(9) == 9 points. The third item says that his program predicted that Team 1 would win by 7 points and that it won by 8 points, so his program was off by abs(7 - 8) == abs(-1) == 1 point. The list can contain any number of these pairs.

Write a Racket function named total-error that takes one argument, a list of this form. The function returns the total of all the differences in the list. For example:
```     > (define example '((2 -7) (-4 -20) (7 8) (-13 2)))
> (total-error example)
41
```
I have provided a check-equal? expression for this example. Write at least three more check-equal? expressions to test your solution.

5. To monitor enrollments each semester, I have a spreadsheet that contains a list of courses with names, enrollments, and capacities. I read the spreadsheet data into a Racket list that looks like this:
```     '(("Dept" "Number" "Section" "Class Nbr" "Capacity" "Enrollment")
("CS" "1000" "1" "11546" "30" "30")
("CS" "1025" "1" "11547" "30" "30")
("CS" "1120" "1" "11557" "30" "15")
("CS" "1130" "1" "11548" "30" "18")
... )
```
The dean and provost frequently ask me for various summary data, such as total enrollments or remaining capacity.

Write a Racket function named max-open-seats that takes such as a list as its only argument. It returns the maximum number of open seats available in any section. For example:
```     > (define example '(...))     ; the data shown above
> (max-open-seats example)
15
```
CS 1120 has 30-15 = 15 open seats. The other classes have 0, 0, and 12 open seats each.

I have provided a check-equal? expression for this example. Write at least three more check-equal? expressions to test your solution.

#### Deliverables

By the due time and date, submit the following files electronically:

• homework03.rkt, the source file containing your function definitions and test cases
No hard copy is required.

Be sure that your submission follows all submission requirements.

Be sure to use the specified names for your file! This enables an autograder to find and run your code.

Eugene Wallingford ..... wallingf@cs.uni.edu ..... February 2, 2023