Tagarray

[EWeiss]

Kennt sich vielleicht jemand mit PowerBasic aus?

Ich weis leider nicht wie ich das interpretieren soll bzw. nach welchen Kriterien hier sortiert wird.
Die Hilfe zu Powerbasic ist leider nicht Informativ genug.

Code:

%MAX_SORT         = 5
'-------
DIM x(1 TO %MAX_SORT ) AS LONG
DIM xx(1 TO %MAX_SORT ) AS LONG 
ARRAY SORT x(),  TAGARRAY xx()

gruss

[Amateurprofi]

Ich kenne mich mit PowerBasic auch nicht aus, aber weil jetzt Weihnachtszeit ist, hab ich mal gegoogelt nach powerbasic sort array

Vielleicht hilft das weiter.
https://forum.powerbasic.com/forum/a...sort-statement

[EWeiss]

Zitat:

Zitat von Amateurprofi (Beitrag 1389588)

Ich kenne mich mit PowerBasic auch nicht aus, aber weil jetzt Weihnachtszeit ist, hab ich mal gegoogelt nach powerbasic sort array

Vielleicht hilft das weiter.
https://forum.powerbasic.com/forum/a...sort-statement

Jo Danke..
Das wäre ja meine frage.

Code:

DIM Users$(100 TO 500), AcctNum&(100 TO 500)
ARRAY SORT Users$(), TAGARRAY AcctNum&()

Aber verstehe immer noch nicht nach welchen Kriterien sortiert wird.

A1 = 1,2,3,4,5
A2 = 1,2,3,4,5

Was und wie wird sortiert ?
Der Inhalt von A1 nach A2 oder A2 nach A1

Wenn A2 der Inhalt von Hinten nach vorn?
A2 nach A1 = 5,4,3,2,1

Hmmm...

gruss

[p80286]

Vorausgesetzt ich hab es richtig verstanden:

User$
1 Ben
2 willi
3 Monika
4 Zebulon
actnum
1 200
2 2
3 105
4 22

und nach dem sort:

1 Ben
2 Monika
3 Willi
4 Zebulon

1 200
2 105
3 2
4 22

Wenn Du so willst, wird User$ sortiert und Actnum wird entsprechend umsortiert.

Gruß
K-H

[EWeiss]

Danke dir..

Wenn deine Annahme nun richtig ist welche alternative könnte ich dann in Delphi
für diese Sortiermethode verwenden?

Vielleicht gibt es da ja was zu Weihnachten. ;)

gruss

[Delphi.Narium]

Meine Idee wäre da ein Array of Record.

Delphi-Quellcode:

type
  tTagRecord = record
    Name : String;
    Wert : Integer;
  end;
  
  tTagArray = Array[0..n] of tTagRecord;

Wenn man nun nach Name sortiert, hat man den zweiten Wert an der gleichen Position.

Alternative:
TStringList:

Delphi-Quellcode:

function AddObject(const S: string; AObject: TObject: Integer;

Dann kann man die mit Sort nach den Strings sortieren und die Objekte werden dann entsprechendf mitsortiert.

Eventuell mal hier schauen:

https://stackoverflow.com/questions/...sort-an-array#
https://www.entwickler-ecke.de/topic...n_21775,0.html

Könnten die als Ideenlieferanten dienen?

array of record sort delphi source

[EWeiss]

Danke muss ich mal schauen.
Mein Problem ist die ZOrder.

Ich drehe Sprites im Kreis.
Damit das ansehnlich ist muss ich das Array sortieren so das die Sprites in ihre ZOrder neu ausgerichtet werden.

Scheint nicht so einfach zu sein.

Mit dem Record wird das wohl so nicht gehen.
Ich habe zwei Array mit gleichem wert die ich der ZOrder entsprechend neu sortieren muss.

Weis nur noch nicht wie. ;)

gruss

[Delphi.Narium]

Kannst Du uns bitte mal die Definition der Arrays zeigen und eventuell ein paar Beispielwerte? Momentan ist mir das noch zu abstrakt um eine genaue Vorstellung davon zu haben, was genau gemacht werden soll.

