CSC 151.03, Class 30: Analyzing procedures

(define sum-of-file
  (lambda (file-name)
    (let ([source (open-input-file file-name)])
      (let kernel ([sum-so-far 0])
        (let ([nextval (read source)])
          (cond
            ; Are we at the end of the file?
            ; Then stop and return our running sum.
            [(eof-object? nextval) 
             (close-input-port source) 
             sum-so-far]
            ; Have we just read a number?
            ; If so, add it to the sum of the remaining numbers.
            [(number? nextval) 
             (kernel (+ nextval sum-so-far))]
            ; Hmmm ... not a number.  Skip it.
            [else 
             (kernel sum-so-far)]))))))

(define file-size
  (lambda (file-name)
    (let ([source (open-input-file file-name)])
      (let kernel ([sum-so-far 0])
        (let ([nextval (read-char source)])
          (cond
            ; Are we at the end of the file?
            ; Then stop and return our running sum.
            [(eof-object? nextval)
             (close-input-port source)
             sum-so-far]
            ; Have we just read a number?
            ; If so, add it to the sum of the remaining numbers.
            [(char? nextval)
             (kernel (+ 1 sum-so-far))]
            ; Hmmm ... not a number.  Skip it.
            [else
             (kernel sum-so-far)]))))))

(define file-size
  (lambda (file-name)
    (let ([source (open-input-file file-name)])
      (let kernel ([sum-so-far 0])
        (let ([nextval (read-char source)])
          (cond
            [(eof-object? nextval)
             (close-input-port source)
             sum-so-far]
            [else
             (kernel (+ 1 sum-so-far))]))))))

#lang racket
(require csc151)

;;; Procedure:
;;;   partition
;;; Parameters:
;;;   lst, a list
;;;   k, a positive integer
;;; Purpose:
;;;   Break lst up into k more-or-less-equal length list
;;; Produces:
;;;   lol, a list of lists
;;; Preconditions:
;;;   [No additional]
;;; Postconditons:
;;;   lol contains k lists.
;;;   (reduce append lol) = lst
(define partition0
  (lambda (lst k)
    ; What's the base case?
    (if (= k 1)
        (list lst)
        (cons (take lst (ceiling (/ (length lst) k)))
              (partition0 (drop lst (ceiling (/ (length lst) k)))
                          (- k 1))))))

(define partition2
  (lambda (lst k)
    ; What's the base case?
    (if (= k 1)
        (list lst)
        (let ([okay-size (ceiling (/ (length lst) k))])
          (cons (take lst okay-size)
                (partition2 (drop lst okay-size)
                            (- k 1)))))))

; Where should we put the `let`?  Generally, at the first point you need or can
; compute the value.  (A bit of a balancing act.)

; Improving the code
;   1. Add a husk.  (Not today.)
;   2. Avoid so many calls to length.  Keep track of the length
(define partition
  (lambda (lst k)
    (let kernel ([remaining lst]
                 [pieces k]
                 [len (length lst)])
      (if (= pieces 1)
          (list remaining)
          (let ([okay-size (ceiling (/ len pieces))])
            (cons (take remaining okay-size)
                  (kernel (drop remaining okay-size)
                          (- pieces 1)
                          (- len okay-size))))))))

; Learning outcomes?a
;   * Learn to satisfice.  Your code may never be perfect.  But think about
;     *reasonable* ways to make it better.a
;   * Simplify from a working solution
;   * Limit recursion

; Palindrome
;   Our goal was that you not recurse through a list.  We wanted you to work
;   with the string directly.
; Idea: Work from ends.
;   Strings have a string-ref procedure.  string-ref is about as efficient
;   as vector-ref.  (IN some languages, strings are mostly vectors of characters.)
(define palindrome
  (lambda (str)
    (let kernel ([left 0]
                 [right (decrement (string-length str))])
      (or (>= left right)
          (and (char=? (string-ref str left) (string-ref str right))
               (kernel (increment left) (decrement right)))))))
; Observation: We could use conditionals, which better match how we
; talk about it.

(define pal?
  (lambda (str)
    (let kernel ([left 0]
                 [right (decrement (string-length str))])
      (if (>= left right)
          #t
          (if (char=? (string-ref str left) (string-ref str right))
              (kernel (increment left) (increment right))
              #f)))))

; The two are similar in efficiency.  Sam finds the first more
; elegant and perhaps even more readable.  Your experience may
; be different than mine.  (YEMBDTM)

; Working with kernels is often useful.

; Create a new list by inserting val at the specified position
; in the list.
; The position has to be between 0 and length, inclusive

; Sam's intuition: Direct recursion may work here.

(define insert-at
  (lambda (lst pos val)
    ; Base case: Insert at the front, which I can do when pos is 0
    (if (zero? pos)
        (cons val lst)
        ; Insert the value in the cdr
        ; Add the front back on
        (cons (car lst)
              (insert-at (cdr lst)
                         (decrement pos)
                         val)))))

(define remove-at
  (lambda (lst pos)
    ; Base case: Insert at the front, which I can do when pos is 0
    (if (zero? pos)
        (cdr lst)
        ; Insert the value in the cdr
        ; Add the front back on
        (cons (car lst)
              (remove-at (cdr lst)
                         (decrement pos))))))

; Problem 4: insert-everywhere
; Basic idea: call insert-at with 0 1 2 3 ... length
(define insert-everywhere
  (lambda (val lst)
    (let ([len (length lst)])
      (let kernel ([pos 0])
        ; Base case: Stop when pos exceeds length
        (if (> pos len)
            null
            (cons (insert-at lst pos val)
                  (kernel (increment pos))))))))

; permutations is already defined.  I'm done.

; Obs: If I have the permutations of (2 3 4), I can get the permutations of
; (1 2 3 4) by inserting 1 into the first permutation and then inserting 1
; into the second perm, ...

(define perms
  (lambda (lst)
    (if (or (null? lst) (null? (cdr lst)))
        (list lst)
        (let ([first (car lst)]
              [partial-permutations (perms (cdr lst))])
          (let kernel ([remaining partial-permutations])
            (if (null? remaining)
                null
                (append (insert-everywhere first (car remaining))
                        (kernel (cdr remaining)))))))))