Leerzeichen in String einfügen

[EgonHugeist]

ich mach nun mal den Deckel für mich zu, damit ich die Datei löschen kann. Habe mal 2 Versionen zur Veranschaulichung zum Ausgang einer Fixen-String Länge von 128-Zeichen gemacht.
Hoffe diesmal ist es leserlicher, da ich schönere Typen-Bezeicher gewählt habe.

Mit allen verfügbaren bisher dargelegten plus der 2 anfolgenden Routinen die Benchmarks vornweg:

Zitat:

Zitat von Benchmarks

Task: Fuege einen "_" -Char an jeder 4. Stelle eines 128 Zeichen langen Strings ein!
Benchmarking DupeString('1234', 1 shl 5) Iterations: 64000000:

Autor: "Mavarik" Function: "MavarikQuadUnderScoreInjector" TickCount: 8250
Autor: "Dejan Vu" Function: "DejanVuQuadUnderScoreInjector" TickCount: 58890
Autor: "EgonHugeist" Function: "leerzeichen" TickCount: 2860
Autor: "Sir Rufo" Function: "StrInsertEveryNthPos" TickCount: 58422
Autor: "EgonHugeist" Function: "EH_StrInsertEveryNthPos_4Chars" TickCount: 12562
Autor: "EgonHugeist" Function: "EH_QuadUnderScoreInjectorBy4" TickCount: 2328
Autor: "EgonHugeist" Function: "EH_QuadUnderScoreInjectorBy8" TickCount: 2235
Autor: "EgonHugeist" Function: "EH_QuadUnderScoreInsertFix128String_a" TickCount: 2468
Autor: "EgonHugeist" Function: "EH_QuadUnderScoreInsertFix128String_b" TickCount: 2063

Version a: (Tiny)

Delphi-Quellcode:

function EH_QuadUnderScoreInsertFix128String_a(Const Text: String): String;
type
  PtrInt = {$IFDEF CPUX64}UInt64{$ELSE}Cardinal{$ENDIF};
  P4Chars = ^T4Chars;
  T4Chars = {$IFDEF UNICODE}UInt64{$ELSE}LongWord{$ENDIF};
  P5CharsRec = ^T5CharsRec;
  T5CharsRec = packed record
    CharQuad: T4Chars;
    UnderScore: Char;
  end;
var
  i: Integer;
  Src: P4Chars;
  Dest: P5CharsRec;
begin
  Assert((Text <> '') and (PLongInt(NativeUInt(Text) - SizeOf(LongInt))^ = 128), 'wrong Text string length!'); //fast get src length
  if (Pointer(Result) = nil) or //result unassigned?
     (PLongInt(NativeUInt(Result) - SizeOf(LongInt))^ <> 159) {PStrRec.Len} or //length different?
     (PLongInt(NativeUInt(Result) - (SizeOf(LongInt) shl 1))^ <> 1) {PStrRec.RefCnt} then //no unique string?
    SetLength(Result,159);
  Src := Pointer(Text);
  Dest := Pointer(Result);
  for i := 0 to 30 do begin
    Dest.CharQuad := Src^; Dest.UnderScore := '_';
    Inc(PtrInt(Dest), SizeOf(T5CharsRec));
    Inc(PtrInt(Src), SizeOf(T4Chars));
  end;
  Dest.CharQuad := Src^;
end;

und Version b: (Huge)

Delphi-Quellcode:

function EH_QuadUnderScoreInsertFix128String_b(Const Text: String): String;
type
  T4Chars = {$IFDEF UNICODE}UInt64{$ELSE}LongWord{$ENDIF};
  P4CharsArray = ^T4CharsArray;
  T4CharsArray = array[0..31] of T4Chars;
  T5CharsRec = packed record
    CharQuad: T4Chars;
    UnderScore: Char;
  end;
  P5CharsArray = ^T5CharsArray;
  T5CharsArray = array[0..31] of T5CharsRec;
var
  Src: P4CharsArray;
  Dest: P5CharsArray;
