Lotto Systemspiele berechnen

[wurzelzwerg]

Moin.

weiss jemand wie man aus den Tipps der verschiedenen Systemspiele(Vollsystem, VEW) die Tippreihen berechnen kann?

Danke :-D

[guinnes]

Hier gibts die Listen für VEW-Systeme, bei Vollsystemen ist es ja eigentlich klar

[MrSpock]

Du müsstest dir eine Methode n_aus_m() schreiben, die allgemein n Elemente aus einer Liste mit m Elementen auswählt. Dann kannst du für ein Vollsystem mit 10 Zahlen eben die Methode aufrufen, um 6 aus 10 zu bekommen.

[wurzelzwerg]

Naja 6 aus 10 ist ja nicht das Problem, aber bei z.B. 10 Zahlen müssen 210 unterschiedliche Tippreihen rauskommen.
Bei 16 Zahlen wären es 8008 Tippreihen

[guinnes]

Zitat:

Zitat von wurzelzwerg (Beitrag 1125647)

Naja 6 aus 10 ist ja nicht das Problem, aber bei z.B. 10 Zahlen müssen 210 unterschiedliche Tippreihen rauskommen.

Ja, und ? Ich verstehe dein Problem nicht, was spricht gegen 6 ineinander verschachtelte Schleifen ?

[MrSpock]

Nochmal: wenn du eine Methode für n aus m schreibt, die z.B. aus einem Array mit m Einträgen alle Listen mit n Einträgen zurückliefert, kannst du doch auch 6 aus 20 berechnen lassen und bekommst damit 20! / (6! *(20-6)!) Einträge also 38760 Einträge.

[Bjoerk]

Hab’s mir mal gegeben. Sollte funktionieren.

Delphi-Quellcode:

unit uLottoTipp;

interface

uses
  Classes;

type
  TLottoVektor = array of integer;
  TLottoMatrix = array of array of integer;

  TLottotipp = class(TObject)
  private
    FList: TList;
    FTipp: TLottoVektor;
    FTipps: TLottoMatrix;
    FCount, FN1, FN2: integer;
    function GetFTipp(I: integer): integer;
    function GetFTipps(I, J: integer): integer;
  public
    property Count: integer read FCount;
    property N1: integer read FN1;
    property N2: integer read FN2;
    property Tipp[I: integer]: integer read GetFTipp;
    property Tipps[I, J: integer]: integer read GetFTipps;
    procedure GetTipp(const Index: integer);
    constructor Create(const Count, N1, N2: integer); overload;
    constructor Create(const N1, N2: integer); overload;
    destructor Destroy; override;
  end;

  TSystemLottotipp = class(TObject)
  private
    FList: TList;
    FTipp: TLottoVektor;
    FTipps: TLottoMatrix;
    FCount, FN, FN1, FN2: integer;
    function GetFTipp(I: integer): integer;
    function GetFTipps(I, J: integer): integer;
    procedure SetTipp;
  public
    property Count: integer read FCount;
    property N: integer read FN;
    property N1: integer read FN1;
    property N2: integer read FN2;
    property Tipp[I: integer]: integer read GetFTipp;
    property Tipps[I, J: integer]: integer read GetFTipps;
    procedure GetTipps;
    constructor Create(const N, N1, N2: integer);
    destructor Destroy; override;
  end;

  function NueberK(const N, K: integer): integer;

implementation

function NueberK(const N, K: integer): integer;
var
  I: integer;
begin
  Result:= 1;
  for I:= 1 to K do
    Result:= Result*(N-I+1) div I;
end;

function InTippsList(const Index, N1: integer; const Tipps: TLottoMatrix): boolean;
var
  I, J: integer;
begin
  Result:= false;
  for I:= 0 to Index-1 do
  begin
    J:= 0;
    while (J <= N1-1) and (Tipps[Index, J] = Tipps[I, J]) do
    begin
      if J = N1-1 then
      begin
        Result:= true;
        Exit;
      end
      else
        Inc(J);
    end;
  end;
