Wektory
Stworzenie wektorów
Dla stworzenia najprostrzego wektoru potrzebujemy napisać taki kod w kompilatorze:
(vector) ==> ( )
(vector 1) ==> (1)
(vector 1 2) ==> (1 2)
Dalej, dla stworzenia wektorów będziemy wykorzystowywać funkcje MAKE-ARRAY, ona jest więcej ogólna funkcja od VECTOR.
Do tworzenia wektora z przypisaniem wszystkich elementów określonego znaczenia, można użyć argumentu INITIAL-ELEMENT.
Naprzykład: stworzymy wektor, jaki składa się z 5 elementów, którzy równą NIL.
(make-array 5 :initial-element nil) ==> #(NIL NIL NIL NIL NIL)
Dalej stworzymy wektor ze zmiennym rozmiarem. Dla tego urzyjmy argumentu FILL-POINTER.
Naprzykład: stworzymy wektor z miejscem dla 5 elementów, ale wektor będzie wygliądać pusty, ponieważ wskaźnik zapełnienia jest równy zero:
(make-array 5 :fill-pointer 0) ==> #( )
Ale jeżeli potrzebukemy wektoru rozmiar jakiego będzie zwiększać w zależności od tego ile elementów wpisujemy do niego, to musimy wykorzystać argument ADJUSTABLE.
(make-array 5 :fill-pointer 0 :adjustable t) ==> #()
Dodawanie elementów do wektorów
A teraz możemy dodać do naszego 5-cio elementowego, ale pustego wektoru, elementy za pomocą funkcji VECTOR-PUSH.
(defparameter *x* (make-array 5 :fill-pointer 0))
(vector-push 'a *x*) ==> 0
*x* ==> #(A)
(vector-push 'b *x*) ==> 1
*x* ==> #(A B)
(vector-push 'c *x*) ==> 2
*x* ==> #(A B C)
Żeby dodać elementy do wektora z dowolnym rozmirem (ADJUSTABLE) elementy, to musimy wykorzystać funkcje VECTOR-PUSH-EXTEND, jaka pracuje tak samo jak VECTOR-PUSH. \
3. Usunięcie elementów z wektorów
Za pomocą funkcji VECTOR-POP możemy zabrać element z wektoru.
(vector-pop *x*) ==> C
*x* ==> #(A B)
(vector-pop *x*) ==> B
*x* ==> #(A)
(vector-pop *x*) ==> A
*x* ==> #()
Dla usuwania elementu z wektoru, możemy wykorzystać funkcje REMOVE. Wpisujemy kod.
(count 1 #(1 2 1 2 3 4))
(remove 1 #(1 2 1 2 3 4))
(setq z (remove 1 #(1 2 1 2 3 4))) ==> (2 2 3 4)
Wyliczanie podanych elementów w wektorze.
Teraz skorzystamy z funkcji COUNT, jaka może policzyć ilość podanych elementów w całym wektorze.
Naprzykład: (count 1 #(1 2 1 2 3 1 2 3 4)) ==> 3
Wyszukiwanie elementów, za pomocą funkcji FIND.
(find 1 #(2 1 2 3 2 3 4)) ==> 1
(find 10 #(1 2 1 2 3 1 2 3 4)) ==> NIL
Skorzystamy z imennogo parametru KEY, jaki będzie pozwalać nam :
(find ‘a #((a 10) (b 20) (a 30) (b 40)) :key #’first) ==> (A 10)
(find ‘a #((a 10) (b 20) (a 30) (b 40)) :key #’first :from-end t) ==> (A 30)
Funkcja POSITION, jaka wskazuje na pozycje szukanego elementu:
(position 1 #(1 2 1 2 3 1 2 3 4)) ==> 0
Porównywanie elementów.
Dla poruwnania elementów skorzystamy funkcjej COUNT i dodamy do niej argument TEST:
(count "foo" #("foo" "bar" "baz") :test #'string=) ==> 1
TEST wykorzystowują dla poruwnania każdego elementu.
Sortówanie elementów.
Funkcja sortuwania SORT:
(sort (vector "1" "3" "2") #'string<) ==> („1” „2” „3”)
(sort (vector "audi" "nissan" "saab" "jaguar" "ford" "bmw" "toyota" "porshe" "mercedes-benz") #'string<) ==>
#("audi" "bmw" "ford" "jaguar" "mercedes-benz" "nissan" "porshe" "saab" "toyota")
Odwracanie elementów
Funkcja odwracanie REVERSE:
(reverse '(1 2 3 4)) ==> (4 3 2 1)
(reverse '(1 (a b) (c d) 4)) ==> (4 (c d) (a b) 1)
Tablicy
Stworzenie tablicy:
(setq array (make-array '(4 4) :initial-element 2)) ==>
((2 2 2 2) (2 2 2 2)(2 2 2 2)(2 2 2 2))
Aby utworzyć talbicę asocjacyną potrzebno użyć funkcji pairlis.
(setq alist (pairlis '(a b c) '(1 2 3))) ==>
((a . 1) (b . 2) (c . 3))
Sortowanie tablicy:
(defun sort-list (x)
(let ((n (length x))
(m nil)
(r nil))
(dotimes (i n r)
(setq m (apply 'min x))
(setq r (append r (list m)))
(setq x (remove m x)))))
Zamiana element w tablice:
(setf (aref array 1 1) 5) array)
Funkcja odwrocania: REVERSE
(setq a (make-array '(2 2) :initial-element (reverse '(1 2 3 4)))) ==>
#2A(((4 3 2 1) (4 3 2 1)) ((4 3 2 1) (4 3 2 1)))
Usuniencie element z tablicy za pomocą REMOVE:
(setq b (make-array '(2 2) :initial-element (remove 1 '(1 2 3 2 1 1 1)))) ==>
#2A(((2 3 2) (2 3 2)) ((2 3 2) (2 3 2)))
Wuszukiwanie element w asocjacyjnej tablice:
(setq alist '((a . 1) (b . 2) (c . 3)))
(cdr (assoc 'a alist)) ==> 1