Startseite < Informatik < Algorithmen < Sortieren Komprimieren < RLE < RLE (8-Bit) RLE (16-Bit) RLE (24-Bit) RLE (32-Bit) [ DRUCK , 2004 , 2005 , 2006 , 2007 , 2008 , 2009 ] RLE (alternierend) > Huffman Lempel-Ziv > Suchen / Primzahltest > Datenstrukturen / Software-Engineering / Programmiersprachen / Künstliche Intelligenz > Schach Privates / Inhalt >
RLE (alternierend)
Einführung Theorie: RLE-Alternierend
Wenn sie folgende Seiten kennen, dann sind sie sicherlich schon selbst darauf gekommen, dass man diese RLE-Algorithmen zu einem Ganzen zusammenfassen kann:
  1. RLE (8-Bit)
  2. RLE (16-Bit)
  3. RLE (24-Bit)
  4. RLE (32-Bit)
So wollen wir möglichst nur die Vorteile dieser Algorithmen ausnutzen.

Wenn nun eine Datei Folgen von gleichen Werten hat, dann soll es völlig egal sein, von welcher Länge (8Bit, 16Bit, 24Bit oder 32Bit) diese Werte sind.
  1. Beim Komprimieren wird an jeder Position der zu komprimierenden Datei geprüft, welcher RLE-Algorithmus sich gerade rentiert.


Der Algorithmus muss jedoch die Wertelänge zusätzlich im Komprimat speicheren, um bei der Dekompression die richtige Wertelänge interpretieren zu können.

Ist dazu ein zusätzliches Byte nötig?

Eigentlich schon, aber! Da wir nur zwischen vier unterschiedlichen Wertelängen unterscheiden, genügen uns zwei zusätzliche Bits (z. B. 00 für 8Bit, 01 für 16Bit, 10 für 24Bit und 11 für 32Bit). Das würde bedeuten, dass die Anzahl der Bits einer Kodierung einer einzelnen Folge von gleichen Werten sich um 2 Bits erhöhen würde. Das können wir akzepieren, wenn wir Einsparungen an einer anderen Stelle der Kodierung vornehmen. Wir hatten für die Anzahl gleicher Werte 8Bit in der Kodierung vorgesehen. Wenn wir von diesen 8Bit 2Bit opfern, dann bleibt die Anzahl der Bits einer Kodierung einer einzelnen Folge von gleichen Werten unverändert.
Nachteil
Da wir Einsparungen an der Zählkomponente machen, kann eine Kodierung nur noch maximal 64 - 1 (ehemals 256 - 1) gleiche Werte aufnehmen, d. h. für 100 a's benötigen wir jetzt zwei Kodierungen (1. Kodierung von 63 a's; 2. Kodierung der restlichen a's).

Diesen Nachteil kann man getrost vernachlässigen, da die meisten Dateien in der Praxis eh' relativ selten lange Folgen von gleichen Werten aufweisen.
Implementierung Implementierung: RLE-Alternierend
Es ist mir durchaus bewusst, dass die folgende Implementierung nicht sehr effizient ist. Mir kommt es hier mehr auf die Semantik bzw. Lesbarkeit an, auch wenn die Effizienz darunter leiden sollte.
Kompression und Dekompression: RLE-Alternierend
unit URleAlternate;

interface

uses
  Classes;

procedure RLEAlternateCompress(Source, Destination: TMemoryStream);
procedure RLEAlternateDecompress(Source, Destination: TMemoryStream);

implementation

type
  T8Bit = Byte;
  T16Bit = Word;
  T24Bit = packed array[0..2] of Byte;
  T32Bit = Longint;

const
  CodeFlag: T8Bit = $FF; // binär: 1111 1111
  NoCode: T8Bit = $00;   // binär: 0000 0000 aus T8Bit\[1..MaxCount]
  MaxCount: T8Bit = $3F; // bin: 00 111111

  Type8: Byte = $00;  // bin: 00 000000
  Type16: Byte = $40; // bin: 01 000000
  Type24: Byte = $80; // bin: 10 000000
  Type32: Byte = $C0; // bin: 11 000000

  TypeMask: T8Bit = $C0; // bin: 11 000000
  CountMask: T8Bit = $3F; // bin: 00 111111

