Vreemde magische vierkanten in Java

Het is onduidelijk wie voor het eerst met een magisch vierkant kwam. Er is een verhaal over een enorme overstroming in China lang geleden. De mensen waren bang dat ze zouden worden weggespoeld en probeerden de riviergod te sussen door offers te brengen. Niets leek te werken totdat een kind een schildpad zag met een magisch vierkant op zijn rug dat het offer bleef omcirkelen. Het plein vertelde de mensen hoe groot hun offer moest zijn om zichzelf te redden. Sindsdien zijn magische vierkanten het hoogtepunt van de mode voor elke veeleisende schildpad.

Niveau: Beginner

Focus: Logica, arrays, methoden

Vreemde magische vierkanten

Als je er nog nooit een bent tegengekomen, is een magisch vierkant een rangschikking van opeenvolgende getallen in een vierkant, zodat de rijen, kolommen en diagonalen allemaal hetzelfde aantal zijn. Een 3x3 magisch vierkant is bijvoorbeeld:

 8 1 6

 3 5 7

 4 9 2

Elke rij, kolom en diagonaal telt op tot 15.

Odd Magic Squares Vraag

Deze programmeeroefening houdt zich bezig met het maken van magische vierkanten met een oneven grootte (d.w.z. de grootte van het vierkant kan alleen een oneven getal zijn, 3x3, 5x5, 7x7, 9x9, enzovoort). De truc bij het maken van zo'n vierkant is om nummer 1 in de eerste rij en middelste kolom te plaatsen. Om te bepalen waar het volgende nummer moet worden geplaatst, schuift u diagonaal naar rechts (d.w.z. één rij omhoog, één kolom overdwars). Als een dergelijke beweging betekent dat je van het vierkant valt, wikkel je dan naar de rij of kolom aan de andere kant. Als je ten slotte naar een vierkant gaat dat al is gevuld, ga je terug naar het oorspronkelijke vierkant en ga je één voor één naar beneden. Herhaal het proces totdat alle vierkanten zijn gevuld.

Een 3x3 magisch vierkant zou bijvoorbeeld als volgt beginnen:

 0 1 0

 0 0 0

 0 0 0

Een beweging diagonaal omhoog betekent dat we ons naar de onderkant van het vierkant wikkelen:

 0 1 0

 0 0 0

 0 0 2

Evenzo betekent de volgende diagonale beweging naar boven dat we ons om de eerste kolom wikkelen:

 0 1 0

 3 0 0

 0 0 2

Nu resulteert de diagonale beweging naar boven in een vierkant dat al is gevuld, dus we gaan terug naar waar we vandaan kwamen en laten een rij vallen:

 0 1 0

 3 0 0

 4 0 2

en het gaat door en door tot alle vierkanten vol zijn.

Programma-eisen

• een gebruiker moet de grootte van het magische vierkant kunnen invoeren.
• ze mogen alleen een oneven aantal invoeren.
• gebruik een methode om het magische vierkant te maken.
• gebruik een methode om het magische vierkant weer te geven.

De vraag is of uw programma een magisch vierkant van 5x5 kan maken zoals hieronder?

 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 

Tip: Naast de programmeeraspecten van deze oefening is het ook een test van logica. Neem elke stap van het maken van het magische vierkant om de beurt en kom erachter hoe het kan worden gedaan met een tweedimensionale array.

Vreemde magische vierkante oplossing

Je programma had het 5x5 magische vierkant hieronder moeten kunnen maken:

 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 

Hier is mijn versie:

 java.util.Scanner importeren;

 openbare klasse MagicOddSquare 

   public static void main (String [] args) 

     Scannerinvoer = nieuwe scanner (System.in);

     int [] [] magicSquare;

     boolean isAcceptableNumber = false;

     int size = -1;

     // accepteert alleen oneven nummers

     terwijl (isAcceptableNumber == false)

       System.out.println ("Voer in vierkantgrootte in:");

       String sizeText = input.nextLine ();

       size = Integer.parseInt (sizeText);

       if (maat% 2 == 0)

         System.out.println ("De grootte moet een oneven getal zijn");

         isAcceptableNumber = false;

       anders

         isAcceptableNumber = true;

     magicSquare = createOddSquare (grootte);

     displaySquare (magisch vierkant); 

   private statische int [] [] createOddSquare (int grootte)

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

     int rij = 0;

     int kolom = grootte / 2;

     int lastRow = row;

     int lastColumn = column;

     int matrixSize = grootte * grootte; 

     magicSq [rij] [kolom] = 1;

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

       // controleer of we naar de tegenovergestelde rij moeten gaan

       if (rij - 1 < 0)

         rij = maat-1;

       anders

         rij--;

       // controleer of we naar de tegenovergestelde kolom moeten gaan

       if (kolom + 1 == grootte)

         kolom = 0;

       anders

         kolom ++;

       // als deze positie niet leeg is, ga dan terug naar waar we zijn

       // gestart en één rij omlaag verplaatsen

       if (magicSq [rij] [kolom] == 0)

         magicSq [rij] [kolom] = k;

       anders

         row = lastRow;

         column = lastColumn;

         if (rij + 1 == grootte)

           tr = 0;

          anders

           rij ++;

         magicSq [rij] [kolom] = k;

       lastRow = rij;

       lastColumn = kolom; 

     retourneer magicSq;

   private statische void displaySquare (int [] [] magicSq)

     int magicConstant = 0;

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

       voor (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 ("De magische constante is" + magicConstant);