## Class 27 — Monday October 26

#### Tasty problem solving

The Magnificent – Seven problems for practice – Let's do them today

### Agenda

• Being functional
• Mindful collaboration
• Appreciation for buddying
• Better able to convert problem specifications into working functions

### Requirements

• The buddy system is strongly encouraged for this effort.
• None of the functions you develop should get input or print output.
• Examine and think about algorithms for the problems. However, do not write any code before class.
• My module file module `magnificent.py` must be used.

### Module `magnificent.py`

• Implements seven functions most of which are related to tasks performed this semester.
• Tester program seven.py is unavailable to the start of class.

### Function `future_me( a, y )`

• Returns how a person whose `a` years-old will be in the year `y`. You can assume the current year is 2020.
• Partial output from a sample run of `seven.py`

a 15 year-old will be 81 in 2086

a 19 year-old will be 98 in 2099

• Possible algorithm
• Compute difference between 2020 and `y`.
• The future age is sum of `a` and the difference.

### Function `manhattan_distance( a1, s1, a2, s2 )`

• Returns the approximate distance in miles between a person at the corner avenue `a1` and street `s1` in Manhattan and a person at the corner of avenue `a2` and street `s2` in Manhattan.
• NYC distance rules:
• Distance of a Manhattan city block running from one street to the next is on average 1/20th of a mile.
• Distance of a Manhattan city block running from one avenue to the next is on average 3/20th of a mile.
• Partial output from a sample run of `seven.py`

Corners ( 6 , 59 ) and ( 7 , 34 ) are 1.4 miles apart

Corners ( 2 , 47 ) and ( 6 , 238 ) are 10.15 miles apart

• Possible algoithm
• Compute absolute value of the street differences
• Compute absolute value of the avenue differences
• The distance between the two locations is the street difference divided by 1/20 plus the avenue difference divided by 3/20.

### Function `relate( x, y )`

• Returns `'comes before'`, `'is equal to'`, or `'comes after'`, depending whether the relationships between strings `x` and `y` are respectively:
• `x` alphabetically comes before `y`,
• `x` is equal to `y`, or
• `x` alphabetically comes after `y`.
• Partial output from a sample run of `seven.py`

kiwi is equal to kiwi

apple comes before banana

orange comes after melon

• Possible algorithm
• Determine which of `x` comes before (<) `y`, `x` equals `y`, or `x` comes after (>) `y` applies.
• Return respectively `'comes before'`, `'is equal to'`, or `'comes after'` depending upon the possible relationships

### Function `youngest( y )`

• Returns the youngest acceptable age for a `y` year-old to date according to the dating folk rule you should only date someone who is at least seven years older than than half your age.
• Partial output from a sample run of `seven.py`

a 19 year-old can date a 16 year-old

a 22 year-old can date a 18 year-old

• Possible algorithm
• Compute and return y divided by 2 plus 7 using integer arithmetic

### Function `is_dateable( y1, y2 )`

• Returns `True` or `False` whether a `y2` year-old is an acceptably-aged date for a `y1`year-old.
• Your implementation should make use of function `youngest()`.
• Partial output from a sample run of `seven.py`

a 15 year-old can date a 22 year-old is True

a 22 year-old can date a 15 year-old is False

a 19 year-old can date a 18 year-old is True

• Possible algorithm
• Determine minimum dateable age for `y1`
• Return whether or not `y2` is at at least that minimum dateable age of `y1`

### Function `mutually_dateable( y1, y2 )`

• Returns `True` or `False` whether both a `y2` year-old is an acceptably-aged date for a `y1` year-old, and a `y1` year-old is an acceptably-aged date for a `y2` year-old
• Your implementation should make use of function `is_dateable()`.
• Partial output from a sample run of `seven.py`

a 25 year-old can date a 65 year-old and vice-versa is False

a 20 year-old can date a 18 year-old and vice-versa is True

• Possible algorithm
• Determine whether or not `y1` is dateable for `y2`
• Determine whether or not `y2` is dateable for `y1`
• Return whether or not both dateable conditions are true

### Function `middle( s )`

• If the length of `s` is odd, the function returns the middle character of `s`; otherwise, the function returns the two middle characters of `s`.
• Partial output from a sample run of `seven.py`

Middle character of abcde is c

Middle character of abcdef is cd

Middle character of abcd is bc

• Questions
• How does the remainder operator `%` help you check whether a number is odd?
• Suppose `n` is the length of `s` and `m` is is `n` `//` `2`.
• If `n` is odd, what is the middle index of `s`?
• If `n` is even, what are the middle indices of `s`?
• Possible algorithm
• Determine the length of `s`
• Use your answer to first question above to test whether the length of `s` is odd.
• Use your answer to the second question above to determone the result.
• Return the result.

 © 2020 Jim Cohoon Resources from previous semesters are available.