LottoTippErstellen

[YXCVBNM1]

Hallo,

ich hab mal in der Suchfunktion geguckt, aber immer nur Threads gefunden in denen Lottozahlen erstellt werden sollen. Ich will aber einen LottoTippZettel erstellen. Man soll die Anzahl an Tipps angeben können die man abgibt und daraufhin sollen einem genau so viele 6er Lotto Tipps erstellt werden. Dazu habe ich folgendes geschrieben:

Delphi-Quellcode:

unit ULotto;

interface
type TLotto=class
private
Tipp:array of array of word;
public
procedure LottoTippErstellen(Anzahl:integer);
procedure SetTipp(x,y,Wert:integer);
end;

implementation

procedure TLotto.SetTipp(x,y,Wert:integer);
begin
Tipp[x,y]:=Wert;
end;

procedure TLotto.LottoTippErstellen(Anzahl: Integer);
VAR n,m,o:integer;
korekt:boolean;
begin
korekt:=false;
SetLength(Tipp,0,0);
SetLength(Tipp,Anzahl,6);
  For n:=1 to Anzahl do
  begin
    For m:=1 to 6 do
    begin
    Repeat
    korekt:=true;
    SetTipp(n,m,(random(49)+1));
      For o:=0 to m-1 do
      begin
      IF Tipp[n,m]=Tipp[n,o] then korekt:=false;
      end;
    Until korekt=true;
    end;
  end;
end;

end.

Das komische ist nur: Wenn ich diese Prozedur mit Anzahl=1 aufrufe funktioniert sie. Rufe ich sie mit Anzahl=2 auf funktioniert sie nicht mehr. Dann kommt die Fehlermeldung "Zugriffsverletzung bei Adresse 0045845A5". Leider finde ich den Fehler nicht.

Ich wäre euch sehr dankbar wenn mir jemande helfen könnte

[Luckie]

Dynamische Arrays sind nullbasierend. Kontrolliere deinen Quellcode daraufhin noch mal.

[YXCVBNM1]

Achja genau. Das war der Fehler. Vielen Danke Jetzt funktioniert es

[himitsu]

Tipp: Projektoptionen > Bereichsprüfung aktivieren (prüft z.B. die Indize von Arrayzugriffen)

[Sir Rufo]

Zudem bietet es sich ja bei OOP an hier etwas feiner zu gliedern:

Delphi-Quellcode:

type

  TLottoTipp = array [1..49] of Boolean;

  TLottoFeld = class
  private
    FTipp : TLottoTipp;
  public
    constructor Create;
    procedure Reset;  // alle Felder zurücksetzen
    procedure FillUp;
  end;
 
procedure TLottoFeld.Reset;
var
  idx : integer;
begin
  for idx := Low( FTipp ) to High( FTipp ) do
    FTipp[ idx ] := False;
end;

constructor Create;
begin
  inherited;
  Reset;
end;

procedure TLottoFeld.FillUp;
var
  idx, Value : integer;
begin
  Reset;
  for idx := 1 to 6 do
    begin
      repeat
        Value := Random( High( FTipp ) - Low( FTipp ) - 1 ) + Low( FTipp );  // Falls das mal nicht bei 1 anfängt =;0)
      until not FTipp[ Value ];
      FTipp[ Value ] := True;
    end;
end;

Jetzt nur noch eine "Sammelklasse" drüberziehen und einen Zugriff auf die Tippfelder gelegt und schon ist die gesamte Klasse fertig

[himitsu]

oder TLottoTipp = array[1..6] of 1..49; aka TLottoTipp = array[1..6] of Byte; (andersrum gespeichert, mit fast 'nem 8-tel an Speicher)

• Vorteil: einfach auf bestimmte Zahl zu prüfen, da Direktzugriff über Index
• Nachteil: Auflisten der Zahlen unpraktischer, da alle 49 Werte durchlaufen werden muß

oder TLottoTipp = set of 1..49; (das Gleiche, wie array of Boolean, nur mit einem Achtel an Speicherverbrauch)

• Vorteil: einfacher Aufzulisten, da alle gesetzen/gezogenen Zahlen direkt ausgelesen werden können (6 Zugriffe per Index)
• Nachteil: Prüfen auf eine Zahl ist schwerer, da alle 0 bis 6 schon gesetzen Werte verglichen werden müssen

(wer es ganz schnell/einfach braucht, nimmt einfach Beides gleichzeitig, also array[1..49] of Boolean und array[1..6] of Byte )

[Sir Rufo]

Zitat von himitsu:

oder TLottoTipp = array[1..6] of 1..49; aka TLottoTipp = array[1..6] of Byte;

Ei jo, aber das Prüfen auf Doppelte geht da nicht so schön

[Sir Rufo]

Zitat von himitsu:

oder TLottoTipp = set of 1..49; (das Gleiche, wie array of Boolean, nur mit einem Achtel an Speicherverbrauch)

Und trotzdem ist das Bool-Array hierbei schicker, da durch einfache Änderung des Arrays auf TLottoTipp = array [1..64] of Boolean; die Klasse immer noch funktioniert.

Und um es ganz flexibel zu gestalten könnte man ein dynamisches Array benutzen und dem Create als Parameter die Anzahl der Tippfelder und Tipps mitgeben

Delphi-Quellcode:

type

  TLottoFeld = class
  private
    FTipp : array of Boolean;
    FMarks : integer;
  public
    constructor Create( AFieldCount, AMarks : integer );
    destructor Destroy; override;
    procedure Reset; // alle Felder zurücksetzen
    procedure FillUp;
  end;
 
procedure TLottoFeld.Reset;
var
  idx : integer;
begin
  for idx := Low( FTipp ) to High( FTipp ) do
    FTipp[ idx ] := False;
end;

constructor TLottoFeld.Create( AFieldCount, AMarks : integer );
begin
  inherited;
  SetLength( FTipp, AFieldCount + 1 );
  FMarks := AMarks;
  Reset;
end;

destructor TLottoFeld.Destroy;
begin
  SetLength( FTipp, 0 );
  inherited;
end;

procedure TLottoFeld.FillUp;
var
  idx, Value : integer;
begin
  Reset;
  for idx := 1 to FMarks do
    begin
      repeat
        Value := Random( High( FTipp ) + 1 );
      until not FTipp[ Value ];
      FTipp[ Value ] := True;
    end;
end;

Jetzt sind die Tipp-Felder allerdings 0 basierend jedoch auch für die Zukunft gerüstet, falls sich beim Lotto mal was ändert

[himitsu]

Zitat:

Ei jo, aber das Prüfen auf Doppelte geht da nicht so schön

Jupp, hatte inzwischen noch was dazueditiert

Hat Beides also seine Vor-/Nachteile

versuch bei dem array of bool mal die gesetzten Zahlen aufzulisten ... muß man erstmal suchen

[Sir Rufo]

Zitat von himitsu:

versuch bei dem array of bool mal die gesetzten Zahlen aufzulisten ... muß man erstmal suchen

Dann machen wir ein Kombi aus beiden Vorschlägen, das Bool-Array zum Tipp erstellen und das Byte-Array zum ausgeben