Array Inhalt versetzen?

[MicMic]

Hallo,
ich habe ein "a:TArray<String>".
Gibt's da vielleicht irgendein Befehl, um den Inhalt nach links und rechts zu versetzen?

Beispiel:
a[0]:='Auto';
a[1]:='Fahrrad';
a[2]:='Flugzeug';

Ich möchte z.B. mit einer Prozedur "nachlinks(a)" oder "nachrechts(a)" erreichen, dass der Inhalt entsprechend neu gesetzt wird. Um ein Beispiel für "nachlinks(a)" zu geben.

1. Aufruf:
a[0]:='Fahrrad';
a[1]:='Flugzeug';
a[2]:='Auto';

Nächster Aufruf:
a[0]:='Flugzeug';
a[1]:='Auto';
a[2]:='Fahrrad';

Ich denke, so ist es verständlich, was ich meine. Das Array hat eine unterschiedliche Größe. Mal mehr Inhalt, mal weniger. Könnte mir vorstellen, dass es hierzu was spezielles für's Array gibt, ums einfach zu lösen.

Gruß Micha

[DieDolly]

Vielleicht so?

Delphi-Quellcode:

procedure Swap(var arr: array of string; A, B: Integer);
var
 Tmp: string;
begin
 Tmp := Integer(arr[A]);
 arr[A]) := arr[B];
 arr[B]) := Tmp;
end;

Swap(a, 0, 1);

[Medium]

Dafür wäre eine TList<> deutlich besser geeignet:

Delphi-Quellcode:

var
  a: TList<String>; // in diesem besonderen Fall gäbe es sogar TStringlist als eigenen Typen
begin
  a[0]:='Auto';
  a[1]:='Fahrrad';
  a[2]:='Flugzeug';

  a.Insert(0, a.Extract(2));
end;

Ergbenis:
a[0]='Flugzeug';
a[1]='Auto';
a[2]='Fahrrad';

[Hobbycoder]

Zitat:

Zitat von DieDolly (Beitrag 1463946)

Vielleicht so?

Delphi-Quellcode:

procedure Swap(var arr: array of string; A, B: Integer);
var
 Tmp: string;  //<--String deklariert
begin
 Tmp := Integer(arr[A]);    //<--nach Integer gecastet
 arr[A]) := arr[B];
 arr[B]) := Tmp;
end;

Swap(a, 0, 1);

Hm...ich denke so funktioniert das besser:

Delphi-Quellcode:

procedure Swap(var arr: array of string; A, B: Integer);
var
 Tmp: string;
begin
 Tmp := arr[A];
 arr[A]) := arr[B];
 arr[B]) := Tmp;
end;

[DieDolly]

Das war einfach frei getippt und von irgendwoher noch kopiert. Klar ist das komplett falsch aber der Swap ansich sollte klar sein.
Wer A zwischenspeichern, A B zuweisen, B den zwischengespeicherten Wert zuweisen.
Hab auch ehrlich gesagt nicht über die Typen nachgedacht. Ist mir auch egal, denn der Sinn sollte klar sein ;)

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1463959)

Wer A zwischenspeichern, A B zuweisen, B den zwischengespeicherten Wert zuweisen.

Ist halt nicht so einfach auf variable Arraylängen anpassbar.

[himitsu]

Zitat:

Zitat von Medium (Beitrag 1463947)

in diesem besonderen Fall gäbe es sogar TStringlist als eigenen Typen

Auch Insert und Delete funktionieren nun endlich auch mit Arrays. (auch wenn CodeInsight das schon seit Jahrzehnten behauptete es aber nie funktionierte)

Delphi-Quellcode:

SetLength(A, 3);
A[0] := 'Auto';
A[1] := 'Fahrrad';
A[2] := 'Flugzeug';

Insert(A[2], A, 1);
Delete(A, 3, 1);

[Hobbycoder]

Zitat:

Zitat von DieDolly (Beitrag 1463959)

Das war einfach frei getippt und von irgendwoher noch kopiert. Klar ist das komplett falsch aber der Swap ansich sollte klar sein.
Wer A zwischenspeichern, A B zuweisen, B den zwischengespeicherten Wert zuweisen.
Hab auch ehrlich gesagt nicht über die Typen nachgedacht. Ist mir auch egal, denn der Sinn sollte klar sein ;)

Och...das war mir klar. Nur macht ihr das bei mir auch immer, wenn ich mal irgendwo auf die schnelle bei sowas eine Typen verwürfele. Da dachte ich mir, ich kann das ja auch mal machen :-D:-D:-D

[MicMic]

Danke für die vielen Antworten.
Ich will es noch mit meinem "TArray<String>" probieren. Trotzdem Danke @Medium für die Info TList.

Ich habe jetzt "nach links verschoben" getestet und es geht:

Code:

 Insert(A[0], A, Length(A));
 Delete(A,0,1);

 // oder auch so:

 SetLength(A,Length(A)+1);
 A[Length(A)-1] := A[0];
 Delete(A,0,1);

Die andere Richtung (nach rechts) habe ich so gemacht:

Code:

 SetLength(A,Length(A)+1);
 Insert(A[Length(A)-1], A, 0);
 Delete(A,Length(A)-1,1);
 SetLength(A,Length(A)-1); // *

* Verstehe ich nicht so ganz. Davor habe ich ja ein Delete. Also ich lösche den letzten Inhalt. Aber da wird wohl die Array-Länge nicht gekürzt. Wobei das mit dem obigen Code (nach links verschieben) dann geht. Dort habe ich kein "SetLength" nach dem "Delete". Auch geht der erste Code (nach links verschieben; der erste Teil) ganz ohne SetLength. Ein Code (nach rechts) ohne "SetLength" habe ich nicht hinbekommen. Wobei ich dachte, "Delete" kürz die Array-Länge und "Insert" macht die Array-Länge automatisch größer. Scheint aber wohl damit zusammenzuhängen, wo man etwas einfügt, sprich am Anfang oder am Ende.

Jedenfalls muss ich hier mit "Length" arbeiten, da das Array ja nicht immer nur 3 Inhalte hat. Kann auch al mehr sein. Aber dann nicht hundert/tausend... vielleicht max. bis 20. Getestet habe ich es gerade mit 9 Inhalten.

[himitsu]

Zitat:

Zitat von MicMic (Beitrag 1464042)

* Verstehe ich nicht so ganz.

Du machst da auch am Anfang ein SetLength+1, also ist am Ende natürlich auch ein SetLength-1 nötig, oder du lässt die SetLength in diesem Fall komplett weg. :zwinker:

[MicMic]

Zitat:

Zitat von himitsu (Beitrag 1464049)

Zitat:

Zitat von MicMic (Beitrag 1464042)

* Verstehe ich nicht so ganz.

Du machst da auch am Anfang ein SetLength+1, also ist am Ende natürlich auch ein SetLength-1 nötig, oder du lässt die SetLength in diesem Fall komplett weg. :zwinker:

Hmm, in der 2. Variante von "nach links verschieben" habe ich auch SetLength+1 aber kein SetLength-1. Aber das geht so.
Wenn ich für "nach rechts verschieben" die beiden SetLength's rausmache, dann verschiebt er aber nicht richtig die Inhalte.

Aber mal zur Info: Ich habe ein String "Dies,Das,Auto,Flugzeug,irgendwas" und mein Array fülle ich dann mit "a:=stringvariable.Split([','])".

[himitsu]

Ja, aber dort entspricht das SetLength zusammen mit dem := einem Insert.

Hier hast du Insert+Delete und die SetLength (ohne eine Zuweisung).




