1:
2:
3:
4:

Inputstring = 'halloWelt';
SearchChar := 'l'; //  l= "el" und nicht "eins"

res := GetNumberOfChars(Inputstring, SearchChar); // res = 3                    

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

function TForm1.SubstringFinden(const Text, Suchstring: String): integer;
var i, Anzahl: integer;
begin
  Anzahl := 0;
  for i := 1 to length(Text) - length(Suchstring) +1 do
    if copy(Text, i, length(Suchstring)) = Suchstring then inc(Anzahl);// gibt sicher was besseres als copy grad nur keine zeit zu gucken
end;                    

1:
2:
3:

    for i := 1 to Length(s) do
      if s[i] = ' ' then
        inc(m1);                    

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

function TForm1.SubstringFinden(const Text, Suchstring: String): integer;
var i, Anzahl: integer;
begin
  Anzahl := 0;
  for i := 1 to length(Text) - length(Suchstring) +1 do
    if copy(Text, i, length(Suchstring)) = Suchstring then inc(Anzahl);
// gibt sicher was besseres als copy grad nur keine zeit zu gucken
  Result := Anzahl // so :D das wichtigste vergessen :P
// soweit ich weis könnte man Anzahl auch weglassen und es so lösen 
  Result:= 0;
  .... then inc(Result);
// dann kann man die letzte Zeile sparen :D (nicht ausprobiert)
end;                    

1:
2:
3:
4:

function CountChars(Haystack: String; Needle: Char): Integer;
begin
    Result := Length(Haystack) - Length(StringReplace(Haystack, Needle, '', [rfReplaceAll]));
end;                    

1:
2:
3:
4:

function CountNonOverlappingStr(Haystack: String; Needle: String): Integer;
begin
    Result := Length(Haystack) - Length(StringReplace(Haystack, Needle, '', [rfReplaceAll]));
end;                    

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

function SubstringFinden(Text, Suchstring: String): integer;
var i, Anzahl: integer;
begin
  Anzahl := 0;
  i := Pos(SuchString, Text);
  while i > 0 do
  begin
    inc(Anzahl);
    i := PosEx(Suchstring, Text, i + Length(SuchString));
  end;
  Result := Anzahl;
end;                    

1:
2:
3:
4:

function CountNonOverlappingStr(Haystack: String; Needle: String): Integer;
begin
    Result := (Length(Haystack) - Length(StringReplace(Haystack, Needle, '',[rfReplaceAll])))div length(Needle);
end;                    

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

// returns the number of found characters (Note: comparison is case sensitive!)
function GetNumberOfChars(const sInput : string; const chrSearch : char) : Integer;
var
  i : Integer;

begin
  Result := 0;
  for i:=1 to Length(sInput) do
    if (sInput[i] = chrSearch) then
      Inc(Result);
end;                    

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:

function GetNumberOfChars(const aString : String; const aChar : Char) : Integer;
var
  FCount : integer;
  FFind  : Integer;
begin
  FCount := 0;
  FFind  := ord(aChar);
  asm
    // ****
    // **** Initialisierung
    // ****
    mov eax, aString // ** Der zu durchsuchende String
    mov ecx, FCount  // ** Ergebnis

    @CNT:                  // ** Schleife
    inc eax                // ** Schleifenzähler inkrementieren
    movzx edx, byte [eax]  // ** n. Zeichen holen
    cmp edx, FFind         // ** Vergleiche n. Zeichen mit Suche
    jne @NXT               // ** Nicht gefunden, springe zu Schleifenende
    inc ecx                // ** Gefunden, Ergebnis inkrementieren
    @NXT:                  // ** Schleifenende
    cmp edx, 0             // ** Ende von String ?
    jne @CNT               // ** Nein, also nächstes Zeichen
    mov FCount, ecx        // ** Fertig, Ergebnis zuweisen
  end;
  Result := FCount;
end;                    

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:

function CountCharOccurrences(const aChar: Char; const aString: String): Integer;
asm
  // Wenn edx 0 ist, abbrechen und 0 zurückgeben
  or edx, edx
  jnz @ValidString
  xor eax, eax
  ret
  @ValidString:

  // Register sichern
  push edi

  // in al ist bereits aChar drin, fehlt für scasb noch der zu scannende
  // String in edi
  mov edi, edx
  mov dword ptr ecx, [edx - $04]

  xor edx, edx // Zähler auf 0

  @repeat:
  inc edx
  {$ifdef UNICODE}
  repne scasw
  {$else}
  repne scasb
  {$endif}
  jz @repeat

  // Ergebnis zurückgeben
  dec edx
  mov eax, edx

  // Register wiederherstellen
  pop edi
end;                    

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:

function GetNumberOfChars(const aChar: Char; const aString: String): Integer;
asm
  // Wenn edx 0 ist, abbrechen und 0 zurückgeben
  cmp edx, 0
  jnz @ValidString
  xor eax, eax
  ret
  @ValidString:

  // Register sichern
  push edi
  push ebx
  push ecx

  xor ebx, ebx // Zähler auf 0

  // in al ist bereits aChar drin, fehlt für scasb noch der zu scannende
  // String in edi
  mov edi, edx
  mov ecx, [edx - $04]

  @repeat:
  inc ebx
  {$ifdef UNICODE}
  repne scasw
  {$else}
  repne scasb
  {$endif}
  jz @repeat

  // Ergebnis zurückgeben
  dec ebx
  mov eax, ebx

  // Register wiederherstellen
  pop ecx
  pop ebx
  pop edi
end;                    

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:

function GetNumberOfChars(const aChar: Char; const aString: String): Integer;
asm
    // Wenn edx 0 ist, abbrechen und 0 zurückgeben
    TEST    EDX, EDX
    JNZ     @@ValidString

    XOR     EAX, EAX
    RET

@@ValidString:

    // Register sichern
    PUSH    EDI

    // in al ist bereits aChar drin, fehlt für scasb noch der zu scannende
    // String in edi
    MOV     EDI, EDX
    MOV     ECX, DWORD PTR [EDX - $04]

    // Zähler auf 0
    XOR     EDX, EDX

@@repeat:
    INC     EDX

    {$IFDEF UNICODE}
    REPNE   SCASW
    {$ELSE}
    REPNE   SCASB
    {$ENDIF}
    JZ @@repeat

    // Ergebnis zurückgeben
//    DEC     EDX
//    MOV     EAX, EDX
    LEA     EAX, DWORD PTR [EDX - $01] 
    //Do the copying with one instruction instead of two
    //This leaves the ALU free for other tasks

    // Register wiederherstellen
    POP     EDI
end;                    

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

function TForm1.Substringmenge(Substring, Text: Pchar): integer;
var PC :Pchar;
    i  : integer;
begin 
  Result := 0;
  PC := Text - 1;
  while (PC <> nil) do
  begin
    inc(PC);
    PC := AnsiStrPos(PC, substring);
    inc(Result);
  end;
  Result := Result - 1;
end;                    

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

Running "c:\fpc\2.2.4\bin\i386-win32\noofchar.exe "
250
Asm : 00:00:02.125
250
Pas : 00:00:00.359
250
Asm : 00:00:02.141
250
Pas : 00:00:00.375
125
SubStringPas : 00:00:06.906                    

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

250
Asm : 00:00:02.125
250
Pas : 00:00:00.235
250
Asm : 00:00:02.156
250
Pas : 00:00:00.234
250
SubStringPas : 00:01:54.032 // Holla???                    

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

Running "c:\noofchar.exe "
1
Asm : 00:00:00.250
1
Pas : 00:00:00.562
1
Asm : 00:00:00.235
1
Pas : 00:00:00.562
1
SubStringPas : 00:00:00.266                    

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

1
Asm : 00:00:00.235
1
Pas : 00:00:00.453
1
Asm : 00:00:00.250
1
Pas : 00:00:00.453
1
SubStringPas : 00:00:00.953                    

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

function GetNumberOfChars_Pas(const aChar: Char; const aString: String): Integer;
var
  i : integer;
begin
  result := 0;
  IF aString = '' then
    exit;
  //Abwärts,weil sonst jedesmal length abgefragt wird
  For i := length(aSTring) downto 1 do
    begin
    if aString[i] = aChar then
      inc(result);
    end;
end;                    

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:

