common lisp

(setf a 'x
      b 'y
      c 'z)
(setf (car '(x y z)) 'n)

(do ((i 0 (+ i 1)) ;; var initial update
     (j 1 (+ j 1)))
    ((> i 10) 'done) ;; end-p return
  (format t "i: ~A, j:~A, ~%" i j)
        )

(dolist (x '(1 2 3))
  (format t "x: ~A~%" x))

(eql (cons 'a nil) (cons 'a nil))

(equal (cons 'a nil) (cons 'a nil))

(setf x '(1 2))
(setf (car x) 4) ;; (car x) is a pointer
x

(nth 0 '(a b c))
(nthcdr 2 '(a b c))
(zerop 3)
(last '(a b c)) ;; car it to get the atom
(first '(0 1 2 3 4 5 6 7 8 9))
(tenth '(0 1 2 3 4 5 6 7 8 9)) ;; first - tenth are defined.
(cadddr '(0 1 2 3 4 5 6 7 8 9)) ;; can use, but not necessary, and hard to read.

;; (mapcar #'(lambda (x) x) '(1 2 3))
(maplist #'(lambda (x) x) '(1 2 3))

(copy-tree '(1 (2 3) 4)) ;; with copy-list, they will have the
(setf x (copy-list '(1 (2 3) 4)))
(setf y (copy-list x))
;; (setf y (copy-list '(1 (2 3) 4)))
(eql (nth 0 x) (nth 0 y))
(substitue 3 2 '(1 (2 3) 4))
(subst 3 2 '(1 (2 3) 4)) ;; substitute in a tree

(member 'a '((a b) (a c) (b c)) :key #'car :test #'equal)
;; for member, the predicate would be:
;; (equal 'a (car '(a b)))
;; key only apply to the LST

(member-if #'oddp '(2 3 4)) ;; with an arbitary predicate.
(adjoin 'b '(a b c)) ;; join only when not a member
(union '(a b c) '(b c d))
(intersection '(a b c) '(b c d))
(set-difference '(a b c) '(b c d)) ;;complement, what the first have and the second don't

(length '(1 2 3))
(subseq '(a b c d) 1 2)
(reverse '(a b c d))
(sort (copy-list '( 1 2  3 4  )) #'> ) ;; sort is destructive, so pass a copy to avoid original list being modified
(every #'oddp '(1 2 3))
(some #'oddp '(1 2 3))
(every #'< '(1 2 3) '(2 3 4))

(setf x '(2 3 4))
(push 1 x)
(pop x)
(pushnew 2 x) ;; use adjoin instead of cons, so only new element be pushed

(setf x '((+ . "add") (- . "sub") (1 2 3)))
(assoc '+ x)
(assoc 1 x) ;;assoc take :test and :key too

(defun occurrences (LST)
  "return an alist '((a . 4) (b . 3)) with '((ELT . OCCURANCE)), sorted ascendingly"
  (let ((result '()))
    (dolist (ELT LST)
      (if (member ELT result :key #'car)
          (setf (cdr (assoc ELT result)) (+ 1 (cdr (assoc ELT result))))
          (push (cons ELT 1) result)
          )
      )
    (sort result #'> :key #'cdr)
    )
  )
(occurrences '(b b a d c a b d a a ))

(defun range (max &key (min 0) (step 1))
  (loop for n from min below max by step
        collect n))
(defun pos+ (LST)
  "each element + its position"
  (mapcar #'+ LST (range (length LST)))
  )
(pos+ '(0 0 0 0))

(defun show-dots (LST)
  "print dot notation of LST"
  (show-dots- LST 0)
  )
(defun show-dots- (LST count)
  (if (null LST)
      (format t (concatenate 'string "NIL" (string-of count ")")))
      (progn
        (format t "(~A . " (car LST))
        (show-dots- (cdr LST) (+ count 1))
        ))
  )
(defun string-of (N STR)
  (apply #'concatenate 'string (make-list N :initial-element STR))
  )
(show-dots '(a b c))

(defun new-paths-no-dup (PATH NODE NET)
  "return a list of path dispatched at NODE"
  (if (null PATH)
      nil
      (mapcar #'(lambda (next)
                  (if (member next PATH)
                      nil
                      (cons next PATH)
                      ))
              (cdr (assoc NODE NET))
              ))
  )
(defun longest-finite-path- (PATHS PATHS-DONE NET)
  (if (every #'null PATHS)
      (sort PATHS-DONE #'> :key #'length)
      (longest-finite-path-
       (append (cdr PATHS) (new-paths-no-dup (car PATHS) (car (car PATHS)) NET)) ;; PATHS
       (if (every #'(lambda (next) (member next (car PATHS))) (cdr (assoc (car (car PATHS)) NET)))
           (cons (car PATHS) PATHS-DONE)
           PATHS-DONE
           )
       NET
       ))
  )
(defun longest-finite-path (NET)
  (longest-finite-path- (list (list (car (car NET)))) nil NET)
  )
(longest-finite-path '((a b c) (b c) (c d)))

(setf arr (make-array '(2 3) :initial-element nil))
(setf arr1d (make-array 4 :initial-element nil)) ;; also a vector
(setf vec (vector "a" 'b 3))
(svref vec 0) ;; a faster aref for vec simple vector
(setf (aref arr 0 0) 'b)
;; #2a((b nil nil)) the way to print if *print-array* is t
;; #na n is dimension
;; #("a" B 3) is a vector
(aref arr 0 0)