Compresia fara pierdere de calitate

Report
UNIVERSITY POLITEHNICA of BUCHAREST
DEPARTMENT OF COMPUTER SCIENCE
Conf. Dr. Ing. Costin-Anton Boiangiu
<[email protected]>
Introducere
 Pana acuma am considerat ca toate simbolurile de intrare sunt
independente
 Acest lucru nu este adevarat pentru cele mai uzuale tipuri de date
 Ex: text, imagini, cod
 Ideea de baza
 Se vor identifica pattern-urile (modelelr) simbolurilor
 Se for codifica aceste modele mai eficient
 Restul de simboluri vor fi codificate folosind un algoritmul de baza (mai
putin eficient)
 In cele mai multe cazuri se va obtine o performanta mult mai buna
 Nota
 Aceasta tehnica poate fi folosite in cazul tipurilor de date precum textul
 Evident, nu va avea succes in cadrul datelor (aproape) intamplatoare -
random
2
Codificarea bazata pe diagrame
 Dictionar
 Toate literele din alfabet +
 Cat mai multe diagrame (perechi de litere)
 Exemplu:
 Marimea dictionarului = 256 intrari
 Alfabet: caracterele ASCII printabile = 95
 Digrame: cele mai comune 161 de perechi de caractere
 Alt examplu: A = {a, b, c, d, r},
 Dictionar:
3
Exemplu
Input: abracadabra
Output: 101
4
Exemplu
Input: --racadabra
X
Output: 101
5
Exemplu
Input: --racadabra
Output: 101100
6
Exemplu
Input: ---acadabra
Output: 101100110
7
Exemplu
Input: -----adadabra
Output: 101100110111
8
Exemplu
Input: -------abra
Output: 101100110111101
9
Exemplu
Input: ---------ra
X
Output: 101100110111101
10
Exemplu
Input: ---------ra
Output: 101100110111101100
11
Exemplu
Input: ----------a
Output: 101100110111101100000
12
Problema: Care diagrame?
Sursa #1: Capitol dintr-o carte (LaTeX)
13
Sursa #2: Cod C
Scurt istoric
 Mai 1977: apare lucrarea (Ziv and Lempel, 1997)
 Desi articolul este intens matematizat, tehnica generala de lucru
este de a considera siruri de caractere care se repata si de a le
inlocui cu un numar a carui reprezentare sa fie mai mica decat cea
a sirului original
 Multe instrumente software de compresie se bazeaza pe acest
algoritm: ZIP, ZOO, ARC, gzip, LhA, CAB, Arj, RAR
 Acest algoritm este denumit LZ77 si nu este foarte raspandit din
cauza dificultatilor de implementare
 Septembrie 1978: apare lucrarea (Ziv and Lempel, 1998)
 Tehnica este deosebita de LZ77 in sensul ca se mentine un
dictionar de siruri in loc de considerarea unei ferestre
 Algoritmul este foarte popular
 Algoritmul se numeste LZ78
Scurt istoric
 20 Iunie 1983: Terry Welch scrie o versiune a lui LZ78
bazandu-se pe simplificari substantiale si un management
mai bun al dictionarului
 Algoritmul se numeste LZW, dupa numele inventatorilor
sai, Lempel-Ziv-Welch
 5 Iulie 1984: Apare UNIX compress, dupa publicarea
articolului lui Welch
 15 Junie 1987: Apare formatul grafic numit GIF
(Graphics Interchange Format), care foloseste pentru
compresie algoritmul LZW
Ideea compresiei bazate pe dictionar
 Aceste metode constau dintr-o serie de reguli de identificare a




unor grupuri de simboluri si gruparea/depunerea lor intr-un
dictionar care se asociaza sursei de informatie
Daca se intalneste un anumit grup de simboluri, se creaza un
indicator (pointer) corespunzator locului ocupat de respectivul
grup in dictionar
Cu cat se intalneste mai des un anumit grup de simboluri, cu
atat este mai mare raportul de compresie
Aceste metode codeaza siruri de simboluri de lungime variabila
cu semne individuale, fiecare semn reprezentand un indicator
(index) intr-un dictionar
Compresia se obtine atunci cand noile semne sunt de lungime
mai mica
Exemplu
 Fie conventia reprezentarii unui cuvant dintr-o carte prin doua
atribute:
(Numarul paginii) / (numarul cuvantului din pagina)
 Atunci, mesajul „Titlul acestui capitol este compresia datelor” poate
fi inlocuit prin
500/3 1/5
10/2
15/9
10/6
12/1
 Cuvantul „Titlul” este inlocuit prin 500/3, ceea ce reprezinta al treilea
cuvant din pagina 500. Cuvantul „compresia” este al 6 cuvant din
pagina 10
Ideea compresiei bazate pe dictionar
 Marimea mesajului comprimat depinde de marimea dictionarului, deci de
numarul de pagini si de numarul de inregistrari pe pagina
 Daca aceste doua marimi se noteaza cu NP (numarul de pagini) si
NR(numarul de inregistrari pe pagina) atunci numarul de biti pentru
reprezentarea (codarea) unui cuvant din dictionar este
[log2(NP)] + [log2(NR)],
unde parantezele drepte arata rotunjurea la cel mai apropiat intreg
 Intrucat trebuie considerat si marimea mesajului de la intrare, exprimat prin
