Page History

...

The basic form for each function that you write , including axillary and local functions, is as followsis shown below:

Example 5. Function definition for computing area of a ringproduct of list-of-number:

Code Block

            ;; areaproduct-of-ringlon : positivelist-real-number positive-real-numberof-numbers -> positive-real-number
            ;; Purpose: to compute the areaproduct of anumbers ringin whosea radius islist
            ;; outerassuming andproduct whoseof holeempty haslist a radius of inner
            ;;is 1

            ;; Examples:
            ;; (areaproduct-of-ringlon 5 3empty) => 50.241
            ;; (areaproduct-of-ring 5 0lon (cons 2 empty)) => 78.52
            ;; (product-of-lon (cons 3 (cons 2 empty))) => 6

            ;; Template Instantiation: (degenerate)instantiation
            #|
             (define (areaproduct-of-ring outer inner) ...)lon a-lon)
            |#
    (cond
        ;; Code:

        [(empty? a-lon) ...]
  (define (area-of-ring outer inner)               [(cons? a-lon) ... (first a-lon) ...
              (- (area-of-disk outer)
                ... (areaproduct-of-disk inner)lon (rest a-lon)) ... ]))

            ;; Test Examples:|#

            ;; Code
            (check-expectdefine (areaproduct-of-ring 5 3) 50.24)
lon a-lon)
             (check-expect (area-of-ring 5 0) 78.5)
cond
               ...
  [(empty? a-lon) 1]
        ;; Provide enough examples and tests to show you tested thoroughly

Example 6. Function definition for computing product of list-of-number:

Code Block

[(cons? a-lon) (* (first a-lon)
              ;; product-of-lon : list-of-numbers -> number
            ;; to compute the (product -of-lon numbers(rest in a lista-lon)))]))

            ;; assumingTest productExamples:
 of empty list is 1

            ;; Examples:
            ;; (check-expect (product-of-lon empty) => 1)
            ;;(check-expect (product-of-lon (cons 2 empty)) => 2)
            ;;(check-expect (product-of-lon (cons 3 (cons 2 empty))) => 6
)
            ;; TemplateProvide instantiation
enough examples and tests to show you      #|
             (define (product-of-lon a-lon)
               (cond
                 [(empty? a-lon) ...]
                 [(cons? a-lon) ... (first a-lon) ...
                                ... (product-of-lon (rest a-lon)) ... ]))
            |#

            ;; Code
            (define (product-of-lon a-lon)
              (cond
                 [(empty? a-lon) 1]
                 [(cons? a-lon) (* (first a-lon)
                                   (product-of-lon (rest a-lon)))]))

            ;; Test Examples:
            (check-expect (product-of-lon empty) 1)
            (check-expect (product-of-lon (cons 2 empty)) 2)
            (check-expect (product-of-lon (cons 3 (cons 2 empty))) 6)tested thoroughly

Remember to follow the design recipe.
It is important that things are presented in this order, so that is clear that you know the correct order for doing things.
Be careful with regard to using the equal? operation in the program code that you write because the worst case running time is the size of the smaller of its two inputs (on inputs that are equal or nearly equal). Of course, the equal? operation and operations that call equal? (like check-expect) are extensively used in test code.
If your examples get too big, then simply define a name for that big argument somewhere before you use it. You can use this name both in your comments in the example section and in the test cases in the Tests section.
Be sure to test your code thoroughly. Corner cases and edge cases should be tested. When dealing with numerical functions, 0 and 1 are often important test inputs.
When testing lists, make sure you test the following cases:
- empty list: empty
- list with one element: ex: (cons 3 empty)
- list with more than one element: ex: (cons 1 (cons 3 (cons 3 (cons 7 empty))))
Local functions cannot be tested individually, so specific tests are not required for them. However, you main function's tests need to be comprehensive enough to test the local functions.

Sample Solution to a Programming Problem
Anchor
SampleSolution
SampleSolution

The following text is a good solution to the problem of sorting a list of numbers into ascending order; it pulls together all of the specific pieces of design documentation, code documentation, and testing mentioned above. It would be better if it included a few more appropriately chosen tests.

Code Block

