(defun my-reverse-r (lista)
  (if (endp lista)
      '()
    (append (my-reverse-r (rest lista))
            (list (first lista)))))

(defun my-reverse-i (lista)
  (my-reverse-do lista '()))

(defun my-reverse-do (lista ack)
  (if (endp lista)
      ack
    (my-reverse-do (rest lista)
                   (cons (first lista) ack))))

(defun my-reverse-deep (lista)
  (cond
   ((endp lista) '())
   ((atom (first lista))
    (append (my-reverse-deep (rest lista))
            (list (first lista))))
   (t (append (my-reverse-deep (rest lista))
              (list (my-reverse-deep (first lista)))))))

;;***OBS!!!*** Läs bara följande funktion och försök förstå varför den
;;inte fungerar, innan du går vidare och ser bättre varianter

(defun alla-udda (lista) ;ofungerande första försök
  (cond
   ((endp lista) nil)
   ((atom (first lista))
    (not (alla-udda (rest lista)))) ;lista skall ha udda längd,
                                    ;(rest lista) skall då ha jämn.
   (t (and (alla-udda (first lista))
           (not (alla-udda (rest lista)))))))

;;(Ett negerat uttryck ("not" ovan) innebär kanske inte riktigt det
;;man först väntar sej ...)

;;En fungerande lösning:

(defun alla-udda (lista)
  (cond
   ((endp lista) nil)
   ((atom (first lista))
    (hela-jämn-delar-udda (rest lista)))
   (t (and (alla-udda (first lista))
	   (hela-jämn-delar-udda (rest lista))))))

(defun hela-jämn-delar-udda (lista)
  (cond
   ((endp lista) t)
   ((atom (first lista))
    (alla-udda (rest lista)))
   (t (and (alla-udda (first lista))
	   (alla-udda (rest lista))))))

;;Eftersom det är ett sanningsvärde som returneras kan följande
;;omskrivning göras utan att det betraktas som missbruk av if/cond:

(defun alla-udda (lista)
  (if (endp lista) nil
    (and (or (atom (first lista))
	     (alla-udda (first lista)))
	 (hela-jämn-delar-udda (rest lista)))))

(defun hela-jämn-delar-udda (lista)
  (if (endp lista) t
    (and (or (atom (first lista))
	     (alla-udda (first lista)))
	 (alla-udda (rest lista)))))

;;Det är ju inte så mycket som skiljer funktionerna åt.
;;Man kan sammanfatta det så här:

(defun alla-udda (lista)
  (alla-udda-do lista nil))

(defun alla-udda-do (lista jämn?)
  (if (endp lista) jämn?
    (and (or (atom (first lista))
	     (alla-udda-do (first lista) nil))
	 (alla-udda-do (rest lista) (not jämn?)))))

---------------------------------------------------------------------------

A kan enkelt göras med t.ex. '((1 . 2) . (3 . 4)) .

D och F kan inte göras (ännu) pga cykler i strukturén.

För B, C, och E tänk på att varje gång man använder ett värde så är det *samma* värde.

B: (let ((temp (list 1)))
     (cons temp temp))    ;*samma* värde används 2 ggr.

C: (let ((temp (cons 2 3)))
     (cons (cons 1 temp) temp))

E: (let ((temp1 (let ((temp2 (list 1)))
		  (cons temp2 temp2))))
     (cons temp1 temp1)