Magic Square – Oldj meg 3×3 rejtvényt a C & segítségével Python Példák

Mi az a Magic Square?

A Magic square egy négyzetmátrix egy speciális számelrendezéssel. Ezek a számok úgy vannak elrendezve, hogy az egyes átlókban, sorokban és oszlopokban szereplő számok összege változatlan maradjon. A mágikus négyzetes játékok egyszerű logikai feladványok, amelyeket a szabadidős matematikában használnak.

Példa a mágikus négyzetekre:

A fenti diagramon egy 3-as rendű varázsnégyzet látható. Minden átló, sor és oszlop összege 15.

Hogyan működik a Magic Square

A mágikus négyzetek n*n mátrixok, amelyek n^2 pozitív egész számból állnak. A négyzetes mátrix sorainak vagy oszlopainak számát a mátrix sorrendjének nevezzük.

A mágikus négyzetes rejtvények általában páratlan sorrendűek, és 1 és n^2 közötti egész számokat viselnek. Minden átló, sor és oszlop összege azonos. Ezt a számot mágikus összegnek vagy mágikus állandónak nevezik. Általában ez a mágikus összeg a mátrix sorrendjétől függ. A mágikus négyzetek képlete az n-es rend mágikus összegére

Vegyünk egy példát egy varázsnégyzetre 3-as egész számokkal. Tehát a bűvös összeg:

Miért hívják Mágiának?

Az ókori matematikusokat számos érdekes számkombináció természete lenyűgözte. A varázstér volt az egyik ilyen. A mágikus négyzetek legkorábbi bizonyítéka Kínából származik, ie 190-ből.

Egyes tanulmányok bizonyítékot mutatnak a Varázsnégyzetek rejtvényre az ókori Japánban, Indiában és Arábiában. Egyes legendák alapján azt feltételezték, hogy ezek a különleges számképződmények a varázsvilághoz kapcsolódnak. Ezért ezeket a négyzeteket mágikus négyzeteknek nevezték el.

A Magic Square típusai

A varázsnégyzet matematikának különböző változatai vannak –

Normál mágikus négyzet: Ez a fajta varázsnégyzet az első n^2 számot tartalmazza.
Félig varázslatos tér: Ennél a típusnál csak a sorok és az oszlop összegezhető a varázsállandó.
Egyszerű varázstér: Az előző típussal ellentétben a sorok, oszlopok és mindkét átló összeadódik a mágikus állandóval.
A legtökéletesebb varázstér: Ez egy normál mágikus négyzet két különleges tulajdonsággal. Itt a mátrix minden 2x2-es résznégyzete összesen 2(n^2+1). És bármely olyan számpár, amely n/2 négyzetnyire van a rácsösszegtől n^2+1-re.

Tulajdonságok alapján sokkal több fajta mágikus négyzet létezik. De amikor csak megemlítjük a varázsnégyzetet, azt feltételezzük, hogy ez egy páratlan rendű normál és egyszerű varázsnégyzet.

Algoritmus a Magic Square generálásához

A páratlan rendű mágikus négyzetek generálására szolgáló algoritmus a következő:

Az első szám vagy 1 az (n/2, n-1) helyen lesz tárolva, ahol az első koordináta a sor, a második koordináta pedig az oszlop pozíciója. A későbbi lépésekhez jelöljük ezt a pozíciót (x, y)-ként.
A következő számok az (x-1, y+1) helyen lesznek tárolva. Ha a pozíció nem érvényes, akkor a következő feltételeket vesszük figyelembe.
1. Ha a sor pozíciója -1, akkor n-1-re vetemedik. Hasonlóképpen, ha a számított oszloppozíció n, akkor 0-ra vetemedik.
2. A sor pozíciója 1-gyel nő, az oszlop pozíciója pedig 2-vel csökken, ha a számított pozíció már tartalmaz számot.
3. Ha a sor pozíciója -1, és a megfelelő oszloppozíció n, az új pozíció (0, n-2.

Jegyzet: Ez az algoritmus csak páratlan sorrendű, érvényes mágikus négyzeteket generál. Ezt a bűvös négyzetet is normális varázsnégyzetnek tekintjük, az első n^2 számmal. Sőt, több megoldás is lehet ugyanarra az n értékre.

Vegyünk egy példát, és nézzük meg, hogyan működik. Tegyük fel, hogy meg akarjuk találni a 3-as rendű varázsnégyzetet. Mivel ez egy egyszerű és normális páratlan varázsnégyzet, az összes számot 1-től 3^2-ig vagy 9-ig fogja tartalmazni.

Hogyan működik?

Szerint algoritmus, a lépések a következők lesznek:

Step 1) Az első szám vagy 1 a (3/2, 3-1) vagy (1, 2) pozícióban lesz. Megállapodás szerint vegyük x= 1 és y= 2 a későbbi lépésekhez.

Step 2) A többi szám pozícióját a következő módon számítjuk ki:

A 2. szám pozíciója:

A következő szám (x-1, y+1) vagy (0, 3) lesz, ami nem érvényes pozíció. Az (a) feltétel használatával a megfelelő érvényes pozíció (0,0) lenne. Tehát x = 0, y = 0.