procedure RLEAlternateCompress(Source, Destination: TMemoryStream);

  function Try8BitCompress: Boolean;
  var
    Counting: Boolean;
    Count: T8Bit;
    CodeCount: T8Bit;
    Try8Bit: packed array[0..3] of T8Bit; // vier 8Bit-Zeichen
    Next8Bit: T8Bit;
  begin
    Result := FALSE;
    // Existenz von vier 8Bit-Zeichen
    if (Source.Size - Source.Position < SizeOf(Try8Bit)) then Exit;
    // Vergleich der vier 8Bit-Zeichen
    Source.ReadBuffer(Try8Bit, SizeOf(Try8Bit));
    Source.Position := Source.Position - SizeOf(Try8Bit);
    if (Try8Bit[0] <> Try8Bit[1]) then Exit;
    if (Try8Bit[1] <> Try8Bit[2]) then Exit;
    if (Try8Bit[2] <> Try8Bit[3]) then Exit;
    // Neuer Rückgabewert: Komprimierversuch gelingt!
    Result := TRUE;
    Source.Position := Source.Position + SizeOf(Try8Bit);
    Count := High(Try8Bit) - Low(Try8Bit) + 1; // Länge der Prüfsequenz

    if (Source.Size - Source.Position >= SizeOf(Next8Bit)) then
      repeat
        Source.ReadBuffer(Next8Bit, SizeOf(Next8Bit));
        Counting := (Try8Bit[0] = Next8Bit);
        if Counting then Inc(Count, 1)
        else Source.Position := Source.Position - SizeOf(T8Bit);
      until (not Counting) or (Count >= MaxCount) or
            (Source.Size - Source.Position < SizeOf(T8Bit));

    CodeCount := Type8 or Count;
    Destination.WriteBuffer(CodeFlag, SizeOf(CodeFlag));
    Destination.WriteBuffer(CodeCount, SizeOf(CodeCount));
    Destination.WriteBuffer(Try8Bit[0], SizeOf(Try8Bit[0]));
  end;

  function Try16BitCompress: Boolean;
  var
    Counting: Boolean;
    Count: T8Bit;
    CodeCount: T8Bit;
    Try16Bit: packed array[0..2] of T16Bit; // drei 16Bit-Zeichen
    Next16Bit: T16Bit;
  begin
    Result := FALSE;
    // Existenz von drei 16Bit-Zeichen
    if (Source.Size - Source.Position < SizeOf(Try16Bit)) then Exit;
    // Vergleich der drei 16Bit-Zeichen
    Source.ReadBuffer(Try16Bit, SizeOf(Try16Bit));
    Source.Position := Source.Position - SizeOf(Try16Bit);
    if (Try16Bit[0] <> Try16Bit[1]) then Exit;
    if (Try16Bit[1] <> Try16Bit[2]) then Exit;
    // Neuer Rückgabewert: Komprimierversuch gelingt!
    Result := TRUE;
    Source.Position := Source.Position + SizeOf(Try16Bit);
    Count := High(Try16Bit) - Low(Try16Bit) + 1; // Länge der Prüfsequenz

    if (Source.Size - Source.Position >= SizeOf(Next16Bit)) then
      repeat
        Source.ReadBuffer(Next16Bit, SizeOf(Next16Bit));
        Counting := (Try16Bit[0] = Next16Bit);
        if Counting then Inc(Count, 1)
        else Source.Position := Source.Position - SizeOf(T16Bit);
      until (not Counting) or (Count >= MaxCount) or
            (Source.Size - Source.Position < SizeOf(T16Bit));

    CodeCount := Type16 or Count;
    Destination.WriteBuffer(CodeFlag, SizeOf(CodeFlag));
    Destination.WriteBuffer(CodeCount, SizeOf(CodeCount));
    Destination.WriteBuffer(Try16Bit[0], SizeOf(Try16Bit[0]));
  end;

  function Try24BitCompress: Boolean;
  var
    Counting: Boolean;
    Count: T8Bit;
    CodeCount: T8Bit;
    Try24Bit: packed array[0..1] of T24Bit; // zwei 24Bit-Zeichen
    Next24Bit: T24Bit;
  begin
    Result := FALSE;
    // Existenz von zwei 24Bit-Zeichen
    if (Source.Size - Source.Position < SizeOf(Try24Bit)) then Exit;
    // Vergleich der zwei 24Bit-Zeichen
    Source.ReadBuffer(Try24Bit, SizeOf(Try24Bit));
    Source.Position := Source.Position - SizeOf(Try24Bit);
    if (Try24Bit[0][0] <> Try24Bit[1][0]) then Exit;
    if (Try24Bit[0][1] <> Try24Bit[1][1]) then Exit;
    if (Try24Bit[0][2] <> Try24Bit[1][2]) then Exit;
    // Neuer Rückgabewert: Komprimierversuch gelingt!
    Result := TRUE;
    Source.Position := Source.Position + SizeOf(Try24Bit);
    Count := High(Try24Bit) - Low(Try24Bit) + 1; // Länge der Prüfsequenz

    if (Source.Size - Source.Position >= SizeOf(Next24Bit)) then
      repeat
        Source.ReadBuffer(Next24Bit, SizeOf(Next24Bit));
        Counting := (Try24Bit[0][0] = Next24Bit[0]) and
                    (Try24Bit[0][1] = Next24Bit[1]) and
                    (Try24Bit[0][2] = Next24Bit[2]);
        if Counting then Inc(Count, 1)
        else Source.Position := Source.Position - SizeOf(T24Bit);
      until (not Counting) or (Count >= MaxCount) or
            (Source.Size - Source.Position < SizeOf(T24Bit));

    CodeCount := Type24 or Count;
    Destination.WriteBuffer(CodeFlag, SizeOf(CodeFlag));
    Destination.WriteBuffer(CodeCount, SizeOf(CodeCount));
    Destination.WriteBuffer(Try24Bit[0], SizeOf(Try24Bit[0]));
  end;

  function Try32BitCompress: Boolean;
  var
    Counting: Boolean;
    Count: T8Bit;
    CodeCount: T8Bit;
    Try32Bit: packed array[0..1] of T32Bit; // zwei 32Bit-Zeichen
    Next32Bit: T32Bit;
  begin
    Result := FALSE;
    // Existenz von zwei 32Bit-Zeichen
    if (Source.Size - Source.Position < SizeOf(Try32Bit)) then Exit;
    // Vergleich der zwei 32Bit-Zeichen
    Source.ReadBuffer(Try32Bit, SizeOf(Try32Bit));
    Source.Position := Source.Position - SizeOf(Try32Bit);
    if (Try32Bit[0] <> Try32Bit[1]) then Exit;
    // Neuer Rückgabewert: Komprimierversuch gelingt!
    Result := TRUE;
    Source.Position := Source.Position + SizeOf(Try32Bit);
    Count := High(Try32Bit) - Low(Try32Bit) + 1; // Länge der Prüfsequenz

    if (Source.Size - Source.Position >= SizeOf(Next32Bit)) then
      repeat
        Source.ReadBuffer(Next32Bit, SizeOf(Next32Bit));
        Counting := (Try32Bit[0] = Next32Bit);
        if Counting then Inc(Count, 1)
        else Source.Position := Source.Position - SizeOf(T32Bit);
      until (not Counting) or (Count >= MaxCount) or
            (Source.Size - Source.Position < SizeOf(T32Bit));

    CodeCount := Type32 or Count;
    Destination.WriteBuffer(CodeFlag, SizeOf(CodeFlag));
    Destination.WriteBuffer(CodeCount, SizeOf(CodeCount));
    Destination.WriteBuffer(Try32Bit[0], SizeOf(Try32Bit[0]));
  end;

  procedure NoCompress;
  var
    Next: T8Bit;
  begin
    if (Source.Size - Source.Position < SizeOf(T8Bit)) then Exit;
    Source.ReadBuffer(Next, SizeOf(Next));
    Destination.WriteBuffer(Next, SizeOf(Next));
    if (Next = CodeFlag) then Destination.WriteBuffer(NoCode, SizeOf(NoCode));
  end;

