Lists

CSC 358/4584.3.2006

Outline

Lab #1 / Homework #1 Lists

A questionListInternals of ListsList operations

Extended Example

Lab #1

(defun add-car (lst1 lst2) (+ (car lst1) (car lst2)))

(defun deal-hand (size deck) (let ((hand '())) (dotimes (i size) (push (pop deck) hand)) hand))

(defun count-face-cards (hand) (let ((counter 0)) (dolist (card hand) (if (face-cardp card) (incf counter))) counter))

(defun face-cardp (card) (not (numberp (card-rank card))))

Lab #1 (Extra credit)

(defun average-face-cards (trials size) (let ((deck (make-deck)) (count 0)) (dotimes (k trials) (setf deck (shuffle-deck deck)) (incf count (count-face-cards (deal-hand size deck)))) (/ (float count) trials)))

Homework #1

;; Cheating version (using case)(defun card-blackp (card) (case (card-suit card) ((H D) nil) ((S C) t)))

;; Non-cheating version (using cond)(defun card-blackp (card) (let ((suit (card-suit card))) (cond ((or (eq suit 'H) (eq suit 'D)) nil)

(t t))))

;; Functional version with boolean return value(defun card-blackp (card) (let ((suit (card-suit card))) (or (eq suit 'S) (eq suit 'C))))

Homework #1

(defun not-twenty-onep (card1 card2) (let ((rank1 (card-rank card1)) (rank2 (card-rank card2))) (if (and (= rank1 1) (= rank2 1)) ;; special case 12 (let ((value1 (card-points-bj rank1)) (value2 (card-points-bj rank2))) (let ((value-sum (+ value1 value2))) (if (= value-sum 21) nil value-sum))))))

(defun card-points-bj (rank) (case rank ((k q j) 10) (1 11) (otherwise rank)))

Homework #1

(defun card-points-skat (rank) (case rank (1 11) (10 10) (k 4) (q 3) (j 2) (otherwise 0)))

(defun skat-trick (trick) (let ((score 0)) (dolist (card trick) (incf score (card-points-skat (card-rank card)))) score))

Homework #1 (XC)(defun can-buildp (hand center) (dolist (hand-card hand) (dolist (center-card center) (if (can-build-cards hand-card center-card hand) (return-from can-buildp

(list hand-card center-card)))))))

(defun can-build-cards (hand-card center-card hand) (let ((hand-value (card-points-cassino (card-rank hand-card))) (center-value (card-points-cassino

(card-rank center-card)))) (let ((build-value (+ hand-value center-value))) (dolist (card hand) (if (= build-value (card-points-cassino

(card-rank card))) (return-from can-build-cards t))))))

(defun card-points-cassino (rank) (case rank (k 13) (q 12) (j 11) (otherwise rank)))

Homework #1

(defun can-buildp (hand center) (let ((ans nil)) (dolist (hand-card hand) (dolist (center-card center)

(if (can-build-cards hand-card center-card hand) (setf ans (list hand-card center-card)))))

ans))

Last week

How to deal with card games with different point values? One possibility

• lots of named functions• ick

Better approach be data-driven let the functions be defined by the data

Problem don't want an extra argument to a comparison

operator• suppose I want to supply the comparison to a sort

function?

Lisp solution

Create an anonymous function using the datause this function for comparing

Benefitscan create as many as neededsymbol table not filled with

unnecessary stuff

card-comparator