end;


{ TLottotipp }


constructor TLottotipp.Create(const Count, N1, N2: integer);
begin
  // N1 <= N2
  // Count <= N2 über N1
  inherited Create;
  FList:= TList.Create;
  FCount:= Count;
  FN1:= N1;
  FN2:= N2;
  SetLength(FTipp, FN1);
  SetLength(FTipps, FCount, FN1);
  Randomize;
end;

constructor TLottotipp.Create(const N1, N2: integer);
begin
  Create(1, N1, N2);
end;

destructor TLottotipp.Destroy;
begin
  FList.Free;
  SetLength(FTipp, 0);
  SetLength(FTipps, 0);
  inherited Destroy;
end;

function TLottotipp.GetFTipp(I: integer): integer;
begin
  Result:= FTipp[I];
end;

function TLottotipp.GetFTipps(I, J: integer): integer;
begin
  Result:= FTipps[I, J];
end;

procedure TLottotipp.GetTipp(const Index: integer);
var
  I, J, T: integer;
begin
  repeat
    FList.Clear;
    for I:= 1 to FN2 do
      FList.Add(Pointer(I));
    for I:= 0 to FN1-1 do
    begin
      J:= Random(FList.Count);
      FTipp[I]:= Integer(FList[J]);
      FList.Delete(J);
    end;
    for I:= 0 to FN1-2 do
      for J:= I+1 to FN1-1 do
      if FTipp[I] > FTipp[J] then
      begin
        T:= FTipp[I];
        FTipp[I]:= FTipp[J];
        FTipp[J]:= T;
      end;
    for J:= 0 to FN1-1 do
      FTipps[Index, J]:= FTipp[J];
  until not InTippsList(Index, FN1, FTipps);
end;


{ TSystemLottotipp }


constructor TSystemLottotipp.Create(const N, N1, N2: integer);
begin
  // N1 <= N2
  // N >= N1, N <= N2
  inherited Create;
  FList:= TList.Create;
  FN:= N;
  FN1:= N1;
  FN2:= N2;
  SetLength(FTipp, FN);
  FCount:= NueberK(FN, FN1);
  SetLength(FTipps, FCount, FN1);
  Randomize;
end;

destructor TSystemLottotipp.Destroy;
begin
  FList.Free;
  SetLength(FTipp, 0);
  SetLength(FTipps, 0);
  inherited Destroy;
end;

function TSystemLottotipp.GetFTipp(I: integer): integer;
begin
  Result:= FTipp[I];
end;

function TSystemLottotipp.GetFTipps(I, J: integer): integer;
begin
  Result:= FTipps[I, J];
end;

procedure TSystemLottotipp.SetTipp;
var
  I, J, T: integer;
begin
  FList.Clear;
  for I:= 1 to FN2 do
    FList.Add(Pointer(I));
  for I:= 0 to FN-1 do
  begin
    J:= Random(FList.Count);
    FTipp[I]:= Integer(FList[J]);
    FList.Delete(J);
  end;
  for I:= 0 to FN-2 do
    for J:= I+1 to FN-1 do
    if FTipp[I] > FTipp[J] then
    begin
      T:= FTipp[I];
      FTipp[I]:= FTipp[J];
      FTipp[J]:= T;
    end;
end;

procedure TSystemLottotipp.GetTipps;
var
  I, J, Index, T: integer;
  A: boolean;
  ATipp: TLottoVektor;
