Anzahl eines Zeichens im String ermitteln

[Harry Stahl]

Zitat:

Zitat von Uwe Raabe (Beitrag 1407264)

Zitat:

Zitat von Harry Stahl (Beitrag 1407261)

Eine fertige Funktion scheint es da aber nicht zu geben, oder (String.split habe ich gesehen, gibt aber ein Array der Teilstrings zurück, ich wäre aber erst mal nur an den Positionen des gesuchten Chars interessiert)?

Nein, sowas gibt es bislang noch nicht.

Schade, dann muss ich mir mal überlegen, wo man das bei einer der hier gezeigten Lösungen am besten noch einbauen könnte. Müsste ja dann wohl eine Art dynamisches Array sein, das die einzelnen Positionen aufnimmt.

[EgonHugeist]

@Uwe,

mir scheint der Compiler kennt die Feder das Autors und meint es gut mit ihm :stupid:

Nungut, W64 kann ich dir und CodeZwerg (warum auch immer) auf deinen Pay-Compiler wohl nicht abgraben!
Beim W32 scheint er nun doch auf deiner Seite fremd zugehen..

@Harry

deine Anregung wäre eine weiter Challange -> neues Thema, jodoch sehr leicht. Dieses Thema hier könnte mann auch noch um eine caseinsensitive Suche aufbohren oder so..


@CodeZwerg, wie schauts mit den Benchmarks auf deiner Seite aus??

[Harry Stahl]

Zitat:

Zitat von EgonHugeist (Beitrag 1407268)

@Harry

deine Anregung wäre eine weiter Challange -> neues Thema, jodoch sehr leicht. Dieses Thema hier könnte mann auch noch um eine caseinsensitive Suche aufbohren oder so..

Hast recht, ist schon erledigt (TIntDyArray in der Funktion von Uwe eingebaut, da ich dort immer nur eine Stelle habe, wo der Zähler hochgeht). Aber danke auch an Dich für den Hinweis mit der blockweisen Bearbeitung, da kommen mir Ideen für andere Funktionen (z.B. in der Bitmap-Bearbeitung)...

[Uwe Raabe]

Zitat:

Zitat von Harry Stahl (Beitrag 1407269)

TIntDyArray in der Funktion von Uwe eingebaut, da ich dort immer nur eine Stelle habe, wo der Zähler hochgeht

Eventuell ist es effizienter, beim ersten Mal die Anzahl der Vorkommen zu ermitteln, dann das Array auf die passende Größe setzen und im zweiten Durchlauf dann die Positionen einzutragen. Mehrfache SetLength-Aufrufe wären da eher suboptimal.

Alternativ eine TList<Integer> füllen und über ToArray in ein Array umwandeln.

Man kann natürlich auch erstmal das Array mit Length(S) anlegen, wenn Speicher keine Rolle spielt.

[KodeZwerg]

Da ich eure Sourcen nicht kompilieren kann werde ich meinen Eigenen Benchmark erweitern und bald hier vorstellen.
Geplant ist eine GUI mit einstellbarer Datenmenge, Anzahl von Wiederholungen, Einzeltests<>Multitests.
Eine Idee um Schwankungen auszugleichen habe ich auch schon, was haltet ihr davon?
Idee: LastNano und CurrNano hält Zeitwerte des letzten und aktuellen Vorgangs, bei neuem Durchgang wird die Differenz von Last und Curr extrahiert, geteilt und der Restwert zugerechnet/abgezogen (je nach dem). Wäre das legitim um einen guten Durchschnittswert zu erhalten?
Eine "AddPosArray" funktionalität für Harry werde ich bei meiner Lieblingsfunktion von Uwe integrieren.
Von Egon hab ich nur zwei Varianten, ich lade mir den letzten Eurer Sourcen und nehme alles mit rein.

Als Ergebnis wird die Liste als Rangfolge dann angezeigt.

[Harry Stahl]

Zitat:

Zitat von KodeZwerg (Beitrag 1407272)

Als Ergebnis wird die Liste als Rangfolge dann angezeigt.

Cool, Danke für die Mühe...:thumb:

[jaenicke]

Die Assemblervariante scheitert unter 64-Bit doch nur an dem Unterschied edi <> rdi. Sprich so funktioniert diese unter beidem:

Delphi-Quellcode:

function CharCountAsm(AStr: PChar; AChar: Char; len: Integer): Integer;
label loop_start, loop_ende, ende;
asm
{$ifdef cpux86}
  push edi
{$else}
  push rdi
{$endif}
  cld
{$ifdef cpux86}
  mov edi, AStr
{$else}
  mov rdi, AStr
{$endif}
  mov ax, AChar
  mov ecx, len
  xor edx, edx
loop_start:
  repnz scasw
  jecxz loop_ende
  inc edx
  jmp loop_start
loop_ende:
  jnz ende
  inc edx
ende:
  mov result, edx
{$ifdef cpux86}
  pop edi
{$else}
  pop rdi
{$endif}
end;

Unter 64-Bit sieht das Ergebnis bei mir dann so aus:

Zitat:

Calibrate - Target missed: 0 <> 7982
00000 Calibrate
07331 1234588 miep
06882 Ydobon
07321 marabu
09920 Missionar
07356 alzaimar
09430 Uwe Raabe StringCountChar
07289 Uwe Raabe StringCountCharFor
02684 KodeZwerg CountCharInString
07353 KodeZwerg CharInStringA
03509 Neutral General CharCountAsm
06809 Uwe Raabe CharCount
10014 Egon Hugeist CharCount_1
06651 Egon Hugeist CharCount_2
05407 Egon Hugeist CharCount_Double_Sided_3
05814 Egon Hugeist CharCount_Double_Sided_4
04472 Delphi CountChar
Benchmark finished!

Da ist die Assemblerversion schon recht schnell.

[jbg]

Dann möchte ich meine schnell zusammengeschrieben Assembler-Rountine auch noch ins Rennen werfen.

Delphi-Quellcode:

function AH_CharCountAsm(const S: string; Ch: Char): Cardinal;
asm
{$IFNDEF CPUX64}
  test eax, eax
  jz @@Empty       // wenn S = '' dann gibt es nichts zu tun

  push ebx
  push esi

  mov esi, eax
  xor eax, eax
  xor ebx, ebx

  // Stringlänge ermitteln
  //mov ecx, DWORD PTR [esi-skew].StrRec.Length
  mov ecx, DWORD PTR [esi-$04]

  // ESI auf das String-Ende zeigen lassen und ECX negieren damit ESI+ECX*2 das erste Zeichen ergibt
  lea esi, [esi+ecx*2]
  neg ecx

@@Loop:
  cmp WORD PTR [esi+ecx*2], dx
  sete bl
  add eax, ebx
  inc ecx
  jnz @@Loop

  pop esi
  pop ebx
@@Empty:
{$ELSE}
  xor rax, rax // Rückgabewert auf 0 setzen

  test rcx, rcx
  jz @@Empty       // wenn S = '' dann gibt es nichts zu tun

  mov r8, rcx
  xor ecx, ecx

  // Stringlänge ermitteln
  //movsxd r9, DWORD PTR [r8-skew].StrRec.Length
  movsxd r9, DWORD PTR [r8-$04]

  // R9 auf das String-Ende zeigen lassen und R9 negieren damit R8+R9*2 das erste Zeichen ergibt
  lea r8, [r8+r9*2]
  neg r9

@@Loop:
  cmp WORD PTR [r8+r9*2], dx
  sete cl
  add eax, ecx
  inc r9
  jnz @@Loop
@@Empty:
{$ENDIF ~CPUX64}
end;

Code:

00000 Calibrate
03237 1234588 miep
05421 Ydobon
02629 marabu
03317 Missionar
03232 alzaimar
02661 Uwe Raabe StringCountChar
02629 Uwe Raabe StringCountCharFor
02144 KodeZwerg CountCharInString
07170 KodeZwerg CharInStringA
03498 Neutral General CharCountAsm
01993 Uwe Raabe CharCount
01772 Andreas Hauladen CharCountAsm  *****
02696 Egon Hugeist CharCount_1
03242 Egon Hugeist CharCount_2
02556 Egon Hugeist CharCount_Double_Sided_3
02681 Egon Hugeist CharCount_Double_Sided_4
03318 Delphi CountChar

[KodeZwerg]

Danke für weiteren (ASM) Methoden, werde ich mit einbauen, ich fange jetzt mal an Delphi anzukurbeln, kann sein das morgen erst fertig, ich wills diesmal Gründlich machen und nicht nur huschi-wuschi wie die initial-Version.

@Harry, sag oder PN mir Deine Lieblingsmethode für AddPosArray funktionalität. Da ich nichts Cross-Entwickle fehlt mir da die Erfahrung was klappt und was nicht.

@EWeiss, ich hab das ASM aus einer CodeLib heraus gehabt, ich glaub von den Schweizern (die langsame ASM version) und ich kann mich den anderen nur anschließen, just for fun.

Was mich immer noch bei all Euren Resultaten sowas von vom Hocker haut ist wie schlecht D2009 mit der Ydobon Methode performt.
Wenn ich neue Version hoch habe würde ich gerne mal das Ergebnis da sehen, mit meinem D2009 Kompilat bin ich bei Werten * 100000 oder so alle anderen Ergebnisse sind relativ gleich, kommt halt viel auf Processor-Architektur und dessen Pro-MHz Leistung an (sowie eventuelle Chipsatz-Features?).

[jaenicke]

Zitat:

Zitat von KodeZwerg (Beitrag 1407287)

Was mich immer noch bei all Euren Resultaten sowas von vom Hocker haut ist wie schlecht D2009 mit der Ydobon Methode performt.
Wenn ich neue Version hoch habe würde ich gerne mal das Ergebnis da sehen, mit meinem D2009 Kompilat bin ich bei Werten * 100000 oder so alle anderen Ergebnisse sind relativ gleich, kommt halt viel auf Processor-Architektur und dessen Pro-MHz Leistung an (sowie eventuelle Chipsatz-Features?).

Delphi optimiert zwar immer noch relativ schlecht, aber es ist mit der Zeit an ein paar Stellen schon besser geworden. An erweiterten CPU Features liegt der Unterschied aber nicht. Du kannst ja spaßeshalber einfach mal den generierten Assemblercode von Delphi 2009 mit Delphi 10.2 vergleichen. ;-)