begin
 Source.Position := 0;
 Destination.Clear;

 while (Source.Size - Source.Position >= SizeOf(T8Bit)) do
   if not Try8BitCompress then
   if not Try16BitCompress then
   if not Try24BitCompress then
   if not Try32BitCompress then NoCompress;

 Source.Position := 0;
 Destination.Position := 0;
end;




procedure RLEAlternateDecompress(Source, Destination: TMemoryStream);
var
  CodeCount: T8Bit;
  Next: T8Bit;

  Count: T8Bit;
  Bits: T8Bit;

  procedure Decode8(Count: T8Bit);
  var
    i: T8Bit;
    MultiNext: T8Bit;
  begin
    Source.ReadBuffer(MultiNext, SizeOf(MultiNext));
    for i := Count downto 1 do
      Destination.WriteBuffer(MultiNext, SizeOf(MultiNext));
  end;

  procedure Decode16(Count: T8Bit);
  var
    i: T8Bit;
    MultiNext: T16Bit;
  begin
    Source.ReadBuffer(MultiNext, SizeOf(MultiNext));
    for i := Count downto 1 do
      Destination.WriteBuffer(MultiNext, SizeOf(MultiNext));
  end;

  procedure Decode24(Count: T8Bit);
  var
    i: T8Bit;
    MultiNext: T24Bit;
  begin
    Source.ReadBuffer(MultiNext, SizeOf(MultiNext));
    for i := Count downto 1 do
      Destination.WriteBuffer(MultiNext, SizeOf(MultiNext));
  end;

  procedure Decode32(Count: T8Bit);
  var
    i: T8Bit;
    MultiNext: T32Bit;
  begin
    Source.ReadBuffer(MultiNext, SizeOf(MultiNext));
    for i := Count downto 1 do
      Destination.WriteBuffer(MultiNext, SizeOf(MultiNext));
  end;