;; COMP 311 HW #Sample
;; Corky Cartwright <cork@rice.edu>

;; A list-of-numbers is either:
;;   empty, or
;;   (cons n alon) where n is a number and alon is a list-of-numbers
;;
;; Examples:
;;   empty
;;   (cons 10 (cons -1 (cons 5 empty))) = '(10 -1 5)
;;   (cons 1 (cons 2 (cons 3 empty)))   = '(1 2 3)
;;   (cons 3 (cons 2 (cons 1 empty)))   = '(3 2 1)

#| Template: (enclosed in block comment brackets)
   (define (lon-f ... a-lon ...)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...

...

empty list: empty
list with one element: ex: (cons 3 empty)
list with more than one element: ex: (cons 1 (cons 3 (cons 3 (cons 7 empty))))

...

 ... (lon-f ... (rest a-lon) ...) ... ]))
|#

;; Main function: sort

;; Contract and purpose:
;; sort: list-of-numbers -> list-of-numbers
;; Purpose: (sort alon) returns the a list with same elements (including duplicates) as alon but in ascending order.

;; Examples:
;; (sort empty) = empty
;; (sort '(0)) = '(0)
;; (sort '(1 2 3)) = '(1 2 3)
;; (sort '(3 2 1)) = '(1 2 3)
;; (sort '(10 -1 10 -20 5)) = (-20 -1 5 10 10)

#| Template Instantiation:
   (define (sort a-lon)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...
                      ... (sort (rest a-lon)) ... ]))
|#
;; Code:

   (define (sort a-lon)
     (cond
       [(empty? a-lon) empty]
       [(cons? a-lon) (insert (first a-lon) (sort (rest a-lon)))]))

;; Tests
(check-expect (sort empty) empty)
(check-expect (sort '(0)) '(0))
(check-expect (sort '(1 2 3)) '(1 2 3))
(check-expect (sort '(3 2 1)) '(1 2 3))
(check-expect (sort '(10 -1 10 -20 5)) '(-20 -1 5 10 10))

;; Auxiliary function

;; Contract and purpose
;; insert: number list-of-numbers -> list-of-numbers
;; Purpose: (insert n alon), where alon is in increasing order, returns a list containing n and the elts of alon in ascending order

;; Examples:

;;  (insert 17 empty) = '(17)
;;  (insert 17 '(17)) = '(17 17)
;;  (insert 4 '(1 2 3)) = '(1 2 3 4)
;;  (insert 0 '(1 2 3)) = '(0 1 2 3)
;;  (insert 2 '(1 1 3 4)) = '(1 1 2 3 4)

#| Template instantiation
   (define (insert n a-lon)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...
                      ... (insert n (rest a-lon)) ... ]))
|#

;; Code
   (define (insert n a-lon)
     (cond
       [(empty? a-lon) (cons n empty)]
       [(cons? a-lon)
        (if (<= n (first a-lon)) (cons n a-lon)
            (cons (first a-lon) (insert n (rest a-lon))))]))
;; Tests

(check-expect (insert 17 empty) '(17))
(check-expect (insert 17 '(17)) '(17 17))
(check-expect (insert 4 '(1 2 3)) '(1 2 3 4))
(check-expect (insert 0 '(1 2 3)) '(0 1 2 3))
(check-expect (insert 2 '(1 1 3 4)) '(1 1 2 3 4))

Note: the Examples and Tests for each function above can be collapsed into a single entry by cutting out each Tests block and pasting it over the corresponding Examples block. Forward references in check-expect invocations work because the execution of check-expect code is deferred to the end of the contents of the definitions pane. For example, the Auxiliary function part can be rewritten as follows:

Code Block

;; Auxiliary function

;; Contract and purpose
;; insert: number list-of-numbers -> list-of-numbers
;; Purpose: (insert n alon), where alon is in increasing order, returns a list containing n and the elts of alon in ascending order

;; Examples and Tests:

(check-expect (insert 17 empty) '(17))
(check-expect (insert 17 '(17)) '(17 17))
(check-expect (insert 4 '(1 2 3)) '(1 2 3 4))
(check-expect (insert 0 '(1 2 3)) '(0 1 2 3))
(check-expect (insert 2 '(1 1 3 4)) '(1 1 2 3 4))

#| Template instantiation
   (define (insert n a-lon)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...
                      ... (insert n (rest a-lon)) ... ]))
|#

;; Code
   (define (insert n a-lon)
     (cond
       [(empty? a-lon) (cons n empty)]
       [(cons? a-lon)
        (if (<= n (first a-lon)) (cons n a-lon)
            (cons (first a-lon) (insert n (rest a-lon))))]))

Updated Sample Program

A function named sort is included in the core library for most (all?) of the Racket dialects supported by DrRacket. The following revision (with no changes to the code other than the name of the sort function) should run in all of the HTDP student languages except Beginner which excludes abbreviated list notation using '.

Code Block

;; COMP 311 HW #Sample
;; Corky Cartwright <cork@rice.edu>
 
;; A list-of-numbers is either:
;;   empty, or
;;   (cons n alon) where n is a number and alon is a list-of-numbers
;;
;; Examples (some written as binding of variable names to values)
;;   empty
;;   (cons 10 (cons -1 (cons 5 empty))) = '(10 -1 5)
(define l0    (cons 0 empty))

...

The following text is a good solution to the problem of sorting a list of numbers into ascending order; it pulls together all of the specific pieces of design documentation, code documentation, and testing mentioned above. It would be better if it included a few more appropriately chosen tests.

Code Block

;; COMP 311 HW #Sample
;; Corky Cartwright <cork@rice.edu>

;; A list-of-numbers is either:
;;   empty, or
;;   (cons n alon) where n is a number and alon is a list-of-numbers
;;
;; Examples:
;;   empty
;;   (cons 10 (cons -1 (cons 5 empty))) = '(10 -1 5)
;;   (cons 1 (cons 2 (cons 3 empty)))   = '(1 2 3)
;;   (cons 3 (cons 2 (cons 1 empty)))   = '(3 2 1)

#| Template: (enclosed in block comment brackets)
   (define (lon-f ... a-lon ...)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...
                      ... (lon-f ... (rest a-lon) ...) ... ]))
|#

;; Main function: sort

;; Contract and purpose:
;; sort: list-of-numbers -> list-of-numbers
;; Purpose: (sort alon) returns the a list with same elements (including duplicates) as alon but in ascending order.

;; Examples:
;; (sort empty) = empty
;; (sort '(0)) = '(0)
;; (sort '(1 2 3)) = '(1 2 3)
;; (sort '(3 2 1)) = '(1 2 3)
;; (sort '(10 -1 10 -20 5)) = (-20 -1 5 10 10)

#| Template Instantiation:
   (define (sort a-lon)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...
                ;;  '(0)
(define l123  (cons ...1 (sortcons 2 (rest a-loncons 3 empty)))) ... ]))
|#
;; Code:

   (define (sort a-lon)
     (cond
  '(1 2 3)
(define l321  (list 3 2 1))      [(empty? a-lon) empty]
       [(cons? a-lon) (insert (first a-lon) (sort (rest a-lon)))]))

;; Tests
(check-expect '(sort3 2 empty1)
 empty)
(check-expect (sort '(0)) '(0))
(check-expect (sort '(1 2 3)) '(1 2 3))
(check-expect (sort '(3 2 1)) '(1 2 3))
(check-expect (sort '(10 -1 10 -20 5)) '(-20 -1 5 10 10))

;; Auxiliary function

;; Contract and purpose
;; insert: number list-of-numbers -> list-of-numbers
;; Purpose: (insert n alon), where alon is in increasing order, returns a list containing n and the elts of alon in ascending order

;; Examples:

;;  (insert 17 empty) = '(17)
;;  (insert 17 '(17)) = '(17 17)
;;  (insert 4 '(1 2 3)) = '(1 2 3 4)
;;  (insert 0 '(1 2 3)) = '(0 1 2 3)
;;  (insert 2 '(1 1 3 4)) = '(1 1 2 3 4)

#| Template instantiation
   (define (insert n a-lon)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...
                      ... (insert n (rest a-lon)) ... ]))
|#

;; Code
   (define (insert n
#| Template for the data type list-of-numbers (enclosed in block comment brackets):
   (define (lon-f ... a-lon ...)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...
                      ... (lon-f ... (rest a-lon) ...) ... ]))
|#
 
;; Main function: _sort_  (the name sort is already defined in the library)
 
;; Contract and purpose:
;; _sort_: list-of-numbers -> list-of-numbers
;; Purpose: (_sort_ alon) returns the a list with same elements (including duplicates) as alon but in ascending order.
 
;; Examples (written as executable tests)
;; Named values which make the executable tests more concise

;; Executable tests (most using named values define as list-of-numbers examples)
(check-expect (_sort_ empty) empty)
(check-expect (_sort_ l0) l0)
(check-expect (_sort_ l123) l123)
(check-expect (_sort_ l321) l123)
(check-expect (_sort_ '(10 -1 10 -20 5)) '(-20 -1 5 10 10))

;; Tests already set up as executable examples
 
#| Template Instantiation for _sort_ function:
   (define (_sort_ a-lon)
     (cond
       [(empty? a-lon) (cons n empty)...]
       [(cons? a-lon)
 ... (first a-lon) ...
    (if (<= n (first a-lon)) (cons n a-lon)
            (cons (first a-lon) (insert n  ... (_sort_ (rest a-lon)))) ... ]))
|#
;; Code Tests

(check-expect (insert 17 empty) '(17))
(check-expect (insert 17 '(17)) '(17 17))
(check-expect (insert 4 '(1 2 3)) '(1 2 3 4))
(check-expect (insert 0 '(1 2 3)) '(0 1 2 3))
(check-expect (insert 2 '(1 1 3 4)) '(1 1 2 3 4))

Note: the Examples and Tests for each function above can be collapsed into a single entry by cutting out each Tests block and pasting it over the corresponding Examples block. Forward references in check-expect invocations work because the execution of check-expect code is deferred to the end of the contents of the definitions pane. For example, the Auxiliary function part can be rewritten as follows:

Code Block

(using not yet defined auxiliary function insert)
 
   (define (_sort_ a-lon)
     (cond
       [(empty? a-lon) empty]
       [(cons? a-lon) (insert (first a-lon) (_sort_ (rest a-lon)))]))

;; Auxiliary function
 
;; Contract and purpose
;; insert: number list-of-numbers -> list-of-numbers
;; Purpose: (insert n alon), where alon is in increasing order, returns a list containing n and the elts of alon in ascending order
 
;; Examples and Tests:
 
(check-expect (insert 17 empty)  '(17))
(check-expect (insert 17 '(17))  '(17 17))
(check-expect (insert 4 '(1 2 3))l123) '(1 2 3 4))
(check-expect (insert 0 '(1 2 3))l123) '(0 1 2 3))
(check-expect (insert 2 '(1 1 3 4)) '(1 1 2 3 4))
 
#| Template instantiation
   (define (insert n a-lon)
     (cond
       [(empty? a-lon) ...]
       [(cons? a-lon) ... (first a-lon) ...
                      ... (insert n (rest a-lon)) ... ]))
|#
 
;; Code
   (define (insert n a-lon)
     (cond
       [(empty? a-lon) (cons n empty)]
       [(cons? a-lon)
        (if (<= n (first a-lon)) (cons n a-lon)
            (cons (first a-lon) (insert n (rest a-lon))))]))
  
;; Tests already set up as executable examples

Termination Argument: (Only programs using generative forms of recursion given in Chapter 23 and beyond)

...

Space shortcuts

Child pages

Versions Compared

Old Version 6

New Version Current

Key

Sample Solution to a Programming Problem
Anchor
SampleSolution
SampleSolution

Updated Sample Program

Termination Argument: (Only programs using generative forms of recursion given in Chapter 23 and beyond)

Space shortcuts

Child pages

Page History

Versions Compared

Old Version 6

New Version Current

Key

Sample Solution to a Programming Problem AnchorSampleSolutionSampleSolution

Updated Sample Program

Termination Argument: (Only programs using generative forms of recursion given in Chapter 23 and beyond)

Sample Solution to a Programming Problem
Anchor
SampleSolution
SampleSolution