as3 यादृच्छिक सरणी - यादृच्छिक सरणी - क्रियालेख 3

Question

आप क्रियालेख 3 का उपयोग करके सरणी को यादृच्छिक कैसे करते हैं?

Answer 1

Array.sort() फ़ंक्शन का उपयोग कर एक लघु संस्करण है:

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)); 

आप नहीं मिल "पर्याप्त" अनियमितता आप कर सकते हैं प्रकार दो बार :)

संपादित करते हैं - लाइन द्वारा स्पष्टीकरण लाइन:

Array कक्षा विधि sort() आप केवलजैसे सॉर्ट विकल्प को पास नहीं कर सकतेऔर इसी तरह, लेकिन आपकी खुद की कस्टम फ़ंक्शन संदर्भ (एक कॉलबैक) जो दो मानकों को स्वीकार करता है (तुलना करने के लिए सरणी से दो तत्व)। एएस 3 दस्तावेज से:

तुलनात्मक कार्य तुलना करने के लिए दो तर्क लेना चाहिए। तत्वों ए और बी को देखते हुए, compareFunction का परिणाम एक, नकारात्मक 0, या सकारात्मक मूल्य हो सकता है:

• एक नकारात्मक वापसी मान कि एक हल कर अनुक्रम में बी से पहले दिखाई देने का उल्लेख है।
• 0 का एक वापसी मूल्य निर्दिष्ट करता है कि ए और बी के समान क्रम क्रम है।
• एक सकारात्मक वापसी मूल्य निर्दिष्ट करता है कि बी क्रमबद्ध अनुक्रम में बी के बाद प्रकट होता है।

नोट: तुलना फ़ंक्शन पैरामीटर टाइप किया जा सकता है (यदि आपके सरणी लिखा गया) और जब आप सरणी सॉर्ट करने के लिए की जरूरत का कोई भी नाम उदा .:

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

इस विधि बहुत उपयोगी है है उनके विशेष गुणों के तत्व। यादृच्छिकरण मामले में compareFunction यादृच्छिक रूप से -1, 0 या 1 देता है और सरणी तत्वों को उनके स्थान (सूचकांक) स्विच करने के लिए बनाता है। मैंने पाया है कि बेहतर यादृच्छिकरण (मेरे व्यक्तिपरक और गणितीय रूप से अवांछित राय में) तब होता है जब विधि केवल -1 और 1 लौटाती है। यह भी ध्यान रखें कि कस्टम तुलना फ़ंक्शन doesn't compare elements sequentially के साथ सॉर्टिंग फ़ंक्शन इसलिए कुछ विशेष मामलों में यादृच्छिक परिणाम आपके अपेक्षा से अलग हो सकते हैं।

Answer 2

मुझे यह बहुत उपयोगी लगता है। मुझे आशा है कि यह आपकी भी मदद कर सकता है।

// 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 :) 

Answer 3

एक बेहतर तरीका है कि आप भी जगह में सरणी randomize करने के लिए, अगर आपको लगता है कि जरूरत की अनुमति देगा नहीं है, और यह आप और अधिक अपने मूल सरणी की एक प्रतिलिपि तो बनाने नहीं होगा।

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; 
     } 
    } 
} 

Answer 4

मेरे पास एक वैकल्पिक आवश्यकता थी जहां मैं यादृच्छिक रूप से लक्ष्य सरणी में बहुत से स्रोत सरणी को यादृच्छिक रूप से डालना चाहता था। Rytis की तरह मैं 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); 

Answer 5

यहां एक आसान कार्य है। बहुआयामी सरणियों

function randomizeArray(array:Array):Array 
{ 
    var newArray:Array = new Array(); 
    while (array.length > 0) 
    { 
     var mn=Math.floor(Math.random()*array.length) 
     newArray[newArray.length]=array[mn] 
     array.splice(mn,1) 
    } 
    return newArray; 
} 

Answer 6

आप अपने सरणी की जरूरत है फेरबदल किए जाने की (अपने तत्वों को दोहराना नहीं कर सकते हैं) पर भी काम करता है।आप इस सुविधा का उपयोग कर सकते हैं:

/** 
* 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; 
} 

उपयोग:

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

Answer 7

यह कैसे मैं एक स्मृति खेल के लिए 36 ताश के पत्तों की मेरी सरणी randomize

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............. 
} 

Answer 8

सरणी

से यादृच्छिक स्ट्रिंग का चयन

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; 
} 

उपयोग:

trace(keyGenerator(16));