Overflow: Auto » Scheme

Problem: Spam-Egg List

Tyler — Thu, 12 Jul 2007 16:08:30 +0000

So on Stoto’s Weblog Tuesday there was a little programming challenge called the Spam-Egg List Problem.

Here is the problem:
Write a function called dumpList that takes as its parameters a string and a reference to an arbitrarily complex nested list and prints the value of each list element on a separate line. The value on each line should be preceded by the string and numbers indicating the depth and index of the element in the list. Assume that the list contains only strings and other nested lists.

For example, given the following nested list:
list = [ 'a string', [ 'a', 'b', 'c' ], ‘spam’, [ 'eggs' ] ] and the string ‘Foo’, the output of dumpList(‘Foo’, list) would look like:

Foo.0: a string
Foo.1.0: a
Foo.1.1: b
Foo.1.2: c
Foo.2: spam
Foo.3.0: eggs

My solution (in scheme) is as follows:

(define (dump-list word sequence)
 
  (define (dump-list-iter word sequence count)
 
    (if (null? sequence)
 
        '()
 
        (cond ((list? (car sequence))
 
                (dump-list-iter
 
                 (string-append
 
                  word "." (number->string count)) (car sequence) 0)
 
                (dump-list-iter word (cdr sequence) (+ count 1)))
 
               (#t
 
                (display
 
                 (string-append word "." (number->string count)
 
                                ": " (car sequence)))
 
                (newline)
 
                (dump-list-iter word (cdr sequence) (+ count 1))))))
 
  (dump-list-iter word sequence 0))

It’s a simple recursive solution with side-effects (printing). It would be relatively easy to rework it to maintain a list of strings and print them at the very end, but the problem didn’t call for it, so I’m satisfied with this solution.

XKCD #287 Comic Solution

Tyler — Mon, 09 Jul 2007 22:18:52 +0000

In today’s xkcd comic the joke was about using the knapsack problem at a restaurant. Just for fun, I solved it in scheme.

(define (make-appetizer name cost)
  (cons name cost))
(define (name app)
  (car app))
(define (cost app)
  (cdr app))
 
(define delta 0.000001)
(define (float-equal? x y)
  (< (abs (- x y)) delta))
 
(define appetizers
  (list
   (make-appetizer "mixed fruit" 2.15)
   (make-appetizer "french fries" 2.75)
   (make-appetizer "side salad" 3.35)
   (make-appetizer "hot wings" 3.55)
   (make-appetizer "mozzarella sticks" 4.20)
   (make-appetizer "sampler plate" 5.80)))
 
(define (append-unless-null set elem)
  (if (null? set)
      '()
      (cons elem set)))
 
(define (appetizers-for-cost-n apps n)
  (if (null? apps)
      '()
      (cond ((float-equal? (cost (car apps)) n) (list (car apps)))
            ((> (cost (car apps)) n)
             (appetizers-for-cost-n (cdr apps) n))
            (else
             (append
              (map (lambda (x) (cons (car apps) x))
                   (appetizers-for-cost-n apps (- n (cost (car apps)))))
              (appetizers-for-cost-n (cdr apps) n))))))

Calling it with: (appetizers-for-cost-n appetizers 15.05)
Results in:

((("mixed fruit" . 2.15)
  ("mixed fruit" . 2.15)
  ("mixed fruit" . 2.15)
  ("mixed fruit" . 2.15)
  ("mixed fruit" . 2.15)
  ("mixed fruit" . 2.15)
  "mixed fruit"
  .
  2.15)
 (("mixed fruit" . 2.15)
  ("hot wings" . 3.55)
  ("hot wings" . 3.55)
  "sampler plate"
  .
  5.8))

Postfix to expression-tree in scheme

Tyler — Mon, 02 Jul 2007 16:33:14 +0000

So today someone on a mailing list asked for help with a postfix to expression-tree converter. While he hasn’t responded to me yet, I thought I’d share my solution on here. It was surprisingly easy to write in Scheme. Please feel free to comment if you have suggestions.

; define a tree structure to work with
(define (make-tree val left right)
  (list val left right))
(define (value tree)
  (car tree))
(define (left-branch tree)
  (cadr tree))
(define (right-branch tree)
  (caddr tree))
 
; converts postfix list to an expression-tree
(define (postfix-to-tree ops)
  (define (postfix-iter symbols values) ;progress through symbols keeping a list of values
    (if (null? symbols)
        (car values) ; returning end result
        (let ((x (car symbols)))
          (cond ((number? x) (postfix-iter (cdr symbols) (cons x values)))
                (else (postfix-iter
                       (cdr symbols)
                       (cons (make-tree x (cadr values) (car values))
                             (cddr values))))))))
  (postfix-iter ops '()))
;(postfix-to-tree '(2 1 + 3 4 * +)) == (+ (* 4 3) (+ 1 2))

Also, suppose rather than making an expression tree, we wanted to evaluate the postfix instead?
We could just eval the output of postfix-to-tree, i.e. (eval (postfix-to-tree ‘(2 1 + 3 4 * +))), but in general I think it’s preferred to avoid eval.
So alternatively, we’ll write a function to evaluate the symbols, and make a minor change to our main function and we’re there.

(define (eval-op op a b)
  (cond ((eq? '+ op) (+ a b))
        ((eq? '- op) (- a b))
        ((eq? '* op) (* a b))
        ((eq? '/ op) (/ a b))))
 
; evaluates postfix-expression
(define (eval-postfix ops)
  (define (postfix-iter symbols values) ;progress through symbols keeping a list of values
    (if (null? symbols)
        (car values) ; returning end result
        (let ((x (car symbols)))
          (cond ((number? x) (postfix-iter (cdr symbols) (cons x values)))
                (else (postfix-iter
                       (cdr symbols)
                       (cons (eval-op x (cadr values) (car values))
                             (cddr values))))))))
  (postfix-iter ops '()))
; (eval-postfix '(2 1 + 3 4 * +)) == 15

These solutions could probably use a little error-checking, but they both operate correctly on valid input and get the job done.