1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Var
 A, B : String;
 I : Integer;
begin
 A := 'Wurzel';
 B := A;
 For I := 1 to length(A) do
  B[length(A)-I+1] := A[I];
 // B := 'lezruW';
end;                    

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

varr   
 A : String;   
 I : Integer; 
 B : char;   
begin   
 A := 'Wurzel';   
 For I := 1 to length(A) do 
 begin
  b := a[i];
  A[I] := A[length(A)-i+1]; 
  A[length(A)-i+1] := b;
 end;  
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

Var
 A, B : String;
 Index : Integer;
begin
 A := 'Wurzel';
 B := '';
 For Index :=  length(A) downto 1 do B := B + A[Index];
 // B := 'lezruW';
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Var
 A, B : String;
 Index : Integer;
 laenge : Integer;
begin
 A := 'Wurzel';
 laenge := Length(A); // Damit Length nur einmal aufgerufen werden muss
 SetLength(B,laenge);
 For Index := laenge downto 1 do B[laenge+1-Index] := A[Index];
end;                    

1:
2:

For I := 1 to length(A) do  
  B[length(A)-I+1] := A[I];                    

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

var s: string;
    i, l: integer;
    b: char;
begin
  s := 'das ist ein test';
  l := length(s);
  for i := 1 to l div 2 do
  begin
    b := s[i];
    s[i] := s[l-i+1];
    s[l-i+1] := b;
  end;
  form1.caption := s;
end;                    

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

Var
 A : String;
 B : Char;
 Index : Integer;
 Ende : Integer;
 laenge : Integer;
begin
 A := 'Wurzel';
 laenge := Length(A); // Damit Length nur einmal aufgerufen werden muss
 Ende := (laenge div 2)+1;
 For Index := laenge downto ende do begin
   B := A[laenge+1-Index];
   A[laenge+1-Index] := A[Index];
   A[Index] := B;
 end;
end;                    

1:

  Edit1.Text := AnsiReverseString(Edit2.Text);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

procedure TForm1.Button1Click(Sender: TObject);
Var
 A : String;
 B : Char;
 Index : Integer;
 Ende : Integer;
 laenge : Integer;
begin
 A := Edit2.Text;
 laenge := Length(A); // Damit Length nur einmal aufgerufen werden muss
 Ende := (laenge div 2)+1;
 For Index := laenge downto ende do begin
   B := A[laenge+1-Index];
   A[laenge+1-Index] := A[Index];
   A[Index] := B;
 end;
 Edit1.Text := A;
end;                    

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

function Reverse(S: string): string;
var
  I: integer;
  L: integer;
  P: PChar;
  Q: PChar;
begin
  L := Length(S);

  if L = 0 then
    Exit;

  SetLength(Result, L);

  P := PChar(Result);
  Q := PChar(S) + (L - 1);

  repeat
    P^ := Q^;
    Inc(P);
    Dec(Q);
  until Q = PChar(Pointer(S));
end;                    

1:

Edit1.Text := Reverse(Edit2.Text);                    

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:

procedure change(s: pchar);
asm
  push edx
  push ecx
  push ebx
  push esi
  xor edx, edx
@goon:
  mov cl, [eax+edx]
  inc edx
  test cl, cl
  jnz @goon
  dec edx
  dec edx
  mov esi, edx
  shr esi, 1

  xor ecx, ecx
@goon2:
  test esi, esi
  jz @ende
  mov bl, [eax+ecx]
  xchg byte ptr [eax+edx], bl
  mov byte ptr[eax+ecx], bl

  dec esi
  dec edx
  inc ecx
  jmp @goon2
@ende:
  pop esi
  pop ebx
  pop ecx
  pop edx
end;

procedure TForm1.FormCreate(Sender: TObject);
var s: string;
begin
  memo1.lines[0] := 'das ist ein test hahahahaha';
  s := memo1.lines[0];
  change(pchar(s));
  form1.caption := s;
end;                    

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

  edtReverseOutput.Text := res;

  sIn := edtReverseInput.Text;
  len := Length(sIn);

  SetLength(sOut, Len);

  for i := 1 to Len do begin
    pchar(integer(pointer(sOut)) + len - i)^ := pchar(integer(pointer(sIn)) + i - 1)^;
  end;


  edtReverseOutput.Text := sOut;                    

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

  For I := 1 to length(S) do
  begin
    P^ := Q^;
    Inc(P);
    Dec(Q);
  end;                    

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

 mov dl,[esi]
 mov [ebx],dl
 inc ebx
 dec esi
 dec eax
 jnz -$09                    

1:
2:
3:
4:
5:

@goon:   
  mov cl, [eax+edx]   // zeichen in cl
  inc edx               // edx hochzählen
  test cl, cl         // zeichen auf 0 testen
  jnz @goon             // wenn nicht wiederhole                    

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

  dec edx           //
  dec edx           // länge um 2 kürzen wegen 1 mal zu viel hochgezählt und der #0
  mov esi, edx     // in ESI
  shr esi, 1     // länge um 2 dividieren, SHR schnellste funktion (besser als delphi mit SAR? des gelöst hat) 

  xor ecx, ecx     // ECX = 0
@goon2:    
  test esi, esi                        // ESI auf 0 testen   
  jz @ende                              // wenn ja zum ende
  mov bl, [eax+ecx]                  // in bl das erste zeichen
  xchg byte ptr [eax+edx], bl      // das letze zeichen mit BL austauschen  (schneller als das was delphi macht)
  mov byte ptr[eax+ecx], bl            // BL ans erste zeichen

  dec esi                              // ESI und EDX runter zählen und ECX hoch
  dec edx   
  inc ecx   
  jmp @goon2                        // und von vorne 
@ende:   
  pop esi   
  pop ebx   
  pop ecx   
  pop edx                    

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

For I := 1 to length(S) do  
begin  
  P^ := Q^;  
  Inc(P);  
  Dec(Q);  
end;