Da man leider an dynamische Arrays (noch) keine Record-Helper hägen kann, um sich direkt solche Funktionen nachzurüsten
und da es unmöglich ist bestehende Record-Helper zu erweitern,
hab ich mir einen Record genommen, dort ein TArray<string> reingebaut, alles noch schön mit impliziten Casts und paar Methoden aufbemotzt
und mir somit eine Art TStringList gebaut, die sich von der Speicherverwaltung wie ein Array verhält, aber solche netten Methoden wie z.B. Insert, Delete und Move enthält. :stupid:

[DieDolly]

Zitat:

Ist halt nicht so einfach auf variable Arraylängen anpassbar.

Verstehe das Problem nicht. Das ist ein einfacher Switch über ein string array.

[Medium]

Zitat:

Zitat von DieDolly (Beitrag 1464064)

Zitat:

Ist halt nicht so einfach auf variable Arraylängen anpassbar.

Verstehe das Problem nicht. Das ist ein einfacher Switch über ein string array.

Nein. Der Fragesteller möchte nicht 2 Elemente tauschen, sondern das erste zum letzten machen, und alle nach dem ersten sollen um einen Indext nach unten rutschen. (Und auch den umgekehrten Weg.) Hatte mich bei deiner ersten Antwort schon gewundert, was das mit dem Problem des TE zu tun hat - außer man rauscht ein Mal kräftig auf "komplizierte" Weise durch das ganze Array.

[MicMic]

Die eine Richtung mit:

Code:

 SetLength(A,Length(A)+1);
 Insert(A[Length(A)-1], A, 0);
 Delete(A,Length(A)-1,1);
 SetLength(A,Length(A)-1);

die nur mit "SetLength+1" und "SetLength-1" geht, habe ich geändert.

Nur ein:

Code:

 Insert(A[Length(A)-1], A, 0);
 Delete(A,Length(A)-1,1);

reicht aber hier nicht. Er setzt hier den vorletzten Eintrag an den Anfang. Auf den letzten Eintrag im Array habe ich gar keinen Zugriff. Das lieg wohl am Aufbau von "Insert" (wegen "Length(A)-1").

Ich habe mir jedenfalls entsprechende Prozeduren gemacht (für beide Richtungen):

Code:

 Procedure TabToLeft(Var A:TArray<String>);
 Begin
   Insert(A[0], A, Length(A));
   Delete(A,0,1);
 End;

 Procedure TabToRight(Var A:TArray<String>);
 Var S : String;
 Begin
  S := A[Length(A)-1];
  Insert(S, Splitted, 0);
  Delete(A,Length(A)-1,1);
 End;

So geht's dann komplett ohne "SetLength".

Danke für die Hilfe meiner Problemlösung.

Gruß Micha

[himitsu]

Ohh, eigentlich sollte der Wert vorher kopiert und als Parameter übergeben werden,
aber könnte wirklich sein, dass hier die Compilermagic und Codeoptimierung durchschlägt, da Insert und Delete nicht wirklich so richtige "normale" Prozeduren sind. :shock:

Über die Record-Operatoren hast hier dann mehr Glück, weil die komplett extrem unoptimierbar sind.


Nja, direkt ist es so eigentlich auch nicht optimal, denn hier wird ja zwei mal die Länge des Arrays geändert und im extremfall auch alles bis zu zwei Mal komplett umkopiert.

[Andreas13]

Anstatt der Änderung der Array-Länge und des damit verbundenen (internen) Umkopierens der Inhalte könntest Du relativ einfach eine Art von Ringpuffer realisieren. Hierbei würde lediglich ein Zeiger auf das Array-Element zeigen und Du könntest diesen Zeiger (Pointer) Inkrementieren bzw. Dekrementieren und den Inhalt nur im Bedarfsfall anzeigen. Allerdings weiß ich nicht, ob eine solche Lösung zu Deiner Anwendung passt oder nicht.
Gruß, Andreas

[Andreas13]