(defvar *default-card-values* '((K 13) (Q 12) (J 11)))

(defvar *ace-high-values* '((1 14) (K 13) (Q 12) (J 11)))

(defvar *skat-card-values* '((1 14) (10 13) (K 12) (Q 11) (J 10)))

(defun rank-to-number2 (rank card-values) (let ((value-pair (assoc rank card-values))) (if value-pair (cadr value-pair) rank)))

(defun card-comparator (&optional (card-values *default-card-values*))

#'(lambda (card1 card2) (let ((rank1 (card-rank card1)) (rank2 (card-rank card2))) (< (rank-to-number2 rank1 card-values) (rank-to-number2 rank2 card-values)))))

Some syntax: lambda

lambdaa lot more about this next weekthis is how we define an anonymous

function defun is just a convenience

(setf (function foo) #'(lambda (x y) (+ x y)))

the same as (defun foo (x y) (+ x y))

lambda is fundamental

Optional arguments

More about this next week I can specify in the parameter list that

some arguments are optionaland then supply default values

Optional arguments must be at the endfor obvious reasons

Closure

Note the function I define using lambda refers to a parameter defined in the

enclosing scope• card-values

the function is returned to the caller• the enclosing scope disappears

can I do this? Yes!

technical term = "lexical closure" more about this next week

Lists

A Question

Why can’t I really deal from my deck?Why does this function not change the

value of its argument?(defun mypop (lst)

(pop lst))> (setf l1 '(a b c))> (mypop l1)A> l1(A B C)

Lists

sequences of itemsatoms or lists

carfirst element

cdrrest

consbuilds a list

Other List Builders

lista list containing the arguments

appenda list combining the arguments

Internals (a b c)

A

B

nil

C

Nested List

nil

A

B

nil

Enil

C

D

Improper List

A B

What Does It Do?*

(setf l1 '(a (b c))) (setf l2 '((d) e)) (car l2) (cdr l1) (cons 'b l1) (list l2 'd) (append l1 l2)

What does it do?

(pop l1) special form short for (setf l1 (cdr l1))

(defun mypop (lst)(pop lst))

(defun my pop (lst)(setf lst (cdr lst)))

(mypop l1) l1 doesn't change

why should it? it is still bound to the same thing

How can we achieve this?

Global variableick

Game state structurepass in and outcontents manipulatedbetter

Example: Blackjack

(defun make-bj-game (player-count) (list (shuffle-deck (make-deck))

(make-list player-count :initial-element nil)))

(defun player-count (game) (length (hands game)))

(defun deck (game) (cadr game))

(defun hands (game) (caddr game))

(defun hand (player game) (nth player (hands game)))

New function

make-listnote the function call:initial-element

• keyword argument• we'll see this again later

Shared Structure

It is easy to create lists that share structure(setf c (append a b))

Not a problem unless a or b is destructively modified

List Functions

Accessorsnavigating around in lists

Operationsmanipulate the whole list

Destructive operationsmodify the list

List Accessors

car, cdr positional

first, second, third(nth i lst)(nthcdr i lst)

end of the listlastactually returns last cdr

List Operations

Many! Mapping functions Boolean operations Finding Modifying (copy) Reduce

Mapping

Functions that apply a function over and over across a list

(mapcar #’fn lst)applies the function to each element in

the listreturns a list of the results

Also works with multiple lists(mapcar #’fn lst1 lst2)

Example

Matt's question What if I want to add 5 to everything in

a list?(mapcar #'(lambda (x) (+ x 5)) '(1 2 3))

Other Mapping Functions

maplistapplies to successive cdrs

mapcanjoins results with append

mapc, mapllike mapcar and maplist but doesn't

return results

Boolean Operations

logical summary of a list relative to a function

(some #’fn lst) true if any element of lst returns true when

the function is applied every

false if any element returns false notany notevery

Example

flushpis a poker hand a flush?

• 5-card hand, please logic

all cards the same suitsimple method

• all spades or all clubs or ...better way?

Finding Operations

(member elem lst)if elem is in list, returns the cdr

headed by elem (position elem lst)

if elem is in list, return position index both return nil is absent

Modifications

(remove elem lst) returns a copy of lst with elem removed not “destructive” Also "if" version

• remove-if• has a test instead of an element

(substitute old new lst) returns a copy of lst with old replaced by new

Reduce

“reduce” list into a single value (reduce #’fn lst)

applies fn to first two elementsapplies fn to that result and next

elementetc.

(reduce #’+ ‘(1 2 3 4)) => 10

Example

count-face-cardsmapcar and reduce

Original version(defun count-face-cards (hand) (let ((counter 0)) (dolist (card hand) (if (face-cardp card) (incf counter))) counter))

(defun face-cardp (card) (not (numberp (card-rank card))))

Destructive Operations I

Most Lisp operations return “new” listsremove(setf lst ‘(b a b a b))(remove ‘a lst) => (b b b)lst => (b a b a b)Use the result of the function

New cons cells creatednot always what you want

Destructive Operations II

Alter the contents of cons cellsrplaca = replace the carrplacd = replace the cdrnconc = destructive appenddelete = destructive removensubst = destructive subst

Others“n” means “non-consing”

Generalized Variables

setf can be similarly used(setf (car lst) val)(setf (cdr lst) val)

Main reason to useefficiency

• creating new cons cells• creating garbage

Problems with Destructive Operations

Shared structure Effects hard to predict Not necessary Main reason to use

efficiencybut remember Knuth

• “Premature optimization is the root of all evil.”

Example

Look at deck after shuffle-deck

defsetf One principle of Lisp is that the

programmer has the same power as the language designer

You can create your own generalized variablesuse defsetf

Example

(defun 3rd (lst) (nth 2 lst))

(defun set-3rd (lst value) (setf (nth 2 lst) value))

(defsetf 3rd set-3rd)

(setf lst '( a b c d))

(setf (3rd lst) 'q)

lst => (a b q d)

(setf (3rd lst))

Association List

Allows lookup of values associated with keys ((key1 . val1) (key2 . val2) ... (keyn . valn))

OK for short associations large associations a hash table is better

(assoc key alist) returns the pair

(rassoc val alist) returns the pair

Keyword parameters

what if the value is not an atom?(rassoc '(21 M) '((John 21 M) (Jane 19 F) (Joe 25

M)))

doesn’t work because rassoc uses eq extra arguments to rassoc

:testspecifies which function to use instead

of default(rassoc '(21 M) '((John 21 M) (Jane 19 F) (Joe 25

M)):test #'equal)

Keyword Parameters

Many functions have these Most common

:test:key

• specifies a function to apply before testing(rassoc '21 '((John 21 M) (Jane 19 F) (Joe 25 M))

:key #'car)

:start:end

Equality Operators

= numerical equality only

eq reference equality

eql eq numbers and characters

equal tests lists element by element can be expensive!

Which one to use? if you know your data type, be specific

• (equal for lists, = for numbers, eql for everything else) if you really want reference equality, use eq

Defining Keyword Parameters (defun foo (a b &key c (d 5))

...)5 is the default value for d

can be called(foo 1 2)(foo 1 2 :c 1 :d 3)

Example

sorting handsby rankby suitallow different possibilities(sort-hand hand :test ...)

Sequences

Many of the list function also work on vectorslisp 1-D arrays

The data type that covers both lists and vectors is called the "sequence"functions that take a sequence as an

argument will operate on either

Extended Example

blackjack