asm
    .....

    // Zähler auf 0
    XOR     EDX,EDX;

    //aChar retten
    PUSH    EBX
    MOVZX   EBX, AL

@@repeat:
    SUB     AL,Byte Ptr [EDI+ECX]
{***** EDIT: wie umständlich....  
    NOT     AL    ; //Nur wenn AL= 0 =>AL = $FF
    ADD     AL,1  ; //und nur dann ist Carry gesetzt
******}
    SUB     AL,1  ; //Nur wenn AL= 0 =>AL-1 = $FF=> Carry gesetzt
    MOV     EAX, EBX  // EAX wiedre zu aChar machen
    ADC     EDX,0 ; //Carry addieren

    DEC     ECX
    JGE     @@repeat //

    ADC     EDX,0 ;
    // Register wiederherstellen

    POP     EBX
    POP     EDI
    MOV     EAX,EDX
end;                    

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:

./NoOfChar

Alle 1 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:06.562  Asm_BenBe_Takte :  19.03
Asm       : 00:00:00.806  Asm_Takte :         2.34
Pas       : 00:00:01.385  PasTakte :          4.02

Alle 7 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:01.529  Asm_BenBe_Takte :   4.43
Asm       : 00:00:00.806  Asm_Takte :         2.34
Pas       : 00:00:01.976  PasTakte :          5.73

Alle 32 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:00.875  Asm_BenBe_Takte :   2.54
Asm       : 00:00:00.806  Asm_Takte :         2.34
Pas       : 00:00:02.266  PasTakte :          6.57

Alle 96 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:00.752  Asm_BenBe_Takte :   2.18
Asm       : 00:00:00.806  Asm_Takte :         2.34
Pas       : 00:00:02.139  PasTakte :          6.20

Alle 254 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:00.714  Asm_BenBe_Takte :   2.07
Asm       : 00:00:00.807  Asm_Takte :         2.34
Pas       : 00:00:02.097  PasTakte :          6.08

Habe fertig                    

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:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:

{$IFDEF FPC}
  {$MODE objFPC}
  {$H+}
  {$ASMMODE INTEL}
  {$Optimization ON,RegVar,CSE,ASMCSE,PeepHole}
  {$CODEALIGN proc= 32,loop=4}
{$ELSE}
  {$APPTYPE CONSOLE}  
{$ENDIF}
uses
  sysutils;

function GetNumberOfChars_Pas(const aChar: Char; aString: AnsiString): Integer;
var
  i : integer;
  pc : pchar;
begin
  result := 0;
  IF aString = '' then
    exit;
  i := length(aSTring)-1;
  pc := pChar(aString);
  For i :=  i downto 0 do
    IF pc[i] = aChar then
      inc(result);
//  For i :=  i downto 0 do   result := result + ORD(pc[i] = aChar);      
end;

function GetNumberOfChars_ASM(const aChar: Char; const aString: AnsiString): Integer;assembler;nostackframe;
asm
    // Wenn edx 0 ist, abbrechen und 0 zurückgeben
    TEST    EDX, EDX
    JNZ     @@ValidString
    XOR     EAX, EAX
    JMP     @@Ende

@@ValidString:

    // Register sichern
    PUSH    EDI
    PUSH    EBX

    // in al ist bereits aChar drin
    MOV     EDI,EDX
    MOV     ECX, DWORD PTR [EDX - $04]

    //aChar retten
    MOVZX     EBX, AL

    // Zähler auf 0
    clc
    XOR     EDX,EDX;

@@repeat:
    SUB     AL,Byte Ptr [EDI+ECX]
    SUB     AL,1  ;   //Nur wenn AL= 0 =>AL = $FF und Carry/Borrow gesetzt
    MOV     EAX, EBX  //EAX wieder zu aChar machen    
    ADC     EDX,0 ;   //Carry addieren
    DEC     ECX
    JGE     @@repeat //

    ADC     EDX,0 ;
    // Register wiederherstellen

    POP     EBX
    POP     EDI
    MOV     EAX,EDX
@@Ende:
end;

function GetNumberOfChars_ASMBe(const aChar: Char; const aString: AnsiString): Integer;assembler;
asm
    // Wenn edx 0 ist, abbrechen und 0 zurückgeben
    TEST    EDX, EDX
    JNZ     @@ValidString

    XOR     EAX, EAX
    RET

