двумерный массив

[: hr :]

OK!!!

Спасибо!!!

[iLoveYou]

arr = [];
arr.push({x:1, y:8});
arr.push({x:1, y:6});
arr.push({x:9, y:8});
arr.push({x:2, y:9});
arr.push({x:5, y:2});
arr.push({x:5, y:6});
arr.push({x:8, y:6});
arr.push({x:4, y:1});
arr.push({x:6, y:2});
arr_len = arr.length;
function sortarr(par1, par2) {
for (var i = 0; i<arr_len; i++) {
	for (var k = i+1; k<arr_len; k++) {
		if (arr[i][par1]>arr[k][par1]) {
			sx = arr[i].x;
			sy = arr[i].y;
			arr[i].x = arr[k].x;
			arr[i].y = arr[k].y;
			arr[k].x = sx;
			arr[k].y = sy;
		} else if (arr[i][par1] == arr[k][par1]) {
			if (arr[i][par2]>arr[k][par2]) {
				sxy = arr[i][par2];
				arr[i][par2] = arr[k][par2];
				arr[k][par2] = sxy;
			}
		}
	}
}
}
function printarr() {
	for (var i = 0; i<9; i++) {
		trace("x : "+arr[i].x+" | "+"y : "+arr[i].y);
	}
}
printarr();
trace("=======");
sortarr("x", "y");
printarr();
trace("=======");
sortarr("y", "x");
printarr();

[Usnul]

trace("Origin");
trace("===========================");
arr = [];
arr2=[];
arr[0] = {x:1, y:10};
arr[1] = {x:2, y:30};
arr[2] = {x:5, y:10};
arr[3] = {x:3, y:10};
arr[4] = {x:2, y:20};
arr[5] = {x:3, y:20};
arr[6] = {x:7, y:20};
arr[7] = {x:4, y:20};
for (var i = 0; i<arr.length; i++) {
trace('x : '+arr[i].x+' | '+'y : '+arr[i].y);
}
trace("sortOn");
trace("===========================");
arr.sortOn("y");
for (var i = 0; i<arr.length; i++) {
trace('x : '+arr[i].x+' | '+'y : '+arr[i].y);
}
for(var i=0;i<arr.length;i++){
if(typeof(arr2[arr[i].y])!="object"){arr2[arr[i].y]=[]}
arr2[arr[i].y][arr[i].x]=arr[i].x
}
for(var i=0;i<arr2.length;i++){
if(typeof(arr2[i])=="object"){
for(var j=0;j<arr2[i].length;j++){
if(typeof(arr2[i][j])=="number"){
if(a==undefined){a=0}
arr[a]={x:j,y:i}
a++
}
}
}
}
trace('after');
trace("===========================");
for (var i = 0; i<arr.length; i++) {
trace('x : '+arr[i].x+' | '+'y : '+arr[i].y);
}

//Всем горе программерам посвящается
//Только парня запутали

[Usnul]

Origin
===========================
x : 1 | y : 10
x : 2 | y : 30
x : 5 | y : 10
x : 3 | y : 10
x : 2 | y : 20
x : 3 | y : 20
x : 7 | y : 20
x : 4 | y : 20
sortOn
===========================
x : 3 | y : 10
x : 5 | y : 10
x : 1 | y : 10
x : 2 | y : 20
x : 3 | y : 20
x : 7 | y : 20
x : 4 | y : 20
x : 2 | y : 30
after
===========================
x : 1 | y : 10
x : 3 | y : 10
x : 5 | y : 10
x : 2 | y : 20
x : 3 | y : 20
x : 4 | y : 20
x : 7 | y : 20
x : 2 | y : 30

[Usnul]

Серег, я первый взялся писать, так что это вроде как наезд
смысл тот же, но я пол часа спустил при написании кода, гони мои пол часа обратно


ЗЫ
Не люблю! Не люблю! Не люблю! Не люблю! Не люблю! Не люблю! Не люблю! Не люблю! Не люблю! Не люблю!

[Nox Noctis]

кхм... я канеш не настолько немеряно крут, чтобы написать три десятка строк за пол часа... и сортировку я не люблю... я люблю луну и спать...

но объясните мне, вот такого кода не достаточно для решения задачи ? :)

arr = [{x: ... , y: ...}, ..... ];
sortXY = function (a, b) {
	return (a.y == b.y)*(a.x>b.x || -1) || (a.y>b.y || -1);
};
arr.sortOn("y");
arr.sort(sortXY);