begin
  SetTipp;
  SetLength(ATipp, FN1);
  Index:= 0;
  repeat
    repeat
      FList.Clear;
      for I:= 0 to FN-1 do
        FList.Add(Pointer(I));
      for I:= 0 to FN1-1 do
      begin
        J:= Random(FList.Count);
        T:= Integer(FList[J]);
        ATipp[I]:= FTipp[T];
        FList.Delete(J);
      end;
      for I:= 0 to FN1-2 do
        for J:= I+1 to FN1-1 do
        if ATipp[I] > ATipp[J] then
        begin
          T:= ATipp[I];
          ATipp[I]:= ATipp[J];
          ATipp[J]:= T;
        end;
      for J:= 0 to FN1-1 do
        FTipps[Index, J]:= ATipp[J];
      A:= InTippsList(Index, FN1, FTipps);
      if not A then Inc(Index);
    until not A;
  until Index = FCount;
end;

end.

Delphi-Quellcode:

unit LottoTippUnit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

uses
  uLottoTipp;

function LottoTippString(const LottoTipp: TLottoTipp; const I: integer): string;
var
  J: integer;
begin
  Result:= '';
  for J:= 0 to LottoTipp.N1-1 do
    Result:= Result + IntToStr(LottoTipp.Tipps[I, J])+'   ';
  Result:= TrimRight(Result);
end;

function SystemLottoTippString(const LottoTipp: TSystemLottoTipp; const I: integer): string;
var
  J: integer;
begin
  Result:= '';
  for J:= 0 to LottoTipp.N1-1 do
    Result:= Result + IntToStr(LottoTipp.Tipps[I, J])+'   ';
  Result:= TrimRight(Result);
end;

function TheSystemLottoTippString(const LottoTipp: TSystemLottoTipp): string;
var
  I: integer;
begin
  Result:= '';
  for I:= 0 to LottoTipp.N-1 do
    Result:= Result + IntToStr(LottoTipp.Tipp[I])+'   ';
  Result:= TrimRight(Result);
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  LottoTipp: TLottoTipp;
  I: integer;
begin
  // LottoTipp:= TLottoTipp.Create(NueberK(49, 6), 6, 49); // AUA
  LottoTipp:= TLottoTipp.Create(100, 6, 49);
  Memo1.Clear;
  Memo1.Lines.BeginUpdate;
  try
    for I:= 0 to LottoTipp.Count-1 do
      LottoTipp.GetTipp(I);
    Caption:= IntToStr(LottoTipp.Count)+' Tipps';
    for I:= 0 to LottoTipp.Count-1 do
      Memo1.Lines.Add(LottoTippString(LottoTipp, I));
  except
    on E: Exception do
      ShowMessage('Fehler vom Typ: '+E.ClassName+', Meldung: '+E.Message);
  end;
  LottoTipp.Free;
  Memo1.Lines.EndUpdate;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  LottoTipp: TSystemLottoTipp;
  I: integer;
begin
  LottoTipp:= TSystemLottoTipp.Create(16, 6, 49);
  Memo1.Clear;
  Memo1.Lines.BeginUpdate;
  try
    LottoTipp.GetTipps;
    Caption:= IntToStr(LottoTipp.Count)+' Tipps';
    Memo1.Lines.Add(TheSystemLottoTippString(LottoTipp));
    Memo1.Lines.Add('');
    for I:= 0 to LottoTipp.Count-1 do
      Memo1.Lines.Add(SystemLottoTippString(LottoTipp, I));
  except
    on E: Exception do
      ShowMessage('Fehler vom Typ: '+E.ClassName+', Meldung: '+E.Message);
  end;
  LottoTipp.Free;
  Memo1.Lines.EndUpdate;
end;

end.

[MrSpock]

Ich wollte eigentlich nur Hilfe zur Selbsthilfe leisten :-)

Wenn du dir schon die Mühe gemacht hast, kannst du ja das Projekt mal anhängen.

[Bjoerk]

Here we go.

[DeddyH]

Vielleicht sollte man aber erst den ganzen doppelten Code entfernen (DRY) ;)

[MrSpock]

Hallo Bjoerg,

