Zufallszahlen mit RND()

Vielleicht mal so als Anregung an RGH :

Könnte man Rnd(N1) auch ein Array von Ganzzahlen übergeben ?

Also, daß Rnd() nur diejenigen Zahlen, die auch im Array sind, zufällig

auswählt. Das Array könnte man ja bei jedem Durchlauf auf die

verbliebenen Zahlen neu modifizieren.

Hintergrund ist eine softwaremäßige Lotto-Ziehungsmaschine.

Wenn man nun so eine Ausspielung 6 aus 49 betrachtet, sind es

ja immer Einzelziehungen bei jedem Neustart der Trommel. Da

ja dann immer eine Zahl fehlt, kommt ja die fortlaufende Nummerierung

nicht mehr in Frage. Man sagt zwar so schön 6 aus 49, das wäre aber streng

genommen nur dann, wenn die 6 gezogenen Zahlen nach einmaligem

Mischen alle mit einem Plumps rausfallen würden.

Theorethisch ist es ja so :

1 Zahl aus 49 möglichen

1 Zahl aus 48 möglichen

1 Zahl aus 47 möglichen

1 Zahl aus 46 möglichen

1 Zahl aus 45 möglichen

1 Zahl aus 44 möglichen

Geht ja auch nicht anders, sonst hätten wir ja öfter doppelt gezogene Zahlen, wo dann

immer ein weiterer Lauf nötig wäre, solange eine doppelte vorhanden wäre.

Wenn Rnd() auch ein Array aktzeptieren würde, wäre so eine Ziehung mehr

realitätsnäher.

Ich frage auch deshalb, weil ich im Netz solche Online - Generatoren gesehen habe,

denen man z.B. einen Pool an Wörtern mit Komma getrennt übergibt und dieser dann

ein Wort zufällig auswählt. Da gibt es ja auch keine Sortierung bzw. Reihenfolge und

die Unter- und Obergrenze ist variabel.

Da würde man sich viel Overhead sparen oder hat jemand da noch eine andere Idee ?

Ist auch nur mal als Gedankenanregung gedacht, damit das Forum hier wieder etwas

belebt wird

Super, schon mal gut.

Na dann noch eine Spielerei mit Zufallswörtern :

DEF RandomWort(1) IF(Len(@$(1), ",") > 1, SubStr$(@$(1), 1 + RND(Len(@$(1), ",")), ","), "")
Randomize
Print RandomWort("Hans,Susi,Kurt,Maria,Gerd")

WaitInput

Kann man bestimmt auch für andere Zwecke gebrauchen. Müssen ja nicht unbedingt

Namen sein.

Hallo, Volkmar

Schön, daß es dir gefällt.

In meinem Alter brauche ich sowas. Lesen und Kreuzworträtsel (wegen dem händischen

Schreiben der Buchstaben) sind ja schon gut. Wenn man dann noch zusätzlich etwas

programmiert, hilft das ungemein, den Geist fit zu halten.

Ich finde das als ideale Ergänzung und kann es beim Älterwerden nur empfehlen.

Es sollte auch durchaus öfter mal etwas kniffliger sein und nicht nur einen Code runterschreiben.

Hier mal eine kleine Lottomaschine, die 6 mal eine Zahl zieht und danach die Superzahl.

Wegen ArrDel geht es aber erst ab Version X3. Könnte man auch umfriemeln mittels einer

anderen Liste, aus der man Einträge löschen kann. Nach jeder Ziehung einer Kugel fehlt diese

ja beim nächsten Durchlauf. Es können ja nicht zwei gleiche gezogen werden.

Declare Long zahl, szahl, xpos
Declare Handle hpic, st, btn1, btn2
Declare Long ende
DEF RNDZahl(1) IF(Len(@$(1), ",") > 1, Val(SubStr$(@$(1), 1 + RND(Len(@$(1), ",")), ",")), "")