numarul de simboluri, NS, rezulta un raport de compresie:
RC( biti ) 
8  NS
8

log( NP )  log( NR ) NS log( NP )  log( NR )
Exemplu numeric
 Daca dictionarul contine 2200 pagini, sunt necesari log2(2200) = 11.03 => 12 biti
pentru a coda numarul paginii, iar daca fiecare pagina contine cuvinte de lungime
256 sunt necesari un numar de :
log2(256) = 8 biti
pentru codarea fiecarui cuvant
 Ca urmare, un cuvant oarecare din dictionar este codat pe
20 (=11+8) biti sau 2.5 => 3 octeti
 Mesajul comprimat va avea lungimea
20 biti * 6 cuvinte = 120 biti /18 octeti
 In reprezentarea ASCII, cele 6 cuvinte necesita un total de
(6+7+7+4+9+7) = 40 * 8 = 320 biti
deci 40 octeti
 Raportul de compresie este
320 biti
RC ( biti ) 
 2.66
120 biti
40octeti
RC ( octeti ) 
 2.22
18octeti
Dictionare
 Dictionarele pot fi
 statice
 adaptive
 Un dictionar static este construit si transmis odata cu textul comprimat si
este folosit ca referintele citate intr-o lucrare stiintifica
 Un dictionar static este construit inaintea efectuariii compresiei si ramane
neschimbat pe toata durata acesteia
 Dictionarul static are avantajul ca poate fi „ales” („acordat”) in vederea
codarii, inregistrarile care apar cu cea mai mare frecventa putand fi codate
cu numarul cel mai mic de biti, in conformitate cu regulile de codare
enrtropica
 Dezavantajul folosirii unui dictionar static apare la compresia fisierelor
mici, cand, din cauza transmisiei/memorarii atat a dictionarului cat si a
fisierului comprimat, raportul de compresie nu este foarte bun, de multe ori
chiar subunitar
 De aceea, cei mai raspanditi sunt algoritmii de compresie bazati pe
dictionare adaptive
Dictionare
 Un dictionar adaptiv consta in adaugarea unei abrevieri pe
langa anumite grupe de simboluri, cand apar prima oara, si
utilizarea in continuare doar a abrevierilor
 Cel mai folosit algoritm de compresie bazat pe dictionar
este cel propus de Jacob Ziv si Abraham Lempel, in doua
variante:
 prima din 1977, cunoscuta sub numele de LZ77
 a doua, din 1978, cunoscuta sub numele de LZ78
Algoritmul Lempel-Ziv
 Urmatorul exemplu se refera la o versiune simpla a
algoritmului Lempel-Ziv
 Schema de compresie trebuie sa imparta datele in sub-siruri, sa
codeze sub-sirurile, si sa fie posibila si operatia inversa
 Fie urmatorul sir de date:
001101100011010101001001001101000001010010110010110
*Preluat din (Princeton, 2004)
Algoritmul Lempel-Ziv
 Primul pas consta in impartirea sirului de date in subsiruri, astfel incat la fiecare
definitie a unui subsir sa nu existe repetitiii, deci el sa nu fi fost definit anterior
 Se va utiliza virgula ca separator de sub-siruri
 La inceputul sirului se pune o virgula pentru a evidentia sirul de lungime zero
 Se pune apoi o virgula dupa primul zero, intracat nu a mai aparut
 Al doilea bit este zero si se considera si al doilea simbol, 1, obtinandu-se sirul 01
 Intrucat acesta este sir nou se pune virgula
 Urmeaza simbolul 1, care fiind caracter nou, atrage virgula dupa el
 Apoi apare un zero, mai trebuie un zero (deci inca un simbol), ca sa fie un sir
nou
 Rezultatul consta in urmatoarea lista de siruri
,0,01,1,011,00,0110,10,101,001,0010,
01101,000,00101,001011,0010110
Algoritmul Lempel-Ziv
 Pasul doi consta in derminarea numarului de biti pentru
reprezentarea secventei astfel obtinute
 Practic, se numeroteaza sirurile incepand cu primul sir de
lungime nenula
 Se determina numarul de biti dupa relatia
k  log2 N 
unde N reprezinta numarul de siruri si paranteza are rolul de
rontunjire la cel mai mic intreg
 Pentru primul exemplu considerat se constata ca sunt 16
simboluri (inclusiv sirul de lungime zero) si sunt necesari 4 biti
pentru reprezentarea fiecarui sir
Algoritmul Lempel-Ziv
 Pasul trei consta codificarea sirurilor, astfel obtinute
 Se completeaza un tabel in care se definesc:
 sirul, numarul ce arata pozitia sirului
 prefixul, numarul ce arata pozitia prefixului
 codul sirului
 Codul sirului este obtinut considerand numarul ce arata
