Martes, 16 de junio de 2015

Estos son de la artículos que me gustan escribir, es cierto que la vanidad y yo no somos muy afectos, pero queda ese sabor agradable de resolver retos que requieren cierto ejercicio de las neuronas.

Hago un paréntesis para resaltar el proceso de aprendizaje llamado "constructivismo", y que debe alentar a las personas que ya estamos entrados en años, al hacer una reflexión siento que este problema con todo el ímpetu que te da la juventud hubiera tardado más, así como también hubiera torturado todavía más a mis ahora pocas neuronas, por lo que nunca es tarde para aprender y generar conocimiento, esto lo resolví con mis conocimientos previos de manejo de arreglos y la recursión.

Dando la materia llamada "Optativa II" hice un tipo reto para programadores, llego a mi, el espíritu de mi maestra Lucía Barrón, y les dejé un problema que escuche por ahí y que medio medité pero jamás había hecho.

La maestra Lucía Barrón - con todo el respeto que me merece, lo mismo nos brindaba una sonrisa angelical y bromas sarcásticas acerca del alto grado de dificultad de sus ejercicios, exámenes y proyectos, y al mismo tiempo fue uno de nuestros más grandes miedos de la carrera; con ella aplicaba la máxima del Tecnológico: "7 es vanidad".

Así pues plantee el siguiente problema computacional: se trata de recorrer un arreglo - hasta ahora cuadrada y de dimensiones pares, no he checado si funcionará con nones - en forma de una espiral, ahora presentó una representación gráfica de este recorrido.

Como se puede observar es una serie de cuadrados de dimensiones de 2x2,4x4, 6x6 y así sucesivamente.

La resolución no era individual, sino en equipo aunque como siempre pasa hay 1 o 2 mentes brillantes que son los que toman la iniciativa para resolver el problema, algunos se acercaron con sus ideas buenas y con lógica, pero el objetivo era mostrar corriendo un programa que resolviera el recorrido en espiral.

Algunos -con el pretexto de la lentitud del internet y las ganas de llegar temprano a casa - se retiraron con la promesa de enviarlo a mi correo.

Sin embargo dos equipos combativos se quedaron al final, y uno de ellos faltando quizás 10 o 15 minutos para salir de la clase y el segundo equipo pasando unos 5 minutos despues de la clase - haciendo que regresará al aula para revisar el programa - resolvieron parcialmente el ejercicio ganándose la oportunidad de elegir la plataforma y el proceso de desarrollo de software que exige la materia.

Al decir parcialmente es que yo pedí el recorrido de adentro hacia afuera y ellos lo resolvieron del recuadro exterior al interior, usaron ambos equipos un ciclo exterior que maneja cada recuadro según la dimensión, y cuatro ciclos internos, que hacen el recorrido de los extremos de cada cuadrante.

En clase mencione acerca de la recursión y como el trayecto de manejo, de la universidad a la casa es bastante extenso, fui "saboreando" la solución e hice infinidad de pruebas mentales.En la noche hice el recorrido de los lados de los cuadros y hoy resolví de forma recursiva Sonrisa. Generalmente - salvo ocasiones que la materia se presta al aprendizaje colaborativo - no me gusta dejar a mis alumnos cosas que yo no he hecho o resuelto.

Aquí el código:

Primero lleno de forma estática el arreglo (lo hice con una matriz de 4x4 y con una de 6x6), y la muestro en pantalla, la aplicación es una aplicación de consola en C# con .NET 2013.

int[,] caracol =new int[6,6]
{
   {1,2,3,4,17,21},
   {5,6,7,8,18,22},
   {9,10,11,12,19,23},
   {13,14,15,16,20,24},
   {25,26,27,28,29,30},
   {31,32,33,34,35,36}
};
for (int i = 0; i < 6; i++)
{
  for (int j = 0; j < 6; j++)
 {
    if(caracol[i,j]<10)
       Console.Write("0"+caracol[i, j].ToString() + "-");
   else
       Console.Write(caracol[i, j].ToString() + "-");
 }
Console.WriteLine("");
}

La pregunta sobre si el elemento es menor a 10, es para agregarle un cero a la izquierda y la tabla se vea simétrica.

El método recursivo le he puesto imprime, hago una instancia de la clase y lo invoco enviando la matriz, el inicio y el tope.

Program alrededor = new Program();

Console.WriteLine("----Resultado------");

alrededor.imprime(caracol, 0, 6);

Y bueno aquí el método recursivo...

void imprime(int[,] analizar, int inicio, int tope)
{
      if (inicio < ((analizar.GetLength(1) / 2)))
      {
           string lado1 = "";
           string lado2 = "";
           string lado3 = "";
           string lado4 = "";
           int k = inicio;
           int l = 0;

           for (k = inicio; k < tope; k++)
           {
                lado1 = lado1 + analizar[inicio, k].ToString() + "-";
                lado3 = lado3 + analizar[tope - 1, (tope - 1) - l].ToString() + "-";
                l = l + 1;
           }
           l = 1;
           for (k = (inicio + 1); k < (tope - 1); k++)
          {
               lado2 = lado2 + analizar[k, (tope - 1)].ToString() + "-";
               lado4 = lado4 + analizar[((tope - 1) - l), inicio].ToString() + "-";
               l = l + 1;
           }
           imprime(analizar, inicio + 1, tope - 1);
           Console.WriteLine(lado1 + lado2 + lado3 + lado4);
      }
}

La idea es guardar los valores en variables string (pudiera también ser en un vector) donde lado1 y lado3 se refieren a los lados verticales y lado2 y lado4 a los horizontales.

Optimizo los ciclos de 4 a 2 ya que para obtener los lados uno va incrementando su columna o renglón según sea el lado, sus líneas paralelas irán decrementando. Esto es-por ejemplo- el lado superior del recuadro -cuadro 1 -(digamos de una tabla de 4x4) irá incrementando su columna esto es 0,0-0,1-0,2-0,3 mientras que su lado paralelo -cuadro 3 -(recuadro inferior), su columna irá en sentido contrario -decrementando 3,3-3,2-3,1-3,0 y bueno igual para los lados perpendiculares. Entonces como voy de fuera a hacia adentro lo que hago es aplicar la recursión, invoco el método y luego imprimo, para que la pila haga su trabajo, el inicio de cada ciclo del recuadro es 0,0-1,1-2,2... hasta la mitad de la longitud de cualquiera de sus dimensiones, esa es la condición de salida para la recursión.

Y listo. En serio que no lo googlee, je,je,je.

Profesor Enrique Nash.


Publicado por neofito69 @ 13:49  | .NET - C#
Comentarios (0)  | Enviar
Comentarios