@@ValidString:

    // Register sichern
    PUSH    EDI

    // in al ist bereits aChar drin, fehlt für scasb noch der zu scannende
    // String in edi
    MOV     EDI, EDX
    MOV     ECX, DWORD PTR [EDX - $04]

    // Zähler auf 0
    XOR     EDX, EDX

@@repeat:
    INC     EDX

    {$IFDEF UNICODE}
    REPNE   SCASW
    {$ELSE}
    REPNE   SCASB
    {$ENDIF}
    JZ @@repeat

    // Ergebnis zurückgeben
//    DEC     EDX
//    MOV     EAX, EDX
    LEA     EAX, DWORD PTR [EDX - $01]
    //Do the copying with one instruction instead of two
    //This leaves the ALU free for other tasks

    // Register wiederherstellen
    POP     EDI
end;

const
  CPUF = 3500000000;   // CPU-Frequenz

  MAXCOUNT= 100000;
  MAXLENGTH = 10000;

procedure Test(Wiederholrate:integer);
var
  t1,t0: TDateTime;
  TestStr : AnsiString;
  TestChr : char;
  i : integer;
begin
  setlength(TestStr,MAXLENGTH);
  //Strings ,die die Abfolge 1234..WIEDERHOLRATE-1 enthalten
  For i := length(TestStr) Downto 1 do
    TestStr[i] := chr(i mod WIEDERHOLRATE +1);
  testChr := chr(1);

  Writeln('Alle ',Wiederholrate,' Zeichen kommt chr(1) im String der Länge ',length(TestStr),' vor');

  t0 := time;
  For I := 1 to MAXCOUNT do
    GetNumberOfChars_ASMBe(TestChr,TestStr);
  t1 := time;
  write('Asm_BenBe : ',FormatDateTime('hh:mm:ss.zzz',t1-t0));
  writeln('  Asm_BenBe_Takte : ',(t1-t0)*86400 /MAXCOUNT/MAXLENGTH*CPUF:6:2);

  t0 := time;
  For I := 1 to MAXCOUNT do
    GetNumberOfChars_ASM(TestChr,TestStr);
  t1 := time;
  write('Asm       : ',FormatDateTime('hh:mm:ss.zzz',t1-t0));
  writeln('  Asm_Takte :       ',(t1-t0)*86400 /MAXCOUNT/MAXLENGTH*CPUF:6:2);

  t0 := time;
  For I := 1 to MAXCOUNT do
    GetNumberOfChars_PAS(TestChr,TestStr);
  t1 := time;
  write('Pas       : ',FormatDateTime('hh:mm:ss.zzz',t1-t0));
  writeln('  PasTakte :        ',(t1-t0)*86400 /MAXCOUNT/MAXLENGTH*CPUF:6:2);
  writeln;
end;
Begin
Test(1); 
Test(7);
Test(32);
Test(96);
Test(254);
writeln;
writeln('Habe fertig');
readln;
end.                    

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:

Alle 1 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:14.314  Asm_BenBe_Takte :  50.10
Asm       : 00:00:00.409  Asm_Takte :         1.43
Pas       : 00:00:00.487  PasTakte :          1.70

Alle 7 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:02.582  Asm_BenBe_Takte :   9.04
Asm       : 00:00:00.410  Asm_Takte :         1.44
Pas       : 00:00:00.906  PasTakte :          3.17

Alle 32 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:01.014  Asm_BenBe_Takte :   3.55
Asm       : 00:00:00.416  Asm_Takte :         1.46
Pas       : 00:00:00.910  PasTakte :          3.18

Alle 96 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:00.723  Asm_BenBe_Takte :   2.53
Asm       : 00:00:00.408  Asm_Takte :         1.43
Pas       : 00:00:00.687  PasTakte :          2.40

Alle 254 Zeichen kommt chr(1) im String der Länge 10000 vor
Asm_BenBe : 00:00:00.632  Asm_BenBe_Takte :   2.21
Asm       : 00:00:00.408  Asm_Takte :         1.43
Pas       : 00:00:00.624  PasTakte :          2.18

Habe fertig