2012-08-16 8 views

Antwort

17

Es ist eine kurze Version mit Array.sort() Funktion:

var arr : Array = [0,1,2,3,4,5,6,7,8,9]; 

function randomize (a : *, b : *) : int { 
    return (Math.random() > .5) ? 1 : -1; 
} 

trace(arr.sort(randomize)); 

Wenn Sie nicht bekommen, "genug" Zufälligkeit Sie sortieren zweimal kann :)

EDIT - Erläuterung Zeile für Zeile:

Für Array Klassenmethode sort() können Sie nicht nur Sortieroptionen wieübergebenund so weiter, aber auch Ihre eigene benutzerdefinierte Vergleichsfunktionsreferenz (ein Callback), die zwei Parameter akzeptiert (zwei Elemente vom zu vergleichenden Array). Aus der AS3-Dokumentation:

Eine Vergleichsfunktion sollte zwei Argumente zum Vergleich benötigen. Bei den Elementen A und B kann das Ergebnis von compareFunction einen negativen, 0 oder positiven Wert haben:

  • Ein negativer Rückgabewert gibt an, dass A vor B in der sortierten Reihenfolge erscheint.
  • Ein Rückgabewert von 0 gibt an, dass A und B dieselbe Sortierreihenfolge haben.
  • Ein positiver Rückgabewert gibt an, dass A nach B in der sortierten Sequenz angezeigt wird.

Hinweis: Vergleichsfunktion Parameter können eingegeben werden (wenn Ihr Array eingegeben wird) und einen beliebigen Namen Sie zB wollen .:

function compareElements (elementA : SomeClass, elementB : SomeClass) : int; 

Diese Methode ist sehr nützlich, wenn Sie Array sortieren müssen Elemente durch ihre besonderen Eigenschaften. In Randomisierung Fall compareFunction gibt zufällig -1, 0 oder 1 zurück und macht Array-Elemente ihre Plätze (Indizes) zu wechseln. Ich habe festgestellt, dass eine bessere Randomisierung (in meiner subjektiven und mathematisch nicht getesteten Meinung) ist, wenn die Methode nur -1 und 1 zurückgibt. Beachten Sie auch, dass die Sortierfunktion mit der benutzerdefinierten Vergleichsfunktion doesn't compare elements sequentially so in einigen speziellen Fällen Randomisierung Ergebnisse abweichen können, was Sie erwarten könnten.

+2

Ich denke '(Math.random() <.5)? -1: 1 ist besser. – Florent

+0

Einverstanden, effizienter und es ist nicht notwendig zu runden – BadFeelingAboutThis

+0

Das ist ziemlich toll. Können Sie die Zeilen aufschlüsseln und erklären, was sie tun? Wie ist das (a: *, b: *) und die Art etc .. –

1

Ich fand das sehr hilfreich. Ich hoffe, es kann dir auch helfen.

// Array to Randomize 
var firstArray:Array = ["One","Two","Three","Four","Five","six","seven","eight","nine","ten"]; 
trace(firstArray); // Prints in order 

var newArray:Array = new Array(); 
function randomizeArray(array:Array):Array 
{ 
    var newArray:Array = new Array(); 

    while (array.length > 0) 
    { 
     newArray.push(array.splice(Math.floor(Math.random()*array.length), 1)); 
    } 

    return newArray; 
} 

var randomArray:Array = randomizeArray(firstArray); 
trace(randomArray); // Prints out randomized :) 
2

Es gibt einen besseren Weg, der auch Ihnen erlaubt, die Anordnung an Ort und Stelle randomisieren, wenn Sie das, und es wird nicht machen Sie mehr als eine einzige Kopie des ursprünglichen Arrays erstellen.