pozitia prefixului urmat de ultimul bit al sirului considerat
Algoritmul Lempel-Ziv
Nr. sirului
1
2
3
4
5
6
7
8
9
10
11
12
13
0
01
1
011
00
0110
10
101
001
0010
01101
000
Codarea
pozitiei
sirului
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
00101
1101
0010
10 = 1010
10101
14
001011
1110
00101
13 = 1101
11011
15
0010110
1111
001011
14 = 1110
11100
Sirul
empty
0
empty
01
0
011
1
10
00
001
0110
00
Codarea
pozitiei
prefixului
0 = 0000
1 = 0001
0 = 0000
2 = 0010
1 = 0001
4 = 0100
3 = 0011
7 = 0111
5 = 0101
9 = 1001
6 = 0110
5 = 0101
0000+0 = 00000
0001+1 = 00011
0000+1 = 00001
00101
00010
01000
00110
01111
01011
10010
01101
01010
Prefix
Sir codat
Algoritmul Lempel-Ziv
 Secventa comprimata este formata prin concatenarea tuturor sirulor
codate, aflate in ultima coloana a tabelului precedent
 Se obtine:
00000-00011-00001-00101-00010-01000-00110-01111
01011-10010-01001-01010-10101-11011-11100
 Comparand lungimea secventei comprimate cu lungimea secventei
originale se constata ca secventa comprimata are o lungime mai mare
 Acest rezultat este explicat prin faptul ca secventa de intrare este de
lungime foarte mica
 Pentru fisiere cu secventa de lungime de milioane de simboluri se
constata cu raport de compresie de pana la 2, depinzand si de continutul
fisierului
LZ78
 LZ77 presupune localitatea grupurilor de simboluri
 LZ78:
 Nu exista un buffer de cautare – dictionarul este explicit
 Codificatorul/decodificatorul construiesc dictionarul intr-un
mod sincronizat
 Codificare: <i, c>


i = indexul din dictionar
c = codul urmatorului simbol
 Example:
 wabbawabbawabbawabbawoowoowoo