begin
  Assert((Text <> '') and (PLongInt(NativeUInt(Text) - SizeOf(LongInt))^ = 128), 'wrong Text string length!'); //fast get src length
  if (Pointer(Result) = nil) or //result unassigned?
     (PLongInt(NativeUInt(Result) - SizeOf(LongInt))^ <> 159) {PStrRec.Len} or //length different?
     (PLongInt(NativeUInt(Result) - (SizeOf(LongInt) shl 1))^ <> 1) {PStrRec.RefCnt} then //no unique string?
    SetLength(Result,159);
  Src := Pointer(Text);
  Dest := Pointer(Result);
  Dest[0 ].CharQuad := Src[0 ]; Dest[0 ].UnderScore := '_';
  Dest[1 ].CharQuad := Src[1 ]; Dest[1 ].UnderScore := '_';
  Dest[2 ].CharQuad := Src[2 ]; Dest[2 ].UnderScore := '_';
  Dest[3 ].CharQuad := Src[3 ]; Dest[3 ].UnderScore := '_';
  Dest[4 ].CharQuad := Src[4 ]; Dest[4 ].UnderScore := '_';
  Dest[5 ].CharQuad := Src[5 ]; Dest[5 ].UnderScore := '_';
  Dest[6 ].CharQuad := Src[6 ]; Dest[6 ].UnderScore := '_';
  Dest[7 ].CharQuad := Src[7 ]; Dest[7 ].UnderScore := '_';
  Dest[8 ].CharQuad := Src[8 ]; Dest[8 ].UnderScore := '_';
  Dest[9 ].CharQuad := Src[9 ]; Dest[9 ].UnderScore := '_';
  Dest[10].CharQuad := Src[11]; Dest[11].UnderScore := '_';
  Dest[11].CharQuad := Src[12]; Dest[12].UnderScore := '_';
  Dest[13].CharQuad := Src[13]; Dest[13].UnderScore := '_';
  Dest[14].CharQuad := Src[14]; Dest[14].UnderScore := '_';
  Dest[15].CharQuad := Src[15]; Dest[15].UnderScore := '_';
  Dest[16].CharQuad := Src[16]; Dest[16].UnderScore := '_';
  Dest[17].CharQuad := Src[17]; Dest[17].UnderScore := '_';
  Dest[18].CharQuad := Src[18]; Dest[18].UnderScore := '_';
  Dest[19].CharQuad := Src[19]; Dest[19].UnderScore := '_';
  Dest[20].CharQuad := Src[20]; Dest[20].UnderScore := '_';
  Dest[21].CharQuad := Src[21]; Dest[21].UnderScore := '_';
  Dest[22].CharQuad := Src[22]; Dest[22].UnderScore := '_';
  Dest[23].CharQuad := Src[23]; Dest[23].UnderScore := '_';
  Dest[24].CharQuad := Src[24]; Dest[24].UnderScore := '_';
  Dest[25].CharQuad := Src[25]; Dest[25].UnderScore := '_';
  Dest[26].CharQuad := Src[26]; Dest[26].UnderScore := '_';
  Dest[27].CharQuad := Src[27]; Dest[27].UnderScore := '_';
  Dest[28].CharQuad := Src[28]; Dest[28].UnderScore := '_';
  Dest[29].CharQuad := Src[29]; Dest[29].UnderScore := '_';
  Dest[30].CharQuad := Src[30]; Dest[30].UnderScore := '_';
  Dest[31].CharQuad := Src[31];
end;

Man sieht, wenn man den letzten Tropfen aus dem Stein drücken will, lohnt sich auch mehr Code.. Lehren aus den unterschiedlichen Verhalten bei gleicher Aufgabenstellung kann sich jeder selber ziehen.

Wenn keiner weitere Anregungen hat, oder du die Zeit nicht findest.. Deckel zu.

Habt Spaß

[FarAndBeyond]

