Ayuda con este ejercicio

[:ohk<any>]

Hola foro, me he topado con este ejercicio y no lo puedo resolver aún, a ver si uno de ustedes me puede echar una mano.

Bueno aquí la descripción.

Realizar de forma recursiva la siguiente matriz denominada ( cubo mágico ).

        8   1   6
        3   5   7
        4   9   2

El cubo mágico es una matriz impar (obligatorio) la cual proporciona un mismo resultado si sumas las filas o las columnas.

      8 + 1 + 6  =  15
      3 + 5 + 7  =  15
      4 + 9 + 2  =  15


      8 + 3 + 4  = 15

Bueno, creo que el punto esta claro hasta ahí.

Ahora bien, hay reglas de llenado de matriz, pues primero siempre debe llenarse la matriz por la fila 0 y en el medio.

Como hacemos esto?
n = tamaño de la matriz, por decir 5
n/2

        8   1   6
        3   5   7
        4   9   2

en nuestro ejemplo, el 1 se debe llenar 1ro.
Ahora bien, como es que llenamos todo lo demás.
Pues utilizamos el salto del caballo y las siguientes restricciones:

1ro.
                1

2do.
Haciendo salto:

De donde nos encontrábamos, nos movemos uno a la derecha y uno hacia arriba.

                         |
                   1  --

Pero que pasa, resulta que nos hemos salido de la matriz por encima de la matriz, entonces debemos utilizar la siguiente condicionante.

Si el numero a introducir cae fuera de la matriz se debe mover 1no a la derecha e ir a la parte de abajo de la matriz, como si fuera un pedazo de papel a la que hemos unido por ambos lados en forma de un cilindro.

        -   1   -
        -   -   -
        -   -   2

Ahora bien, si continuamos con la regla, avanzamos 1no a la derecha y uno hacia arriba, pero al avanzar a la derecha ya estamos fuera de la matriz, fuera de la columnas, entonces hacemos lo siguiente.

En ves de ir uno mas hacia la derecha, nos vamos hacia el principio y subimos de fila (o bajamos, dependiendo de como lo vean) y colocamos el numero donde debe ser.

        -   1    -
        3   -   -
        -   -   2

Ahora bien, siguiendo con el procedimiento nos movemos 1no a la derecha y 1no hacia arriba, pero que pasa, ahora resulta que la matriz en la posición que nos toca ocupar ya tiene un valor, entonces hacemos el siguiente procedimiento.

        -   1   -
        3   -   -
        4   -   2

Colocamos el siguiente número por debajo del número anterior, como se ve en el ejemplo.

Luego continuamos con los pasos y no encontramos ningún problema en el siguiente número, 1no a la derecha y 1no hacia arriba.

        -   1   -
        3   5   -
        4   -   2

He incluso no encontramos problemas hasta en el siguiente número. 1no derecha y 1no arriba.

        -   1   6
        3   5   -
        4   -   2

Continuando con las reglas avanzamos 1no a la derecha (y ya estamos fuera y por lo mismo consiguiente nos vamos al inicio de la columna) y subimos 1no, y ahora nos hemos salido de la fila y por lo mismo consiguiente nos vamos por debajo

        -   1   6
        3   5   -
        4   -   2

Pero como resultado tenemos el lugar ocupado, entonces recurrimos a:

Colocamos el siguiente número por debajo del número anterior

        -   1   6
        3   5   7
        4   -   2

Y lo hacemos según los procedimientos ya mencionados en los pasos anteriores hasta culminar con la matriz.

Ahora bien, cual es el axioma?

Nos preguntamos, cuando debe terminar de llenar?

Pues cuando haya llegado a 9 (que es el caso de nuestro ejemplo)
Lo cual podemos sacar con el tamaño de la matriz.

n = 5;  // Tamaño de la matriz

  if(contador == n*n)

Bueno, espero que el enunciado este claro.

Buena suerte!

Un saludo

OHK

[chrominum]

Si es que soy el fucking crack  toma, todo hecho:

Código [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Text;

namespace CuadradosMagicos
{
    class CuadradosMagicosApp
    {
        static void Main(string[] args)
        {
            int Numero, x, y;
            int[,] Numeros;
            do
            {
            Console.Write("Introduce un numero impar: ");
            Numero = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine();
            } while (Numero % 2 == 0); //Mientras sea par

            Numeros = new int[Numero, Numero];

            Numeros = CMRecursivo(Numeros, Numero, 1, 0, Numero / 2);

            for (x = 0;x < Numero;x++)
            {
                for (y = 0;y < Numero;y++)
                {
                    Console.Write("{0} ", Numeros[x, y]);
                }
                Console.WriteLine();
            }

            Console.ReadKey();
        }

        public static int[,] CMRecursivo(int[,] Numeros, int n, int Actual, int x, int y)
        {
            if (x < 0)
                x += n;
            else if (x > n - 1)
                x %= n;

            if (y < 0)
                y += n;
            else if (y > n - 1)
                y %= n;

            while (Numeros[x, y] != 0)
            {
                x = (x + 2) % n;
                y--;

                if (y < 0)
                    y += n;
            }

            Numeros[x, y] = Actual;
            return (Actual == n * n) ? Numeros : CMRecursivo(Numeros, n, ++Actual, x - 1 , y + 1);
        }
    }
}

[:ohk<any>]

jejeje 

me falto decir que deben resolverlo en Java

pero no hay problema, voy a ver como cuernos lo paso 

Un saludo

OHK

[:ohk<any>]

Código (java) [Seleccionar] Expandir



public class Magico
{


    public static void main (String [] args)
    {
        int fil = 0;
        int n = 4;
        int colmedio = n / 2;
        int c = 1;
        int mat [] [] = new int [n] [n];

        magico1 (mat, fil, colmedio, c, n);
        mostrar (mat, n);
    }
    static void magico1 (int mat [] [], int fil, int colmedio, int c, int n)
    {
        if (c == n * n)
            mat [n-1] [colmedio] = c;
        else
        {
            if (fil < 0 && colmedio == n)
                magico1 (mat, fil + 2, n - 1, c, n);
            else
            {
                if (fil < 0)
                    magico1 (mat, n - 1, colmedio, c, n);
                else
                {
                    if (colmedio == n)
                        magico1 (mat, fil, 0, c, n);
                    else
                    {
                        if (mat [fil] [colmedio] == 0)
                        {
                            mat [fil] [colmedio] = c;
                            magico1 (mat, fil - 1, colmedio + 1, c + 1, n);
                        }
                        else                           
                            magico1 (mat, fil + 2, colmedio - 1, c, n);
                    }
                }
            }

        }
    }


    static void mostrar (int mat [] [], int n)
    {
        for (int j = 0 ; j < n ; j++)
        {
            System.out.println ();
            for (int i = 0 ; i < n ; i++)
            {
                System.out.print ("\t" + mat [j] [i]);
            }
        }
    }
}