[STUFF] Lucky Number Random Script

[Kandidat]

Hallo liebe Flasher,

ich habe ein Randomscript entwickelt, das innerhalb eines bestimmten Maximums bereits "gewürfelte" Nummern notiert und eine Wiederwahl ausschließt bis nicht alle möglichen Nummern einmal gewürfelt worden.

Verstanden?


Funktion:
Also zuerst wird ein Maxmimum festgelegt (z.B. Maximum = 5) dann wird zum ersten Mal "gewürfelt" (d.h. Math.random(max) ausgeführt) und das Ergebnis in einem Array (EXCLUDE) festgehalten. Der Array wächst von Wurf zu Wurf und vergleicht jedes Random-Ergebnis so lange bis eine Zahl entspringt, die noch nicht im Array gelistet wurde. Wenn soviel Mal gewürfelt wurde wie es dem Maximum entspricht, wird der Array neugestartet und die Prozedur wiederholt sich von vorne.


Ein gutes Anwende-Beispiel: Alienscript

Das kleine Alien auf der rechten Seite spielt zufällig ausgewählte MP3-Streams ab. Um lästige Wiederholungen der kurzen Loops zu vermeiden kommt das Lucky-Number-Script zum Einsatz und hält mögliche Wiederholungen so lange zurück bis jeder Loop einmal gespielt wurde!


Anwendung
Script einfach in eine neue Flash-Datei kopieren und ausprobieren

// [url]www.biffbang.de[/url]
//
// Zu Beginn einen Spielraum festlegen
_global.MAXIMUM = 5;
// Click-Counter
_global.click = 0;
// Array zum Ausschließen der Nummern
EXCLUDE = [];
//
// LUCKY NUMBER Funktion
LuckyNumber = function () {
    // RANDOM
    this.mixXit = function() {
        this.LN = Math.round(random(MAXIMUM));
        EXCLUDE[click] = this.LN;
        trace(this.LN);
        this.compare();
    };
    // VERGLEICH
    this.compare = function() {
        for (var i = 0; i<EXCLUDE.length-1; i++) {
            if (this.LN == EXCLUDE[i]) {
                this.mixXit();
            }
        }
    };
    // RESET Click-Counter && Array
    if (click>=MAXIMUM) {
        EXCLUDE.splice(0, EXCLUDE.length, this.LuckyNumber);
        click = 1;
        trace("-R-E-S-E-T----------");
        trace("");
    }
    // TRIGGER
    this.mixXit();
    this.LuckyNumber = this.LN;
    click++;
    // 
    // trace
    trace("Listed: "+EXCLUDE.join(", "));
    trace("Lucky Random Number: "+this.LuckyNumber);
    trace("");
};
_root.onMouseDown = LuckyNumber; 

[McMannus]

Is zwar OT, aber dein Script war genau eine Aufgabe aus meiner letzten Kursarbeit in Informatik

[Kandidat]

Siehste, und ich hab's mir selbst beigebracht =)

[pape]

hm, der Algorithmus ist aber ziemlich ineffizient, da mixXit ja u.U. unendlich oft aufgerufen wird, falls zufällig immer genau die Zahlen kommen, die schon waren. Außerdem läuft die For-Schleife nach dem (verschränkt-)rekursiven Aufruf noch weiter, was zu nicht gewünschtem Verhalten füren könnte (muss man im Ergebnis nicht sehen, aber intern kann da einiges schief laufen).

Mein Tipp wäre es nach dem folgenden Prinzip vorzugehen:

Maximum setzen, zahlen von 1 bis Maximum in ein Array nochZuZiehen schreiben.
Per Random aus nochZuZiehen.length ein Element des Array auswählen. Dieses aus dem array löschen und in ein Array schonGezogen packen (falls man das wissen will).
Das macht man so lange, wie nochZuZiehen.length > 0 ist. Anschließend füllt man das Array neu (löscht ggf das schonGezogen Array, es seiden man möchte die gesamte Ziehungsreihenfolge dokumentieren) und speichert vorher aber, welche Zahl zuletzt gezogen wurde, um dann den Sonderfall auszuschließen zu können, bei dem z.B. 3 als letztes gezogen wurde und dann nach einem neu Befüllen des Arrays wieder als erstes 3 gezogen wird und somit 2 mal das gleiche Element vorkommt.

