none
Redistribuir aleatoriamente los valores de un array bidimensional RRS feed

  • Pregunta

  • Buenas tardes a todos.

    Lenguaje c#

    Supongamos el siguiente array genérico de 4 filas y 2 columnas:

    int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }

    Cómo puedo aplicar la función RANDOM u otra para obtener una redistribución aleatoria de los valores dentro del array?

    por ejemplo, una vez podría ser: {{1,2},{5,6},{7,8},{3,4}}

    una segunda vez podría ser: {{3,4},{5,6},{1,2},{7,8}}

    etc.

    Gracias por vuestra atención. Saludos.

    domingo, 1 de marzo de 2020 14:26

Respuestas

  • Hola Georgina

    El programa que copio reordena aleatoriamente el array de 2D (las filas) por un mecanismo que no permite que se repitan los indices. Podes ejecutarlo varias veces para ver que salen diferentes versiones, incluso puede quedar igual.

    using System;
    
    namespace Array2D
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
    
                Random gen = new Random(DateTime.Now.Millisecond);
                bool[] ocupado = new bool[array2D.GetLength(0)];
                int[] indices = new int[array2D.GetLength(0)];
                int[,] copia = (int[,])array2D.Clone();
                int a, b, nuevo, indice;
    
                Console.WriteLine("Array2D inicial:");
                ImprimirArray(array2D);
    
                for (a = 0; a < array2D.GetLength(0); a++)
                {
                    indice = gen.Next(0, array2D.GetLength(0) - 1);
                    if (ocupado[indice] == true)
                    {
                        nuevo = indice + 1;
                        if (nuevo == array2D.GetLength(0))
                            nuevo = 0;
                        for (b = nuevo; ocupado[b] == true; )
                        { 
                            b++;
                            if (b == array2D.GetLength(0))
                                b = 0;
                        }
                        indices[a] = b;
                        ocupado[b] = true;
                    }
                    else
                    {
                        indices[a] = indice;
                        ocupado[indice] = true;
                    }
                }
    
                for (a = 0; a < indices.Length; a++)
                {
                    array2D[a, 0] = copia[indices[a], 0];
                    array2D[a, 1] = copia[indices[a], 1];
                }
    
                Console.WriteLine("Array2D reordenado aleatoriamente:");
                ImprimirArray(array2D);
    
                Console.WriteLine("Pulsa Enter para terminar.");
                Console.ReadLine();
            }
    
            private static void ImprimirArray(int[,] array) 
            {
                int a;
                for (a = 0; a < array.GetLength(0); a++) 
                    Console.Write("{" + array[a, 0] + ", " + array[a, 1] + "}, ");
                Console.WriteLine();
            }
        }
    }
    

    Saludos

    Pablo


    domingo, 1 de marzo de 2020 16:33

Todas las respuestas

  • Hola Georgina

    El programa que copio reordena aleatoriamente el array de 2D (las filas) por un mecanismo que no permite que se repitan los indices. Podes ejecutarlo varias veces para ver que salen diferentes versiones, incluso puede quedar igual.

    using System;
    
    namespace Array2D
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
    
                Random gen = new Random(DateTime.Now.Millisecond);
                bool[] ocupado = new bool[array2D.GetLength(0)];
                int[] indices = new int[array2D.GetLength(0)];
                int[,] copia = (int[,])array2D.Clone();
                int a, b, nuevo, indice;
    
                Console.WriteLine("Array2D inicial:");
                ImprimirArray(array2D);
    
                for (a = 0; a < array2D.GetLength(0); a++)
                {
                    indice = gen.Next(0, array2D.GetLength(0) - 1);
                    if (ocupado[indice] == true)
                    {
                        nuevo = indice + 1;
                        if (nuevo == array2D.GetLength(0))
                            nuevo = 0;
                        for (b = nuevo; ocupado[b] == true; )
                        { 
                            b++;
                            if (b == array2D.GetLength(0))
                                b = 0;
                        }
                        indices[a] = b;
                        ocupado[b] = true;
                    }
                    else
                    {
                        indices[a] = indice;
                        ocupado[indice] = true;
                    }
                }
    
                for (a = 0; a < indices.Length; a++)
                {
                    array2D[a, 0] = copia[indices[a], 0];
                    array2D[a, 1] = copia[indices[a], 1];
                }
    
                Console.WriteLine("Array2D reordenado aleatoriamente:");
                ImprimirArray(array2D);
    
                Console.WriteLine("Pulsa Enter para terminar.");
                Console.ReadLine();
            }
    
            private static void ImprimirArray(int[,] array) 
            {
                int a;
                for (a = 0; a < array.GetLength(0); a++) 
                    Console.Write("{" + array[a, 0] + ", " + array[a, 1] + "}, ");
                Console.WriteLine();
            }
        }
    }
    

    Saludos

    Pablo


    domingo, 1 de marzo de 2020 16:33
  • Gracias a los dos.

    Ambos códigos funcionan perfectamente.

    Saludos.

    lunes, 2 de marzo de 2020 11:53