зы: голову ! берегите голову !

[Mage Lord]

Спакуха, Нокс. Нифига ты не понимаешь в колбасных обрезках. Нормальные герои всегда идут в обход.

[Jlekc]

Если делать то универсально . Сортировка с любым количеством аргументов:

Array.prototype.mySortOn = function() {
	this.constructor.arg = arguments;
	//	проблема с аргументами проверю потом
	//	-----	begin Compare
	function compare() {
		var argPrev = arguments[1].constructor.argPrev;
		arguments[1].constructor.argPrev = arguments[0];
		if (argPrev == undefined) {
			arguments[1].sortOn(arguments[0]);
		} else {
			var i = 0;
			var _arr = [arguments[1][0]];
			var _sort = [];
			while (i<arguments[1].length) {
				if (arguments[1][i][argPrev] == arguments[1][i+1][argPrev]) {
					_arr.push(arguments[1][i+1]);
				} else {
					_arr.sortOn(arguments[0]);
					_sort = _sort.concat(_arr);
					delete _arr;
					_arr = [arguments[1][i+1]];
				}
				++i;
			}
			return _sort;
		}
		return arguments[1];
	}
	//	-----	end of Compare
	while (this.constructor.arg.length>0) {
		this = compare(this.constructor.arg.shift(), this);
	}
	//	????????????????? this уже не принадлежит к arr
	arr = this;
};
//	-------	end Of Function
arr = [];
arr.push({x:1, y:1, z:1});
arr.push({x:2, y:2, z:2});
arr.push({x:2, y:2, z:1});
arr.push({x:2, y:1, z:1});
arr.push({x:3, y:1, z:1});
arr.push({x:2, y:1, z:2});
arr.mySortOn("y", "x", "z");
//
for (var i = 0; i<arr.length; i++) {
	trace("x : "+arr[i].x+" | "+"y : "+arr[i].y+" | "+"z : "+arr[i].z);
}

Только народ возник глюк . Объект и его псевдоним раздилились, пришлось писать какойто бред см. строку 34. Может кто чо понимает??

[iLoveYou]

Оригинал написал(а) Nox Noctis
но объясните мне, вот такого кода не достаточно для решения задачи ?
голову ! берегите голову !

Нокс, я тебя уважаю
Но когда я смотрю на предложенное тобой решение, вспоминаю времена, когда вы с BlooDeliMiter'ом и другими умными людьми соревновались на предмет "кто напишет один и тот же по смыслу код короче". Мне кажется, что здесь это не нужно, так как человеку требуется не решение как таковое, а освоение принципа. тогда он не скажет через неделю:"Нокс, а переделай свой код для меня так, чтобы он еще..........., короче, кофе в постель приносил" Ведь, согласись, твое решение не всем понятно и очевидно, хотя красиво и кратко. А показанный мной алгоритм до такой степени прост и прозрачен, что, может быть, лучше не жертвовать строками кода ради краткости. Мне кажется, понимание важнее.

[Nox Noctis]

Оригинал написал(а) Sergey"iLoveYou"
Нокс, я тебя уважаю :)

так мы с вами уважаемые люди ! :)))

в ифах слишком много строк :) но в любом случае - я сильно удивился тому как вы хитрецки стали решать эту сортировку...
_________________________________

есть два свойства - Y и X, нужно отсортировать по обоим, причем приоритет у Y...

первая сортировка делается через Array.sortOn - это сделали все. а вторая - делается через Array.sort с нестандартной функцией сортировки.. это не очевидно ? вопрос только в том как правильно эту функцию сформулировать...

2: hr :
функция сортировки получает два элемента массива A и B и выдает
1 : если A нужно поставить перед B
-1 : если А нужно поставить после В
0 : если менять местами А и В не нужно

учитывая что у нас в массиве объекты, и что сортировку по Y нарушать нельзя, получается следующее:

сортировка(А, В) {
        1. если  А.Y не равно B.Y => по X сортировать нельзя, 
            надо руководствоваться значениями Y. 
            возвращаем 1 если А.Y>B.Y, -1 если А.Y<B.Y и 0 если они равны.

        2. если  А.Y равно B.Y => по X сортировать можно. 
            возвращаем 1 если А.X>B.X, -1 если А.X<B.X
}