Iterar matriz multidimensional con statement anidada Foreach

Creo que esta podría ser una pregunta bastante simple, pero aún no he podido descifrarla. Si tengo una matriz bidimensional así:

int[,] array = new int[2,3] { {1, 2, 3}, {4, 5, 6} }; 

¿Cuál es la mejor manera de recorrer cada dimensión de la matriz con una statement foreach anidada?

Si desea iterar sobre cada elemento de la matriz como si fuera una matriz aplanada, puede hacer lo siguiente:

 foreach (int i in array) { Console.Write(i); } 

que imprimiría

123456

Si también desea conocer los índices xey, deberá hacer lo siguiente:

 for (int x = 0; x < array.GetLength(0); x += 1) { for (int y = 0; y < array.GetLength(1); y += 1) { Console.Write(array[x, y]); } } 

Alternativamente, podría usar una matriz irregular (una matriz de matrices):

 int[][] array = new int[2][] { new int[3] {1, 2, 3}, new int[3] {4, 5, 6} }; foreach (int[] subArray in array) { foreach (int i in subArray) { Console.Write(i); } } 

o

 int[][] array = new int[2][] { new int[3] {1, 2, 3}, new int[3] {4, 5, 6} }; for (int j = 0; j < array.Length; j += 1) { for (int k = 0; k < array[j].Length; k += 1) { Console.Write(array[j][k]); } } 

A continuación, le mostramos cómo visitar cada elemento en una matriz bidimensional. Esto es lo que estabas buscando?

 for (int i=0;i 

Con arreglos multidimensionales, puede usar el mismo método para recorrer los elementos, por ejemplo:

 int[,] numbers2D = new int[3, 2] { { 9, 99 }, { 3, 33 }, { 5, 55 } }; foreach (int i in numbers2D) { System.Console.Write("{0} ", i); } 

El resultado de este ejemplo es:

 9 99 3 33 5 55 

Referencias

  • MSDN: Uso de foreach con matrices

En Java, las matrices multidimensionales son una matriz de matrices, por lo que funciona lo siguiente:

  int[][] table = { { 1, 2, 3 }, { 4, 5, 6 }, }; for (int[] row : table) { for (int el : row) { System.out.println(el); } } 

Sé que esta es una publicación anterior, pero la encontré a través de Google, y después de jugar con ella creo que tengo una solución más fácil. Si me equivoco, por favor indíquelo, ‘porque me gustaría saber, pero esto funcionó para mis propósitos al menos (se basa en la respuesta de ICR):

 for (int x = 0; x < array.GetLength(0); x++) { Console.Write(array[x, 0], array[x,1], array[x,2]); } 

Como las dos dimensiones son limitadas, cualquiera de ellas puede ser números simples y, por lo tanto, evitar un ciclo nested. Admito que soy nuevo en C #, así que por favor, si hay una razón para no hacerlo, por favor dime ...

La matriz 2D en C # no se presta bien a un foreach nested, no es el equivalente de una matriz dentada (una matriz de matrices). Podrías hacer algo como esto para usar un foreach

 foreach (int i in Enumerable.Range(0, array.GetLength(0))) foreach (int j in Enumerable.Range(0, array.GetLength(1))) Console.WriteLine(array[i, j]); 

Pero aún usaría i y j como valores de índice para la matriz. La legibilidad se conservaría mejor si en lugar de eso eligiera la variedad de jardín.

Dos caminos:

  1. Defina la matriz como una matriz dentada y use foreachs nesteds.
  2. Defina la matriz normalmente y use foreach en todo.

Ejemplo de # 2:

 int[,] arr = { { 1, 2 }, { 3, 4 } }; foreach(int a in arr) Console.Write(a); 

La salida será 1234. ie. exactamente lo mismo que hacer yo de 0 a n, y j de 0 a n.

Puede usar un método de extensión como este:

 internal static class ArrayExt { public static IEnumerable Indices(this Array array, int dimension) { for (var i = array.GetLowerBound(dimension); i <= array.GetUpperBound(dimension); i++) { yield return i; } } } 

Y entonces:

 int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; foreach (var i in array.Indices(0)) { foreach (var j in array.Indices(1)) { Console.Write(array[i, j]); } Console.WriteLine(); } 

Será un poco más lento que el uso de loops pero probablemente no sea un problema en la mayoría de los casos. No estoy seguro si hace que las cosas sean más legibles.

Tenga en cuenta que las matrices c # pueden ser distintas de cero, por lo que puede usar un ciclo for como este:

 int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; for (var i = array.GetLowerBound(0); i <= array.GetUpperBound(0); i++) { for (var j= array.GetLowerBound(1); j <= array.GetUpperBound(1); j++) { Console.Write(array[i, j]); } Console.WriteLine(); } 

Utilice LINQ .Cast() para convertir una matriz 2D a IEnumerable .

Ejemplo de LINQPad:

 var arr = new int[,] { { 1, 2, 3 }, { 4, 5, 6 } }; IEnumerable values = arr.Cast(); Console.WriteLine(values); 

Salida:

La secuencia es 1,2,3,4,5,6

También puedes usar enumeradores. Cada tipo de matriz de cualquier dimensión admite el método Array.GetEnumerator. La única advertencia es que tendrás que lidiar con el boxeo / unboxing. Sin embargo, el código que necesita escribir será bastante trivial.

Aquí está el código de muestra:

 class Program { static void Main(string[] args) { int[,] myArray = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 } }; var e = myArray.GetEnumerator(); e.Reset(); while (e.MoveNext()) { // this will output each number from 1 to 6. Console.WriteLine(e.Current.ToString()); } Console.ReadLine(); } } 
 int[,] arr = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; for(int i = 0; i < arr.GetLength(0); i++){ for (int j = 0; j < arr.GetLength(1); j++) Console.Write( "{0}\t",arr[i, j]); Console.WriteLine(); } output: 1 2 3 4 5 6 7 8 9 

Como se mencionó en otra parte, puede iterar sobre la matriz y generará todos los resultados en orden en todas las dimensiones. Sin embargo, si quiere conocer los índices también, ¿qué le parece usar esto? http://blogs.msdn.com/b/ericlippert/archive/2010/06/28/computing-a-cartesian-product-with- linq.aspx

luego haciendo algo como:

 var dimensionLengthRanges = Enumerable.Range(0, myArray.Rank).Select(x => Enumerable.Range(0, myArray.GetLength(x))); var indicesCombinations = dimensionLengthRanges.CartesianProduct(); foreach (var indices in indicesCombinations) { Console.WriteLine("[{0}] = {1}", string.Join(",", indices), myArray.GetValue(indices.ToArray())); }