"array-Einträge" nicht doppelt auslesen

[schmitzlipp]

Ich soll als Schulprojekt ein kleines Quiz bauen.
Ich lese Frage und Antworten jeweils aus einer Zeile in einen array of string ein.

Delphi-Quellcode:

AssignFile(myFile,datei);
    Reset(myFile);
    while not Eof(myFile) do
    begin
      ReadLn(myFile, text[i]);
      inc(i);
    end;
closefile(myfile);

Dannach wird per random ein string aus diesem array "rausgefischt" den ich dann Zerlege.
Nach dem die Frage beantwortet wurde, wird wieder ein string zufällig ausgewählt.
Nun kann es aber passieren dass ein string doppelt ausgewählt wird, was ich aber unterbinden möchte,
da das quiz sonst witzlos wäre, wenn man zweimal die gleiche frage bekäme.
Nun bräuchte ich eine Lösung die solange string heraussucht (nicht doppelt, keine festgelegte reihenfolge), bis jeder string einmal dran war.
Ich hatte schon eine Idee:
Jedem string im array text eine zahl zu vergeben und diese dann in einem anderen array zu speichen,
wenn der zugehörige string benutzt wird.
Es haperte aber an der Umsetzung, auserdem erschien es mir zu kompliziert.
Vieleicht gibt es ja eine möglichkeit geziehlt strings zu entfernen ...
ich hoffe, mir kann jemand helfen
thx schmitzlipp

[Klaus01]

Du könntest Dir ein zweites Array mit der gleichen Länge erstellen.

TFragen_erledigt = Array[1...] of Boolean

Wenn Du eine Frage gestellt hast markierst Du den Eintrag mit true
Wenn Du eine neue Frage auswählst, schaust Du nach ob der Eintrag true oder false
in dem Boolschen Array ist und benutzt die Frage oder verwirst sie.

Grüße
Klaus

[marabu]

Herzlich willkommen in der Delphi-PRAXiS.

Hier noch eine Alternative: wenn du statt eines Arrays eine StringList verwendest, dann könntest du deine Fragen einfach per LoadFromFile() einlesen, per Index auf die einzelnen Fragen und Antworten zugreifen und auch verbrauchte Fragen löschen.

Delphi-Quellcode:

var
  s: TStringList;
  i: Integer;
  fn: TFileName;
begin
  fn := 'FragenAusDemTierreich.txt';
  s := TStringList.Create;
  with s do
  begin
    LoadFromFile(fn);
    while Count > 0 do
    begin
      i := Random(Count);
      ShowMessage(Format('', [Names[i], ValueFromIndex[i]]));
      Delete(i);
    end; 
    Free;
  end;
end;

Für ein Array müsstest du dir eine Prozedur schreiben, die das verbrauchte Element durch Zusammenschieben der restlichen Elemente entfernt und die Zahl der Elemente im Array verringert.

Freundliche Grüße vom marabu

[TheAn00bis]

Du könntest den entsprechenden String ja wirklich einfach aus dem Array löschen.

Delphi-Quellcode:

procedure DeleteEntry(var pArray: Array of String; pPos: integer);  //Prozedur zum Löschen eines beliebigen Eintrags des Arrays
var i, j: integer;
    h: array; 
begin
   h := pArray;
   j := 0;
   for i:=low(h) to high(h) do
      begin
         if (i <> pPos) then
             begin
                pArray[j] := h[i];    
                inc(j);
             end; 
      end;
     setlength(pArray, length(pArray)-1);
end;

function ChoseRandomString: String;  //Wählt zufällig einen String aus un löscht ihn
var i:integer;
begin
   i := randomrange(low(StringArray), high(StringArray));
   result := StringArray[i];
   DeleteEntry(StringArray, i);
end;

Hab das mal eben so in die Tastatur gehämmert, bin mir nicht sihcer ob es funktioniert.
Aber vor allem das Prinzip sollte klar werden.

