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))

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)

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()