Dürfte dann effizienter und leichter zu durchschauen sein. Aber an sich ist ein solcher Stuff-Eintrag sicherlich für den ein oder anderen hilfreich

Ferner könnte man sogar komplett auf MAXIMUM verzichten und einfach nur die Arrays betachten. Was in den Arrays drinsteht ist eigentlich für den Algorithmus egal.

//Edit: Könnte dann z.B. so aussehen (wobei hier jetzt nicht das letzte gezogene gespeichert wird):

/**
* @author pape
* @version 0.1
*/
 
class LuckyNumber {
    var original_pool:Array;
    var pulled:Array;
    var pool:Array; 
    var trackProcess:Boolean;
    var lastItem:Object;
    
    public function LuckyNumber(pool:Array, trackProcess:Boolean)
    {
        if (0>=pool.length)
        {
            trace("LuckyNumber - Error: empty Array!");
        }
        else
        {
            this.original_pool = pool.slice();
            this.pool = pool.slice();
            this.pulled = new Array();
            this.trackProcess = trackProcess;
        }
    }
    public function getRandomItem()
    {
        if (0>=pool.length)
            reset();
        var item:Object = pool.splice(Math.floor(Math.random()*pool.length) , 1);
        pulled.push(item);
        trace("gezogen: "+pulled);
        trace("verbleibend: "+pool);
        return item;
        
    }
    private function reset():Void
    {
        this.pool = this.original_pool.slice();
        if (!this.trackProcess)
        {
            this.pulled = new Array();
        }
    }
} 

Beispiel zum Benutzen der Klasse:

import LuckyNumber;
a = new Array(1,2,3,4,5);
var l = new LuckyNumber(a, false);
_root.onMouseDown = function () {
    /* Hier nicht vergessen das zurückgegebene Object wieder in seinen eigentlichen Typ zu type-casten.
      (auch wenn es hier in diesem Beispiel erstmal keinen Unterschied macht.. aber wenn man z.B. prüfen
      wollen würde, ob das gezogene Element == 1 ist, dann gäbe es Ärger, da Object immer ungleich Number ist ;)
      In diesem Beispiel hier also nach Number casten.*/
    trace("Diesmal gezogen: "+Number(l.getRandomItem().toString()))+"\n---");
} 

[Kandidat]

Danke, dass Du Dich mit dem Script befasst hast. Ich hab' zwar leider zu wenig Erfahrung mit der Art von Action-Script, mit dem Du das geschrieben hast, um weiter mitreden zu können, finde aber Deinen Beitrag echt cool.

Außerdem habe ich momentan wenig Zeit zum Flashen, da ich mich mit dutzenden Farbproofs und Visitenkarten außeinandersetzen muss. (Pain in the Ass ) Man will das perfekte Farbergebnis von mir.

Wobei Leonard Cohen es doch so schön singt: "Forget your perfect offering. There is a crack in everything, that's how the light get's in."

Grüße
Paul

[Kandidat]

Hallo

ich habe begriffen, was Robert sich ausgedacht hat und habe die Idee auch mal umgesetzt. Einen Array schrumpfen zu lassen ist viel besser als die mögliche Endlosschleife zwischen zwei Funktionen zu provozieren.

Im Code seht ihr ein vereinfachtes Beispiel fürs Ausgabe-Fenster. Die luckyNumber() Funktion operiert hier als einfache return-Methode. Wichtig dabei ist, dass die Initialisierung vor der Anwendung der luckyNumber() Funktion ausgeführt wird, da sonst der Array leer ist.

Danke Robert =)

function initLuckyNumber() {
	var maximal = 10;
	possible = [];
	for (var i = 0; i<maximal; i++) {
		possible[i] = i;
	}
}
function luckyNumber() {
	var wert;
	var rndm;
	rndm = random(possible.length);
	wert = possible[rndm];
	possible.splice(rndm, 1);
	if (possible.length<=0) {
		initLuckyNumber();
	}
	if (wert == 0) {
		wert = 0;
	}
	return wert;
}
//
initLuckyNumber();
//
// Anwendung
for (var i = 1; i<20; i++) {
	trace(i+". Ergebnis: "+luckyNumber());
}