package 
{ 
    import flash.display.Sprite; 

    public class RandomizeArrayExample extends Sprite 
    { 
     public function RandomizeArrayExample() 
     { 
      super(); 
      testDistribution(); 
     } 

     private function testDistribution():void 
     { 
      var hash:Object = { }; 
      var tester:Array = [1, 2, 3, 4]; 
      var key:String; 

      for (var i:int; i < 1e5; i++) 
      { 
       randomize(tester); 
       key = tester.join(""); 
       if (key in hash) hash[key]++; 
       else hash[key] = 1; 
      } 
      for (var p:String in hash) trace(p, "=>", hash[p]); 
     } 

     private function randomize(array:Array):Array 
     { 
      var temp:Object; 
      var tempOffset:int; 
      for (var i:int = array.length - 1; i >= 0; i--) 
      { 
       tempOffset = Math.random() * i; 
       temp = array[i]; 
       array[i] = array[tempOffset]; 
       array[tempOffset] = temp; 
      } 
      return array; 
     } 
    } 
} 
1

Ich hatte eine alternative Anforderung, bei der ich willkürlich viele Quellarrays zufällig in ein Zielarray einfügen wollte. Wie Rytis bin ich ein großer Fan der Funktionen forEach, map und sort auf Arrays.

var randomInsert:Function = function callback(item:*, index:int, array:Vector.<MyItem>):void 
{ 
    var j:Number = Math.floor(Math.random() * targetArray.length); 
    targetArray.splice(j,0,item);     
} 

targetArray = new Vector.<MyItem>(); 
sourceArray1.forEach(randomInsert, this); 
sourceArray2.forEach(randomInsert, this); 
1

Hier ist eine einfachere Funktion. Funktioniert auch auf mehrdimensionalen Arrays

0

Wenn Sie Ihr Array gemischt werden müssen (Ihre Elemente können nicht wiederholt werden).Sie könnten diese Funktion nutzen:

/** 
* Shuffles array into new array with no repeating elements. Simple swap algorithm is used. 
*/ 
public function shuffleArray(original:Array):Array 
{ 
    // How many swaps we will do 
    // Increase this number for better results (more shuffled array, but slower performance) 
    const runs:int = original.length * 3; 
    var shuffled:Array = new Array(original.length); 

    var i:int; 
    var a:int; 
    var b:int; 
    var temp:Object; 

    // Copy original array to shuffled 
    for(i=0; i<shuffled.length; i++){ 
     shuffled[i] = original[i]; 
    } 

    // Run random swap cycle 'runs' times 
    for(i=0; i<runs; i++){ 
     // There is a chance that array element will swap with itself, 
     // and there is always small probability it will make your shuffle 
     // results not that good, hence try to experiment with 
     // different runs count as stated above 
     a = Math.floor(Math.random() * original.length); 
     b = Math.floor(Math.random() * original.length); 

     // Swap messages 
     temp = shuffled[a]; 
     shuffled[a] = shuffled[b]; 
     shuffled[b] = temp; 
    } 

    return shuffled; 
} 

Verbrauch:

var testArray:Array = ["Water", "Fire", "Air", "Earth"]; 
trace(shuffleArray(testArray).concat()); 
0

das ist, wie ich meine Array von 36 Karten für ein Memory-Spiel randomisieren

const QUANT_CARTAS: int = 36; 

//get the 36 numbers into the array 
for (var i: int = 0; i < QUANT_CARTAS; i++) 
{ 
    cartas.push(i); 
} 

//shuffles them =) 
for (var moeda: int = QUANT_CARTAS - 1; moeda > 0; moeda--) 
{ 
    var pos: int = Math.floor(Math.random() * moeda); 
    var carta: int = cartas[moeda]; 
    cartas[moeda] = cartas[pos]; 
    cartas[pos] = carta; 
} 
// and add them using the random order... 

    for (i = 0; i < QUANT_CARTAS; i++) 
{ 
    var novaCarta: Carta = new Carta(); 
    novaCarta.tipoCarta = cartas[i]; 
    etcetcetc............. 
} 
0

wählt zufälligen Zeichenfolge aus Array

function keyGenerator(len:Number):String 
{ 
    function randomRange(minNum:Number, maxNum:Number):Number 
    { 
     return (Math.floor(Math.random() * (maxNum - minNum + 1)) + minNum); 
    } 
    var hexArray = ['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F']; 
    var key = ""; 
    for (var i=0; i<len; i++) 
    { 
     key += hexArray[randomRange(0,hexArray.length-1)]; 
    } 
    return key; 
} 

Verwendung:

trace(keyGenerator(16));