ende = 0
xpos = 10
WindowTitle "Lotto - Ausspielung"
Window 600, 250
st   = Create("STATIC", %HWnd, 10, 10, 560, 80)
btn1 = Create("Button", %HWnd, "Start", 10, 120, 60, 25)
btn2 = Create("Button", %HWnd, "Ende",  100, 120, 60, 25)

Mcls 560, 80, RGB(0,0,0)
hPic = Create("hPic", 0, "&MEMBMP")
StartPaint st
   DrawPic hPic, 0, 0; 0
EndPaint

WhileNot ende
  WaitInput
  If Clicked(btn1)
     StartPaint st
       DrawPic hPic, 0, 0; 0
     EndPaint
     xpos = 10
     Ausspielung()
  ElseIf Clicked(btn2)
     ende = 1
  EndIf
EndWhile


Proc Ausspielung
Declare Long LZahlen[], GZahlen[], SZahlen[],apos
SetSize LZahlen[], 49
SetSize GZahlen[], 6
SetSize SZahlen[], 10
MAT LZahlen[] < 1
MAT LZahlen[] + 1
MAT SZahlen[] < 1
UseCursor 2
Whileloop 0, 5
  Randomize
  zahl = RNDZahl(ImplodeNum(LZahlen[]))
  GZahlen[&LOOP] = zahl
  apos = IndexOf(LZahlen[], zahl)
  ArrDel LZahlen[], apos, 1
  ' Hier die gezogene Zahl löschen, damit sie beim nächsten
  ' Durchlauf nicht wieder gezogen wird.
EndWhile
  Randomize
  szahl = RNDZahl(ImplodeNum(SZahlen[]))
  SortArray(GZahlen[])
WhileLoop 0, 5
  DrawKugel(xpos, GZahlen[&LOOP])
  Inc xpos, 70
  Sleep 400
EndWhile
  Inc xpos, 70
  DrawKugel(xpos, szahl)
UseCursor 0  
EndProc

Proc ImplodeNum
Parameters S&[]
ClearList
If Move("ArrToList", S&[])
   DeleteString(0, GetCount(0) - 1)
   Return Move("ListToStr", ",")
Else
   Return ""
EndIf
EndProc

Proc SortArray
Parameters Long ZZahlen[]
ClearList
Move("ArrToList", ZZahlen[])
SortList 5
Move("ListToArr", ZZahlen[])
EndProc

Proc DrawKugel
Parameters Long x, gzahl
StartPaint st
  Ellipse x, 10 - x + 60, 70
  DrawText x + 30, 35, Str$(gzahl), 6
EndPaint
EndProc

Die Animation einer Trommel mit laufenden Kugeln (mit OGL ?) habe ich mir erspart.

Viel Spaß damit.

Hallo Jörg,

Das mit der 0 stimmt. Habs im Netz nochmals nachgeschaut und

auch bei lotto.de sieht man bei der History (gezogene Zahlen für

einen gewissen Zeitraum), manchmal ein 0.

Deswegen das extra Array von 0 - 9. Und die ist immer einstellig.

Was du evtl. meinst, ist die Landeslotterie. Da wird die Spielschein-Nr.

bzw. Losnummer auf Gewinn geprüft.

Ich habe dir mal einen alten Tippschein angehängt. Da siehst du

unter den Zahlenreihen auch die Superzahl und darunter in der

großen eckigen Klammer die Losnummer für die Landeslotterie,

was durch Super 6 und Spiel 77 abgelöst wurde. Anbei auch die

Quoten.

Ja, schau mal auf dem Qucktipp-Spielschein unter der letzten Zahlenreihe (14.)

Da steht Superzahl 2

Die scheint immer identisch mit der letzten Ziffer der Spielscheinnummer zu sein.

Man braucht ja nicht unbedingt Arrays zu nehmen.

List!(N) - List$(N) - List%(N) - List&(N) und Create("List", T)

und natürlich auch die interne Listboxliste oder sonstige Stringlisten

würden zwar auch gehen, nur müßte man jedesmal in eine echte

