var target:Number = 1024;
var slices:Array = [target];
var leng:int = 11;

for (var i:int = 0; i<leng-1; i++){
	 var index:int = int(Math.random()*slices.length);
	 var val:Number = slices[index];
	 var rand:Number = Math.random() * val/2;
	 slices[index] = val - rand;
	 slices.push(rand);
}

trace(slices);

// test that they all add up
var sum:Number = 0;
for (i = 0; i<slices.length; i++){
	sum += slices[i];
}
trace("test that they all add up: ", sum);

The above snippet creates an array of a specified length whose elements all add up to the variable target. Here is some example output:


165.31133050055192,322.23456030456015,
257.47582363389245,26.9984893942173,1.96283924962002,
5.466277873168191,21.362282634705164,62.68168197512457,
76.63028224500404,36.27274381401516,12.558309228795265,35.04537914634583
test that they all add up: 1024


var target:Number = 360;
var steps:Array = new Array();
for (var step:Number = 0; step < target; step += int(Math.random() * 36 + 36)){
	steps.push(Math.min(target,step));
}
steps.push(target);
trace(steps);
/* outputs something similar to:
0,46,99,144,189,259,330,360
*/

This is something I’ve had to do a few times recently…. it randomly steps a number toward a given target…

function uniqueCompare(arr:Array, compare:Function):void {
	var leng:int = arr.length;
	for (var i:int = 0; i<leng; i++){
		for (var j:int = i + 1; j<leng; j++){
			compare(arr[i], arr[j]);
		}
	}
}

var numbers:Array = [1, 2, 3, 4, 5];

uniqueCompare(numbers, compareCallback);

function compareCallback(a:*, b:*):void {
	trace("compare " + a + " to " + b);
}

/*
outputs:
compare 1 to 2
compare 1 to 3
compare 1 to 4
compare 1 to 5
compare 2 to 3
compare 2 to 4
compare 2 to 5
compare 3 to 4
compare 3 to 5
compare 4 to 5
*/

This snippet shows a function called uniqueCompare() that compares all elements in an array to all other elements in an array without repeating a comparison.

function randomize(a:*, b:*):int{
       return Math.round(Math.random()*8) - 4;
}

var i:int;
var fruits:Array;

trace("Math.random()");
for (i = 0; i<4; i++){
  // reset fruits array:
  fruits = ["apple", "grape","pear","cherry"];
  fruits.sort(randomize);
  trace(fruits);
}


// seeds
var s1:Number= 0xFF00FF;
var s2:Number = 0xCCCCCC;
var s3:Number= 0xFF00F0;

function tRandomize(a:*, b:*):int{
       return Math.round(rand()*8) - 4;
}

trace("nTausworthe rand()");
for (i= 0; i<4; i++){
  fruits = ["apple", "grape","pear","cherry"];
  fruits.sort(tRandomize);
  trace(fruits);
}
// from www.ams.org/mcom/1996-65-213/S0025-5718-96-00696-5/S0025-5718-96-00696-5.pdf
function rand():Number {
	s1=((s1&4294967294)<<12)^(((s1<<13)^s1)>>19);
	s2=((s2&4294967288)<<4)^(((s2<<2)^s2)>>25);
	s3=((s3&4294967280)<<17)^(((s3<<3)^s3)>>11);
	var r:Number = (s1^s2^s3) * 2.3283064365e-10;
	r = (r<0) ? r+=1 : r;
	return r;
}

/*
outputs:
Math.random()
grape,apple,pear,cherry
pear,cherry,apple,grape
grape,apple,pear,cherry
grape,apple,cherry,pear

Tausworthe rand()
apple,grape,pear,cherry
cherry,grape,pear,apple
grape,apple,cherry,pear
grape,pear,apple,cherry
*/

The above shows how to randomly sort or shuffle an array. This is useful in games. To achieve this I made use of the compareFunction argument of Array.sort(). Most sorting algorithms go through the array and compare values until the desired sort order is achieved. The compareFunction argument is a function that takes two values a and b and returns an integer that is negative positive or zero… see this info from the docs:
* A negative return value specifies that A appears before B in the sorted sequence.
* A return value of 0 specifies that A and B have the same sort order.
* A positive return value specifies that A appears after B in the sorted sequence.

So in the case of a randomizing an array you simply need to return a random int -1, 0 or 1. This is what I’ve done in the past (Math.round()*2) -1) … but when I was writing this snippet it seemed like 0 caused less variation in the output of the array so I made the range from -4 to 4 instead. This could have just been my imagination, but it seems like having less chance of a zero caused the arrays to be a bit more shuffled.

The reason I also included a version that uses Tausworthe is because of the easy seeding. In some cases you may want to use seeded randomness to sort an array.

UPDATE:
Was digging around about this and found a much faster method for randomizing arrays… not a big deal if you have small arrays, but if you need to randomize 1000’s of values this method is much faster than using Array.sort()