Python :: Aufgabe #322

3 Lösungen Lösungen öffentlich

Magisches Quadrat (magic square)

Fortgeschrittener - Python von JKooP - 28.02.2021 um 10:54 Uhr
Von einem Magischen Quadrat spricht man, wenn
- alle Zahlen nur einmal vorkommen und die Summe der Zahlen
- aller Zeilen,
- aller Spalten sowie
- der Diagonalen immer gleich ist.

Beispiele für Magische Quadrate sind als Bilder angehängt.

Schreibe eine Methode/Funktion, mit der man überprüfen kann, ob es sich bei einer
beliebig großen quadratischen Matrix um ein solch magisches Quadrat handelt.
Zusätzlich kann, bei positiver Prüfung, auch die gesuchte Summe ausgegeben werden.

Zur Darstellung der Matrix können je nach Programmiersprache oder Vorliebe Arrays,
Vektoren oder auch generische Listen verwendet werden.

Viel Spaß

Lösungen:

vote_ok
von AlexGroeg (2010 Punkte) - 05.03.2021 um 23:23 Uhr
Quellcode ausblenden Python-Code

'''
Ein magisches Quadrat ist eine Tabelle mit n Zeilen und n Spalten, 
gefüllt mit den ersten n² natuerlichen Zahlen (beginnend mit 1), 
wobei die Summe der Zahlen in jede Zeile, Spalte und Diagonale gleich ist.

Schreibe ein Programm, welches das magische Quadrat einer ungeraden Zahl
zwischen 2 und 10 berechnet. 
Die ungerade Zahl darf nicht kleiner als 2 oder größer als 10 sein.

'''

# Prüffunktionen.
def zeilensumme(quadrat, i):
    summe = 0
    for n in range(len(quadrat)):
        summe = summe + quadrat[i][n]
    return summe

def spaltensumme(quadrat, i):
    summe = 0
    for n in range(len(quadrat)):
        summe = summe + quadrat[n][i]
    return summe

def diagonalsumme_lr(quadrat):
    summe = 0
    i = 0
    for n in range(len(quadrat)):
        summe = summe + quadrat[i][n]
        i += 1
    return summe

def diagonalsumme_rl(quadrat):
    summe = 0
    i = len(quadrat) -1
    for n in range(len(quadrat)-1, -1, -1):
        summe = summe + quadrat[i][n]
        i -= 1
    return summe


# Prüfe Quadrat.
def pruefen(quadrat):   
    r = 0
    for i in range(0, dim-1):
        if zeilensumme(quadrat,i) == qsum:
            if spaltensumme(quadrat,i) == qsum:
                r += 1    
                
    if r == dim-1:
        if diagonalsumme_lr(quadrat) == qsum:  
            if diagonalsumme_rl(quadrat) == qsum:
                return 'richtig'

    return 'falsch'

# Test Quadrat erstellen.
def quadrat_erstellen(dim):
    quadrat = []
    for i in range(dim):
        quadrat.append(list([0 for x in range(dim)]))
    return quadrat

# Quadrat füllen.
def quadrat_ungerade(quadrat,dim,zahlen):
    # erste Zahl einfügen
    x = (dim -1) // 2
    y = 0
    for i in range(0,dim**2 -0): #-0 zum testen -1, -2 usw.
        if x > dim-1: 
            x = 0
        if y < 0:  
            y = dim-1
        if quadrat[y][x] != 0:
            x-=1; y+=2
            if y > dim-1: y = 1
            quadrat[y][x] = zahlen.pop(0)
        else:
            quadrat[y][x] = zahlen.pop(0)

        x+=1; y-=1   


## Start..............................

dim    = 5 # größe Quadrat (ungerade Zahl)
qsum   = ( dim * (dim**2 + 1) ) / 2
zahlen = list( [x for x in range(1, dim**2 + 1)] )

# Funktionen aufrufen.
quadrat = quadrat_erstellen(dim)

if dim % 2 != 0:
    quadrat_ungerade(quadrat, dim, zahlen)

# Quadrat formatiert ausgeben.
m = max(len(i) for i in quadrat)
for l in quadrat:
    print(" ".join("{0:{1}}".format(i, m) for i in l)) 

print('\n  ', pruefen(quadrat), 'Quersumme =', int(qsum))

vote_ok
von satn1241 (3040 Punkte) - 06.03.2021 um 19:51 Uhr
Quellcode ausblenden Python-Code
import numpy as np

testmatrix = np.array([[4, 9, 2], [3, 5, 7], [8, 1, 6]])


def matrix_check(matrix):
    # Check Duplikate
    liste = []
    for e in matrix:
        for x in e:
            liste.append(x)
    liste.sort()
    for i in range(0, len(liste) - 1):
        if liste[i] == liste[i + 1]:
            print("kein magisches Quadrat")
            return None
    # Check Zeile, Spalte, Diagonale
    t_matrix = matrix.transpose()
    check = []
    d1 = 0
    d2 = 0
    for i in range(0, matrix.ndim + 1):
        check.append(sum(matrix[i]))
        check.append(sum(t_matrix[i]))
        d1 += matrix[i, i]
        d2 += (matrix[matrix.ndim - i, matrix.ndim - i])

    if not d1 == d2:
        print("Kein magisches Quadrat")
        return None
    for e in check:
        if not e == d1:
            print("kein magisches Quadrat")
            return None
    print("magisches Quadrat")
    return None


matrix_check(testmatrix)
vote_ok
von eisheiliger (3240 Punkte) - 13.03.2021 um 19:41 Uhr
Quellcode ausblenden Python-Code

"""
#322: Magisches Quadrat (magic square)
Von einem Magischen Quadrat spricht man, wenn alle Zahlen nur einmal vorkommen und die Summe der Zahlen aller Zeilen,
aller Spalten sowie der Diagonalen immer gleich ist.
"""
import numpy as np


def prf_maqua(arr):
    dia1, dia2 = 0, 0
    sol = (len(arr) * [sum(arr[0])])
    zei = (np.sum(arr, axis=1))
    spa = (np.sum(arr, axis=0))
    for n in range(0, len(arr)):
        dia1 += arr[n][n]
        dia2 += arr[n][len(arr) - n - 1]

    print("Magisches Quadrat Soll:", sum(arr[0]))
    print("Zeilenprüfung:         ", (np.array_equal(zei, sol)))
    print("Spaltenprüfung:        ", (np.array_equal(spa, sol)))
    if dia1 == sum(arr[0]) and dia2 == sum(arr[0]):
        print("Diagonalenpruefung:     True")
    else:
        print("Diagonalenpruefung:     False")


def prf_form(qua):
    print("Vorgabe:", qua)
    struct = np.shape(qua)
    if (struct[0] == struct[1]) and (len(np.unique(qua)) == struct[0] * struct[1]):
        print("Es besteht ein Zahlenquadrat mit eindeutigen Werten")
        prf_maqua(qua)
    else:
        print("Kein Quadrat oder nicht eindeutige Werte")


def main():
    prf_form([[-0.5, 2, 0], [1, 0.5, 0], [1, -1, 1.5]])
    prf_form([[-0.5, 2, 0], [1, 0.5, 0]])
    prf_form([[67, 1, 43], [13, 37, 61], [31, 73, 7]])
    prf_form([[67, 1, 43], [13, 37, 61], [31, 73, 8]])


if __name__ == '__main__':
    main()