A 3. szám pozíciója:

A 3-as szám (x-1, y+1) vagy (-1, 1) helyen lesz, ami nem érvényes pozíció. Az (a) feltétel használatával az érvényes sorpozíció n-1 vagy 2 lenne. Tehát a 3-as szám a (2, 1) helyen lesz. A következő számhoz x= 2, y= 1.

A 4. szám pozíciója:

A 4-es számnak (x-1, y+1) vagy (1, 2) helyen kell lennie, ami érvényes pozíció. De ez a pozíció már tartalmaz egy számot. A (b) feltétel szerint az érvényes pozíció (1+1, 2-2) vagy (2,0) lenne. A következő számnál x= 2, y= 0.

A 5. szám pozíciója:

Az 5-ös számnak (x-1, y+1) vagy (1, 1) helyen kell lennie, ami érvényes pozíció. A következő számnál x= 1, y= 1.

A 6. szám pozíciója:

Az 6-ös számnak (x-1, y+1) vagy (0, 2) helyen kell lennie, ami érvényes pozíció. A következő számnál x= 0, y= 2.

A 7. szám pozíciója:

A 7-es számnak (x-1, y+1) vagy (-1, 3) helyen kell lennie, ami nem érvényes pozíció. A (c) feltétel szerint az érvényes pozíció (0, n-2) vagy (0, 1) lenne. A következő számnál x= 0, y= 1.

A 8. szám pozíciója:

A 8-as számnak (x-1, y+1) vagy (-1, 2) helyen kell lennie, ami nem érvényes pozíció. Az (a) feltétel használatával az érvényes pozíció a (2, 2) lenne. A következő számnál x= 2, y= 2.

A 9. szám pozíciója:

A 9-es számnak (x-1, y+1) vagy (1, 3) helyen kell lennie, ami nem érvényes pozíció. Az (a) feltétel használatával az érvényes pozíció (1, 0) lenne.

Pszeudo-kód

Begin
	Declare an array of size n*n
	Initialize the array to 0
	Set row = n/2
	Set column = n-1
	For all number i: from 1 to n*n
		If the row = -1 and column = n
			row = 0
			column = n-2
		Else
			If row = -1
				row = n-1
			If column = n
				column = 0
		If the position already contains a number
			decrement column by 2
			increment row by 1
			continue until the position is not 0
		Else
			put the number i into the calculated position
			increment i		
		Increment column value
		Decrement row value
End

C++ Code Magic Square

Bemenet:

/*
A C/C++ program for generating odd order magic squares
*/
#include <bits/stdc++.h>
using namespace std;

void GenerateMagicSquare(int n)
{
    int magic[n][n];
    //initializing the array
    for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
	        magic[i][j] = 0;
    //setting row and column value
    int i = n / 2;
    int j = n - 1;
    for (int k = 1; k <= n * n;) 
    {
//checking condition (c)
	if (i == -1 && j == n) 
	{
		j = n - 2;
		i = 0;
	}
	else 
	{
		//checking condition (a)
		if (j == n)
			j = 0;
		if (i < 0)
			i = n - 1;
		}
		//checking condition (b)
		if (magic[i][j]) 
		{
			j -= 2;
			i++;
			continue;
		}
		else
		{
		   	//placing the number into the array
		   	magic[i][j] = k; 
			k++;
		}	
		//for the next number setting (i-1, j+1)
		j++;
		i--; 
	}
	//printing the matrix
	for (int i = 0; i < n; i++)
 {
		for (int j = 0; j < n; j++)
			cout << magic[i][j] << "  ";
		cout << endl;
	}	
}
int main()
{
	//This code works for only odd numbers
	int n = 7;
	cout<<"The magic sum is " << n*(n*n+1)/2 <<endl;
	GenerateMagicSquare(n);
	return 0;
}

Példa kimenete:

The magic sum is 175

20  12  4  45  37  29  28
11  3  44  36  35  27  19
2  43  42  34  26  18  10
49  41  33  25  17  9  1
40  32  24  16  8  7  48
31  23  15  14  6  47  39
22  21  13  5  46  38  30

Python Code Magic Square

def GenerateMagicSquare(n):
#initializing the array
	magic = [[0 for x in range(n)]
				for y in range(n)]
	#setting row and column value
	i = n // 2
	j = n - 1
	k = 1
	while k <= (n * n):
	    #checking condition (c)
		if i == -1 and j == n: 
			j = n - 2
			i = 0
		else:
			#checking condition (a)
			if j == n:
				j = 0
			if i < 0:
				i = n - 1
        #checking conditon (b)
		if magic[i][j]: 
			j = j - 2
			i = i + 1
			continue
		else:
		    #placing the number into the array
			magic[i][j] = k
			k = k + 1
        #for the next number setting (i-1, j+1)
		j = j + 1
		i = i - 1 
	#printing the matrix
	for i in range(0, n):
		for j in range(0, n):
			print('%2d ' % (magic[i][j]),end='')
			if j == n - 1:
				print()
#This code works for only odd numbers
n = 7
print("The magic sum is ",n * (n * n + 1) // 2, "\n")
GenerateMagicSquare(n)