Programming-Idioms.org

(princ "Hello, world!")

(print "Hello World")

(format T "Hello World")

(loop repeat 10 do (write-line "Hello"))

(defun show (message)
  (format t "Hello: ~a" message)
  (values))

(defun square (x)
  (* x x))

(defstruct point
  (x 0.0d0 :type double-float)
  (y 0.0d0 :type double-float))

(map nil #'something items)

(loop for i from 0 and x across items
      do (format t "~a = ~a~%" i x))

(let ((table (make-hash-table)))
  (setf (gethash 'one table) 1)
  (setf	(gethash 'two table) 2))

(defclass node ()
  ((value 
      :initarg :value :initform nil 
      :accessor node-value)
   (left-child 
      :initarg :left-child :initform nil 
      :accessor node-left-child)
   (right-child 
      :initarg :right-child :initform nil 
      :accessor node-right-child)))

(let ((end (length x)))
 (loop for i from 0 below end
       do (rotatef (aref x i)
                   (aref x (+ i (random (- end i)))))))

(nth (random (length x)) x)

(member x list)

(find x list :test #'equal)

(loop for k being each hash-key of mymap
      for x being each hash-value of mymap                                                                            
      do (format t "~A ~A~%" k x)))

(+ a (random (float (- b a))))

(defun r (a  b)
(+ a (random (+ 1 (- b a )))))

(reverse x)

(defun mysearch (x m)
  (loop for i below (array-dimension m 0)
        do (loop for j below (array-dimension m 1)
                 when (eql x (aref m i j))
                 do (return-from my-search
                                 (values i j)))))

(rotatef a b)

(setf i (parse-integer s))

(defvar *s* "ネコ")

(make-array (list m n)
   :element-type 'double-float
   :initial-element 1.0d0)

(defparameter *x*
  (make-array (list m n p)
              :element-type 'double-float
              :initial-element 0.0d0))

(sort #'< items :key #'p)

(defun f (i)
  (if (< i 2)
    1
    (* i (f (- i 1)))))

(loop
  for (power rem) = (list p 0) then (multiple-value-list (floor power 2))
  for multiple = 1 then (if (zerop rem) multiple (* multiple base))
  for base = x then (* base base)
  when (= power 0) return 1
  when (= power 1) return (* multiple base)))

(defun compose (f g)
  (lambda (x) (g (f x))))

(defun curry (fn &rest args)
  (lambda (&rest remaining-args)
    (apply fn (append args remaining-args))))

(defun add (a b)
  (+ a b))

(funcall (curry add 2) 1) 
  

(setf u (subseq s i j))

(setf ok (search word s))

(reverse s)

(loop named outer
      for i below (array-dimension m 0)
      do (loop for j below (array-dimension m 1)
               for v = (aref m i j)
               when (minusp v)
               do (progn
                    (print v)
                    (return-from outer))))

(defun ins (lst x i)
 (if (zerop i) (cons x lst)
     (cons (car lst) (ins (cdr lst) x (- i 1)))))

(setf s (ins s x i))

(sleep 5)

(setf *t* (subseq s 0 5))

(setf *t* (subseq s (- (length s) 5)))

(setf s "a
b
c
d")

 
(defun words (s)
  (if (equalp s "") nil 
      (let ((p (position #\Space s )))
    (cond ((null p) (list s))
          ((zerop p ) (words (subseq s 1)))
          (T (cons (subseq s 0 p) (words (subseq s (+ 1 p ))))))))) 

(setf chunks (words s))

(loop)

(defun infinite-loop (x)
  (apply x (infinite-loop x)))

(nth-value 1 (gethash k m))

(defvar y (format nil "~{~A~^, ~}" x))

(setf y (format nil "~{~a~^,~}" x))

(setf y (reduce (lambda (a b)
                   (concatenate 'string a ", " b))
                 x))

(reduce #'+ x)

(setf s (princ-to-string i))

(lambda (fn)
  (pdotimes (i 1000)
    (funcall fn i)))

(setf y (remove-if-not p x))

(with-open-file (stream f)
  (uiop:slurp-stream-string stream))

(defvar *lines*
   (with-open-file (stream f)
      (let ((contents (make-string (file-length stream))))
            (read-sequence contents stream)
      :return contents)))

(format *error-output*
        "~a is negative"
        x)

(setf x (expt 3 247))

(let ((x (make-array n :element-type 'bit))))

call random_seed (put=s)

(setf *random-state* (make-random-state t))

(format t "~{~A~^ ~}~%" *args*)

(setf x (lcm a b))

(let ((x #c(-2 3)))
  (* x #c(0 1)))

(loop do (something)
      while c)

(defparameter *y* (float x))

(truncate x)

(defun rnd (y) (floor (+ y 0.5)))

;;; s=str, t=pattern
(defun cnt_substr (str pattern)
  (loop for i from 0 to (- (length str) (length pattern) ) 
    sum (if (equal pattern (subseq str i (+ i (length pattern )))) 1  0 )))

(setf c (logcount i))

(exit)

(with-open-file (out "data.json" :direction :output)
  (yason:encode-plist x out))

(defun control (f)
   (funcall f))

(describe x)

(defvar x (osicat-posix:stat-size (osicat-posix:stat #P"path")))

(defun check-prefix (s prefix)
 (cond ((> (length prefix) (length s)) Nil)
       ( T ( equal prefix (subseq s 0 (length prefix ))))))

(setf b (check-prefix s prefix))

(defun check-suffix (str suf )
  (if (> (length suf) (length str )) nil (equalp (subseq str (- (length str) (length suf)) (length str )) suf )))

(setf b (check-suffix s suffix))

(sort items #'c)

(defvar *s* (string (dex:get u)))

(serapeum:write-stream-into-file
   (dex:get u :want-stream t)
              #P"result.txt"
              :direction :output
              :if-exists :supersede
              :if-does-not-exist :create)

(let ((x (plump:parse #p"data.xml")))
  ...)

(setf blank (not (find #\space s :test-not #'eql)))

(sb-ext:run-program '("a" "b") "/path/to/x")

(setf n (length x))

(setf y (remove-duplicates x))

(remove-duplicates x)

(setf n (read-from-string (remove-if-not #'digit-char-p (read-line))))

(assert (isConsistent))

(time (foo))

(defun foo () (format t "bar") t)

(cond (c1 (f1))
      (c2 (f2))
      (c3 (f3)))

(time (f))

(defparameter *items* (list a b c))

(remove-if (lambda (val) (= val x)) items)

(setf b (every #'digit-char-p s))

(map nil #'print (append items1 items))

(remove-if-not (lambda (i) (<= 0 i 127))
               s
               :key #'char-code)

(read)

(defparameter *s* (string c))

(format nil "~a~d" s i)

(defparameter +planet+ "Earth")

(defun detect-architecture ()
  (let ((arch (machine-type)))
    (cond ((equalp arch "X86-64") (f64))
          ((equalp arch "X86") (f32))
          (t "unknown"))))

(mapcar (lambda (n) (* n c))
        elements)

(setf x (car (last items)))

(setf ab (append a b))

(setf n (length s))

(length s)

(drakma:http-request u :method :post)

(dex:post u)

(lambda (bytes &aux (size (* 2 (length bytes))))
  (let ((hex (make-array size :element-type 'character :fill-pointer 0)))
    (prog1 hex
      (with-output-to-string (o hex)
        (map () (lambda (byte) (format o "~2,'0x" byte)) bytes)))))

(setf b (and (< x1 x x2)
             (< y1 y y2)))

(setf _t (chronicity:parse "tomorrow"))

(defstruct disjoint-set
  elements)

(defun make-disjoint-set (elements) 
  (make-disjoint-set :elements elements))

(defun partition (disjoint-set)
  (loop for element in (disjoint-set-elements disjoint-set) 
       collect 
        (let ((found (find element (mapcar #'first (rest disjoint-set)) 
                    :test #'equal)))
          (if found
              (acons element element found :test #'equal)
              (acons element element nil :test #'equal)))))

(defvar y (mapcar #'T (remove-if-not p x)))

(defun words (str)
  (if (equalp str "") nil 
      (let ((p (position #\Space str )))
    (cond ((null p) (list str))
          ((zerop p ) (words (subseq str 1)))
          (T (cons (subseq str 0 p) (words (subseq str (+ 1 p ))))))))) 

(setf s " aa  bbb  cc1 ")

 (let ((ws (words s )))
   (setf t (car ws))
   (dolist (w (cdr ws ))
     (setf t (concatenate 'string t " " w ))))
 (print t)
 

(let ((*t* (remove-if-not #'digit-char-p *s*)))
	(format t "~A~%" *t*))

(loop for item in items
      when (check-match item) return (do-something item)
      finally (return (do-something-else))

(map '(vector (unsigned-byte 8)) #'logxor a b)

(print a )

(defun plist (lst)
  (if (< (length lst) 20 )  
      (loop for elem in lst do (p elem))
      (let ((l (length lst )))
         (p (nth 0 lst )(nth 1 lst )(nth 2 lst )(nth 3 lst )
         "... (" l " in total)... "
         (nth (- l 4) lst )(nth (- l 3 ) lst )(nth (- l 2 ) lst )(nth (- l 1 ) lst ) )
      )))

(defun p (x &rest others)
  (cond ((listp x)( plist x   ))
        ((stringp x)(format t x  ))
        (T (write x)))
  (format t " ") 
  (if others (p others))

(dotimes (i 6) (print (- 5 i)))

(defvar *x* (format NIL "~2,'0D:~2,'0D:~2,'0D" 12 34 56))

(do ((i 0 (+ i 1 )))( (= i n) s)
  (setf s (concatenate 'string s v)))

(loop for i from 1 to 100
   do (print
       (cond ((zerop (mod i 3))
              (if (zerop (mod i 5)) "FizzBuzz" "Fizz"))
             ((zerop (mod i 5)) "Buzz")
             (t (format nil "~d" i)))))

(let ((b (directory p)))
  (if (null b) t nil))

(defun rmv (elem lst) 
 (if (null lst) nil
   (if (equal elem (car lst)) 
     (cdr lst)
     (cons (car lst) (rmv elem (cdr lst))))) )

(setf x (rmv e x ))

(setf b (not (null (member e x))))

;; comment

(defun fibonacci (n &optional (a 0) (b 1) (acc ()))
  (if (zerop n)
      (nreverse acc)
      (fibonacci (1- n) b (+ a b) (cons a acc))))