objetos - guardar datos en un array javascript

Cómo atravieso una matriz en diagonal en javascript

Question

Tengo una matriz con cadenas que me gustaría atravesar diagonalmente.
Suposiciones

• Cada cadena tiene la misma longitud.
• Las matrices pueden ser cuadradas o rectangulares, horizontales o verticales.

La matriz se ve así:

A B C D
E F G H
I J K L

Me gustaría obtener (de arriba a la izquierda a abajo a la derecha):

A
EB
IFC
JGD
KH
L

y (de abajo a la izquierda a arriba a la derecha):

I
JE
KFA
LGB
HC
D

Ya tengo un código que funciona 3/4 del camino, pero no puedo entender lo que estoy haciendo (mal).

//the array
var TheArray = [''ABCD'',''EFGH'',''IJKL''];

//amount of rows
var RowLength = TheArray.length;
//amount of colums
var ColumnLength = TheArray[0].length;

El código que he cortado las diagonales en 4 de estos bucles para obtener todas las diagonales. Se ve como 2 para bucles con un ciclo de si no se superponen los valores independientes. El pseudo código se parece un poco a esto:

for(loop rows){
 var outputarray = [];
   for(loop columns){
      if(delimit for out of bound){
       var temprow = TheArray[something?];
       var tempvalue = temprow[something?];
       outputarray.push(tempvalue);
       }
   }
 //use values
document.getElementById("theDiv").innerHTML += outputarray.join("")+"<br>";
}

Espero que alguien pueda ayudarme con esto.

Answer 1

De arriba a la izquierda a abajo a la derecha

var array = ["ABCD","EFGH","IJKL"];