WOW, was man so alles findet wenn man hier und da mal mitliest...
Danke für die interessanten Infos, die PAS werd' ich mir mal ziehen...
Mal sehen wo ich im Benchmark liege...

Mein erster Ansatz wäre das hier gewesen:

Delphi-Quellcode:

Function InsertChar(MyChar: String; Pos: Integer; Text: String): String;
  Var
   I, Counter: Integer;
   NewStr    : String;
 Begin
  If Text = ''
  Then
   Begin
    Result:= 'No Input...';
    Exit;
   End;

  If Length(Text) >= Pos
  Then
   Begin
    Counter:= 0;

     For I:= 1 To Length(Text)
     Do
      Begin
       Counter:= Counter +1;
       NewStr := NewStr  +Text[I];

        If Counter = Pos
        Then
         Begin
          Counter:= 0;
          NewStr := NewStr +MyChar;
         End;
      End;

    Result:= NewStr;
   End
  Else Result:= Text;
 End;


Procedure TForm1.Button1Click(Sender: TObject);
 Begin
  Label1.Caption:= InsertChar('_', 4, Edit1.Text);
  Edit1.Clear;
 End;

[EgonHugeist]

Guten Morgen FarAndBeyond, Lucki, alle

ich habe gerade bemerkt(FarAndBeyond, du scheinst FPC'ler zu sein), das ich in der unit überall den NativeUInt versauwurschtelt habe. Ich meine der Typ war mit D2007 eingeführt und buggy bis ?D2010? und ich weiß nicht, ob der FPC ihn inzwischen kennt.

Für gewöhnlich deklariere ich den Typ selbst(Für alle Compiler, wo er fehlt oder falsch deklariert war und wenns Compiler unabhängig werden soll), und versuch den Code zur neuesten Compilerversion zu adaptieren. Somit gehe ich davon aus, das die Unit nicht auf jedem Delphi/FPC compiliert. Deswegen habe ich den den Typ mal durch einen PtrInt ersetzt, welches für den Laien eventuell intuitiver ist. Hinzu kommt, daß der FPC, nicht wie Delphi, für String-Länge und RefCount im TStrRec den LongInt-Typ beibehält, sondern diesen mit dem Compile-Target unterschiedlichen SizeInt nutzt.

Damit alle etwas von dem kleinen Experiment haben, habe ich das gändert und die Unit nochmals angehängt.

@FarAndBeyond

dein Ansatz wird keinen hier vorangegangenen schlagen können, dennoch wird(wenn du dran bleibst und die anderen Vorschläge betrachtest)es dir helfen, deine Version, oder weitere darauffolgende immer weiter zu verbessern. So lernt man es selbst am aller besten. Learning-By-Doing. Versuch zum Anfang mal nur dich selber zu schlagen indem du eine Version schreibst, und weiter ableitest und den neuere Versionen mit einem Prefix 'a...z' oder so, behaftest und alle anderen bereits in der Unit enthaltenen erst mal auskommentierst. Betrachte die Versionen und beobachte, wie sich das compilat zu den anderen Versionen verhält.

Der Thread ist nun schon ziehmlich lang, die deine herangehensweise mit dem Concatieren "NewStr := NewStr +Text[I]" fehtlt hier noch. Warum?
Übrigens reit sich dein Vorschlag in der Kategorie TestVary ein.

Also an alle: viel Spaß beim experimentieren!
Michael, ZeosDevTeam

[Bjoerk]

Habt ihr die schon?

Delphi-Quellcode:

function InsertAfterEveryNthPos(const AStr, AInsertStr: string; const APos: integer): string;
var
  I, InsertCount: integer;
begin
  Result := '';
  if APos > 0 then
  begin
    InsertCount := Length(AStr) div APos;
    for I := 1 to InsertCount do
      Result := Result + Copy(AStr, APos * (I - 1) + 1, APos) + AInsertStr;
    if Length(AStr) mod APos <> 0 then
      Result := Result + Copy(AStr, InsertCount * APos + 1, Length(AStr) - InsertCount * APos);
  end;
end;