Sekwencje

Sekwencja

 ­ grupa typów danych (listy, wektory, tablice, ciągi znaków).

Funkcje działające na sekwencjach:

1. 

Make­sequence

. Ta funkcja tworzy sekwencje o zadanym typie. Typy są takie: list,

array, vector, string. Wywolamy tę funckje:

(make­sequence typ_danych rozmiar)

Przykład: 

(make­sequence ‘list 4). 

Stworzy nam liste z elementami nil. Jeśli chemy

stworzyć listę z zadanymi elementami, powinniśmy dopisać 

:initial­element

 ;

Naprzykład, chcemy stworzyć listę z 4 elementami, które są równe 0:

(make­sequence ‘list 4 :initial­element 0) 

;

2. 

Concatenate

. Ta funkcja łacze dwie sekwencji w jedną.

(concatenate typ_danych sekwencja sekwencja)

Przykład: 

(concatenate 'string "Hello" " " "world")

3.

Elt

. Funkcja zwraca n­element sekwencji.

(elt sekwencja pozycja)

Naprzykład:

(elt '(NIL T 1 6 "cat") 3)

=> 6
Zwróci 6 bo rachujemy 1 element jak 0.

4.

Aref. 

Ta funkcja działa jak elt, no może być zastosowana dla tablic wielomiarowych.

(aref sekwencja pozycja)

Naprzykład: 

(aref (make­array '(10 10) :initial­element  "World") 9 9); 

W tablice

wielomiarowej 10x10 zapisaliśmy każdy element jako string World. I wywolujemy
element 9 9. wynnik: World.

5. 

Subseq

. Ta funkcja wypisuje sekwencje, zaczynającą się od elementu początek a

kończącą się elementem koniec.

(subseq sekwencja początek koniec)

Przykład: 

(subseq "Hello world" 3 5); 

Funkcja wypisze nam 

"lo"

. Możemy nie

zanzaczać koniec, jeśli chcemy wypisać od elementu początek aż do końca
sekwencji.

6. 

Copy­seq

. Ta funkcja zwraca kopie sekwencji

(copy­seq sekwencja)

Przykład: 

(copy­seq "Hello world"). 

W wynniku: “Hello world”).

7. 

Reverse

. Ta funkcja odwraca kolejność elementów w sekwencji.

(reverse sekwencja)

(defun REV (L)

(cond

((n

ll L) nil)

((listp L)

(append

(REV (cdr L))

(list (car L))))

(t

)))

Przykłąd: (reverse ‘(Hello world) ). Wynnik: world Hello.

8. 

Length. 

Zwraca ilość elementów w sekwencji.

(length sekwencja)

Przykład:  

(length '(Hello world)); 

Wynnik: 

2;

 (defun list­length1 (x)
  (do ((n 0 (+ n 2))            ;Counter
       (fast x (cdr(cdr fast)))     ;Fast pointer: leaps by 2
       (slow x (cdr slow)))     ;Slow pointer: leaps by 1
      (nil)
 (when (endp fast) (return n))
    (when (endp (cdr fast)) (return (+ n 1)))
  (when (and (eq fast slow) (> n 0)) (return nil))))

9

. Count

. Zwraca liczbę elementów w sekwencji

(count n sekwencja)

Przykład:

 (count 4 ‘(1 2 3 4 4))

 => 2

 (defun cou

10.

Count­if

. Zwraca liczbę elementów które są zgodne z funkcją

(count­if funkcja sekwenja)

Przykład:

(count­if #’NUMBERP ‘(2 2 1 a))

 => 3

11.

Count­if­not.

 Zwraca liczbę elementów które są nie zgodne z funkcją.

(count­if­not funkcja sekwenja)

Przykład:

(count­if­not #’NUMBERP ‘(2 2 1 a))

 => 1

12.

Remove. 

Ta funkcja usuwa wszystkie wystąpienia danego elementu z sekwencji.

(remove element sekwencja)

Przykład: 

(remove 3 '( 1 2 3 4 5 3)); 

Wynnik (1 2 4 5).

13.

Remove­if. 

Ta funkcja działa jak remove, tylko usuwa wszystkie elementy dla

których podana funkcja zwróci wartość prawdy (t).

(remove­if #'funkcja sekwencja)

Przykład: 

(remove­if #'oddp '(1 2 4 1 3 4 5)); 

Wynnik: (2 4 4);

14.

Remove­if­not. 

Funkcja odwrotna do 

remove­if.

(remove­if­not #'funkcja sekwencja)

Przykład: 

(remove­if­not #'evenp  '(1 2 4 1 3 4 5)); 

Wynnik:(2 4 4);

15.

Substitute

.Funkcja zastępuje każdy element zastąpiony zastępowanym.

(substitute zastąpiony zastępowany sekwencja)

Przykład:

(substitute 0 1 ‘(0 1 1 0)) 

=> (0 0 0 0)

16. 

Substitute­if.

Zastępuje wszystkie wystąpienia elementu zastępowany dla których

funkcja zwróci wartość prawdy.

(substitute­if zastępowany funkcja sekwencja)

Przykład:

(substitute­if 'number #'numberp '(a b 3 d "yo" 4.2 e))

=>(A B NUMBER D "yo" NUMBER E)

17. 

Substitute­if­not. 

Zastępuje wszystkie wystąpienia elementu zastępowany dla

których funkcja zwróci wartość falszu.
Przykład:

(substitute­if 'notnumber #'numberp '(a b 3 d "yo" 4.2 e))

=>(NOTNUMBER NOTNUMBER 3 NOTNUMBER NOTNUMBER 4.2 NOTNUMBER)

18.

Remove­duplicates. 

Funkcja usuwa wszystkie powtarzające się elementy z

sekwencji.

(remove­duplicates sekwecja)

Przykład: 

(remove­duplicates '(1 2 2 3)); 

Wynik: (1 2 3);

19.

Merge. 

Funkcja łączy dwie sekwencje o podanym typie ustalając kolejność za

pomocą funkcji przekazywanej jako czwarty parametr.

Przykład: 

(merge 'list (list 1 2 3)(list 2 3 4) #'>); 

Wynik: (2 3 4 1 2 3);

20.

Position. 

Ta

 

funkcja zwraca pozycje elementu w sekwencj, a jeśli takiego

elementu niema, to zwraca nil.

(position element sekwencja)

Przykład:

(position 'A '( B C A D))

; Wynik: 2;

 

21.

Find. 

Ta funkcja zwraca znaleziony element w sekwencji, a jeśli takiego elementu

niema, to zwraca wartość nil.

(find element sekwencja)

Przykład: 

(find 'a '(b c d f a)); 

Wynik: A;

22. 

Search

.Funkcja zwraca pozycję znalezionego elementa w sekwencji lub

wartość nil.

(search sekwecja1 sekwencja2)

Przykład: (search ‘(1 23) ‘(2 3 5 0 11)) => NIL

23. 

Sort.

Funkcja sortuje sekwencję za pomocą funkcji przekazywanej jako drugi

parametr.

(sort sekwencja #'>)

Przykład: 

(sort ‘(2 4 10 1 0) #’<) 

=>(0 1 2 4 10)

Tablica haszująca
Tablica haszująca lub tablica mieszająca, to struktura dannych, która jest jednym ze
sposobów realizacji tablicy asocjacyjnej. Umożliwia również szybkie porównywanie
dannych. Tablica zawira klucz i argument klucza. Możliwe są takie działania:
1)Stworzenie tablicy. Dla jej stworzenia wykorzysta się make­hach­table
Przykład: (setq table(make­hash­table)),

                (setq a(make­hash­table)),
                gdzie a i table to nazwy tablic;
2)Zapisywanie dannych do tablicy. Dla zapisywania wykorzysta się gethash
Przykłady: (setf(gethash “name” a)’Andrey)=>ANDREY
                  (setf(gethash ‘color a)’gray)=>BROWN.
3) Odczytywanie dannych za pomocą klucza.
Przykłady: (gethash ‘name a)=>Andrey;
                  (gethash ‘color a)=>Gray.
4) Porównywanie tablic. Dla porównia wykarzysta się equalp
Przykłady: (equapl a b).

Tablica asocjatywna składa się z par klucz i wartość.
Dla stworzenia tablicy należy użyć
setq alist
Przykład:
(setq alist ‘((c . 5)));
Dla zwracania par klucza należy użyć assoc
Przykład:
(cdr(assoc ‘c alist));