1:
2:

type
  T2dBolFeld  = array[0..255,0..255] of Boolean;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

program LogNueberK;
var
  i: integer;
  k,S:extended;
begin
  S:= 1.0;
  For i := 1 to 32768 do
  begin
    k := 65536-i;
    S := S+ln(k)-ln(i);
    writeln(i:8,'  e^ ',s:0:4);
  end;
end.					

1:
2:
3:
4:
5:
6:

T2DBoolFeld = Array of Array of Boolean;

//aber bei setlength verwende ich Byte und somit werden die Arrays nicht größer als 255*255 sein 
var x:Byte;
X := "neueBreite";
setlength( T2DBoolFeld, X );					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

program t_ba_md5;

{$APPTYPE CONSOLE}

uses
   hash,md5;
type
  T2DBoolFeld = Array of Array of Boolean;
var
  arr: T2DBoolFeld;
  i,j: integer;
var
  Context: THashContext;
  Digest : TMD5Digest;
begin
  //Allokieren und belegen
  setlength(arr,40,200);
  for i:= low(arr) to high(arr) do begin
    for j:=low(arr[i]) to high(arr[i]) do arr[i,j] := random(2)=1;
  end;
  //MD5 berechnen
  MD5Init(Context);
  for i:= low(arr) to high(arr) do begin
    for j:=low(arr[i]) to high(arr[i]) do MD5Update(Context,@arr[i],1);
  end;
  MD5Final(Context,Digest);
end.					

1:

for j:=low(arr[i]) to high(arr[i]) do MD5Update(Context,@arr[i,j],1); //heißen?					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:

uses Math;

{type
  Boolean2DArray = Array of Array of Boolean;
  THash = Array[1..4] of Byte;}
function HashIt( Booleans: Boolean2DArray ): THash;
var Bytes: Array of Byte;
    Hash: Array of Byte;
    C: Word; // (255*255 / 8) wird maximal benötigt
    X,Y : Byte;
begin
//Booleans Bitweise in Hash schreiben
setlength( Hash, Ceil( Length(Booleans)*Length(Booleans[0])/8) );
//letztes Byte initialisieren, alle anderen werden vollkommen "überschrieben"
Hash[ High(Hash) ] := 0;
For X:=0 to High(Booleans) do
For Y:=0 to High(Booleans[X]) do
  begin
  C := Y*(Length(Booleans)+1) +X;
  if Booleans[X,Y] then
    Hash[ C div 8 ] := Hash[ C div 8 ] or (1 shl (C mod 8));
  end;

//Hashen ?!
while Length(Hash)>4 do
  begin
  setlength(Bytes, Length(Hash)-1);
  For C:=1 to High(Hash) do
    begin
      case (C mod 3) of
      0:    Bytes[C-1] := Hash[C-1] and Hash[C];
      1:    Bytes[C-1] := Hash[C-1] or Hash[C];
      2:    Bytes[C-1] := Hash[C-1] xor Hash[C];
      else  Bytes[C-1] := Hash[C-1] and not Hash[C]; //trifft nie ein !
      end;
    end;

  //Hash in Bytes schreiben !
  setlength(Hash, Length(Bytes));
  For C:=0 to High(Bytes) do
    Hash[C] := Bytes[C];
  end;
For C:=0 to High(Hash) do //Wenn es nur wenige booleans sind (<25) dann sinds <3 Bytes !
   Result[C+1] := Hash[C];
//Falls "zu wenig" booleans übermittelt wurde Ergebnis-unbenutzte-Bytes-initialisieren
For C:=High(Hash)+1 to 3 do
   Result[C+1] := 0;

end;