[schmitzlipp]

Danke für die schnellen antworten !!!!!!
mir persönlich gefällt die letzte methode am besten, da mir genau so etwas vorschwebte.
'Hab aber heute keinen Bock mehr zu probieren, ich setz mich morgen mal dran.
Nochmals DANKE an ALLE !!!!!!!!

[himitsu]

@TheAn00bis:
Da ein dynamisches Array immer bei null beginnt, kannst du das Low(...) auch durch 0 ersetzen, oder halt weglassen.

Warum das Array doppel kopieren?
es reicht doch, wenn die Daten nach dem zu entfernenden Eintrag um eine Position vorrücken ... also statt immer 200%-1 zu kopieren wird so durchschnittlich nur 50%-1 kopiert/verschoben ... und schneller geht es, wenn man alle nötigen Einträge auf einmal verschiebt (siehe Move)

Delphi-Quellcode:

procedure DeleteEntry(var pArray: Array of String; pPos: integer);
var i: integer;
begin
   for i := pPos to High(pArray) do
      pArray[i] := pArray[i + 1];
   SetLength(pArray, High(pArray));
end;

function ChoseRandomString: String;
var i:integer;
begin
   i := Random(Length(StringArray));
   Result := StringArray[i];
   DeleteEntry(StringArray, i);
end;

Hie mal die Variante mit Move.
Bei deiner For-Variante werdne ja im Grunde alle String 2-mal Kopiert (na ja, bei AnsiStrings werden nur die Refferenzzähler erhöht/verringert, aber bei anderen Stukturen, ohne Refferenzzählung, werden die Inhalte 2mal kopiert).

Delphi-Quellcode:

procedure DeleteEntry(var pArray: Array of String; pPos: integer);
begin
   // String löschen
   pArray[i] := '';
   // die zu nötigen StringPointer vorkopieren
   Move(@pArray[pPos + 1], @pArray[pPos], (High(pArray) - pPos) * SizeOf(Pointer));
   // letzen Pointer löschen ... dieser wurde ja eine Stelle vorkopiert
   Pointer(pArray[High(pArray)]) = nil;   SetLength(pArray, High(pArray));
end;

// ich hove bei Move war es Source-Dest-Length und nicht Dest-Source-Length ._.

[TheAn00bis]

Zitat von himitsu:

Warum das Array doppel kopieren?
es reicht doch, wenn die Daten nach dem zu entfernenden Eintrag um eine Position vorrücken ... also statt immer 200%-1 zu kopieren wird so durchschnittlich nur 50%-1 kopiert/verschoben ... und schneller geht es, wenn man alle nötigen Einträge auf einmal verschiebt (siehe Move)

Hast vollkommen recht, bin ich vorhin gar nicht drauf gekommen. Move kannte ich gar nicht. Finde den Gebrauch von Pointern in deinem Code sehr schön.

[Hawkeye219]

Stimmt, die Lösung von himitsu ist die effizienteste. Der Compiler war aber noch nicht ganz zufrieden. Hier die Korrektur mit einigen Sicherheitsabfragen:

Delphi-Quellcode:

type
  TDynStrArray = array of string;

procedure DeleteEntry(var pArray: TDynStrArray; pPos: integer);
begin
  // DAU-Schutz ;-)
  if ((pPos < 0) or (pPos > High(pArray))) then
    exit;
  // String löschen
  pArray[pPos] := '';
  // die nötigen StringPointer verschieben
  if (pPos < High(pArray)) then
    Move(pArray[pPos + 1], pArray[pPos], (High(pArray) - pPos) * SizeOf(Pointer));
  // letzten Pointer löschen ... dieser wurde ja eine Stelle vorkopiert
  Pointer(pArray[High(pArray)]) := nil;
  // Array verkleinern
  SetLength(pArray, High(pArray));
end;

Gruß Hawkeye