Noch einfacher wäre ein gleichlanges Integer-Array, in welchem die Elemente auf die gewünschte Position des String-Arrays zeigen. Damit kannst Du die Reihenfolge durch Änderung der "Integer-Zeiger" einfach ändern und auch die String-Inhalte

Delphi-Quellcode:

StringArray[IntegerArray[i]]

anzeigen.

[Uwe Raabe]

Zitat:

Zitat von Andreas13 (Beitrag 1464119)

Noch einfacher wäre ein gleichlanges Integer-Array, in welchem die Elemente auf die gewünschte Position des String-Arrays zeigen.

Da die Strings selbst auch nur als Pointer in den Array-Elementen vorliegen, ergibt sich m.E. hier kein nennenswerter Vorteil.

Ich kann auch mit folgendem Code keinen Fehler feststellen (getestet in 10.3.3):

Delphi-Quellcode:

procedure RotateRight(var A: TArray<String>);
begin
  Insert(A[Length(A)], A, 0);
  Delete(A, High(A), 1);
end;

procedure RotateLeft(var A: TArray<String>);
begin
  Insert(A[0], A, Length(A));
  Delete(A, 0, 1);
end;

[himitsu]

Delphi-Quellcode:

var
  A: TArray<Integer>;
  T: Integer;
  i: Integer;
begin
  // Hoch - BubbleMode
  for i := High(A) - 1 downto 0 do begin
    T := A[i];
    A[i] := A[i + 1];
    A[i + 1] := T;
  end;

  // Hoch - SingleMove
  T := A[0];
  for i := High(A) - 1 downto 0 do
    A[i] := A[i + 1];
  A[High(A)] := T;

  // Runter
  T := A[High(A)];
  for i := High(A) downto 1 do
    A[i] := A[i - 1];
  A[0] := T;

  // Hoch - FullMove
  T := A[0];
  FinalizeArray(@A[0], TypeInfo(T), 1);  // eigentlich FinalizeRecord, aber siehe InitializeRecord
  Move(A[1], A[0], High(A) * SizeOf(A));
  InitializeArray(@A[High(A)], TypeInfo(T), 1);  // InitializeRecord, aber das ist nicht öffentlich und geht letztendlich eh nur auf die Array-Funktion
  A[High(A)] := T;

  // ohne das Finalize und Initialize, wenn man für T "immer" eine Variable von ungemanagtem Typ verwendet, wie z.B. Integer oder ein Byte-Array,
  // denn bei Typen ala String, DynArray, Interface oder Variant zerschießt man sich sonst das automatische Speichermanagement, wenn man das nicht beachtet (eines von Beidem)
  Move(A[0], T, SizeOf(A));
  Move(A[1], A[0], High(A) * SizeOf(A));
  Move(T, A[High(A)], SizeOf(A));

Die Dinge ohne Move haben den Vorteil, dass man nichts falsch und kaputt machen kann. (so lange man die Indexprüfung nicht deaktiviert)

[Medium]

Es wäre alles so einfach, wenn der TE bloß eine TList<String> oder grad TStringlist einsetzen würde. Jegliche potenzielle Konvertion zur notwedigen Form ist 100%ig einfacher und performanter als all die Workarounds, die hier so auftauchen. Warum nicht einfach die geeignete Datenstruktur? Das ist doch, was einen guten Programmierer ausmacht: Das richtige Werkzeug für den jeweiligen Einsatzzweck erkennen. :?

[MicMic]

Zitat:

Zitat von Uwe Raabe

Ich kann auch mit folgendem Code keinen Fehler feststellen (getestet in 10.3.3):

Delphi-Quellcode:

procedure RotateRight(var A: TArray<String>);
begin
  Insert(A[Length(A)], A, 0);
  Delete(A, High(A), 1);
end;

procedure RotateLeft(var A: TArray<String>);
begin
  Insert(A[0], A, Length(A));
  Delete(A, 0, 1);
end;