begin
  Source.Position := 0;
  Destination.Clear;

  while (Source.Size - Source.Position >= SizeOf(T8Bit)) do
  begin
    Source.ReadBuffer(Next, SizeOf(Next));
    if (Next = CodeFlag) then
    begin
      Source.ReadBuffer(CodeCount, SizeOf(CodeCount));
      Count := CodeCount and CountMask;
      if (Count > 0) then
      begin
        Bits := CodeCount and TypeMask;
        if Bits = Type8 then Decode8(Count)
        else if Bits = Type16 then Decode16(Count)
        else if Bits = Type24 then Decode24(Count)
        else Decode32(Count);
      end
      else Destination.WriteBuffer(Next, SizeOf(Next));
    end
    else Destination.WriteBuffer(Next, SizeOf(Next));
  end;

  Source.Position := 0;
  Destination.Position := 0;
end;

end.
⇑ Kompression und Dekompression: RLE-Alternierend ⇑
Beispiele Beispiele zu RLE-Alternierend
Text-Beispiel
Das folgende Beispiel ist eine Text-Datei.

Die Zeichenfolge '0D 0A' ist ein Zeilenumbruch.
Klartext (Text)
Zeile 00 01 02 03 04 05 06 07  08 09 10 11 12 13 14 15 Text
00
16
32
48
64
 48 61 61 61 61 61 61 61  61 61 61 61 61 6C 6C 6F
21 21 21 0D 0A 69 69 69  69 69 69 69 69 69 69 69
69 69 69 69 69 69 69 69  69 69 69 69 69 69 69 69
63 68 20 62 69 69 69 69  69 69 69 69 69 69 69 69
69 69 69 69 69 69 69 69  69 6E 73 21 21 21 21
 Haaaaaaaaaaaallo
!!!··iiiiiiiiiii
iiiiiiiiiiiiiiii
ch biiiiiiiiiiii
iiiiiiiiins!!!!
Komprimat (Text)
Zeile 00 01 02 03 04 05 06 07  08 09 10 11 12 13 14 15 Text
00
16
 48 FF 0C 61 6C 6C 6F 21  21 21 0D 0A FF 1B 69 63
68 20 62 FF 15 69 6E 73  FF 04 21
 H•·allo!!!··•·ic
h b•·ins•·!
Bitmap-Beispiel
Das folgende Beispiel ist eine 16-Farben-Bitmap-Datei, die ein graues X auf schwarzem Hintergrund repräsentiert.
Klartext (Bitmap)
Zeile 00 01 02 03 04 05 06 07  08 09 10 11 12 13 14 15 Text
000
016
032
048
064
080
096
112

128
144
160
176
192
208
224
240

256
272
288
304
320
336
352
368

384
400
416
432
448
464
480
496

512
528
544
560
576
592
608
624
 42 4D 76 02 00 00 00 00  00 00 76 00 00 00 28 00
00 00 20 00 00 00 20 00  00 00 01 00 04 00 00 00
00 00 00 02 00 00 CE 0E  00 00 CE 0E 00 00 00 00
00 00 00 00 00 00 00 00  00 00 00 00 80 00 00 80
00 00 00 80 80 00 80 00  00 00 80 00 80 00 80 80
00 00 C0 C0 C0 00 80 80  80 00 00 00 FF 00 00 FF
00 00 00 FF FF 00 FF 00  00 00 FF 00 FF 00 FF FF
00 00 FF FF FF 00 00 00  00 00 00 00 00 00 00 00

