आप क्रियालेख 3 का उपयोग करके सरणी को यादृच्छिक कैसे करते हैं?as3 यादृच्छिक सरणी - यादृच्छिक सरणी - क्रियालेख 3
उत्तर
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 के साथ सॉर्टिंग फ़ंक्शन इसलिए कुछ विशेष मामलों में यादृच्छिक परिणाम आपके अपेक्षा से अलग हो सकते हैं।
मुझे यह बहुत उपयोगी लगता है। मुझे आशा है कि यह आपकी भी मदद कर सकता है।
// 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 :)
एक बेहतर तरीका है कि आप भी जगह में सरणी 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;
}
}
}
मेरे पास एक वैकल्पिक आवश्यकता थी जहां मैं यादृच्छिक रूप से लक्ष्य सरणी में बहुत से स्रोत सरणी को यादृच्छिक रूप से डालना चाहता था। 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);
यहां एक आसान कार्य है। बहुआयामी सरणियों
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;
}
आप अपने सरणी की जरूरत है फेरबदल किए जाने की (अपने तत्वों को दोहराना नहीं कर सकते हैं) पर भी काम करता है।आप इस सुविधा का उपयोग कर सकते हैं:
/**
* 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());
यह कैसे मैं एक स्मृति खेल के लिए 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.............
}
सरणी
से यादृच्छिक स्ट्रिंग का चयन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));
मुझे लगता है कि '(Math.random() <.5)? -1: 1' बेहतर है। – Florent
सहमत, अधिक कुशल और – BadFeelingAboutThis
को गोल करने की कोई आवश्यकता नहीं है यह बहुत बढ़िया है। क्या आप लाइनों को तोड़ सकते हैं और समझा सकते हैं कि वे क्या कर रहे हैं? जैसा है (ए: *, बी: *) और सॉर्ट इत्यादि .. –