Bei mir geht RotateRight nicht. Ich habe diese 10.3 Community Version
Ich bin mit meinem "...Right" zufrieden. Trotzdem Danke

Delphi-Quellcode:

 Procedure TabToRight(Var A:TArray<String>);
 Var S : String;
 Begin
  S := A[Length(A)-1];
  Insert(S, Splitted, 0);
  Delete(A,Length(A)-1,1);
 End;

Zitat:

Zitat von Medium

Es wäre alles so einfach, wenn der TE bloß eine TList<String> oder grad TStringlist einsetzen würde. Jegliche potenzielle Konvertion zur notwedigen Form ist 100%ig einfacher und performanter als all die Workarounds, die hier so auftauchen. Warum nicht einfach die geeignete Datenstruktur? Das ist doch, was einen guten Programmierer ausmacht: Das richtige Werkzeug für den jeweiligen Einsatzzweck erkennen.

Ich habe es nicht ausprobiert, da ich ja eine Lösung gefunden habe und beim TList<String> erst mal schauen müsste, wo ich sonst im Programmcode was abändern muss. Ich arbeite ja an verschiedenen Stellen mit meinem Array. Wäre wohl jetzt nicht ein großes Problem mit ein paar Codeänderungen aber es geht ja jetzt. Dieses Array hat auch nicht viele Einträge. Evtl. max 20 oder so. Mein "TabToLeft" und "TabToRight" was ich hier gepostet habe, geht nun wie gewünscht.

Auch noch Danke an "himitsu" für seinen Code.

Gruß Micha

[himitsu]

Zitat:

Zitat von MicMic (Beitrag 1464181)

Bei mir geht RotateRight nicht.

Vermutlich weil

Delphi-Quellcode:

A[Length(A)]

nicht existiert. :wink:

[MicMic]

Zitat:

Zitat von himitsu (Beitrag 1464182)

Zitat:

Zitat von MicMic (Beitrag 1464181)

Bei mir geht RotateRight nicht.

Vermutlich weil

Delphi-Quellcode:

A[Length(A)]

nicht existiert. :wink:

Uwe meinte aber, es geht bei ihm so :)

[himitsu]

Gute Frage: Copy&Paste-Error oder "es knallt nicht" weil Indexprüfung nicht aktiv.

[MicMic]

Jedenfalls mit meiner "TabToRight" bin ich jetzt zufrieden. Anfangs war's ja noch alles mit "SetLength". Auch alles recht übersichtlich jetzt und für meinen Anwendungszweck supi.

[Uwe Raabe]

Zitat:

Zitat von himitsu (Beitrag 1464186)

oder "es knallt nicht" weil Indexprüfung nicht aktiv.

Das ist tatsächlich so. Es ist aber kein Copy-Paste Error. Interessanterweise führt ein

Delphi-Quellcode:

Lenght(A) - 1

zu einem falschen Ergebnis! Ursache ist das intern aufgerufene _DynArrayInsertElem. Da wird zunächst das Array verschoben, um am Anfang Platz zu schaffen. Dadurch schiebt sich das letzte Array-Element genau unter den von

Delphi-Quellcode:

A[Length(A)]

angegebenen Speicherbereich.

[himitsu]

Hatte nicht nachgesehn, aber würde dann das hier bestätigen.

Zitat:

Zitat von himitsu (Beitrag 1464113)

Ohh, eigentlich sollte der Wert vorher kopiert und als Parameter übergeben werden,
aber könnte wirklich sein, dass hier die Compilermagic und Codeoptimierung durchschlägt, da Insert und Delete nicht wirklich so richtige "normale" Prozeduren sind. :shock:

[himitsu]

Man könnte es jetzt so lösen und die Prüfung deaktivieren.

Delphi-Quellcode:

procedure RotateRight(var A: TArray<String>);
begin
  {$RANGECHECKS OFF}
  Insert(A[Length(A)], A, 0);
  Delete(A, High(A), 1);
  //{$RANGECHECKS ON}  = Default ist OFF