var Ylength = array.length;
var Xlength = array[0].length;
var maxLength = Math.max(Xlength, Ylength);
var temp;
for (var k = 0; k <= 2 * (maxLength - 1); ++k) {
    temp = [];
    for (var y = Ylength - 1; y >= 0; --y) {
        var x = k - y;
        if (x >= 0 && x < Xlength) {
            temp.push(array[y][x]);
        }
    }
    if(temp.length > 0) {
        document.body.innerHTML += temp.join('''') + ''<br>'';
    }
}

(vea también este violín )

De abajo a la izquierda a la derecha

var array = ["ABCD","EFGH","IJKL"];

var Ylength = array.length;
var Xlength = array[0].length;
var maxLength = Math.max(Xlength, Ylength);
var temp;
for (var k = 0; k <= 2 * (maxLength - 1); ++k) {
    temp = [];
    for (var y = Ylength - 1; y >= 0; --y) {
        var x = k - (Ylength - y);
        if (x >= 0 && x < Xlength) {
            temp.push(array[y][x]);
        }
    }
    if(temp.length > 0) {
        document.body.innerHTML += temp.join('''') + ''<br>'';
    }
}

(vea también este violín )

Conjunto

Como solo hay una línea de diferencia entre ambos, puede combinarlos fácilmente en una sola función:

var array = ["ABCD","EFGH","IJKL"];

function diagonal(array, bottomToTop) {
    var Ylength = array.length;
    var Xlength = array[0].length;
    var maxLength = Math.max(Xlength, Ylength);
    var temp;
    var returnArray = [];
    for (var k = 0; k <= 2 * (maxLength - 1); ++k) {
        temp = [];
        for (var y = Ylength - 1; y >= 0; --y) {
            var x = k - (bottomToTop ? Ylength - y : y);
            if (x >= 0 && x < Xlength) {
                temp.push(array[y][x]);
            }
        }
        if(temp.length > 0) {
            returnArray.push(temp.join(''''));
        }
    }
    return returnArray;
}

document.body.innerHTML = diagonal(array).join(''<br>'') +
                          ''<br><br><br>'' +
                          diagonal(array, true).join(''<br>'');

(vea también este violín )

Answer 2

Aquí está mi intento para ''de arriba a la izquierda a abajo a la derecha'':

for (i=0; i<nbRows; i++) {
    x = 0; y = i;
    while (x < nbColumns && y >= 0) {
        print(array[x, y]);
        x++; y--;
    }
    print("/n");
}
for (i=1; i<nbColumns; i++) {
    x = i; y = nbRows - 1;
    while (x < nbColumns && y >=0) {
        print(array[x, y]);
        x++; y--;
    }
}

Necesita algunas adaptaciones para adaptarse a la sintaxis de JavaScript.

Answer 3

Esto debería funcionar incluso para matrices rectangulares:

var array = ["ABCD", "EFGH", "IJKL"];
var arrOfArr = [];
var resultArray = [];
for (var i = 0; i < array.length; ++i) {
    arrOfArr.push(array[i].split(''''));
}

var rows = arrOfArr.length;
var columns = arrOfArr[0].length;

var index = 0;

for (var i = 0; i < rows; ++i) {
    var k = 0;
    resultArray[index] = new Array();
    for (var j = i; j >= 0; --j) {
        resultArray[index].push(arrOfArr[j][k]);
        ++k;
        if ( k === columns) {
            break;
        }
    }
    resultArray[index] = resultArray[index].join('''');
    ++index;
}

for (var j = 1; j < columns; ++j) {
    var k = rows - 1;
    resultArray[index] = new Array();
    for (var i = j; i < columns; ++i) {
        resultArray[index].push(arrOfArr[k][i]);
        --k;
        if ( k === -1) {
            break;
        }
    }
    resultArray[index] = resultArray[index].join('''');
    ++index;
}
console.log(JSON.stringify(resultArray));

Answer 4

Esto hace el truco y arroja los resultados deseados a la pantalla:

var array = [''ABCD'',''EFGH'',''IJKL''];
var rows = array.length;
var cols = array[0].length;
for (var n = 0; n < cols + rows - 1; n += 1)
{
  var r = n;
  var c = 0;
  var str = '''';
  while (r >= 0 && c < cols)
  {
    if (r < rows)
      str += array[r][c];
    r -= 1;
    c += 1;
  }
  document.write(str+"<br>");
}

Resultado:

A
EB
IFC
JGD
KH
L

Answer 5

Nota: Esto supone que todas las cadenas tienen el mismo tamaño, o al menos son tan grandes como la primera cadena.

En una matriz 2D (o en este caso, una matriz de cadenas), los índices de una diagonal se suman al número de la diagonal (como un número de fila). 00, 01 10, 02 11 20, etc.

Usando este método, el número de "filas" diagonales (comenzando en cero) es igual a la suma de los índices más grandes, o la suma de (longitud de columna + longitud de fila-2).

Por lo tanto, mi solución es iterar a través de los números de fila diagonales e imprimir todos los pares de índices cuya suma es igual a la fila diagonal actual.

var TheArray = ["ABCD","EFGH","IJKL"];
//amount of rows
var RowLength = TheArray.length;
//amount of colums
var ColumnLength = TheArray[0].length;

var text = ''''
for (i = 0; i <= (RowLength+ColumnLength-2); i++){
    for (x = 0; x<=i; x++){
    if (TheArray[i-x] && TheArray[i-x][x]){
        text += TheArray[i-x][x];
    }
  }
  text += "<br/>";
}

document.getElementById(''text'').innerHTML = text;

JSFiddle Link

Answer 6

Otra solución más:

function getAllDiagonal(array) {
    function row(offset) {
        var i = array.length, a = '''';
        while (i--) {
            a += array[i][j + (offset ? offset - i : i)] || '''';
        }
        return a;
    }

    var result = [[], []], j;
    for (j = 1 - array.length; j < array[0].length; j++) {
        result[0].push(row(0));
        result[1].push(row(array.length - 1));
    }
    return result;
}

var array = [''ABCD'', ''EFGH'', ''IJKL''];

document.write(''<pre>'' + JSON.stringify(getAllDiagonal(array), 0, 4) + ''</pre>'');

Answer 7

Prueba esto

var TheArray = [''ABCD'', ''EFGH'', ''IJKL''];
    //amount of rows
    var RowLength = TheArray.length;
    //amount of colums
    var ColumnLength = TheArray[0].length;

    var totalNoComb = RowLength + ColumnLength - 1;
    var combArr = new Array(totalNoComb);
    for (var i = 0; i < totalNoComb; i++) {
        combArr[i] = "";
        for (var j = RowLength-1; j >-1; j--) {
            if (i - j > -1 && i - j < ColumnLength)
                combArr[i] += TheArray[j][i-j];
        }
    }
    alert(combArr);

    for (var i = 0; i < totalNoComb; i++) {
        combArr[i] = "";
        for (var j = 0; j < RowLength; j++) {
            if (i - j > -1 && i - j < ColumnLength)
                combArr[i] += TheArray[ RowLength -1-j][i - j];
        }
    }
    alert(combArr);

Answer 8

Solución completa para ambas diagonales:

var TheArray = [''ABCD'', ''EFGH'', ''IJKL''];
var RowLength = TheArray.length;
var ColumnLength = TheArray[0].length;

// Diagonals
var diagonal = [[], []];
for (var i = 0; i < Math.min(RowLength, ColumnLength); i++) {
    diagonal[0].push({''row'': 0-i, ''col'': i});
    diagonal[1].push({''row'': 0-i, ''col'': 0-i});
}

// Entry points
// 1///
// 2///
// 3456
var points = [[], []];
for (var y = 0; y < RowLength; y++) {
    points[0].push({''row'': y, ''col'': 0});
}
for (var x = 1; x < ColumnLength; x++) {
    points[0].push({''row'': RowLength - 1, ''col'': x});
}

// Entry points
// ///6
// ///5
// 1234
for (var x = 0; x < ColumnLength; x++) {
    points[1].push({''row'': RowLength - 1, ''col'': x});
}
for (var y = RowLength - 2; y >= 0; y--) {
    points[1].push({''row'': y, ''col'': ColumnLength - 1});
}

var strings = [[], []];
for (var line = 0; line < diagonal.length; line++) {
    for (var point = 0; point < points[line].length; point++) {
        var inside = true;
        var index = 0;
        var string = '''';
        while (inside && index < diagonal[line].length) {
            var row = points[line][point][''row''] + diagonal[line][index][''row''];
            var col = points[line][point][''col''] + diagonal[line][index][''col''];
            if (row >= 0 && row < RowLength && col >= 0 && col < ColumnLength) {
                string += TheArray[row][col];
                index++;
            } else {
                inside = false;
            }
        }
        strings[line].push(string);
    }
}

console.log(strings);

Answer 9

Usa índices:

[i][j-i]

Donde voy de 0 a M-1

j va de 0 a i

Mientras j ++ <N

para la matriz

tipo Array [M] [N]

Sin embargo, puede omitir algunos en la parte inferior derecha si la matriz es rectangular, y es posible que necesite un segundo ciclo anidado para i y j para capturarlos.