Programmieren lernen

package consoleprogramme.array;

import java.util.Scanner;

public class MagischesQuadrat {

    public static void main(String[] args) {
	System.out.println();
	System.out.println("+====================================+");
	System.out.println("|  ***    MAGISCHES QUADRAT     ***  |");
	System.out.println("+====================================+");
	System.out.println(" ");

	int n = 0;
	Scanner sc = new Scanner(System.in);
	System.out.print("Ungerade Zahl zwischen 2 und 10 eingeben: ");
	n = sc.nextInt();

	if ((n % 2 == 0) || (n < 3) || (n > 9)) {
	    System.out.println(" ");
	    System.err
		    .println("Nur ungerade Zahlen zwischen 2 und 10 sind erlaubt!\noder Zahl darf nicht kleiner als 2 oder grösser 10 sein!");
	    System.exit(0);
	}

	int[][] quad = new int[n][n];

	int zeile = n / 2;
	int spalte = n / 2 + 1;

	for (int i = 1; i <= n * n; i++) {

	    quad[zeile][spalte] = i;

	    zeile = zeile - 1;
	    spalte = spalte + 1;

	    if (zeile < 0)
		zeile = n - 1;
	    if (spalte == n)
		spalte = 0;

	    if (quad[zeile][spalte] != 0) {
		zeile = zeile + 1;
		spalte = spalte + 1;
		if (zeile == n)
		    zeile = 0;
		if (spalte == n)
		    spalte = 0;
	    }
	}

	/** Ausgabe */
	System.out.println(" ");
	for (int i = 0; i < quad.length; i++) {
	    for (int j = 0; j < quad[i].length; j++) {
		if (quad[i][j] < 10)
		    System.out.print(" ");
		System.out.print(" " + quad[i][j]);
	    }
	    System.out.println();
	}
    }
}

                

Lösung von: Houssein Fofana ()

/*----------------------------------------------------------------------------*\ 
|  Umsetzung gemäß 
|  http://de.wikipedia.org/wiki/Magisches_Quadrat#Konstruktion_magischer_Quadrate
|  Funktioniert auch mit ungeraden zahlen > 10
|  Die restriktion könnte ich noch einfügen, bin ich aber gerade zu faul zu.
\*----------------------------------------------------------------------------*/
   
var size = prompt("Kantenlänge des Quadrats (ungerade Zahl):"),
    x, y,
    current = 1,
    theSquare = [];
    
function test(num) {                // für die randüberschreitungen
   if (num == -1) return size - 1;
   if (num == size) return 0;
   return num;
}
    
// leeres quadrat erzeugen
for (y = 0; y < size; y++) {
   theSquare[y] = [];
   for (x = 0; x < size; x++) theSquare[y][x] = 0;
}

// beginn im mittleren feld der ersten reihe
y = 0;
x = Math.ceil(size / 2) - 1;
theSquare[x][y] = current;

// quadrat füllen
while (current < Math.pow(size, 2)) {
   if (current % size == 0) y = test(y + 1);
   else {
      x = test(x + 1); 
      y = test(y - 1);
   }
   current++;
   theSquare[x][y] = current;
} 

// ausgabe
document.write('<table>');
for (y = 0; y < size; y++) {
   document.write('<tr>');
   for (x = 0; x < size; x++) {
      document.write('<td style="padding:.5em;text-align:center">' + 
         theSquare[x][y] + '</td>');
   }
   document.write('</tr>');
}
document.write('</table>');                                 // lissalanda@gmx.at
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

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

                

Lösung von: Alex Groeg (Freies Lernen)