(defun build-straights-matrice (n)
"Declaring variables"
(setq temp '())
(setq horizontal '())
(setq vertical '())
(setq diagonal '())
(setq master '())
"For building the horizontal set."
(loop for i from 1 to (* n n)
do (if (not (eq (mod i n) 0))
(setq temp (append temp (list i)))
(progn
(setq temp (append temp (list i)))
(setq horizontal (append horizontal (list temp)))
(setq temp ()))))
"For building the vertical set."
(loop for i from 1 to n
do (loop for j in horizontal
do (setq temp (append temp (list (nth (1- i) j)))))
(setq vertical (append vertical (list temp)))
(setq temp ()))
"For building the left diagonal."
(setq temp-counter 0)
(loop for j in horizontal
do (setq temp (append temp (list (nth temp-counter j))))
(setq temp-counter (1+ temp-counter)))
(setq diagonal (append diagonal (list temp)))
(setq temp ())
"For building the right diagonal."
(setq temp-counter (- n 1))
(loop for j in horizontal
do (setq temp (append temp (list (nth temp-counter j))))
(setq temp-counter (1- temp-counter)))
(setq diagonal (append diagonal (list temp)))
"Merging all..."
(setq master (append (append master horizontal) (append (append master vertical) (append master diagonal)))))
;(print "mapping tests")
;; Helper that given a 2 length string, it will determine
;; if the (car L) is smaller than the value
;(defun map-help (L val)
; (cond
; ((< (car L) val) (car (cdr L)))
; )
;)
;(defun mapping (L val)
; (cond
; ((null l) nil)
; ((null (map-help (car L) val)) (mapping (cdr L) val))
; (T (cons (map-help (car L) val) (mapping (cdr L) val)))
; )
;)
;(print (mapping `((3 hello) (1 there)) 5))
;(print (mapping `((3 hello) (5 notme) (1 there)) 5))
;(print (mapping `((35 kim) (67 clinton) (45 emma)) 40))
;(print (mapping `((24 a) (15 b) (56 c) (19 d)) 26))
;(print (mapping `((90 a) (80 b) (70 c)) 40))
(defun pattern-helper(L1 L2)
(cond
((null (cdr L1)) (eq (car L1) (car L2))))
((eq (car L1) (car L2)) (pattern-helper (cdr L1) (cdr L2)))
)
)
(write-line "Hello World")
(defun fibonacci (n)
(if (< n 3)
1
(+ (fibonacci (- n 1)) (fibonacci (- n 2))) ) )
;(princ "Enter Number: ")
;(setq num (read))
(loop for i from 1 to 20
do (format t "~D, " (fibonacci i)))
;(setq a '(a b c))
;(print a)
(defun endcons (A L)
(cond
((null L) (cons A nil))
(T(cons (car L) (endcons A (cdr L))))
)
)
(defun my-length(L)(cond
((null L) 0)
(T(+ 1(my-length(cdr L))))
)
)
(defun my-memq(_symbol _list)(cond
((null _list) nil)
((eq _symbol (car _list)) _list)
(T (my-memq _symbol (cdr _list)))
)
)
;(defun my-append(_list1 _list2)(cond
; ((null _list2) _list1)
; ;(T (my-append (reverse (cons (car _list2) (reverse _list1))) (cdr _list2)))
; ;(T (my-append (endcons (car _list2) _list1) (cdr _list2)))
; ;(T (my-append (cons (car _list2) _list1) (cdr _list2)))
; (T (my-append (cons _list1 _list2) nil))
; )
;)
(defun my-append(L1 L2)(cond
((null L2) L1)
((null L1) L2)
((Listp L1) (cons (car L1) (my-append (cdr L1) L2)))
((Listp L2) (cons (car L1) (my-append L1 (cdr L2))))
;(T (my-append (cdr L1) (cdr L2)))
)
)
(defun my-attach(O L)
(cond
((null L) (cons O nil))
(T(cons (car L) (my-attach O (cdr L))))
)
)
(defun my-assoc(A L)(cond
((null L) nil)
((eq A (car (car L))) (car L))
(T (my-assoc A (cdr L)))
)
)
;(defun freq(A L)(cond
; ((null L) 0)
; ;((and (atom L) ) 1)
; (T(+ (freq A (car L)) (freq A (cdr L))))
; )
;)
(defun freq(A L)
(cond
((null L) 0)
((Atom L)
(cond
((eq A L) 1)
(T 0)
)
)
(T(+ (freq A (car L)) (freq A (cdr L))))
)
)
(defun mapping(L val)
(cond
((null L) nil)
((> val (car (car L))) (cons (car (cdr (car L))) (mapping (cdr L) val)) )
(T(mapping (cdr L) val))
)
)
;(defun my-last(A L)
; (cond
; ((null L) nil)
; ;((eq A (car L)) (cons A (my-last A (cdr L))))
; ((eq A (car L)) (cons nil (cons A (my-last A (cdr L)))))
; ;;((eq A (car L)) (cons A (my-last A (cdr L))))
; ;(T(cons (car L) (cdr L)))
; (T(cons (car L) (my-last A (cdr L))))
; ;;(T(my-last A (cdr L)))
; )
;)
;(defun my-last(A L)
; (cond
; ((null L) nil)
; ;((eq A (car (my-reverse L))) (cons(car (my-reverse L)) nil))
; ;((eq A (car (my-reverse L))) (cons(car (my-reverse L)) (my-last A nil)))
; ;(T(cons(car (my-reverse L)) (cdr (my-reverse L))))
; ((eq A (car (my-reverse L)))(cons(car (my-reverse L)) (cdr (my-reverse L))))
; (T (my-last A (reverse (cdr (reverse L)))))
; )
;)
;(defun my-last(A L)
; (cond
; ((null L) nil)
; ((eq A (car (my-reverse L))) nil)
; (T (cons (car (my-reverse L)) (my-last A (my-reverse (cdr (my-reverse L))))))
; )
;)
;(defun my-last(A L)
; (cond
; ((null L) nil)
; ;((eq A (car (my-reverse L))) A)
; ;(T (cons (my-last A (my-reverse (cdr (my-reverse L)))) (car (my-reverse L))))
; ((eq A (car (my-reverse L))) (my-attach A nil) )
; (T (my-append (my-last A (my-reverse (cdr (my-reverse L)))) (my-attach(car (my-reverse L)) nil)))
; )
;)
;(defun my-last(A L)
; (cond
; ((eq A (car (my-reverse L)))(cons(car (my-reverse L)) (cdr (my-reverse L))))
; (T (my-last A (reverse (cdr (reverse L)))))
; )
;)
;(defun my-last(A L)
; javascript:void(0) (cond
; ((null L) nil)
; ;((eq A (car (my-reverse L))) A)
; ;(T (cons (my-last A (my-reverse (cdr (my-reverse L)))) (car (my-reverse L))))
; ((eq A (car (my-reverse L))) (my-attach A nil) )
; (T (my-append (my-last A (my-reverse (cdr (my-reverse L)))) (my-attach(car (my-reverse L)) nil)))
; )
;)
(defun my-last-helper-two(A L)
(cond
((null L) nil)
((eq A (car L)) (my-last A (cdr L)))
(T(my-last A L))
)
)
(defun my-last-two(A L)
(cond
((null L) nil)
((null (my-memq A L)) nil)
((null (my-memq A (cdr L))) L)
(T(my-last-two A (cdr L)))
)
)
(defun my-last-three(A L)
(cond
;((eq L (my-last-helper-two A L)) nil)
;((equal L (my-last-helper-two A L)) nil)
((eq (my-length L) (my-length (my-last-helper-two A L))) nil)
(T(my-last-helper-two A L))
)
)
(defun my-last-helper(A L)
(cond
((null L) nil)
;((eq A (car L)) (cdr L) )
;((eq A (car L)) (cdr L))
((eq A (car L)) (cdr L))
;(T(my-last-helper A (cdr L)))
(T(my-last-helper A (cdr L)))
)
)
(defun my-last(A L)
(cond
((null L) nil)
((eq A (car (my-reverse L))) (my-attach A nil) )
(T (my-append (my-last A (my-reverse (cdr (my-reverse L)))) (my-attach(car (my-reverse L)) nil)))
)
)
(defun my-reverse(L)
(cond
((null L) nil)
(T(my-append (my-reverse (cdr L)) (my-attach (car L) nil) ))
;((Atom L) L)
;(T(my-append (my-reverse (cdr L)) (List (car L)) ))
;(T(cons (my-reverse (cdr L)) (car L) ))
;(T(my-append (my-reverse (cdr L)) ('(car L)) ))
)
)
;(defun my-last-two(A L)
; (cond
; ((null L) nil)
;((null (my-last-helper A L)) (cons A L))
;((null (my-last-helper A L)) L)
;((null (my-last-helper A L)) nil)
;((null (cdr (my-last-helper A L))) A)
; ((null (my-last-helper A L)) (cons A L))
;(T(my-last-two A (my-last-helper A L)))
; (T(my-last-two A (my-last-helper A L)))
; )
;)
;(print (my-last-two 'g '(a b c a b c a b c d e f g)))
;(print (my-last-two 'f '(a b c a b c a b c d e f g)));
;(print (my-last-two 'h '(a b c a b c a b c d e f g)))
;(print (my-last-two 'a '(a b c a b c a b c d e f g)))
;(print (my-last-two 'b '(a b c a b c a b c d e f g)))
;(print (my-last-helper 'g '(a b c a b c a b c d e f g)))
;(print (my-last-helper 'c (my-last-helper 'c '(a b c a b c a b c d e f g))))
;(print (my-last-helper 'a (my-last-helper 'a '(a b c a b c a b c d e f g))))
;(print(my-memq 'a (my-memq 'a '(a b c a b c a b c d e f g))))
(print (my-last-two 'a '(a b c a b c a b c d e f g)))
(print (my-last-two 'b '(a b c a b c a b c d e f g)))
(print (my-last-two 'c '(a b c a b c a b c d e f g)))
(print (my-last-two 'g '(a b c a b c a b c d e f g)))
(print (my-last-two 'h '(a b c a b c a b c d e f g)))
(defun is-pattern?(pat str)
(cond
((null pat) nil)
((null str) nil)
;((eq (car pat) (car str)) (car pat))
;((eq (car pat) (car str)) (cons (car pat) (is-pattern? (cdr pat) (cdr str)) ))
;(T((cons is-pattern? (cdr pat) (cdr str))))
((eq (car pat) (car str))
(cond
((null (cdr pat)) str)
(T(cons (car pat) (is-pattern? (cdr pat) (cdr str))))
)
)
(T(is-pattern? pat (cdr str)))
)
)
(defun first-atom(L)
(cond
((null L) nil)
((Atom L) L)
((Listp L) (first-atom (car L)))
)
)
;(defun find-all(A L)
; (cond
; ((null L) nil)
; ((eq A (car L)) (cons (car (cdr L)) (find-all A (cdr L))) )
; (T(find-all A (cdr L)))
; )
;)
(defun find-all(A L)
(cond
((null L) nil)
(T )
)
)
;(cond
; ((null L) 0)
; ((Atom L)
; (cond
; ((eq A L) 1)
; (T 0)
; )
; )
; (T(+ (freq A (car L)) (freq A (cdr L))))
;)
;(print (my-length a))
(print (my-last-helper 'b '(a b c a b c a b c d e f g)))
(print (endcons 'a '(b c d)))
(print (my-memq 'a'(a b c)))
(print (my-append '(a b c) '(d e f)))
(print (my-append '(a b c) '()))
(print (my-append '() '(d e f)))
(print (my-append '(a b c) '(d e f g)))
(print (my-append '(a b c d) '(e f g)))
(print (my-attach 'a'()))
(print (my-attach 'd '(a b c)))
(print (my-attach '(a) '(b c)))
(print (my-assoc 'a nil) )
(print (my-assoc 'a '((a . b)(c e f)(b))))
(print (my-assoc 'c '((a . b)(c e f)(b))))
(print (my-assoc 'b '((a . b)(c e f)(b))))
(print (my-assoc 'f '((a . b)(c e f)(b))))
(print (my-assoc 'f '(()()())))
(print (freq 'c '((a c) c e)))
(print (freq 'f '(((s) o ) d)))
(print (freq 'f '(((f) f) f f)))
(print (freq 'f '(((f) f) f (()()()(()(()()((()(f))))())(f)(((f)))(f)) f)))
(print (mapping '((35 kim) (67 clinton) (45 emma)) 40))
(print (mapping '((35 kim) (30 chi) (67 clinton) (45 emma)) 40))
(print (mapping '((35 kim) (30 chi) (67 clinton) (45 emma) (20 ma) ) 40))
(print (my-last 'a '(a b c a b c a b c d e f g)))
(print (my-last 'b '(a b c a b c a b c d e f g)))
(print (my-last 'c '(a b c a b c a b c d e f g)))
(print (my-last 'g '(a b c a b c a b c d e f g)))
(print (my-last 'h '(a b c a b c a b c d e f g)))
(print (my-reverse nil))
(print (my-reverse '(a)))
(print (my-reverse '(1 2 3 4 5)))
(print (my-reverse '((1 2 3) 4 ((5 6)))))
(print (is-pattern? '(a b s) '(c d b a s)))
(print (is-pattern? '(c a c) '(b a j a c a c t u s)))
(print (is-pattern? nil '(a n y l i s t)))
(print (is-pattern? '(l i s p) nil))
(print (first-atom nil))
(print (first-atom '((2 (1) 4) 6)))
(print (first-atom '((((s)) o ))))
(print (first-atom '(1 (((2)) 3 4))))
(print (find-all 'a nil))
(print (find-all 'a '(b a c a e)))
(print (find-all 'a '(b d c e)))
(print (find-all 'a '(b (a a) c)))
(print (find-all 'a '((b a) ((c a b)))))
;(setq a '((a . b)(c e f)(b)))
;(print (car (car a)))
;(print (car (car (cdr a))))
;(print (car '(((f) f) f f)))
;(print (car (car '(((f) f) f f))))
(defun subhelp(pat str)
;Checks pattern to be an atom. If it is, check the pattern against the first character in the string.
(cond ((atom pat) (eq pat (car str)))
;else, if the cdr of the pattern is null (last letter of pattern), then check the letter against the
;string.
((null (cdr pat)) (eq (car pat) (car str)))
;else, recursively call subhelp on each letter of pattern to the string respectively.
(T (and (subhelp (car pat) str) (subhelp (cdr pat) (cdr str))))))
;((subhelp (car pat) str)
; (cond
; ((subhelp (cdr pat) (cdr str)))
; )
;)
;)
;)
(defun is-pattern?-helper(pat str)
(cond
((Atom pat) (eq pat (car str)))
((null (cdr pat)) (eq (car pat) (car str)))
((is-pattern?-helper (car pat) str)
(cond
((is-pattern?-helper (cdr pat) (cdr str)))
)
)
)
)
(defun is-pattern?(pat str)
(cond
((null (car str)) nil)
((is-pattern?-helper pat str) str)
(T (is-pattern? pat (cdr str)))
)
)
(print (is-pattern? '(a b s) '(c d b a s)))
(print (is-pattern? '(c a c) '(b a j a c a c t u s)))
(print (is-pattern? nil '(a n y l i s t)))
(print (is-pattern? '(l i s p) nil))
(defun find-all-helper (L)
;Check if L is an atom.
(cond
((Atom (car L)) (cdr L))
;If L is not an atom, check to see if L is a one element list. If so return cdr of L.
((Null (find-all-helper (car L))) (cdr L))
;Else recursively call the function to the first car and cons with the cdr.
(T (cons (find-all-helper (car L)) (cdr L)))
)
)
(defun find-all (A L)
;checks if list is empty
(cond
((Null L) nil)
;checks if A is the same as first atom, if so, cons the first atom of the rest of the list to a
;recursive call to the rest of the list.
((eq A (first-atom L)) (cons (first-atom (find-all-helper L)) (find-all A (find-all-helper L))))
;Else just check the rest of the list.
(T (find-all A (find-all-helper L)))
)
)
(print (find-all 'a nil))
(print (find-all 'a '(b a c a e)))
(print (find-all 'a '(b d c e)))
(print (find-all 'a '(b (a a) c)))
(print (find-all 'a '((b a) ((c a b)))))
(defun my-length(x)
(cond ((null x) 0)
(t (+ 1 (my-length(cdr x))))
)
)
(print (my-length '(A B C)))
(defun my-memq(a x)
(cond ((null x) nil)
((eq a (car x)) (cdr x))
(t (my-memq(a (cdr x))))
)
)
(print (my-memq 'a nil))
(defun my-append(l1 l2)
(if (null l1)
l2
(cons (car l1) (my-append (cdr l1) l2))
)
)
(print (my-append '(a b c) '(d e f)))
(defun my-attach(o l)
(push o (cdr (last l)))
l
)
(print (my-attach '(d) '(a b c)))
(defun my-assoc(x l)
(cond ((null l) nil)
((eq x (car(car l))) (car l))
(t (my-assoc x (cdr l)))
)
)
(print (my-assoc 'a '((a . b)(c e f)(b))))
(print (my-assoc 'c '((a . b)(c e f)(b))))
(defun freq(a l)
(cond ((null l) 0)
((listp (car l)) (+ (freq a (car l)) (freq a (cdr l))))
((eq a (car l)) (+ 1 (freq a (cdr l))))
(t (freq a (cdr l)))
)
)
(print (freq 'c '((a c) c e)))
(defun mapping(l val)
(cond ((null l) nil)
((> val (car(car l))) (cons (car (cdr (car l))) (mapping (cdr l) val)))
(t (mapping (cdr l) val))
)
)
(print (mapping '((35 kim) (67 clinton) (45 emma)) 40) )
(defun check-last(a l)
(cond ((null l) nil)
((eq a (car l)) t)
(t (check-last a (cdr l)))
)
)
(defun my-last(a l)
(cond ((null l) nil)
((and (eq a (car l)) (null (check-last a (cdr l)))) l)
(t (my-last a (cdr l)))
)
)
(print (my-last 'a '(a b c a b c a b c d e f g)) )
(defun my-reverse(l)
(cond ((null l) nil)
((null (cdr l)) l)
(t (my-attach (car l) (my-reverse (cdr l))))
)
)
(print (my-reverse '((1 2 3) 4 ((5 6)))) )
(defun check-substr(l1 l2)
(cond ((null l1) l2)
((eq (car l1) (car l2)) (check-substr (cdr l1) (cdr l2)))
(t (check-substr l1 (cdr l2)))
)
)
(defun is-pattern?(pat str)
(cond ((null pat) nil)
((null str) nil)
(t (my-append pat (check-substr pat str)))
)
)
(print (is-pattern? '(c a c) '(b a j a c a c t u s)))
(defun first-atom(l)
(cond ((null l) nil)
((atom (car l)) (car l))
(t (first-atom (car l)))
)
)
(print (first-atom '((((s)) o ))))
(print (last '(a b c)))
(defun get-last(a l)
(eq a (car (last l)))
)
(defun get-next(a l)
(cond ((null l) nil)
; ((eq a (car l)) (cons (car (cdr l)) (get-next a (cdr l))))
((eq a (car l)) (car (cdr l)))
(t (get-next a (cdr l)))
)
)
(defun get-first(l)
(cond ((listp (car l)) (get-first (car l)))
(t (car l))
)
)
(print (get-first '(((b a)) ((c a b)))))
(print (get-next 'a '(b a c a e)))
(defun append-three(l1 l2 a)
(my-attach a l1)
(my-append l1 l2)
)
(print (append-three '(a) '(b c) 'd))
(defun find-all-temp(a l)
(cond ((null l) nil)
((and (listp (car l)) (get-last a (car l))) (append-three (find-all-temp a (car l)) (find-all-temp a (cdr l)) (first-atom (cdr l))))
((and (listp (car l)) (null (get-last a (car l)))) (cons (find-all-temp a (car l)) (find-all-temp a (cdr l))))
((eq a (car l)) (cons (get-next a l) (find-all-temp a (cdr l))))
(t (find-all-temp a (cdr l)))
)
)
(defun st (l)
(cond ((null l) nil)
((atom l) (list l))
(t (loop for a in l appending (st a))))
)
(defun find-all(a l)
(st (find-all-temp a l))
)
(print (find-all 'a '((b a) c a e)))
(print (find-all 'a '((b a) ((c a b)))))
; Explanation: A macro is not a function. According to https://wiki.c2.com/?LispMacro ; "x[Lisp macros] are a way to transform Lisp code. During a macroexpansion phase, ; the Lisp expression will be passed to the macro function. The macro function ; can do arbitrary computation at macroexpansion time. The result of this call ; has to be again Lisp code. This Lisp code then is what the interpreter or ; compiler sees and executes or compiles." ; ; The original macro - "setTo10" does nothing of the sort. It actually does more like: ; 1. recieve the symbol 'x' ; 2. do nothing with it ; 3. assign '10' to the local variable named num ; 4. print out the value of that local variable ; ; After it is complete, x still equals 25. ; ; Our goal in class was to, instead, increment the number. The macro "plusOne" does this ; 1. recieve the symbol x, x is filled in for num below ; 2. create the command (setq num (+ 1 num)) EXCEPT - x is substituted for num ; 3. evaluate (now we have run: (setq x(+ 1 x)) which is what we wanted ) ; ; Also there's a builtin called incf which does the same thing. (defmacro setTo10(num) (setq num 10)(format t "Inside setTo10 num = ~D~%" num)) (defmacro plusOne (num) `(setq ,num (+ 1 ,num))) (defvar x 25) (format t "After assignment: x = ~D~%" x) (setTo10 x) (format t "After setTo10: x = ~D~%" x) (plusOne x) (format t "After plusOne: x = ~D~%" x) (incf x) (format t "After incf: x = ~D~%" x)
; Explanation: A macro is not a function. According to https://wiki.c2.com/?LispMacro ; "x[Lisp macros] are a way to transform Lisp code. During a macroexpansion phase, ; the Lisp expression will be passed to the macro function. The macro function ; can do arbitrary computation at macroexpansion time. The result of this call ; has to be again Lisp code. This Lisp code then is what the interpreter or ; compiler sees and executes or compiles." ; In this case, we call the function "setTo10" (misnamed now) with "x" ; x is not 25, x is the symbol which points to 25 ; So in order to use 25, the option used here is to use 'symbol-value' to ask: ; "What is the value of the symbol x?" which is 25. ; Note though that this doesn't actually point x to a different value - after the ; macro call, x is still 25. (This is true of the original "setTo10" macro too) (defmacro setTo10 (num) (setq num (+ 1 (symbol-value num))) (print num) ) (setq x 20) (print x) (setTo10 x)
We use cookies to provide and improve our services. By using our site, you consent to our Cookies Policy. Accept Learn more