[EWeiss]

Zitat:

Zitat von Delphi.Narium (Beitrag 1389614)

Kannst Du uns bitte mal die Definition der Arrays zeigen und eventuell ein paar Beispielwerte? Momentan ist mir das noch zu abstrakt um eine genaue Vorstellung davon zu haben, was genau gemacht werden soll.

Delphi-Quellcode:

zorder: Array[1..10]
faceorder: Array[1..10]

Das Array zorder ist gefüllt mit den wert der Positionen der einzelnen Icons.

Delphi-Quellcode:

procedure DrawCarousel(WinHandle: HWND);
var
  K: Integer;
  Angle: single;
  rc: TRect;
  fl: single;
  speed: Integer;
  xcenter, ycenter, zcenter: Single;
  radius: Single;
  anglePi: Single;
  scale, z: Single;
  x, y: Single;
begin
    if bAnimate then
    begin
       y      := trbY.GetTrackValue(trbY.Handle);
       speed  := trbSpeed.GetTrackValue(trbSpeed.Handle) div 4;
       fl     := trbFocallength.GetTrackValue(trbFocallength.Handle) / 100;

       if fl < 0.02 then
         fl := 0.001;
       PiDiv180 := 1.74532925199433E-2;

       GetClientRect(HSprCtrl, rc);
       xcenter  :=(rc.Right - 128) / 2;
       ycenter  :=(rc.Bottom - 128) / 2;
       zcenter  := ycenter / 2;
       radius   := rc.Right / 3.675;

       for K := ID_MAX_SPRITE downto 1 do
       begin
         Angle := gSpriteData[K].rAngle;
         anglePi := Angle * PiDiv180;
         z := sin(anglePi) * radius + zcenter;
         scale := fl / (fl + z);
         x := cos(anglePi) * radius;
         gSpriteData[K].xPos := round(x * scale + xcenter);
         gSpriteData[K].yPos := round(y * scale + ycenter - y);

         zorder[K] := round(Angle - 90);
         if zorder[K] > 180 then
           zorder[K] := 360 - zorder[K];

         faceorder[K] := K;

         if bMoveToLeft then
         begin
           Angle := Angle - speed;
           if Angle < 1 then
             Angle := 360
         end else
         begin
           Angle := Angle + speed;
           if Angle > 359 then
             Angle := Angle - 360;
         end;
         gSpriteData[K].rAngle := round(Angle);

         // Skalierungsfaktor berechnen
         if Check3Ddepth.GetCheckButtonStatus(Check3Ddepth.Handle) then
           gSprCtrl.GD_SetObjectScale(gSpriteData[K].ID, (ABS(zorder[K]) MOD 182) * 0.0027777 + 0.5)
         else
         gSprCtrl.GD_SetObjectScale(gSpriteData[K].ID, 1);

         // Alpha Kanal unschalten
         if CheckOpacity.GetCheckButtonStatus(CheckOpacity.Handle) and (fl > 0.999) then
               gSprCtrl.GD_SetObjectAlpha(gSpriteData[K].ID, round(MIN(100 * scale, 255)), false)
         else
         gSprCtrl.GD_SetObjectAlpha(gSpriteData[K].ID, 255, false);

         gSprCtrl.GD_SetObjectXY(gSpriteData[K].ID, gSpriteData[K].xPos, gSpriteData[K].yPos);

         if CheckSelfRotation.GetCheckButtonStatus(CheckSelfRotation.Handle) then
           gSprCtrl.GD_SetObjectAngle(gSpriteData[K].ID, round(gSpriteData[K].rAngle))
         else
         gSprCtrl.GD_SetObjectAngle(gSpriteData[K].ID, 0);
       end;

       // müsste hier das Array sortieren ...
       // ARRAY SORT zorder(), TAGARRAY faceorder() 

       // Sprite ZOrder setzen
       K := faceorder[1];
       if bMoveToLeft then
       begin
         inc(K);
         if K > ID_MAX_SPRITE then
           K := 1;
       end;

       gSprCtrl.GD_SetObjectZorder(gSpriteData[K].ID, GD_ORDER_BOTTOM);
       gSprCtrl.GD_SetObjectZorder(gSpriteData[faceorder[ID_MAX_SPRITE]].ID, GD_ORDER_TOP);

       if CheckMarquee.GetCheckButtonStatus(CheckMarquee.Handle) then
         DrawMarquee(rc.Right);

       gSprCtrl.GI_UpdateWindow(HSprCtrl, false);
    end;