28
Exemplu LZ78
Input: wabbawabbawabbawabbawoowoowoo
Output:
Dictionar:
Index
29
Intr.
Exemplu LZ78
Input: wabbawabbawabbawabbawoowoowoo
Output:
Dictionar:
30
Index
Intr.
1
w
<0, C(w)>
Exemplu LZ78
Input: -abbawabbawabbawabbawoowoowoo
Output:
Dictionar:
31
Index
Intr.
1
w
2
a
<0, C(w)>
<0, C(a)>
Exemplu LZ78
Input: --bbawabbawabbawabbawoowoowoo
Output:
Dictionar:
32
Index
Intr.
1
w
2
a
3
b
<0, C(w)>
<0, C(a)>
<0, C(b)>
Exemplu LZ78
Input: ---bawabbawabbawabbawoowoowoo
Output:
Dictionar:
33
Index
Intr.
1
w
2
a
3
b
4
ba
<0,
<0,
<0,
<3,
C(w)>
C(a)>
C(b)>
C(a)>
Exemplu LZ78
Input: -----wabbawabbawabbawoowoowoo
Output:
Dictionar:
Index
Intr.
1
w
2
a
3
b
4
ba
5
34
<0,
<0,
<0,
<3,
<0,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
Exemplu LZ78
Input: ------wabbawabbawabbawoowoowoo
Output:
Dictionar:
Index
Intr.
1
w
2
a
3
b
4
ba
5
6
35
wa
<0,
<0,
<0,
<3,
<0,
<1,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
C(a)>
Exemplu LZ78
Input: --------bbawabbawabbawoowoowoo
Output:
Dictionar:
Index
Intr.
1
w
2
a
3
b
4
ba
5
36
6
wa
7
bb
<0,
<0,
<0,
<3,
<0,
<1,
<3,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
C(a)>
C(b)>
Exemplu LZ78
Input: ----------awabbawabbawoowoowoo
Output:
Dictionar:
Index
Intr.
1
w
2
a
3
b
4
ba
5
37
6
wa
7
bb
8
a
<0,
<0,
<0,
<3,
<0,
<1,
<3,
<2,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
C(a)>
C(b)>
C( )>
Exemplu LZ78
Input: ------------wabbawabbawoowoowoo
Output:
Dictionar:
Index
Intr.
1
w
2
a
3
b
4
ba
5
38
6
wa
7
bb
8
a
9
wab
<0,
<0,
<0,
<3,
<0,
<1,
<3,
<2,
<6,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
C(a)>
C(b)>
C( )>
C(b)>
Exemplu LZ78
Input: ---------------bawabbawoowoowoo
Output:
Dictionar:
Index
Intr.
1
w
2
a
3
b
4
ba
5
39
6
wa
7
bb
8
a
9
wab
10
ba
<0,
<0,
<0,
<3,
<0,
<1,
<3,
<2,
<6,
<4,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
C(a)>
C(b)>
C( )>
C(b)>
C( )>
Exemplu LZ78
Input: ------------------wabbawoowoowoo
Output:
Dictionar:
Index
Intr.
1
w
2
a
3
b
4
ba
5
40
6
wa
7
bb
8
a
9
wab
10
ba
11
wabb
<0,
<0,
<0,
<3,
<0,
<1,
<3,
<2,
<6,
<4,
<9,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
C(a)>
C(b)>
C( )>
C(b)>
C( )>
C(b)>
Exemplu LZ78
Input: ----------------------awoowoowoo
Output:
Dictionar:
Index
Intr.
1
w
11
wabb
2
a
12
a w
3
b
4
ba
5
41
6
wa
7
bb
8
a
9
wab
10
ba
<0,
<0,
<0,
<3,
<0,
<1,
<3,
<2,
<6,
<4,
<9,
<8,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
C(a)>
C(b)>
C( )>
C(b)>
C( )>
C(b)>
C(w)>
Exemplu LZ78
Input: -------------------------oowoowoo
Output:
Dictionar:
Index
Intr.
1
w
11
wabb
2
a
12
a w
3
b
13
o
4
ba
5
42
6
wa
7
bb
8
a
9
wab
10
ba
<0,
<0,
<0,
<3,
<0,
<1,
<3,
<2,
<6,
<4,
<9,
<8,
<0,
C(w)>
C(a)>
C(b)>
C(a)>
C( )>
C(a)>
C(b)>
C( )>
C(b)>
C( )>
C(b)>
C(w)>
C(o)>
Exemplu LZ78
Input: --------------------------owoowoo
Output:
Dictionar:
Index
Intr.
1
w
11
wabb
2
a
12
a w
3
b
13
o
4
ba
14
o
5
43
6
wa
7
bb
8
a
9
wab
10
ba
<0, C(w)>
<0, C(a)>
<0, C(b)>
<3, C(a)>
<0, C( )>
<1, C(a)>
<3, C(b)>
<2, C( )>
<6, C(b)>
<4, C( )>
<9, C(b)>
<8, C(w)>
<0, C(o)>
<13, C( )>
Exemplu LZ78
Input: ----------------------------woowoo
Output:
Dictionar:
Index
Intr.
1
w
11
wabb
2
a
12
a w
3
b
13
o
4
ba
14
o
15
wo
5
44
6
wa
7
bb
8
a
9
wab
10
ba
<0, C(w)>
<0, C(a)>
<0, C(b)>
<3, C(a)>
<0, C( )>
<1, C(a)>
<3, C(b)>
<2, C( )>
<6, C(b)>
<4, C( )>
<9, C(b)>
<8, C(w)>
<0, C(o)>
<13, C( )>
<1, C(o)>
Exemplu LZ78
Input: ------------------------------owoo
Output:
Dictionar:
Index
Intr.
1
w
11
wabb
2
a
12
a w
3
b
13
o
4
ba
14
o
15
wo
16
o w
5
45
6
wa
7
bb
8
a
9
wab
10
ba
<0, C(w)>
<0, C(a)>
<0, C(b)>
<3, C(a)>
<0, C( )>
<1, C(a)>
<3, C(b)>
<2, C( )>
<6, C(b)>
<4, C( )>
<9, C(b)>
<8, C(w)>
<0, C(o)>
<13, C( )>
<1, C(o)>
<14, C(w)>
Exemplu LZ78
Input: ---------------------------------oo
Output:
Dictionar:
Index
Intr.
1
w
11
wabb
2
a
12
a w
3
b
13
o
4
ba
14
o
15
wo
5
46
6
wa
16
o w
7
bb
17
oo
8
a
9
wab
10
ba
<0, C(w)>
<0, C(a)>
<0, C(b)>
<3, C(a)>
<0, C( )>
<1, C(a)>
<3, C(b)>
<2, C( )>
<6, C(b)>
<4, C( )>
<9, C(b)>
<8, C(w)>
<0, C(o)>
<13, C( )>
<1, C(o)>
<14, C(w)>
<13, C(o)>
LZ78
 Observatie
 Daca continuam sa codificam, dictionarul continua sa
creasca
 Solutii practice
 Oprirea cresterii dictionarului

efectiv ,considerarea dictionarului ca unul static
 Micsorarea dictionarului
 Ex: pe baza statisticilor de utilizare
 Resetarea dictionarului
 Fara a cunoaste informatii specifice referitoare la sursa,
tehnicile de mai sus nu garanteaza succesul
47
Algoritmul Lempel-Ziv-Welch
 Idea de baza este de a imparti (parse-in limba engleza)
secventa de intrare in blocuri (siruri) diferite de lungime
diferita
 Multimea blocurilor diferite defineste un dictionar
 Indexul cuvintelor din dictionar este salvat in fisierul
comprimat
Algoritmul Lempel-Ziv-Welch
ALGORITM DE CODARE LZW:
Date intiale: Alfabetul A; secventa de intrare in;
#1. Initializeaza dictionarul cu simbolurile alfabetului;
#2. Initializeaza secventa comprimata: code =’’;
#3. Citeste primul caracter de intrare, sirul prefix S: S = in(1);
#4. CAT TIMP nu s-a parcurs toata secventa de intrare EXECUTA:
#4.1.Citeste urmatorul caracter de intrare: K = in(i+1).
#4.2. DACA sirul SK este in tabel
ATUNCI
#4.2.1. Asigneaza: S = SK;
ALTFEL
#4.2.2. Memoreaza SK in dictionar;
#4.2.3. Asigneaza: S = K;
#4.2.4. Scrie: code = code + code(S)
END #4.2;
END #5;
END.
Exemplu (1)
 Fie mesajul „abba_baba_buba” si dictionarul initializat cu
