Zufallsreihen

[Kaeru Gaman]

das mit der 9/8=IMA war en typo...
grundsätzlich braucht man nur 10 felder, wenn man nur reihen aus ziffern bilden will.
und ich hab die 0 mal weggelassen, weil die ausm rahmen fällt mit ihrem ASCII-Code.
ich könnt auch bei 0 anfangen und mit 10 ziffern arbeiten,
oder bei A anfangen und mit 26 ziffern arbeiten,
oder bei " " anfangen, und mit 128 ziffern arbeiten.

grundsätzlich klar: je mehr möglichkeiten ich hab, ne schon gewählte zahl zu erwischen,
desto langsamer werde ich in der gesamtauswahl.

das trial&error-prinzip hat sowieso nur einen Sinn in einer Umgebung,
wo ich eine Zufallszahl zeitnah anfordern kann.
wenn die Anforderung einer Zufallszahl so lange braucht wie die Überprüfung von nem Dutzend Datenfeldern,
ist jeder logische Algorithmus dem Trial&Error überlegen.
Umkehrschluß:
wenn die Überprüfung lange dauert, ist das Reinpowern eines schnellen Trial&Error überlegen.

...ihr seht: einmal mehr ist das Environment entscheident...

[gnasen]

Tut es aber nicht! Wenn ich 8 angebe, müsste die ForEach-Schleife auch 8x durchlaufen werden, oft wird sie aber weniger durchlaufen (jedoch nie öfter als 8x).

Warum ist das so?

Code: Alles auswählen

Procedure myZufallsreihe2(zahl, LinkedList.l())
	Repeat
		AddElement(LinkedList())
			LinkedList()=CountList(LinkedList())
	Until CountList(LinkedList()) = zahl
	ForEach LinkedList()
		Protected *element=@LinkedList()
		SelectElement(LinkedList(), Random(zahl-1))
		SwapElements(LinkedList(), *element, @LinkedList())
		ChangeCurrentElement(LinkedList(), *element)
	Next
EndProcedure

NewList test.l()
myZufallsreihe2(8, test())
ForEach test()
	Debug test()
Next

Wenn ich mich recht erinner, stellt die ForEach-Schleife einfach den Pointer aufs erste Element. Wenn du nun das Element wechselst "ChangeCurrentElement(LinkedList(), *element)" wird der Pointer dorthin zeigen. Und wie das bei einer For-Schleife ist, macht er von dort aus weiter bis zum Ende. Er überspringt sozusagen Teile.

Ich habe diese Problem mal folgendermaßen gelöst

Code: Alles auswählen

Global NewList Test.l()

For a=0 To 5
  AddElement(Test())
  Test() = a
Next

;/ Variante 1

ForEach Test()
  
  Debug "Inneres Ding"
  Debug Test()
  Debug "Äußeres Ding"
  
  ForEach Test()
    Debug Test()
  Next
  
Next


Procedure.l DoIrgendwas(Argument.l)
  
  ForEach Test()
    Debug Test()
  Next
  
  ProcedureReturn Argument
  
EndProcedure

;/ Variante 2

Debug ""
Debug "Besser"
Debug ""

FirstElement(Test())

For a=0 To CountList(Test()) -1 
  
  SelectElement(Test(),a)
  
  Debug "Inneres Ding"
  Debug Test()
  Debug "Äußeres Ding"
  
  a = DoIrgendwas(a)
  
Next

; Wie man sieht, kommen die Pointer nicht durcheinander

Vergleicht man die 2 Schleifen, sieht man was in die Hose geht. Ich denke es wird das selbe Prob sein

[AND51]

> Wenn du nun das Element wechselst "ChangeCurrentElement(LinkedList(), *element)" wird der Pointer dorthin zeigen. Und wie das bei einer For-Schleife ist, macht er von dort aus weiter bis zum Ende
ja, ich habe auch die vermutung, dass der Befehl SwapElements() nicht den Inhalt der Elemente, sondern die Elemente an sich, also die Pointer vertauscht.

Mein Gedanke war: Direkt zu Beginn der ForEach-Schleife merke ich mir das aktuelle Element, selektiere ein neues, vertausche ("swappe") es und kehre wieder zum ursprünglichen Element zurück.
Dieses Zurückkehren klappt aber nicht, weil ich mir zwar anfangs das 2. Element zum Beispiel merke, der Swap-Vorgang aber aus dem 2. das 7. von 8 Elementen macht. Ist das so richtig?

Dennoch bin ich persönlich mit dem Ergebnis, welches die Prozedur liefert, zufrieden. Die Zufallsreihe scheint mir ziemlich ausreichend durcheinandergewürfelt zu werden.