end;

Wie man hier sehen kann ist das total durcheinander.

gruss

[p80286]

Ich würde statt eines Arrays die gute alte doppel verpointerte Liste nehmen.
z.B.

Delphi-Quellcode:

type
  pMyrecord=^tMyrecord; 
  tMyrecord : record
                next,last : pMyrecord;
                Name : string;
                Wert : integer;
              end;

var
  firstrec,
  lastrec,
  actrec : pMyrecord; 

...
  if actrecord^.Name>actrecord^.nextrecord^.Name then Tausche(actrecord);

Ist nur ein grobes Beispiel, da fehlt z.B. die Prüfung auf NIL.

Oder gleich eine (Object)Liste, die bekommt eine Sortierfunktion oder 2 oder 3... und fertig ist die Laube.

Gruß
K-H

Bitte nicht schlagen, ich bin extrem konservativ.

[EWeiss]

Zitat:

Zitat von p80286 (Beitrag 1389621)

Ich würde statt eines Arrays die gute alte doppel verpointerte Liste nehmen.
Oder gleich eine (Object)Liste, die bekommt eine Sortierfunktion oder 2 oder 3... und fertig ist die Laube.

Gruß
K-H

Bitte nicht schlagen, ich bin extrem konservativ.

Entschuldige weis jetzt nicht was du meinst. :)

gruss

[p80286]

Na Pointerlisten sind doch aus der Hexenküche der alten Säcke!

Gruß
K-H

[Delphi.Narium]

Keine Ahnung, ob ich mich jetzt blamiere ;-)

Nur mal so 'ne hingedaddelte Idee (ungetestet, nicht kompiliert, nur so mal eben hingehauen ;-))

Delphi-Quellcode:

procedure BubbleSort(var zorder: array of Integer; var faceorder: array of Integer);
var
  i : Integer;
  tempZ : Integer;
  tempFace : Integer;
  done : Boolean;
begin
  repeat
    done := True;
    for i := Low(zorder) to High(zorder) - 1 do
    begin
      if zorder[i] > zorder[i + 1] then
      begin
        tempZ := zorder[i];
        tempFace := faceorder[i];
        zorder[i] := zorder[i + 1];
        faceorder[i] := faceorder[i + 1];
        zorder[i + 1] := tempZ;
        faceorder[i + 1] := tempFace;
        done := False;
      end;
    end;
  until done;
end;

[EWeiss]

Danke :)

Daran habe ich auch schon gedacht wusste aber nicht nach welchen Kriterien ich sortieren soll.
Fehler gibt es keinen nur sichtbare die ZOrder ist immer noch durcheinander.
Hmmm.. vielleicht liegt es an meiner DLL muss das nochmal gegen prüfen.

gruss

[EWeiss]

Irgendwie ist die Sortierung noch nicht in Ordnung.
Mit dem Bubblesort geht es nicht auch nicht nach meiner Änderung.

Delphi-Quellcode:

procedure BubbleSort(var zorder: array of Integer; var faceorder: array of Integer);
var
   i : Integer;
   tempZ : Integer;
   tempFace : Integer;
   done : Boolean;
begin
   repeat
     done := True;
     for i := 10 downto 1 do 
     begin
       if zorder[i] > zorder[i + 1] then
       begin
         tempZ := zorder[i];
         tempFace := faceorder[i];
         zorder[i] := zorder[i + 1];
         faceorder[i] := faceorder[i + 1];
         zorder[i + 1] := tempZ;
         faceorder[i + 1] := tempFace;
         done := False;
       end;
     end;
   until done;
end;