alfabetul sursei, adica D={a,_,b,u}.
 Initializare:
 code={}, S=’’
 D={a,_,b,u}
 Citeste primul caracter: „abba_baba_buba”
K " a", SK " a" D, S  SK " a"
Exemplu (1)
 Citeste urmatorul caracter „abba_baba_buba”
K " b" , SK " ab" D 
D  D  {SK}  {a, _,b, u, ab}
code  code index( S )  code index("a" )  {1}
S  K " b"
 Citeste urmatorul caracter „abba_baba_buba”
K " b" , SK " bb" D 
D  D  {SK}  {a, _,b, u, ab, bb}
code  code index( S )  code index("b" )  {1,3}
S  K " b"
Exemplu (1)
 Citeste urmatorul caracter „abba_baba_buba”
K " a" , SK " ba" D 
D  D  {SK}  {a, _,b, u, ab, bb, ba}
code  code index( S )  code index("b" )  {1,3,3}
S  K " a"
 Citeste urmatorul caracter „abba_baba_buba
K " _", SK " a _" D 
D  D  {SK}  {a, _,b, u, ab, bb, ba, a _}
code  code index( S )  code index("a" )  {1,3,3,1}
S  K " _"
Exemplu (1)
 Citeste urmatorul caracter „abba_baba_buba”
K " b" , SK " _ b" D 
D  D  {SK}  {a, _,b, u, ab, bb, ba, a _, _ b}
code  code index( S )  code index(" _")  {1,3,3,1,2}
S  K " b"
 Citeste urmatorul caracter „abba_baba_buba”
K " a", SK "ba" D  S  SK "ba"
Exemplu (1)
 Citeste urmatorul caracter „abba_baba_buba”
K " b" , SK " bab" D 
D  D  {SK}  {a, _,b, u, ab, bb, ba, a _, _ b, bab}
code  code index( S )  code index("ba" )  {1,3,3,1,2,7}
S  K " b"
 Citeste urmatorul caracter „abba_baba_buba”
K " a", SK "ba" D  S  SK "ba"
Exemplu (1)
 Citeste urmatorul caracter „abba_baba_buba”
K " _", SK " ba _" D 
D  D  {SK}  {a, _,b, u, ab, bb, ba, a _, _ b, aba, ba _}
code  code index( S )  code index("ba" )  {1,3,3,1,2,7,7}
S  K " _"
 Citeste urmatorul caracter „abba_baba_buba”
K "b", SK " _ b" D  S  SK " _ b"
Exemplu (1)
 Citeste urmatorul caracter „abba_baba_buba”
K " u" , SK " _ bu" D 
D  D  {SK}  {a, _,b, u, ab, bb, ba, a _, _ b, aba, _ bu}
code  code index( S )  code index(" _ b" )  {1,3,3,1,2,7,7,9}
S  K " u"
 Citeste urmatorul caracter „abba_baba_buba”
K " b" , SK " ub" D 
D  D  {SK}  {a, _,b, u, ab, bb, ba, a _, _ b, aba, _ bu, ub}
code  code index( S )  code index("u" )  {1,3,3,1,2,7,7,9,4}
S  K " b"
Exemplu (1)
 Citeste urmatorul caracter „abba_baba_buba”
K " a", SK "ba" D  S  SK "ba"
 Rezultatele finale sunt:
D = { 'a' '_' 'b' 'u' 'ab' 'bb' 'ba' 'a_' '_b' 'bab' 'ba_' '_bu' 'ub'}
code = {1, 3, 3, 1, 2, 7, 7, 9, 4}
 Presupunand ca se cunoaste alfabetul si dictionarul, atat la emisie cat si la receptie,
ar rezulta un raport de compresie maxim
14sim boluri* 8biti
112
RC 

 2.48