00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00  77 77 00 00 00 00 00 00
00 00 77 77 00 00 00 00  77 77 00 00 00 00 00 00
00 00 77 77 00 00 00 77  77 77 77 00 00 00 00 00
00 77 77 77 77 00 00 77  77 77 77 00 00 00 00 00
00 77 77 77 77 00 00 77  77 77 77 77 00 00 00 00
77 77 77 77 77 00 00 77  77 77 77 77 00 00 00 00
77 77 77 77 77 00 00 00  77 77 77 77 77 00 00 77

77 77 77 77 00 00 00 00  77 77 77 77 77 00 00 77
77 77 77 77 00 00 00 00  00 77 77 77 77 77 77 77
77 77 77 00 00 00 00 00  00 77 77 77 77 77 77 77
77 77 77 00 00 00 00 00  00 00 77 77 77 77 77 77
77 77 00 00 00 00 00 00  00 00 77 77 77 77 77 77
77 77 00 00 00 00 00 00  00 00 00 77 77 77 77 77
77 00 00 00 00 00 00 00  00 00 00 77 77 77 77 77
77 00 00 00 00 00 00 00  00 00 00 77 77 77 77 77

77 00 00 00 00 00 00 00  00 00 00 77 77 77 77 77
77 00 00 00 00 00 00 00  00 00 77 77 77 77 77 77
77 77 00 00 00 00 00 00  00 00 77 77 77 77 77 77
77 77 00 00 00 00 00 00  00 77 77 77 77 77 77 77
77 77 77 00 00 00 00 00  00 77 77 77 77 77 77 77
77 77 77 00 00 00 00 00  77 77 77 77 77 00 00 77
77 77 77 77 00 00 00 00  77 77 77 77 77 00 00 77
77 77 77 77 00 00 00 77  77 77 77 77 00 00 00 00

