Scheme Skill-builder 1 – The Means to Correct

Table of Contents

Taking a break from the Simply Scheme book to work on some exercises of my own in order to develop some skills.

Composability of If

Exercise 1

I made up this exercise myself to work on internalizing the idea of the if procedure being composable that is discussed in chapter 6 of Simply Scheme. The program figures out whether it is election day based on user input

(define (election-day month day year)
  (se 'It
      (if (and (= 11 month)(= 3 day)(= 2020 year))
              '(is Election Day)
              '(is not Election Day))))

(define (election-day month day year)

(se 'It

(if (and (= 11 month)(= 3 day)(= 2020 year))

'(is Election Day)

'(is not Election Day))))

Test cases:

(election-day 11 3 2020)
It is Election Day

(election-day 11 4 2020)
It is not Election Day

(election-day 11 3 2020)

It is Election Day

(election-day 11 4 2020)

It is not Election Day

Exercise 2

(define (bank-account-status amount)
 (se '(Your account)
     (if (< amount 0)
         (se '(is overdrawn by) (word amount) 'dollars)
         (se 'balance 'is (word "$" amount) 'dollars))))


(bank-account-status -50)
;'(Your account is overdrawn by -50 dollars)

(bank-account-status 200)
;'(Your account balance is $200 dollars)

(define (bank-account-status amount)

(se '(Your account)

(if (< amount 0)

(se '(is overdrawn by) (word amount) 'dollars)

(se 'balance 'is (word "$" amount) 'dollars))))

(bank-account-status -50)

;'(Your account is overdrawn by -50 dollars)

(bank-account-status 200)

;'(Your account balance is $200 dollars)

Ran into an issue with this one. I initially didn’t use (se for the parts inside the if. I was thinking that I should just be able to pass multiple arguments to the se for the overall program – the one next to '(Your account). se does indeed take multiple arguments, but if does not, so if you want to use if like I do you have to group the things together. And you can’t just call procedures from inside a sentence – you can’t do e.g.

'(is overdrawn by (word '$ 500) 'dollars)

1 2	'(is overdrawn by (word '$ 500) 'dollars)

If I just enter that in Scheme, I get back '(is overdrawn by (word '$ 500) 'dollars). Scheme thinks the stuff inside the attempted invocation of word is just part of the sentence. So for what I want to do above, I need something that will let me call stuff like word and combine that with other stuff, grouping that into a single argument which the if can return and which the first se can take as an argument. And for my purposes se is what does that.

Nested Ifs

Exercise 1

I made a program to test my understanding of how to use nested if procedures.

Context: For U.S. Presidential elections, if no one wins a majority of electoral votes, then the incoming (newly-elected) House of Representatives selects the President, and each state House delegation from the states gets 1 vote. So the party that controls a majority of state House delegations in the incoming House of Representatives will pick the President.

There are 538 Electoral Votes up for grabs. I assume that it’s a two-man race and no votes will go to anyone else.

The program attempts to represent the following state of affairs:
– If Trump gets less than 50% of electoral votes (less than 269), that’s an outright loss. So he just loses, the end.
– If Trump gets exactly 50% of electoral votes (exactly 269), then he wins if the GOP controls a majority of the state delegations in the House. Trump loses if they do not control a majority of state House delegations.
– If Trump gets more than 50% of electoral votes (270 or higher) then he just wins.

The way I actually represented this in the program was as follows:

If Trump gets less than 269 electoral votes, he loses. Alternatively, we go to if #2.

Within if #2, if Trump has exactly 269 electoral votes, then we go to the next if statement. Otherwise, Trump wins (sine we covered \< 269 and = 269, > 269 is the only possibility left, and Trump wins in that case).

Within if #3 (where, again, Trump has exactly 269 electoral votes), if house-state-delegation-control does NOT equal gop, Trump loses. Otherwise, he wins.

<br /><br />(define (election-result trump-evs house-state-delegation-control)
  (if (< trump-evs 269)
      '(Trump loses)
      (if (= trump-evs 269)
          (if (not (equal? house-state-delegation-control 'gop))
              '(Trump loses)
              '(Trump wins!))
          '(Trump wins!))))



; test cases:

(election-result 268 'gop)
;'(Trump loses)

(election-result 269 'gop)
;'(Trump wins!)

(election-result 269 'dem)
;'(Trump loses)

(election-result 270 'dem)
;'(Trump wins!)

(election-result 270 'gop)
;'(Trump wins!)

<br /><br />(define (election-result trump-evs house-state-delegation-control)

(if (< trump-evs 269)

'(Trump loses)

(if (= trump-evs 269)

(if (not (equal? house-state-delegation-control 'gop))

'(Trump loses)

'(Trump wins!))

'(Trump wins!))))

; test cases:

(election-result 268 'gop)

;'(Trump loses)

(election-result 269 'gop)

;'(Trump wins!)

(election-result 269 'dem)

;'(Trump loses)

(election-result 270 'dem)

;'(Trump wins!)

(election-result 270 'gop)

;'(Trump wins!)

I made a tree of the logic of this program. I found the tree extremely helpful.

Analysis of buntine’s Valid Date Range Checker

I liked how a github user called buntine solved one of the Scheme problems (regarding a valid date range checker). His solution is here and pasted below. I wanted to understand the program better, so i decided to try describing it in words.

(define (divisible? x y)
  (= (remainder x y) 0))

(define (valid-range? n bound)
  (and (number? n) (> n 0) (> (+ 1 bound) n)))

(define (days-in-month m d y)
  (cond
    ((= m 1) 31)
    ((= m 2)
      (if (divisible? y 4)
        (if (divisible? y 100)
          (if (divisible? y 400)
            29 28)
          29)
        28))
    ((= m 3) 31)
    ((= m 4) 30)
    ((= m 5) 31)
    ((= m 6) 30)
    ((= m 7) 31)
    ((= m 8) 31)
    ((= m 9) 31)
    ((= m 10) 30)
    ((= m 11) 30)
    ((= m 12) 31)
    (else 0)))

(define (valid-date? m d y)
  (and (valid-range? m 12)
       (valid-range? d (days-in-month m d y))
       (number? y)))

(define (divisible? x y)

(= (remainder x y) 0))

(define (valid-range? n bound)

(and (number? n) (> n 0) (> (+ 1 bound) n)))

(define (days-in-month m d y)

(cond

((= m 1) 31)

((= m 2)

(if (divisible? y 4)

(if (divisible? y 100)

(if (divisible? y 400)

29 28)

29)

28))

((= m 3) 31)

((= m 4) 30)

((= m 5) 31)

((= m 6) 30)

((= m 7) 31)

((= m 8) 31)

((= m 9) 31)

((= m 10) 30)

((= m 11) 30)

((= m 12) 31)

(else 0)))

(define (valid-date? m d y)

(and (valid-range? m 12)

(valid-range? d (days-in-month m d y))

(number? y)))

February Logic

I made a tree of the logic of the part of the program that handles February in order to help me understand it. I found it extremely helpful for this purpose.

The Program Generally

Commenting on the program as I go along, skipping divisible:

(define (valid-range? n bound)
  (and (number? n) (> n 0) (> (+ 1 bound) n)))

(define (valid-range? n bound)

(and (number? n) (> n 0) (> (+ 1 bound) n)))

This predicate helper function offers a general solution to the problem of wanting to find whether a number is in a valid range. It checks if an argument is i) a number, and ii) greater than 0, and iii) less than a bound which is defined by the second argument passed into the program. If all these conditions are met, it returns #t. Otherwise, it returns #f.

days-in-month is a helper procedure that returns the number of days in a month depending on the month and year provided. The February logic is addressed in my tree above. If the value of the month is anything other than 1 through 12, days-in-month returns 0.

Finally, the main program:

(define (valid-date? m d y)
  (and (valid-range? m 12)
       (valid-range? d (days-in-month m d y))
       (number? y)))

(define (valid-date? m d y)

(and (valid-range? m 12)

(valid-range? d (days-in-month m d y))

(number? y)))

this program makes two calls to the valid-range? procedure. the first checks that the number of months is 1 through 12 (the 12 gets used as the bound). the second call to valid-range? is more interesting. the days-in-month procedure is used to generate the bound for checking the validity of the value for days d. Finally, the year is checked to ensure it is a number. If all these checks are passed, the entire procedure returns #t.

Composability of If

Exercise 1

Exercise 2

Nested Ifs

Exercise 1

Analysis of buntine’s Valid Date Range Checker

February Logic

The Program Generally

Leave a Reply Cancel reply