9sim boluri_ index* 5biti 45
Exemplu (2)
Input: wabbawabbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
7
8
9
10
p =
Output:
Exemplu (2)
Input: wabbawabbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
7
8
9
10
p = w
Output:
Exemplu (2)
Input: -abbawabbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
8
9
10
p = wa
Output:
5 (‘w’)
Exemplu (2)
Input: --bbawabbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
ab
8
9
10
p = ab
Output:
5 (‘w’)
2 (‘a’)
Exemplu (2)
Input: ---bawabbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
ab
8
bb
9
10
p = bb
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
Exemplu (2)
Input: ----awabbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
ab
8
bb
9
ba
10
p = ba
Output:
5
2
3
3
(‘w’)
(‘a’)
(‘b’)
(‘b’)
Exemplu (2)
Input: -----wabbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
ab
8
bb
9
ba
10
a
p = a
Output:
5
2
3
3
2
(‘w’)
(‘a’)
(‘b’)
(‘b’)
(‘a’)
Exemplu (2)
Input: ------wabbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p =
Index
Intr.
11
w
2
a
12
3
b
13
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
w
Output:
5
2
3
3
2
1
(‘w’)
(‘a’)
(‘b’)
(‘b’)
(‘a’)
(‘ ’)
Exemplu (2)
Input: -------abbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = wa
Index
Intr.
11
w
2
a
12
3
b
13
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5
2
3
3
2
1
(‘w’)
(‘a’)
(‘b’)
(‘b’)
(‘a’)
(‘ ’)
Exemplu (2)
Input: --------bbawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = wab
Index
Intr.
11
w
wab
2
a
12
3
b
13
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5
2
3
3
2
1
6
(‘w’)
(‘a’)
(‘b’)
(‘b’)
(‘a’)
(‘ ’)
(‘wa’)
Exemplu (2)
Input: ---------bawabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = bb
Index
Intr.
11
w
wab
2
a
12
3
b
13
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5
2
3
3
2
1
6
(‘w’)
(‘a’)
(‘b’)
(‘b’)
(‘a’)
(‘ ’)
(‘wa’)
Exemplu (2)
Input: ----------awabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = bba
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5
2
3
3
2
1
6
8
(‘w’)
(‘a’)
(‘b’)
(‘b’)
(‘a’)
(‘ ’)
(‘wa’)
(‘bb’)
Exemplu (2)
Input: -----------wabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = a
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5
2
3
3
2
1
6
8
(‘w’)
(‘a’)
(‘b’)
(‘b’)
(‘a’)
(‘ ’)
(‘wa’)
(‘bb’)
Exemplu (2)
Input: ------------wabbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = a w
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
Exemplu (2)
Input: -------------abbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = wa
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
Exemplu (2)
Input: --------------bbawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = wab
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
Exemplu (2)
Input: ---------------bawabbawoowoowoo
Dictionar:
Index
Intr.
1
p = wabb
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
Exemplu (2)
Input: ----------------awabbawoowoowoo
Dictionar:
Index
Intr.
1
p = ba
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
Exemplu (2)
Input: -----------------wabbawoowoowoo
Dictionar:
Index
Intr.
1
p = ba
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
8
bb
18
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
Exemplu (2)
Input: ------------------wabbawoowoowoo
Dictionar:
Index
Intr.
1
p =
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
8
bb
18
9
ba
19
10
a
20
w
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
Exemplu (2)
Input: -------------------abbawoowoowoo
Dictionar:
Index
Intr.
1
p =
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
8
bb
18
9
ba
19
10
a
20
wa
wa
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
Exemplu (2)
Input: --------------------bbawoowoowoo
Dictionar:
Index
Intr.
1
p = ab
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
8
bb
18
9
ba
19
10
a
20
wa
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
Exemplu (2)
Input: ---------------------bawoowoowoo
Dictionar:
Index
Intr.
1
p = abb
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
wa
8
bb
18
abb
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
Exemplu (2)
Input: ----------------------awoowoowoo
Dictionar:
Index
Intr.
1
p = ba
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
wa
8
bb
18
abb
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
Exemplu (2)
Input: -----------------------woowoowoo
Dictionar:
Index
Intr.
1
p = ba
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
wa
8
bb
18
abb
9
ba
19
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
Exemplu (2)
Input: ------------------------woowoowoo
Dictionar:
Index
Intr.
1
p = ba w
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
wa
8
bb
18
abb
9
ba
19
ba w
10
a
20
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
Exemplu (2)
Input: -------------------------oowoowoo
Dictionar:
Index
Intr.
1
p = wo
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
wa
8
bb
18
abb
9
ba
19
ba w
10
a
20
wo
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
Exemplu (2)
Input: --------------------------owoowoo
Dictionar:
Index
Intr.
1
Output:
p = oo
Index
Intr.
Index
Intr.
11
w
21
oo
2
a
12
wab
22
3
b
13
bba
23
4
o
14
a w
24
5
w
15
wabb
25
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
Exemplu (2)
Input: ---------------------------woowoo
Dictionar:
Index
Intr.
1
Output:
p = o
Index
Intr.
Index
Intr.
11
w
21
oo
o
2
a
12
wab
22
3
b
13
bba
23
4
o
14
a w
24
5
w
15
wabb
25
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
Exemplu (2)
Input: ----------------------------woowoo
Dictionar:
Index
Intr.
1
p =
Output:
w
Index
Intr.
Index
Intr.
11
w
21
oo
o
2
a
12
wab
22
3
b
13
bba
23
4
o
14
a w
24
5
w
15
wabb
25
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
Exemplu (2)
Input: -----------------------------oowoo
Dictionar:
Index
Intr.
1
p =
wo
Index
Intr.
Index
Intr.
11
w
21
oo
2
a
12
wab
22
o
3
b
13
bba
23
wo
4
o
14
a w
24
5
w
15
wabb
25
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
11 (‘ w’)
Exemplu (2)
Input: ------------------------------owoo
Dictionar:
Index
Intr.
1
Output:
p = oo
Index
Intr.
Index
Intr.
11
w
21
oo
2
a
12
wab
22
o
3
b
13
bba
23
wo
4
o
14
a w
24
5
w
15
wabb
25
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
11 (‘ w’)
Exemplu (2)
Input: -------------------------------woo
Dictionar:
Index
Intr.
1
Output:
p = oo
Index
Intr.
Index
Intr.
11
w
21
oo
2
a
12
wab
22
o
3
b
13
bba
23
wo
4
o
14
a w
24
5
w
15
wabb
25
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
oo
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
11 (‘ w’)
21 (‘oo’)
Exemplu (2)
Input: --------------------------------woo
Dictionar:
Index
Intr.
1
p =
Output:
w
Index
Intr.
Index
Intr.
11
w
21
oo
2
a
12
wab
22
o
3
b
13
bba
23
wo
4
o
14
a w
24
5
w
15
wabb
25
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
oo
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
11 (‘ w’)
21 (‘oo’)
Exemplu (2)
Input: ---------------------------------oo
Dictionar:
Index
Intr.
1
p =
wo
Index
Intr.
Index
Intr.
11
w
21
oo
2
a
12
wab
22
o
3
b
13
bba
23
wo
4
o
14
a w
24
5
w
15
wabb
25
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
oo
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
11 (‘ w’)
21 (‘oo’)
Exemplu (2)
Input: ----------------------------------o
Dictionar:
Index
Intr.
1
p =
woo
Index
Intr.
Index
Intr.
11
w
21
oo
2
a
12
wab
22
o
3
b
13
bba
23
wo
4
o
14
a w
24
oo
5
w
15
wabb
25
woo
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
Output:
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
11 (‘ w’)
21 (‘oo’)
23 (‘ wo’)
Exemplu (2)
Input: ----------------------------------Dictionar:
Index
Intr.
1
Output:
p = o
Index
Intr.
Index
Intr.
11
w
21
oo
2
a
12
wab
22
o
3
b
13
bba
23
wo
4
o
14
a w
24
oo
5
w
15
wabb
25
woo
6
wa
16
ba
26
7
ab
17
wa
27
8
bb
18
abb
28
9
ba
19
ba w
29
10
a
20
wo
30
5 (‘w’)
2 (‘a’)
3 (‘b’)
3 (‘b’)
2 (‘a’)
1 (‘ ’)
6 (‘wa’)
8 (‘bb’)
10 (‘a ’)
12 (‘wab’)
9 (‘ba’)
11 (‘ w’)
7 (‘ab’)
16 (‘ba ’)
5 (‘w’)
4 (‘o’)
4 (‘o’)
11 (‘ w’)
21 (‘oo’)
23 (‘ wo’)
4 (‘o’)
Exemplu decodificare (2)
Input:
5 2 3 3 2 1 6 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output:
p =
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
7
8
9
10
Exemplu decodificare (2)
Input:
5 2 3 3 2 1 6 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: w
p = w
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
7
8
9
10
Exemplu decodificare (2)
Input:
- 2 3 3 2 1 6 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wa
p = wa
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
8
9
10
Exemplu decodificare (2)
Input:
- - 3 3 2 1 6 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wab
p = ab
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
ab
8
9
10
Exemplu decodificare (2)
Input:
- - - 3 2 1 6 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabb
p = bb
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
ab
8
bb
9
10
Exemplu decodificare (2)
Input:
- - - - 2 1 6 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba
p = ba
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
ab
8
bb
9
ba
10
Exemplu decodificare (2)
Input:
- - - - - 1 6 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba
p = a
Dictionar:
Index
Intr.
1
2
a
3
b
4
o
5
w
6
wa
7
ab
8
bb
9
ba
10
a
Exemplu decodificare (2)
Input:
- - - - - - 6 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wa
p =
wa
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
3
b
13
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wa
p = wa
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
3
b
13
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - 8 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabb
p = wabb
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
wab
2
a
12
3
b
13
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabb
p = bb
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
wab
2
a
12
3
b
13
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - 10 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba
p = bba
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba
p = bba
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba
p = a
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - 12 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba wab
p = a wab
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - - 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba wab
p = wab
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - - 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba wab
p = wab
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - - 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba wab
p = wab
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - - 9 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba wabba
p = wabba
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - - - 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba wabba
p = ba
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - - - 11 7 16 5 4 4 11 21 23 4
Output: wabba wabba wabba w
p = ba w
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
8
bb
18
9
ba
19
10
a
20
Exemplu decodificare (2)
Input:
- - - - - - - - - - - - 7 16 5 4 4 11 21 23 4
Output: wabba wabba wabba w
p =
w
Dictionar:
Index
Intr.
1
Index
Intr.
11
w
2
a
12
wab
3
b
13
bba
4
o
14
a w
5
w
15
wabb
6
wa
16
ba
7
ab
17
8
bb
18
9
ba
19
10
a
20
… and so on …
Concluzii
 Asa cum este de asteptat, rezultatele compresiei depind