77 77 77 77 77 00 00 77  77 77 77 77 00 00 00 00
77 77 77 77 77 00 00 77  77 77 77 00 00 00 00 00
00 77 77 77 77 00 00 77  77 77 77 00 00 00 00 00
00 77 77 77 77 00 00 00  77 77 00 00 00 00 00 00
00 00 77 77 00 00 00 00  77 77 00 00 00 00 00 00
00 00 77 77 00 00 00 00  00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
00 00 00 00 00 00
 BMv·······v···(·
·· ··· ·········
······•···•·····
············•··•
···••·•···•·•·••
··•••·•••···•··•
···••·•···•·•·••
··•••···········

················
········ww······
··ww····ww······
··ww···wwww·····
·wwww··wwww·····
·wwww··wwwww····
wwwww··wwwww····
wwwww···wwwww··w

wwww····wwwww··w
wwww·····wwwwwww
www······wwwwwww
www·······wwwwww
ww········wwwwww
ww·········wwwww
w··········wwwww
w··········wwwww

w··········wwwww
w·········wwwwww
ww········wwwwww
ww·······wwwwwww
www······wwwwwww
www·····wwwww··w
wwww····wwwww··w
wwww···wwwww····

wwwww··wwwww····
wwwww··wwww·····
·wwww··wwww·····
·wwww···ww······
··ww····ww······
··ww············
················
······
Komprimat (Bitmap)
Zeile 00 01 02 03 04 05 06 07  08 09 10 11 12 13 14 15 Text
000
016
032
048
064
080
096
112

128
144
160
176
192
208
224
240

256
272
288
304
320
336
 42 4D 76 02 FF 06 00 76  00 00 00 28 FF C2 00 00
00 20 00 00 00 01 00 04  FF 06 00 02 FF C2 00 00
CE 0E FF 10 00 FF 82 80  00 00 00 80 80 00 80 00
00 FF 43 00 80 80 00 00  C0 C0 C0 00 80 80 80 00
FF 82 00 00 FF 00 00 00  FF 00 FF 00 00 FF 00 00
00 FF 43 00 FF FF 00 00  00 FF 00 FF 00 FF 00 FF
23 00 77 77 FF 08 00 77  77 FF 04 00 77 77 FF 08
00 77 77 00 00 00 FF 04  77 FF 06 00 FF 04 77 00

00 FF 04 77 FF 06 00 FF  04 77 00 00 FF 05 77 FF
04 00 FF 05 77 00 00 FF  05 77 FF 04 00 FF 05 77
00 00 00 FF 05 77 00 00  FF 05 77 FF 04 00 FF 05
77 00 00 FF 05 77 FF 05  00 FF 0A 77 FF 06 00 FF
0A 77 FF 07 00 FF 08 77  FF 08 00 FF 08 77 FF 09
00 FF 06 77 FF 0A 00 FF  06 77 FF 0A 00 FF 06 77
FF 0A 00 FF 06 77 FF 09  00 FF 08 77 FF 08 00 FF
08 77 FF 07 00 FF 0A 77  FF 06 00 FF 0A 77 FF 05

00 FF 05 77 00 00 FF 05  77 FF 04 00 FF 05 77 00
00 FF 05 77 00 00 00 FF  05 77 FF 04 00 FF 05 77
00 00 FF 05 77 FF 04 00  FF 05 77 00 00 FF 04 77
FF 06 00 FF 04 77 00 00  FF 04 77 FF 06 00 FF 04
77 00 00 00 77 77 FF 08  00 77 77 FF 04 00 77 77
FF 08 00 77 77 FF 22 00
 BMv·•··v···(••··
· ······•···••··
•·•··•••···••·•·
·•C·••··•••·•••·
••··•···•·•··•··
·•C·••···•·•·•·•
#·ww•··ww•··ww•·
·ww···•·w•··•·w·

·•·w•··•·w··•·w•
··•·w··•·w•··•·w
···•·w··•·w•··•·
w··•·w•··•·w•··•
·w•··•·w•··•·w•·
·•·w•··•·w•··•·w
•··•·w•··•·w•··•
·w•··•·w•··•·w•·

·•·w··•·w•··•·w·
·•·w···•·w•··•·w
··•·w•··•·w··•·w
•··•·w··•·w•··•·
w···ww•··ww•··ww
•··ww•"·
Unrealistisches Beispiel
Das folgende Beispiel ist eine Text-Datei mit 220 a's gefolgt von 2 Blanks gefolgt von 300 b's gefolgt von 2 Blanks gefolgt von 220 c's

Dieses Beispiel ist recht unrealistisch; derartige Dateien sind selten!
Klartext (unrealistisch)
Zeile 00 01 02 03 04 05 06 07  08 09 10 11 12 13 14 15 Text
000
016
032
048
064
080
096
112

128
144
160
176
192
208
224
240

256
272
288
304
320
336
352
368

384
400
416
432
448
464
480
496

512
528
544
560
576
592
608
624

640
656
672
688
704
720
736
 61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61

61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 61 61 61 61
61 61 61 61 61 61 61 61  61 61 61 61 20 20 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62

62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62

62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62
62 62 62 62 62 62 62 62  62 62 62 62 62 62 62 62

62 62 62 62 62 62 62 62  62 62 20 20 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63

63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63  63 63 63 63 63 63 63 63
63 63 63 63 63 63 63 63
 aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa

aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaa
aaaaaaaaaaaa  bb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb

bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb

bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbb

bbbbbbbbbb  cccc
cccccccccccccccc
cccccccccccccccc
cccccccccccccccc
cccccccccccccccc
cccccccccccccccc
cccccccccccccccc
cccccccccccccccc

cccccccccccccccc
cccccccccccccccc
cccccccccccccccc
cccccccccccccccc
cccccccccccccccc
cccccccccccccccc
cccccccc
Komprimat (unrealistisch)
Zeile 00 01 02 03 04 05 06 07  08 09 10 11 12 13 14 15 Text
00
16
32
 FF 3F 61 FF 3F 61 FF 3F  61 FF 1F 61 20 20 FF 3F
62 FF 3F 62 FF 3F 62 FF  3F 62 FF 30 62 20 20 FF
3F 63 FF 3F 63 FF 3F 63  FF 1F 63
 •?a•?a•?a•·a  •?
b•?b•?b•?b•0b  •
?c•?c•?c•·c
Startseite   Sitemap   Downloads   Hilfe   Impressum   Lastenheft  
Startseite < Informatik < Algorithmen < Sortieren Komprimieren < RLE < RLE (8-Bit) RLE (16-Bit) RLE (24-Bit) RLE (32-Bit) [ DRUCK , 2004 , 2005 , 2006 , 2007 , 2008 , 2009 ] RLE (alternierend) > Huffman Lempel-Ziv > Suchen / Primzahltest > Datenstrukturen / Software-Engineering / Programmiersprachen / Künstliche Intelligenz > Schach Privates / Inhalt >