Odd Magic Squares in Java

Non è chiaro chi abbia inventato per primo un quadrato magico. C'è una storia su un'enorme alluvione in Cina molto tempo fa. Le persone erano preoccupate che sarebbero state spazzate via e hanno cercato di placare il dio del fiume facendo sacrifici. Nulla sembrava funzionare fino a quando un bambino non notò una tartaruga con un quadrato magico sul dorso che continuava a circondare il sacrificio. La piazza ha detto alla gente quanto doveva essere grande il loro sacrificio per salvarsi. Da allora i quadrati magici sono stati l'altezza della moda per qualsiasi tartaruga esigente.

Livello: Principiante

Messa a fuoco: Logica, array, metodi

Quadrati magici dispari

Nel caso in cui non ne abbia mai incontrato uno prima, un quadrato magico è una disposizione di numeri sequenziali in un quadrato in modo che le righe, le colonne e le diagonali si sommino tutte allo stesso numero. Ad esempio, un quadrato magico 3x3 è:

 8 1 6

 3 5 7

 4 9 2

Ogni riga, colonna e diagonale aggiunge fino a 15.

Domanda sui quadrati magici dispari

Questo esercizio di programmazione si occupa della creazione di quadrati magici di dimensioni dispari (ovvero, la dimensione del quadrato può essere solo un numero dispari, 3x3, 5x5, 7x7, 9x9 e così via). Il trucco per realizzare un quadrato del genere è posizionare il numero 1 nella prima riga e nella colonna centrale. Per trovare dove posizionare il numero successivo, spostati in diagonale verso l'alto a destra (ad esempio, una riga verso l'alto, una colonna attraverso). Se una tale mossa significa che cadi dal quadrato, avvolgi la riga o la colonna sul lato opposto. Infine, se la mossa ti porta in un quadrato già riempito, torna al quadrato originale e spostati verso il basso di uno. Ripeti il processo fino a riempire tutti i quadrati.

Ad esempio, un quadrato magico 3x3 inizierà così:

 0 1 0

 0 0 0

 0 0 0

Una mossa in diagonale verso l'alto significa che ci avvolgiamo nella parte inferiore del quadrato:

 0 1 0

 0 0 0

 0 0 2

Allo stesso modo, la prossima mossa diagonale verso l'alto significa che ci avvolgiamo alla prima colonna:

 0 1 0

 3 0 0

 0 0 2

Ora la mossa diagonale verso l'alto si traduce in un quadrato che è già riempito, quindi torniamo da dove siamo venuti e scendiamo di una riga:

 0 1 0

 3 0 0

 4 0 2

e continua all'infinito fino a quando tutti i quadrati sono pieni.

Requisiti del programma

un utente deve essere in grado di inserire le dimensioni del quadrato magico.
devono solo essere autorizzati a inserire un numero dispari.
usa un metodo per creare il quadrato magico.
utilizzare un metodo per visualizzare il quadrato magico.

La domanda è: il tuo programma può creare un quadrato magico 5x5 come quello qui sotto?

 17 24 1 8 15

 23 5 7 14 16

  4 6 13 20 22

 10 12 19 21 3

 11 18 25 2 9

Suggerimento: Oltre agli aspetti di programmazione di questo esercizio è anche un test di logica. Fai ogni passo per creare il quadrato magico a sua volta e capire come può essere fatto con un array bidimensionale.

Odd Magic Square Solution

Il tuo programma avrebbe dovuto essere in grado di creare il quadrato magico 5x5 di seguito:

 17 24 1 8 15

 23 5 7 14 16

  4 6 13 20 22

 10 12 19 21 3

 11 18 25 2 9

Ecco la mia versione:

 import java.util.Scanner;

 classe pubblica MagicOddSquare

   public static void main (String [] args)

     Input scanner = new Scanner (System.in);

     int [] [] magicSquare;

     booleano isAcceptableNumber = false;

     int size = -1;

     // accetta solo numeri dispari

     while (isAcceptableNumber == false)

       System.out.println ("Inserisci in dimensione del quadrato:");

       String sizeText = input.nextLine ();

       size = Integer.parseInt (sizeText);

       if (size% 2 == 0)

         System.out.println ("La dimensione deve essere un numero dispari");

         isAcceptableNumber = false;

       altro

         isAcceptableNumber = true;

     magicSquare = createOddSquare (dimensione);

     displaySquare (Quadrato Magico);

   private static int [] [] createOddSquare (int size)

     int [] [] magicSq = new int [size] [size];

     int row = 0;

     int column = size / 2;

     int lastRow = row;

     int lastColumn = column;

     int matrixSize = size * size;

     magicSq [riga] [colonna] = 1;

     per (int k = 2; k < matrixSize+1;k++)

       // controlla se dobbiamo avvolgere nella riga opposta

       if (riga - 1 < 0)

         riga = dimensione-1;

       altro

         riga--;

       // controlla se dobbiamo avvolgere nella colonna opposta

       if (colonna + 1 == dimensione)

         colonna = 0;

       altro

         colonna ++;

       // se questa posizione non è vuota, torna a dove siamo

       // avviato e sposta di una riga in basso

       if (magicSq [riga] [colonna] == 0)

         magicSq [riga] [colonna] = k;

       altro

         row = lastRow;

         colonna = lastColumn;

         if (riga + 1 == dimensione)

           row = 0;

          altro

           fila ++;

         magicSq [riga] [colonna] = k;

       lastRow = row;

       lastColumn = colonna;

     restituire magicSq;

   vuoto statico privato displaySquare (int [] [] magicSq)

     int magicConstant = 0;

     per (int j = 0; j<(magicSq.length);j++)

       per (int k = 0; k<(magicSq[j].length);k++)

         System.out.print (magicSq [j] [k] + "");

       System.out.print;

       magicConstant = magicConstant + magicSq [j] [0];

      System.out.print ("La costante magica è" + magicConstant);

Scienza