mult de tipul datelor de comprimat
 In tabelul de mai jos se prezinta rezultatele obtinute pentru
diferite continute ale fisierelor
Adaptive Huffman
(compact sub Unix)
Lempel-Ziv
(compress sub
UNIX)
LaTeX file
66%
44%
Speech file
65%
64%
Image file
94%
88%
Concluzii
 Aceasta metode de compresie se foloseste la o serie de
standarduri de imagine
 GIF si TIFF
 standardul V.24bis al modemurilor
 standardul PostScript Level 2
 LZW este un algoritm general care poate lucra pe orice tip de
date
 Este rapid atat la compresie cat si la decompresie si nu necesita
operatii in virgula mobila
 LZW scrie datele compresate sub forma de octeti si nu ca si
cuvinte, ceea ce face ca datele comprimate sa fie independente
de platforma
Concluzii
 LZW este cunoscut ca facand parte din categoria algoritmilor
de codare bazati pe dictionar sau substitutional
 Algoritmul construieste un dictionar (denumit si tabel de
translatie sau tabel de siruri) al datelor ce apar in fluxul de date
ce trebuie comprimat
 In fluxul de date se identifica forme de date (“substrings”) si
memorate in intrarile dictionarului
 Daca un subsir nu este prezent in dictionar, la momentul intalnirii