Zahl umwandeln. Das Löschen eines Eintrages müßte man mit

DeleteString machen. Daher waren die Arrays der beste Weg. Ansonsten

ist ja codemäßig nicht sehr schwierig.

Man muß bei jedem Durchlauf halt eines beachten :

Bei der realen Ziehung wird ja auch nach jeder gezogenen Kugel

die Maschine neu gestartet. Deshalb muß dies auch beachtet

werden :

1 Zahl aus 49 möglichen Zahlen

1 Zahl aus 48 möglichen Zahlen

1 Zahl aus 47 möglichen Zahlen

1 Zahl aus 46 möglichen Zahlen

1 Zahl aus 45 möglichen Zahlen

1 Zahl aus 44 möglichen Zahlen

Das war der hauptsächliche Knackpunkt bei meiner Maschine und deshalb

kam mir ArrDel da sehr gelegen. Bei den früheren Profanversionen könnte

man das auch mit Umkopieren der Arrays erreichen.

Auch das ganze mit Bereichen zu machen, wäre interessant. Da kannst du deiner

Kreativität freien Lauf lassen.

Zitat von JörgG

Ich hätte einfach 6x immer aus 49 Zahlen gewürfelt und im Falle einer bereits gezogenen Zahl, einfach weiter gewürfelt, bis eine frische Zahl kommt und die dann als nächste neue Zahl präsentiert - und das eben solange, bis 6 Zahlen zusammen sind

Das macht aber dann die Abfragen komplizierter. Bei den ersten beiden gezogenen Kugeln geht es noch,

aber nach der dritten, vierten und fünften Kugel wird es interessant. Da war das Löschen der gezogenen

Kugeln aus dem Array einfacher, da man dann einfach immer einen frischen Satz der noch gültigen Kugeln

beim nächsten Durchlauf hat. Du mußt ja immer die 49 Werte testen, weil die gezogenen Werte ja in diesem

Bereich (1-49) liegen können. Einfacher wäre es, wenn die 49 als erstes usw. gezogen würde, aber das ist

ja nur selten der Fall. Da geht u.U. dann auch eine Menge Zeit drauf, wenn du mit Rnd() solange ziehen mußt,

bis keine der schon gezogenen Zahlen dabei ist. Finde ich höchst uneffizient.

ach so meinst du das. Das ist mir jetzt gar nicht aufgefallen, daß du das auch genau so umgesetzt hast - schau ich gleich nochmal genauer hin

Ich kenne das, weil ich früher öfters samstags abends die Liveziehung mitverfolgt hatte. Da hatte ich gesehen, daß nach

jeder gezogenen Kugel die Trommel neu anlief. Und logischerweise immer mit einer Kugel weniger.

So o.ä. könnte man ein ArrDel in Profan Version 11.2 realisieren :

Declare a&[]

Cls
WhileLoop 0, 9
  a&[&LOOP] = &LOOP + 1
EndWhile

Print "Alte Größe : ", SizeOf(a&[])

ArrayDel(a&[], 3) 

WhileLoop 0, SizeOf(a&[]) - 1
  Print a&[&LOOP]
EndWhile

Print "Neue Größe : ", SizeOf(a&[])

Proc ArrayDel
Parameters b&[], p&
Declare L&
L& = Create("List", SizeOf(b&[] - 1))
WhileLoop 0, SizeOf(b&[]) - 1
   If b&[&LOOP] <> p&
      AddString(L&, Str$(b&[&LOOP]))
   EndIf   
EndWhile
SetSize b&[], GetCount(L&) - 1
WhileLoop 0, GetCount(L&) - 1
    b&[&LOOP] = Val(GetString$(L&, &LOOP))
EndWhile
EndProc

Waitkey

Ich mußte auf eine Liste mit Create zurückgreifen. Ein b&[] = Arr&[] funktioniert nicht, weil Profan da immer

eine 0 als Platzhalter für das gelöschte Element setzt. Ist jetzt nur für Long (&) - Arrays.