Replacing symbols in a (nested)? List in LISP - common-lisp

Question

I am supplying a list in the following format:
(test '((Q H)(A D)(J C)(Q S)(3 S)))
The aim is to to search through the list and replace the symbols J Q K and A with the respective numbers 11 12 13 and 14. Currently my function is this (I'm sorry):
(defun test (hand)
(cond ((equal (first (first hand)) 'J)
(setf (first (first hand)) '11))
((equal (first (first hand)) 'Q)
(setf (first (first hand)) '12))
((equal (first (first hand)) 'K)
(setf (first (first hand)) '13))
((equal (first (first hand)) 'A)
(setf (first (first hand)) '14))
(t (print '(It's ogre now))))
(cond ((equal (first (second hand)) 'J)
(setf (first (second hand)) '11))
((equal (first (second hand)) 'Q)
(setf (first (second hand)) '12))
((equal (first (second hand)) 'K)
(setf (first (second hand)) '13))
((equal (first (second hand)) 'A)
(setf (first (second hand)) '14))
(t (print '(It's ogre now))))
(cond ((equal (first (third hand)) 'J)
(setf (first (third hand)) '11))
((equal (first (third hand)) 'Q)
(setf (first (third hand)) '12))
((equal (first (third hand)) 'K)
(setf (first (third hand)) '13))
((equal (first (third hand)) 'A)
(setf (first (third hand)) '14))
(t (print '(It's ogre now))))
(cond ((equal (first (fourth hand)) 'J)
(setf (first (fourth hand)) '11))
((equal (first (fourth hand)) 'Q)
(setf (first (fourth hand)) '12))
((equal (first (fourth hand)) 'K)
(setf (first (fourth hand)) '13))
((equal (first (fourth hand)) 'A)
(setf (first (fourth hand)) '14))
(t (print '(It's ogre now))))
(cond ((equal (first (fifth hand)) 'J)
(setf (first (fifth hand)) '11))
((equal (first (fifth hand)) 'Q)
(setf (first (fifth hand)) '12))
((equal (first (fifth hand)) 'K)
(setf (first (fifth hand)) '13))
((equal (first (fifth hand)) 'A)
(setf (first (fifth hand)) '14))
(t (print '(It's ogre now))))
(print hand))
I am certain there is a cleaner way of doing this. Could anyone point me in the right direction?

Answer 1

As you want to replace all occurrences of J/Q/K/A with the corresponding numbers, you can use the SUBST function:
(subst 11 'J (subst 12 'Q (subst 13 'K (subst 14 'A hand))))
or, with a loop, which would look nicer if you had more things to substitute:
(loop for (letter value) in '((J 11) (Q 12) (K 13) (A 14))
for hand% = (subst value letter (or hand% hand))
finally (return hand%))

Answer 2

Lets do this. [dons code-review hat]
Firstly, your procedure is going to mutate its input, and that's considered bad style.
CL-USER> (defun test (hand)
...
(print hand))
TEST
CL-USER> (defparameter *a-hand* '((Q H)(A D)(J C)(Q S)(3 S)))
*A-HAND*
CL-USER> (test *a-hand*)
(IT 'S OGRE NOW)
((12 H) (14 D) (11 C) (12 S) (3 S))
((12 H) (14 D) (11 C) (12 S) (3 S))
CL-USER> *a-hand*
((12 H) (14 D) (11 C) (12 S) (3 S))
CL-USER>
This is because you're using setf all over the place to mutate your argument. The alternative to performing that mutation is to build up a new list of pairs with the first element replaced by its numeric representation. Building up a new list with some transformation applied to it happens to be the purpose of the mapcar function in Common Lisp. In order to apply that strategy, we need to figure out what it is that you're doing to each element of the incoming list. The pattern should be obvious from the above:
...
(cond ((equal (first (first hand)) 'J)
(setf (first (first hand)) '11))
((equal (first (first hand)) 'Q)
(setf (first (first hand)) '12))
((equal (first (first hand)) 'K)
(setf (first (first hand)) '13))
((equal (first (first hand)) 'A)
(setf (first (first hand)) '14))
(t (print '(It's ogre now))))
...
So. Lets get a separate function that takes a list and sometimes replaces its first element by some number.
(lambda (lst)
(cond ((equal (first lst) 'J)
(cons '11 (cdr lst)))
((equal (first lst) 'Q)
(cons '12 (cdr lst)))
((equal (first lst) 'K)
(cons '13 (cdr lst)))
((equal (first lst) 'A)
(cons '14 (cdr lst)))
(t lst)))
Note that we've replaced (first (first hand)) with a reference to our argument (first lst), and that we now use cons to build a new list with a replacement element at the first position. We can now map this function over your hand by calling mapcar.
(defun test (hand)
(print (mapcar (lambda (lst)
(cond ((equal (first lst) 'J)
(cons '11 (cdr lst)))
((equal (first lst) 'Q)
(cons '12 (cdr lst)))
((equal (first lst) 'K)
(cons '13 (cdr lst)))
((equal (first lst) 'A)
(cons '14 (cdr lst)))
(t lst)))
hand)))
This no longer causes visible side-effects to your argument.
CL-USER> (defun test (hand)
(print (mapcar (lambda (lst)
(cond ((equal (first lst) 'J)
(cons '11 (cdr lst)))
((equal (first lst) 'Q)
(cons '12 (cdr lst)))
((equal (first lst) 'K)
(cons '13 (cdr lst)))
((equal (first lst) 'A)
(cons '14 (cdr lst)))
(t lst)))
hand)))
STYLE-WARNING: redefining COMMON-LISP-USER::TEST in DEFUN
TEST
CL-USER> (defparameter *a-hand* '((Q H)(A D)(J C)(Q S)(3 S)))
*A-HAND*
CL-USER> (test *a-hand*)
((12 H) (12 D) (12 C) (12 S) (12 S))
((12 H) (12 D) (12 C) (12 S) (12 S))
CL-USER> *a-hand*
((Q H) (A D) (J C) (Q S) (3 S))
CL-USER>
You're printing your output (along with some It's ogre now lines in the original) instead of merely returning it. As you can see in the REPL, this'll cause multiple copies to be displayed, and if you want to compose your test function later, the print won't really do anything for you. If you need to print the output, it's probably a better idea to leave that piece of logic up to the caller and merely focus on doing the replacement in the function itself.
(defun test (hand)
(mapcar (lambda (lst)
(cond ((equal (first lst) 'J)
(cons '11 (cdr lst)))
((equal (first lst) 'Q)
(cons '12 (cdr lst)))
((equal (first lst) 'K)
(cons '13 (cdr lst)))
((equal (first lst) 'A)
(cons '14 (cdr lst)))
(t lst)))
hand))
We've still got some repetition happening in that lambda form we're passing to mapcar. In particular, each clause involves consing a new value onto the cdr (or synonymously rest) of the input. Since the flow-control structures in Common Lisp are also functions that return values, we can compose them a little less repetitively.
(defun test (hand)
(mapcar (lambda (lst)
(cons
(cond ((equal (first lst) 'J) '11)
((equal (first lst) 'Q) '12)
((equal (first lst) 'K) '13)
((equal (first lst) 'A) '14)
(t (car lst)))
(cdr lst)))
hand))
cond probably isn't the best thing to use here in the first place. Since we're always doing the same check, and that check happens to be equality, we can instead use case.
(defun test (hand)
(mapcar (lambda (lst)
(cons
(case (first lst)
(J '11)
(Q '12)
(K '13)
(A '14)
(t (first lst)))
(cdr lst)))
hand))
Alternately, you could define a table of values, and look up the first element in it.
(defun test (hand)
(let ((table '(J 11 Q 12 K 13 A 14)))
(mapcar
(lambda (lst)
(cons (or (getf table (car lst)) (car lst))
(cdr lst)))
hand)))
Finally, you don't need to quote numbers Common Lisp. They're already self-evaluating.
(defun test (hand)
(mapcar (lambda (lst)
(cons
(case (first lst)
(J 11)
(Q 12)
(K 13)
(A 14)
(t (first lst)))
(cdr lst)))
hand))
If you're just getting started with programming, I'd recommend you go through these fantastic tutorials for Racket, rather than diving into Common Lisp right away.