sale, respectivul subsir se memoreaza si se codifica in dictionar
 Codul alocat subsirului este scris in secventa de iesire, care este
secventa comprimata
 Cand se intalneste un subsir deja existent in dictionar, in secventa
de iesire se scrie codul subsirului existent in dictionar
Concluzii
 Avantajul LZW este ca nu trebuie memorat dictionarul in
vederea decodarii secventei comprimate, lucru avantajos
in unele aplicatii
 Cand se comprima fisiere text, LZW initializeaza primele
256 intrari ale dictionarului cu codul ASCII ca fiind fraze
(siruri de lungime 1)
 Mai departe, toate subsirurile sunt construite pe baza
simbolurilor individuale, definite anterior
Concluzii
 Pentru secvente de intrare foarte mari lungimea dictionarului poate
creste foarte mult
 De aceea, in practica, dimensiunea dictionarului este limitata la 4096
cuvinte, ceea ce corespunde la o reprezentare a indexului (codul
cuvintelor sir din dictionar) de 12 biti
 Daca indexul este reprezentat prin secvente binare de lungime
variabila, atunci se obtine varianta lungime variabila-lungime
variabila a algoritmului Lempel-Ziv
 Atentie!!!
 Algoritmul LZ codifica pozitia prefixului urmat de ultimul caracter
 Algoritmul LZW codifica numai pozitia sirului in dictionar si numai
pentru cuvinte(siruri) noi din dictionar
Compresia MTF (“Move to front”)
 Una dintre cele mai intuitive metode de compresie a
datelor
 Foloseşte o tehnică adaptivă bazată pe un dicţionar,
realizănd compresia fişierul de intrare cuvânt cu cuvânt
 Un cuvânt este definit ca orice şir de caractere situat între
două spaţii albe sau între două caractere ce marchează o
linie nouă
 Deoarece nu se iau în considerare spaţiile albe, această
metoda de compresie este una cu pierderi de date,
neputând diferenţia la ieşire de exemplu: „_” şi „___ ”
122
Algoritmul de compresie
 Pentru fiecare cuvânt din fişierul de intrare


Dacă cuvântul este unul care a mai fost întâlnit în prealabil
 Returnează poziţia
 Mută cuvântul la începutul listei
Altfel
 Adaugă cuvântul la începutul listei de cuvinte
123
Detalii
 Algoritmul construieşte gradual o listă de cuvinte întâlnite
la intrare (un dicţionar)
 Cel mai recent cuvânt întâlnit de-a lungul procesului de
compresie este mutat la începutul listei
 ca urmare, cuvintele cele mai des întâlnite în text vor avea
tendinţa de a se grupa în apropierea începutului listei.
 Codificând cuvintele situate la indici mai mici în dicţionar
cu un număr mai mic de biţi decât cuvintele situate mai la
sfârşitul listei de cuvinte, se obţine o compresie mai bună
decât dacă s-ar înlocui fiecare cuvânt cu un număr întreg
spre exemplu
124
Dezavataje
 Principala deficienţa a compresiei MTF o reprezintă creşterea
necontrolată în dimensiune a dicţionarului folosit, care poate
duce la probleme de memorie (în cazul în care fişierul de
intrare conţine mai multe cuvinte decât pot fi memorate pe
aparatul de calcul)
 Solutie:
 limitarea dimensiunii listei de cuvinte la un număr prestabilit;
deoarece majoritatea cuvintelor cele mai des întâlnite sunt mutate
în faţă, cuvintele care rămân pe dinafară (şi deci vor fi transmise
necodat) apar foarte rar şi astfel eficienţa compresiei nu este
afectată foarte tare
 Ce se intampla spre exemplu în cazul în care fiecare cuvânt are o
lungime foarte mare (de exemplu 8000 de caractere)?

memoria devine iarăşi insuficientă
125
Proprietati
 In orice moment, dicţionarul va conţine primele 4096 cele mai
recent întâlnite cuvinte (presupunând că dimensiunea sa este
limitată la 4096)
 Acestea nu sunt însă neapărat şi cele mai des întâlnite cuvinte
din text
 Ca urmare, cuvintele cele mai comune pot fi uitate foarte uşor
după 4096 de poziţii, în caz că nu se repetă din nou
 Există pericolul ca algoritmul să consume cea mai mare
parte din timp adaptându-se constant la noile tipare ce
apar în text, fără a se concentra pe densitatea de apariţie a
elementelor (care este de fapt cheia acestui tip de compresie)
126
Exemplu
127
Exemplu
128
Exemplu
129
Exemplu
130

similar documents