LISP: Reversing a List in LISP using RPLACA/RPLACD/NCONC

Question

So I'm trying to make a function takes in a list and reverses in place it but I'm not sure how I would use the RPLACA/RPLACD/NONC. Basically does the same thing as reverse but it uses the cons nodes of the original list and does not allocate any new cons nodes. What I have so far is

(defun rip(lst)
(cond   (( null lst) 0)
    ((eq (nil) (cdr (last lst))) 1)
    (((setq x (car (last lst)))
     (rplaca (car (last lst)) (car first lst))
     (rplaca (car first lst) x)) + 2 rip(butlast(rest lst)))))

Answer 1

So a potential list argument would be (1 2). We could imagine the argument is to the list with address #A and that it looks like this:

#A=(1 . #B)
#B=(2 . nil) 

For each cons we create local variable storing cdr before setting the cdr to the previous cons which is nil for the first cons. When the current cons is nil your're done and the result is the previous cons. The result for our example would be:

#A=(1 . nil)
#B=(2 . #A) 

The only mutating function you'll need would be rplacd since the only thing that changes are the cdr. The function could look something like this:

(defun nreverse (list)
  (labels ((aux (list prev)
             (if (endp list)
                 <??>
                 (let ((next <??>))
                   (rplacd <??> <??>)
                   (aux <??> <??>)))))
    (aux list nil)))

Or if you don't mind leaking you can do this:

(defun nreverse (list &optional prev)
  (if (endp list)
      <??>
      (let ((next <??>))
        (rplacd <??> <??>)
        (nreverse <??> <??>))))

Answer 2

So I believe that this was the answer they were looking for:

Recursive: 
(define rip (lst)
(if (null lst) nil (nconc (rip (rest lst))(rplacd lst nil))))

Non-Recursive:
(defun rip (lst)
(do ((res nil) (todo (rest lst)(rest lst)))
    ((null lst) res)
  (setf res (rplacd lst res))
  (setf lst todo) ))