Es drehen sich alle im Kreis aber der Visuelle Effekt ist der einer Schlange.
Das letzte Icon ist das grüne Index 10 die anderen setzen sich jetzt alle dahinter.

Bubblesort macht eigentlich nichts, wenn ich sie nicht verwende habe ich das gleiche verhalten.

gruss

[p80286]

So auf den ersten Blick scheint das grundsätzlich in Ordnung zu sein. Aber

Delphi-Quellcode:

for i := 10 downto 1 do

ist nicht so optimal

Delphi-Quellcode:

for i := length(zorder)-1 downto 0 do

wäre wohl besser (oder das high/low Gespann).

Und wenn sich nichts tut, liegen die Daten vllt. schon sortiert vor?

Gruß
K-H

P.S.
Schöne Feiertage wünsch ich Dir.

[EWeiss]

Delphi-Quellcode:

for i := length(zorder)-1 downto 0 do

Es ist kein Dynamisches Array und die werte sind bekannt.
Deshalb dürfte das von der Berechnung her erst einmal egal sein.

Zitat:

So auf den ersten Blick scheint das grundsätzlich in Ordnung zu sein.

Nur dann frage ich mich warum die ZOrder dann falsch ist.

Zitat:

Schöne Feiertage wünsch ich Dir.

Ich dir/euch auch.

Im Bild kannst du sehen das sich die Icons schlängeln.
Wenn das 10 Icon (grün) durch ist müssen sich die anderen in der ZOrder über das davor liegende setzen.. wenn die Icons sich nach rechts drehen.
Sind aber alle dahinter. sehe gerade ein Icon fehlt (kann ich später berichtigen ;) )


gruss

[p80286]

Zitat:

Zitat von EWeiss (Beitrag 1389634)

Es ist kein Dynamisches Array und die werte sind bekannt.
Deshalb dürfte das von der Berechnung her erst einmal egal sein.

Bist Du Dir da sicher?

Delphi-Quellcode:

procedure BubbleSort(var zorder: array of Integer; var faceorder: array of Integer);

Hiernach hängt sich Zorder zumindest ein Dynamik-Mäntelchen über. Kontrollier das doch mal bitte im Debugger.
Und wenn dein kleinstes Element den Index 0 hat dann ist 1 für das kleinste Element nicht so optimal.
Aber müßte dann der Index 10 nicht vor die Wand laufen?:gruebel: (Bereichsprüfung?)

Gruß
K-H

[EWeiss]

Zitat:

Und wenn dein kleinstes Element den Index 0 hat dann ist 1 für das kleinste Element nicht so optimal.

Hat sich erst mal erledigt liegt an meiner LIB.
Trotzdem Danke.

gruss

[EWeiss]

OK ich muss nochmal dran.

würde das vielleicht über TArray funktionieren?
Also 2 Arrays sortieren?

Hab mich da mal versucht aber irgendwie komme ich damit nicht so recht klar.

TArray(A1, A2) ?
Ich habe schon eine aber die kann ich leider nicht verwenden.

Die Lösung\Vorschlag von hier funktioniert so leider nicht.


gruss

[EWeiss]

Habe jetzt mal meine eigene Variante erstellt aber auch diese funktioniert nicht.
Hoffe das ist richtig so ;)
Bereichsprüfung ist an Fehler gibt es keinen.

Delphi-Quellcode:

procedure BubbleSwap(var Value1, Value2: Integer);
var
  lTemp: Integer;

begin

  lTemp := Value1;
  Value1 := Value2;
  Value2 := lTemp;
end;

procedure BubbleSort(var zorder: array of Integer; var faceorder: array of Integer);
var
  IntI, IntK: Integer;
begin

  for IntI := Low(zorder) to (High(zorder) - 1) do
  begin
    for IntK := (IntI + 1) to High(zorder) do
    begin
       if zorder[IntI] > zorder[IntK] then
       begin
         BubbleSwap(zorder[IntI], zorder[IntK]);
         BubbleSwap(faceorder[IntI], faceorder[IntK]);
       end;
    end;
  end;
end;

gruss