end;

procedure RotateRight(var A: TArray<String>);
begin
  {$UNDEF _TEMP_}
  {$IFOPT R+} {$DEFINE _TEMP_} {$ENDIF}  
  {$RANGECHECKS OFF}
  Insert(A[Length(A)], A, 0);
  Delete(A, High(A), 1);
  {$IFDEF _TEMP_} {$RANGECHECKS ON} {$ENDIF}  
end;

Aber wenn irgendwann am Verhalten von INSERT was geändert wird und es dann "richtig" funktioniert,
oder wenn es schon jetzt auf verschiedenen Plattformen unterschiedliche arbeitet (Win64, Android, ...),
dann hast ein Problem.

Effektiv verbleibt aber diese Lösung:

Delphi-Quellcode:

procedure RotateRight(var A: TArray<String>);
var
  T: Temp;
begin
  T := A[High(A)];
  Insert(T, A, 0);
  Delete(A, High(A), 1);
end;

// oder :lol:
procedure RotateRight(var A: TArray<String>);
begin
  Insert(StrToInt(IntToStr(A[High(A)])), A, 0);  // oder Insert(Min(A[High(A)], A[High(A)]), A, 0);
  Delete(A, High(A), 1);
end;

Test-Code:

Delphi-Quellcode:

var
  i, j: Integer;
  A: TArray<Byte>;
  B: array[0..7] of string;
begin
  {$RANGECHECKS OFF}
  SetLength(A, 10);
  for i := 0 to High(B) do
    B[i] := StringOfChar('_', 12 * 2) + ' ';

  // move first +1
  for i := 0 to High(A) do A[i] := $80 or i;
  Insert(A[Length(A)], A, 0);  BinToHex(A[0], PChar(B[0]), Length(A));
  Delete(A, High(A), 1);       BinToHex(A[0], PChar(B[1]), Length(A));

  // move first
  for i := 0 to High(A) do A[i] := $80 or i;
  Insert(A[High(A)], A, 0);    BinToHex(A[0], PChar(B[2]), Length(A));
  Delete(A, High(A), 1);       BinToHex(A[0], PChar(B[3]), Length(A));

  // move first none-optimize
  {$OPTIMIZATION OFF}
  for i := 0 to High(A) do A[i] := $80 or i;
  Insert(A[High(A)], A, 0);    BinToHex(A[0], PChar(B[4]), Length(A));
  Delete(A, High(A), 1);       BinToHex(A[0], PChar(B[5]), Length(A));
  {$OPTIMIZATION ON}

  // move last
  for i := 0 to High(A) do A[i] := $80 or i;
  Insert(A[0], A, Length(A));  BinToHex(A[0], PChar(B[6]), Length(A));
  Delete(A, 0, 1);             BinToHex(A[0], PChar(B[7]), Length(A));

  for i := 0 to High(B) do for j := Length(A) downto 0 do Insert(' ', B[i], j * 2 + 3);
  ShowMessage(
    B[0] + 'first+1'#10  + B[1] + #10#10 +
    B[2] + 'first'#10    + B[3] + #10#10 +
    B[4] + 'first no'#10 + B[5] + #10#10 +
    B[6] + 'last'#10     + B[7]);
end;

Delete hat das Problem natürlich nicht, denn hier muß ja zuerst ausgelesen werden und dann wird damit die Länge geändert.

Delphi-Quellcode:

var
  i: Integer;
  A: TArray<Byte>;
  B: string;
begin
  SetLength(A, 10);
  for i := 0 to High(A) do A[i] := i;
  B := StringOfChar('_', Length(A) * 2);

  Delete(A, A[5], 1);

  BinToHex(A[0], PChar(B), Length(A));
  for i := Length(A) downto 0 do Insert(' ', B, i * 2 + 3);
  ShowMessage(B);
end;