zunächst mal danke für's hochladen. Ich hatte verstanden, dass der TE wissen wollte, wie er einen Vollsystemtip "erzeugt". Also wenn man z.B. 10 Zahlen eingibt dann sollen alle "tatsächlich getippten" Reihen erzeugt werden, also alle Möglichkeiten 6 Zahlen aus den 10 auszuwählen. Dazu hatte ich vorgeschlagen eine Methode n_aus_m zu schreiben, die für beliebiges n und beliebiges m (ggf. begrenzt auf 15 oder so) die Möglichkeiten erzeugt. Ich würde sogar die Zahlen von 1 bis m nehmen und daraus alle Ziffernfolgen mit n Zahlen generieren, dann könnte man diese als Index in einem Array [1..m] hernehmen.

Das macht dein Programm ja nicht.

[Bjoerk]

Zitat:

Zitat von DeddyH (Beitrag 1125783)

Vielleicht sollte man aber erst den ganzen doppelten Code entfernen (DRY) ;)

Stimmt, das Sortiern ist vier mal drinne, sorry. Anyway..

[Bjoerk]

Zitat:

Zitat von MrSpock (Beitrag 1125810)

Hallo Bjoerg,

...

Das macht dein Programm ja nicht.

Logisch macht es das, gib einfach in Button3Click enstprechende Werte vor.

[wurzelzwerg]

Vielen Dank schon mal.

@Bjoerg
Wies aussieht erzeugst du Zufallstipps.
Ich wollte z.B. System 007
Eingabe: 1, 2, 3, 4, 5, 6, 7
Ergebnis:
1,2,3,4,5,6
1,2,3,4,5,7
1,2,3,4,6,7
1,2,3,5,6,7
1,2,4,6,5,7
1,3,4,5,6,7
2,3,4,5,6,7

Also aus 7-16 vorgegenen Zahlen alle möglichen Kombinationen errechnen.

Zu VEW:
Sind das bei System VEW vorgegebene Kombinationen die nicht errechnet werden, also irgenwo definiert werden müssen?

[Bjoerk]

Zitat:

Zitat von wurzelzwerg (Beitrag 1125857)

Vielen Dank schon mal.

@Bjoerg
Wies aussieht erzeugst du Zufallstipps. ...

Siehe Button3Click.

[wurzelzwerg]

Ja, ok die Stelle zum setzen der Zahlen ist klar, danke.
Aber warum das J:= Random(FList.Count) in GetTipps?
Ich habe mal versucht immer den letzten Eintrag der Liste zu nehmen (J:= FList.Count-1),
das ergibt aber eine Endlosschleife.

[Bjoerk]

Wenn Count beispielsweise 5 ist liefert Random(Count) eine Zahl zwischen null und vier. Count ändert sich auch immer, weil jeweils ein Item aus FList heraus gelöscht wird.

[wurzelzwerg]

Schon klar was count liefert, aber warum nimmst du Zufallszahlen an der Stelle?
Dass J:= FList.Count-1 dort nicht funktioniert versteh ich nicht, müsste doch Zahlen von x..0 liefern.

[Bjoerk]

Bei Random(Count-1) würde ein Item fehlen.
Schau dir mal LottoTipp.GetTipp an, ist einfacher zu verstehen.

[MrSpock]

Also hier mal das, was ich mit n_aus_m meinte. Eine schnuckelige rekursive Prozedur, die das Vollsystem erzeugt ;-)

[wurzelzwerg]

Danke MrSpock, schau ich mir an.
Was hälst du davon?

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
type
  TSpiel = record
    z1, z2, z3, z4, z5, z6: integer;
  end;
var
  i, k, l, m, n, o, p, max: integer;
  tipps: array of TSpiel;
  tipp: array[1..16] of integer;
