Как "перемешать" элементы в массиве?

[mihael_p]

Есть определенный массив:

private var someDigits:Array = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];

как отсортировать массив - понятно, а вот как перемешать его - нет.
Подскажите, пожалуйста, как быть?

[КорДум]

Как-то ваял.

package ru.kordum.utils {
 
	/**
	 * @author KorDum
	 */
 
	public class ArrayShuffler {
		private static var _array:Array;
 
		//---------------------------------------------------------------------------
		//
		// CONSTRUCTOR
		//
		//---------------------------------------------------------------------------
 
		public function ArrayShuffler() {
 
		}
 
 
		//---------------------------------------------------------------------------
		//
		// PRIVATE STATIC METHODS
		//
		//---------------------------------------------------------------------------
 
		private static function startRandomize():void {
			var length:uint = _array.length;
 
			while (length--) {
				var n:int = Math.random() * (length + 1);
				swap(length, n);
			}
		}
 
 
		private static function swap(x:uint, y:uint):void{
			var temp:* = _array[x];
			_array[x] = _array[y];
			_array[y] = temp;
		}
 
 
		//---------------------------------------------------------------------------
		//
		// PUBLIC STATIC METHODS
		//
		//---------------------------------------------------------------------------
 
		public static function randomize(array:Array, count:uint = 1):Array {
			if (!array) return null;
 
			_array = array.slice();
 
			for (var i:uint = 0; i < count; i++) {
				startRandomize();
			}
 
			return _array;
		}
	}
}

[udaaff]

public static function shuffle(array:Array):void
{
	var t:*;
	var r:int;
	var i:int = array.length;
	while (i) 
	{
		r = Math.floor(Math.random() * i--);
		t = array[i];
		array[i] = array[r];
		array[r] = t;
	}
}

[КорДум]

У меня то же самое, но с приведением рандома с нормальных законом распределения к более-менее равномерному (у Чуви взял). Последствия очевидны.

[mihael_p]

КорДум спасибо огромное, то что нужно

[udaaff]

но с приведением рандома с нормальных законом распределения к более-менее равномерному

В моём примере какое-то другое распределение?

[КорДум]

По идее, нормальное ) Math.random() в as3 живет по этому закону. Чуви проводил эксперименты, рисовал графики. Потом дошел до метода какого-то там, наваял код, приводящий нормальное к равномерному, а я нагло стырил.

Добавлено через 8 минут
А хотя по коду то же самое вообще у нас. Разве что у меня несколько раз можно "шуффлировать".

[strangedk]

var _source:Array = [1,2,3,4,5,6,7,8,9,0];
var _result:Array = [];
 
while (_source.length > 0) {
    _result.push(_source.splice(Math.round(Math.random() * (_source.length - 1)), 1)[0]);
}

[expl]

Сообщение от strangedk

var _source:Array = [1,2,3,4,5,6,7,8,9,0];
var _result:Array = [];
 
while (_source.length > 0) {
    _result.push(_source.splice(Math.round(Math.random() * (_source.length - 1)), 1)[0]);
}

Не знаю, более ли этот вариант правильное распределение даёт, чем предыдущие, но сплайсить массив n раз дорого - сложность почти n * n + затраты на выделение памяти и сборку мусора.
Math.round(Math.random() * (_source.length - 1)) вроде бы эквивалентно int(Math.random() * _source.length), не?
Как написать то же самое (1 в 1), но без сплайса и без создания другого массива (линейная сложность ):

public static function shuffle(array:Array):void {
	var length:int = array.length;
	while (length > 0) {
		var index:int = int(Math.random() * length);
		var value:int = array[index];
 
		// Элемент выбран, появилась дырка - заделываем элементом с условного конца
		// и у нас снова ровный массив из оставшихся элементов
		array[index] = array[length - 1];
 
		// Кидаем выбранный элемент в текущий условный конец массива - там выборки уже не будет
		// Т.е. слева у нас старый массив - справа строим новый
		array[length - 1] = value;
 
		// Левый (исходный) массив поубавился
		length--;
	}
}

[Nikem79]

Сообщение от strangedk

var _source:Array = [1,2,3,4,5,6,7,8,9,0];
var _result:Array = [];
 
while (_source.length > 0) {
    _result.push(_source.splice(Math.round(Math.random() * (_source.length - 1)), 1)[0]);
}

У меня код работает в таком виде:

var _source:Array = [1,2,3,4,5,6,7,8,9,0,11,12,13,14,15];
var _result:Array = [];
 
while (_source.length > 0) {
    _result.push(_source.splice(Math.round(Math.random() * (_source.length - 1)), 1)[0]);
	trace(_result[_source]);
}
 
trace("Дальше");
 
for(var six:int=0;six<15;six++){
	trace(_result[six]);
}

Подскажите пожалуйста, а как сделать количество перемешиваемых чисел переменной?
Чтобы в строчку его можно было поместить

N=50;
вместо var _source:Array = [1,2,3,4,5,6,7,8,9,0];
это: var _source:Array = [N];

и чтобы в итоге перемешивались не 10 данных, а сколько понадобится?..