[rendner[i]]

Was für ein Sinn macht das?

PHP-Code:

if (wert == 0) {
        wert = 0;
    } 


[_geo_]

Ich denk keinen

mein AS1/2 is schon etwas eingerostet aber ich denk so könnt mans auch machen (über ne Art Array mischen funktion)

PHP-Code:

// LUCKY NUMBER Funktion
LuckyNumber = function(source:Array)
{
    var source_index:Number = -1;
    var source:Array = source;
    
    // mix it
    var shuffle = function()
    {
        source.sort(function(){return 1-random(3)});
        source_index = source.length - 1;
    };
    
    // get random number
    this.getNumber = function()
    {        
        if(source_index < 0){
            shuffle();
        }
        
        trace(source[source_index--]);
        //return source[source_index--];
    }
};

ln = new LuckyNumber( new Array(1,2,3,4,5,6,7,8,9) );
_root.onMouseDown = ln.getNumber; 


lg

[hgseib]

bis auf eine kleinigkeit perfekt ;-)

deshalb:
http://www.seibsprogrammladen.de/fra...rithmen/Zufall
Zufallsreihenfolgen aneinander reihen

Erzeugt immer wieder eine neue Reihe von Zufallszahlen, wobei die letzte Zahl nicht mit der ersten Zahl der neuen Reihe identisch ist.

[Kandidat]

Ich habe die "if wert == 0" Möglichkeit mit eingebunden, weil es beim üblichen Math.random() keinen Null-wert gibt sondern höchstens "0.0003123". Außerdem kann eine Null bei der Aleatorik zum kompletten Löschen eines Wertes beitragen und in der if Operation kann man verhindern, dass eine Null ausgespuckt wird.

Übrigens kann man an der Stelle "return wert" noch eine /10 einfügen also "return wert/10" so dass es mehr Ähnlichkeit mit Math.random() erhällt.

Gruß Paul

[rendner[i]]

Zitat von Kandidat

Ich habe die "if wert == 0" Möglichkeit mit eingebunden, weil es beim üblichen Math.random() keinen Null-wert gibt sondern höchstens "0.0003123". Außerdem kann eine Null bei der Aleatorik zum kompletten Löschen eines Wertes beitragen und in der if Operation kann man verhindern, dass eine Null ausgespuckt wird.

Arbeitet dein Compiler anders?

PHP-Code:

trace( (0 == 0.0003123) ); 


Und Math.random nutzt du gar nicht...

[Kandidat]

Ich habe das Script nun optimiert und jeglichen Schnick Schnack weggelassen!!

Die Methode ist jetzt einfach anzuwenden ohne vorherige Initiierungs-Funktion. Einzige Veränderung die passiert wenn das Script im Film eingefügt wird sind ein Array (PB) der nach außen geht. (Wenn man mehrere Instanzen des Scriptes benötigt, muss der Array unbedingt umbenannt werden, da es zu Konflikten kommen wird.)

luckyNumber() ist jetzt eine einfache return-Methode.

Ziel ist es nach wie vor Zufallszahlen zu erzeugen, die sich innerhalb eines Maximalwertes nicht wiederholen.

PHP-Code:

function luckyNumber() {
    //////////////////
    var MAXIMUM = 2;
    /////////////////
    function init(startup, kickout) {
        for (var i = 0; i<MAXIMUM; i++) {
            PB[i] = i;
        }
        if (!startup) {
            PB.splice(kickout, 1);
        }
    }
    if (PB == undefined) {
        PB = [];
        init(true);
    }
    var rndm;
    var wert;
    rndm = random(PB.length);
    wert = PB[rndm];
    PB.splice(rndm, 1);
    if (PB.length == 0) {
        init(false, wert);
    }
    return wert;
}
// Auslöser
for (var i = 0; i<15; i++) {
    trace(luckyNumber());
} 


In dieser Form ähnelt luckyNumber() dem random()

Wenn man return wert/10; schreibt und das MAXIMUM auf 10 Setzt ähnelt es dem Math.random()

Wenn alles klappt poste ich bald eine URL, in der ich das Script ziemlich cool angewandt habe. Dauert aber noch