begin
  for i:= 1 to 16 do
    tipp[i]:= i;  // bzw. individueller Tipp 
  max := 16;
  i := 1;
  for k := 1 to max - 5 do
    for l := k + 1 to max - 4 do
      for m := l + 1 to max - 3 do
        for n := m + 1 to max - 2 do
          for o := n + 1 to max - 1 do
            for p := o + 1 to max do
            begin
              SetLength(tipps, i);
              tipps[i - 1].z1 := tipp[k];
              tipps[i - 1].z2 := tipp[l];
              tipps[i - 1].z3 := tipp[m];
              tipps[i - 1].z4 := tipp[n];
              tipps[i - 1].z5 := tipp[o];
              tipps[i - 1].z6 := tipp[p];
              inc(i);
            end;

  Memo1.Lines.Clear;
  Memo1.Lines.BeginUpdate;
  for i := Low(tipps) to high(tipps) do
  begin
    Memo1.Lines.Add(IntToStr(tipps[i].z1) + ' ' +
      IntToStr(tipps[i].z2) + ' ' +
      IntToStr(tipps[i].z3) + ' ' +
      IntToStr(tipps[i].z4) + ' ' +
      IntToStr(tipps[i].z5) + ' ' +
      IntToStr(tipps[i].z6));
  end;
  Memo1.Lines.EndUpdate;
  Caption := IntToStr(Memo1.Lines.Count) + ' Tippreihen';
end;

Nun bleibt noch das VEW.
Sind das von Lotto festgelegte Kombinationen die man sich definieren muss?

[BoolString]

Hab den Thread nur kurz überflogen. Meinst du so etwas:

Delphi-Quellcode:

Procedure TForm1.CalcCombinatoricGenes (CombinatoricResult, Rest : String; CalcDepth : Integer);
Var Runner  : Longint;
    Counter : Int64;
Begin
//  If (Rest='') Or (CalcDepth=0) THen
//  Begin
//    If CheckRules (CombinatoricResult)THen
//    Begin
//      ListBox1.Items.Add(CombinatoricResult);
//    end;

    ListBox1.Items.Add (CombinatoricResult);

  end
  Else
  Begin
    For Runner := 1 to Length (Rest) do
    Begin
      CalcCombinatoricGenes (CombinatoricResult + Rest [Runner],
                               Copy (Rest, 1, Runner-1) + Copy (Rest, Runner+1, Length (Rest)-1),
                               CalcDepth-1);
    end;
  end;
end;



procedure TForm1.BitBtn1Click(Sender: TObject);
begin
  CalcCombinatoricGenes ( '', '123456789', 5);
end;

Komlett rekursiv.

- CombinatoricResult enthält die Ergebnisse
- Rest enthält die noch nicht entnommenen Elemente; bei erstem Aufruf die übergebene Liste der zur Verfügung stehenden Elemente
- Depth sagt, wie viele Elemente aus der Ursprungsmenge von Rest entnommen werden sollen

Für deine Anwendung müsstest du dir überlegen, wie du deine Zahlen/Elemente 'tokenisen' kannst. Z.B. in Chars umwandeln. Bin mir aber gerade nicht sicher, ob das komplett Unicode konform ist...

Falls das komplett am Ziel vorbei schießt, schmeist meinen Beitrag einfach aus dem Thread...

Jan

[Sir Rufo]

Auf den ersten Blick: Das löppt so nicht ...

[MrSpock]

Zitat:

Zitat von wurzelzwerg (Beitrag 1126097)

Danke MrSpock, schau ich mir an.
Was hälst du davon?
...

Die Lösung funktioniert auch. Die rekursive ist allgemeiner, weil sie prinzipiell für beliebige n und m funktioniert. Die iterative Lösung ist dafürwohl etwas schneller.

[Bjoerk]

Zitat:

Zitat von MrSpock (Beitrag 1126039)

Also hier mal das, was ich mit n_aus_m meinte. Eine schnuckelige rekursive Prozedur, die das Vollsystem erzeugt ;-)

Stimmt, schnuckelige Procedure. Hast du die auch für N aus N (N Fakultaet Möglichkeiten) ? Könnte ich für meine Schneideskizze gebrauchen.

