CODEWITHSUNDEEP
lispcommon-lispclisp
klk2ptx
klk2ptx

Reputation: 99

Common Lisp - Gentle introduction to symbolic computation: Excercise 4.4

I am learning Common Lisp using clisp and have entered following code:

(defun ordered (x y)
   (if (< x y)
       (list x y)
       (list y x)))

(setq l (ordered 28 49))
(print l)
(setq l (ordered 49 28))
(print l)

Expected these answers: (28 49) (49 28)

Got these answers: (28 49) (28 49)

In the solutions of this book I have found the same function definition. What could be wrong?

Upvotes: 0

Views: 206

Answers (1)

Will Ness
Will Ness

Reputation: 71065

Your code 

(defun

defines a function,

        ordered

named "ordered",

                (x y)

that expects two arguments which will be known as "x" and "y" in its body, whereupon on receiving the arguments (i.e. having been called with two values, e.g. (ordered 49 28))

   (if (< x y)

it will compare them, and in case the first was smaller than the second, it will produce 

       (list x y)

the same two values repackaged in a list (i.e. '(49 28)); or otherwise, if the first value was not smaller than the second, 

       (list y x)))

it will produce the list containing the second value first, and then the first argument value (i.e. '(28 49)).

So, which was the case here, of comparing the 49 and 28?

Reading this code generally, we can say that if it receives the smaller number as its first argument, it will produce the smaller number first and the bigger number second, in the result list;

and in case it receives the smaller number as its second argument, it will produce the smaller number first and the bigger number second, in the result list.

Reading this back, we can see that this description can be simplified further into one simple statement: it will always produce ______ number first, and ______ second, in the resulting list.

Another way to attack this, is to write down the function created by that definition,

( lambda (x y)  (if   (< x y)    (list x y)    (list y x) ) )

Then follow its application symbolically:

(   ( lambda (x y)  (if   (< x y)    (list x y)    (list y x) ) )
    49
    28  )

==

(let  (   (x   49)
          (y   28)
      )
                    (if   (< x y)    (list x y)    (list y x) ) )

==

(let  (   (x   49)
          (y   28)
      )
                    (if   (< 49 28)  (list x y)    (list y x) ) )

==

(let  (   (x   49)
          (y   28)
      )
                    (if   FALSE      (list x y)    (list y x) ) )

==

(let  (   (x   49)
          (y   28)
      )
                                                   (list y x)   )

==

(let  (   (x   49)
          (y   28)
      )
                                                   (list 28  49) )

==

(list  28  49)

Upvotes: 4

Related Questions