1
2
3
4
5
6
7
8
9
int lim = 0x12345678; int pp = 256;
for (int i = 1; (lim-pp) / ((64 + i) + pp) != 0; i++) {
    if (atan(i - ((i / lim) * lim)) > 1.55) // > ~50
        lim = (lim / 50) * 40;
    int foo = lim; // bar
    for (int j = 0; j < 0x123456; j++)
        foo ^= (j >> 3) | (j << 29); // tidy
    pp &= foo; // in 42-0
    if (lim - ((lim / i) * i) == 0) {
 ...

1
2
3
4
5
6
7
8
9
 (funcall (lambda (toi three xexp xx pred)
           (funcall (lambda (x)
                      (map (quote (vector character)) (lambda (i) (funcall (lambda (x) (code-char (+ 48 x))) (ldb (byte (funcall toi (lambda (f) (lambda (x) (funcall f (funcall f (funcall f x)))))) i) x)))
                           (funcall (lambda (x)
                                      (declare (special x))
                                      (funcall (lambda (tf) (funcall (lambda (f) (funcall tf f)) (lambda (f) (funcall tf f))))
                                               (lambda (f)
                                                 (cons (funcall toi x)
                                                       (unless (funcall (funcall x (lambda (x) nil)) t)
 ...

1
2
3
4
5
6
7
8
9
(defun fibonacci-seq 
  ((fn rfib [a b] 
      (cons a (lazy-seq (rfib b (+ a b)))))
    0 1))
 
(defun reduced-fib-seq [a]
  (drop 2 (take (+ 2 a) (fibonacci-seq))))
 
(defun satz-von-zeckendorf [coll]
 ...

1
2
3
4
5
6
7
8
9
(defn fibonacci-seq 
  ((fn rfib [a b] 
      (cons a (lazy-seq (rfib b (+ a b)))))
    0 1))
 
(defn reduced-fib-seq [a]
  (drop 2 (take (+ 2 a) (fibonacci-seq))))
 
(defn satz-von-zeckendorf [coll]
 ...

1
2
3
4
5
6
7
(defun square (x)
   "Berechne das Quadrat von X."
   (declare (fixnum x)    ; Typangabe für ein Argument
            (optimize (speed 3)
                      (debug 0)
                      (safety 1)))
   (the fixnum (* x x)))

1
2
3
4
5
6
7
8
9
(defun fibonacci-seq []
  ((fn rfib [a b] 
      (cons a (lazy-seq (rfib b (+ a b)))))
    0 1))
 
(defun reduced-fib-seq [a]
  (drop 2 (take (+ 2 a) (fibonacci-seq))))
 
(defun satz-von-zeckendorf [coll]
 ...

1
2
3
4
5
6
7
8
9
(defun sentence () (append (noun-phrase) (verb-phrase)))
(defun noun-phrase () (append (article) (noun)))
(defun verb-phrase () (append (verb) (noun-phrase)))
(defun article () (one-of '(the a)))
(defun noun () (one-of '(man ball woman table)))
(defun verb () (one-of '(hit took saw liked)))
 
(defun one-of (set)
  "Pick one element of set and make a list of it."
 ...

1
2
3
(setq a '((1 2 3) (4 5 6) (7 8 9)))
(setq b (map '#(lambda (x) (sum x)) a))
(format t b)

1
2
(setq a '((1 2 3) (4 5 6) (7 8 9)))
(setq b (map '#(lambda (x) (+ x 1)) a)

1
2
3
4
5
6
7
8
9
int lim = 0x12345678; int pp = 256;
for (int i = 1; (lim-pp) / ((64 + i) + pp) != 0; i++) {
    if (atan(i - ((i / lim) * lim)) > 1.55) // > ~50
        lim = (lim / 50) * 40;
    int foo = lim; // bar
    for (int j = 0; j < 0x123456; j++)
        foo ^= (j >> 3) | (j << 29); // tidy
    pp &= foo; // in 42-0
    if (lim - ((lim / i) * i) == 0) {
 ...

1
2
3
4
5
6
7
8
9
(defn fibonacci-seq []
  ((fn rfib [a b] 
      (cons a (lazy-seq (rfib b (+ a b)))))
    0 1))
 
(defn reduced-fib-seq [a]
  (drop 2 (take (+ 2 a) (fibonacci-seq))))
 
(defn satz-von-zeckendorf [coll]
 ...

1
2
3
4
5
6
7
8
9
(defn fibonacci-seq []
  ((fn rfib [a b] 
      (cons a (lazy-seq (rfib b (+ a b)))))
    0 1))
 
(defn reduced-fib-seq [a]
  (drop 2 (take (+ 2 a) (fibonacci-seq))))
 
(defn satz-von-zeckendorf [coll]
 ...

1
2
3
4
5
6
7
8
9
(defn fibonacci-seq []
  ((fn rfib [a b] 
      (cons a (lazy-seq (rfib b (+ a b)))))
    0 1))
 
(defn reduced-fib-seq [a]
  (drop 2 (take (+ 2 a) (fibonacci-seq))))
 
(defn satz-von-zeckendorf [coll]
 ...

1
2
3
4
(dotimes (x 10)
  (dotimes (y 10)
    (format t "~3d " (* (1+ x) (1+ y))))
  (format t "~%"))

1
2
3
4
(dotimes (x 10)
  (dotimes (y 10)
    (format t "~3d " (* (1+ x) (1+ y))))
  (format t "~%"))

1
(print (format nil "~R" 311))

1
(format nil "~R" 311)

1
2
3
4
5
6
7
8
9
(defconst GENMAX   13)
(defconst OPWORDS  '((+ plus) (- minus) (* times) (/ divide)))
(defconst NUMWORDS '(zero one two three four five six seven eight nine ten eleven twelve thirteen ))
 
(defun math-words-equal (a b)
  (equal (sorted-explode (equation-to-mathwords a))
         (sorted-explode (equation-to-mathwords b))))
 
(defun numword (n) (symbol-name (nth n NUMWORDS)))
 ...

1
2
3
(if ()
  'stuff
  'no-stuff)

1
2
3
4
5
6
7
8
(define (margreteborg row col)
(cond ((< row col) #f)
((or (= 0 col) (= row col)) 1)
(else (+ (margreteborg (- row 1) col) (margreteborg (- row 1) (- col 1))))))
 
N (margreteborg 2 2)+(margreteborg 3 2)+(margreteborg 11 2)
(margreteborg 6 3)+(margreteborg 3 2)
.(margreteborg 12 5)- (margreteborg 5 3)
 ...

1
(cond (nil (format t "hello")))

1
(cond ((= 42 41) (format t "hello"))

1
2
3
4
5
6
7
8
9
(setq a 18)
(setq b 64)
(setq c 22)
(setq y 22)
(defun g (m n)
  (if (> m n)
    m
    n))
(print (+(+ a b)(*(+(g a c)(+(g a b)(*(+(+(* b c)a)c)c)c)c)1124000727777607680000)))

1
2
3
4
5
6
7
8
9
(setq a 18)
(setq b 64)
(setq c 22)
(setq y 22)
(defun g (m n)
  (if (> m n)
    m
    n))
(+(+ a b)(*(+(g a c)(+(g a b)(*(+(+(* b c)a)c)c)c)c)1124000727777607680000))

1
2
3
4
5
6
7
8
9
(setq a 18)
(setq b 64)
(setq c 22)
(setq y 22)
(defun g (m n)
  (if (> m n)
    m
    n))
(+(+ a b)(*(+(g a c)(+(g a b)(*(+(+(* b c)a)c)c)c)c)(f y)))

1
2
3
(atom t)
(atom t t)
(atom nil)

1
2
(atom t)
(atom t t)

1
2
3
4
5
6
7
8
9
(defun rotate-polygon (angle points)                                                                              
  (mapcar #'(lambda (xy)                                                                                          
              (destructuring-bind (x . y) xy                                                                      
                (cons (+ (* (cos angle) x)                                                                        
                         (* (- (sin angle)) y))                                                                   
                      (+ (* (sin angle) x)                                                                        
                         (* (cos angle) y)))))                                                                    
          points))                                                                                                
                                                                                                                  
 ...

1
2
3
4
5
6
7
8
9
(defun rotate-polygon (angle points)                                                                              
  (mapcar #'(lambda (xy)                                                                                          
              (destructuring-bind (x . y) xy                                                                      
                (cons (+ (* (cos angle) x)                                                                        
                         (* (- (sin angle)) y))                                                                   
                      (+ (* (sin angle) x)                                                                        
                         (* (cos angle) y)))))                                                                    
          points))                                                                                                
                                                                                                                  
 ...

1
2
3
4
5
6
7
 
(defun fu (x y)
(loop
(when (or (= x 0) (= y 0)) (return (+ x y)))
(if (> x y) (setq x (mod x y)) (setq y (mod y x)))
))