[MrSpock]

Zitat:

Zitat von Bjoerk (Beitrag 1126141)

Zitat:

Zitat von MrSpock (Beitrag 1126039)

Also hier mal das, was ich mit n_aus_m meinte. Eine schnuckelige rekursive Prozedur, die das Vollsystem erzeugt ;-)

Stimmt, schnuckelige Procedure. Hast du die auch für N aus N (N Fakultaet Möglichkeiten) ? Könnte ich für meine Schneideskizze gebrauchen.

Was genau meinst du mit N aus N? Bei N aus N gibt es nur genau eine Möglichkeit, nämlich alle N Elemente. :?

[Bjoerk]

Alle möglichen Kombinationen (nicht sortiert).

Beispiel: N = 3

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

[leddl]

Zitat:

Zitat von Bjoerk (Beitrag 1126163)

Alle möglichen Kombinationen (nicht sortiert).

Beispiel: N = 3

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

Bei n über k ist die Reihenfolge irrelevant :zwinker: Es geht beim Lotto schließlich nur um die gezogenen Zahlen, nicht in welcher Reihenfolge diese angekreuzt wurden ;)

[Bjoerk]

Zitat:

Bei n über k ist die Reihenfolge irrelevant :zwinker: Es geht beim Lotto schließlich nur um die gezogenen Zahlen, nicht in welcher Reihenfolge diese angekreuzt wurden ;)

Kein Mensch hat was anderes behauptet, ich benötige das für etwas anderes, -> siehe # 25.

[leddl]

Zitat:

Zitat von Bjoerk (Beitrag 1126170)

Kein Mensch hat was anderes behauptet, ich benötige das für etwas anderes, -> siehe # 25.

Mir ist bewusst, dass du was anderes willst. Du hattest aber in Bezug auf MrSpocks Funktion nach "n aus n" gefragt. Die liefert aber nunmal etwas grundlegend anderes ab ;)
Das was du suchst, nennt sich "Permutation" und sollte ohne Probleme hier im Forum zu finden sein.

[Bjoerk]

Dank' dir für den Hinweis.

[Bjoerk]

Permutation ist soweit jetzt klar, Thanx. Zurück zum Lotto. Mir ist das Teilsystem noch nicht klar. Bei VEW 612 zum Beispiel gibt es eine Tabelle mit 12 Systemzahlen und 22 Spielen. Was bedeutet das? Würde man das als Vollsystem spielen, ergäben sich 924 Tippreihen. Also, welche Tippreihen werden denn dann gestrichen und wieviele Tippreihen hat man dann überhaupt?

[guinnes]

VEW-Systeme sind so optimiert, daß z.B. alle möglichen 3er Kombinationen in den Reihen berücksichtigt werden. Damit ist aber auch nur garantiert, daß du einen 3er hast, wenn du 3 Richtige in deinen 22 Zahlen hast. Beim System 610 sind die 10 Zahlen so kombiniert, daß du garantiert 2 Mal 4 hast, wenn du 4 in deinen 10 Zahlen hast. Ein 5er ist schon nicht mehr garantiert. Und die Frage nach der Anzahl der Tippreihen hast du dir schon selber beantwortet

[renekr]

Hi,

ich muss das Thema mal wieder aufrollen :)

bin soeben auch dabei ein kleines Tool zu machen allerdings möchte ich nicht nur die End Zahl vorgeben 49 oder so sondern auch die Start Zahl,
also nur Zahlen von 15-35 z.b:

Habe schon einiges versucht bekomme es aber leider nicht richtig hin.

Hoffe mir kann jemand helfen ?

Vielen Dank

[Bjoerk]

Mit der n aus m Routine kannst du das doch machen?

Sogar beliebige Zahlen, z.B. 3 aus 5 und die 5 sind z.B. 11, 17, 200, 22, -7.