magisches Quadrat der Ordnung n ?

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • magisches Quadrat der Ordnung n ?

    Ich habe im Internet gesucht. Und es ist mehr in Beziehung mit Mathematik. Kann jemand mir hier helfen:

    Ein magisches Quadrat der Ordnung n enthält die Zahlen von 1 bis n^2 so, dass die Summe der Zahlen in jeder Zeile, Spalte und Diagonale gleich groß ist. Ein Beispiel für ein Quadrat der Ordnung 4 (alle Summen sind gleich 34):
    16 2 3 13
    5 11 10 8
    9 7 6 12
    4 14 15 1
    Schreiben Sie ein Programm, das für eine vorgegebene Ordnung (max. 6) die magischen Quadrate ermittelt und ausgibt.
    ---

    Wie?

  • ich habe gefunden, noch kann jemand mir es ein bischen erklaeren:

    Quellcode

    1. #include "stdafx.h"
    2. #include <vector>
    4. using namespace std;
    6. void OddMagicSquare(vector<vector<int> > &matrix, int n);
    7. void DoublyEvenMagicSquare(vector<vector<int> > &matrix, int n);
    8. void SinglyEvenMagicSquare(vector<vector<int> > &matrix, int n);
    9. void MagicSquare(vector<vector<int> > &matrix, int n);
    10. void PrintMagicSquare(vector<vector<int> > &matrix, int n);
    12. int main(int argc, char* argv[])
    13. {
    14. int n;
    15. printf("Enter order of square: ");
    16. scanf("%d", &n);
    18. vector<vector<int> > matrix(n, vector<int> (n, 0));
    20. if (n<3)
    21. {
    22. printf("\nError: n must be greater than 2\n\n");
    23. return -1;
    24. }
    26. MagicSquare(matrix, n);
    28. //Print results
    29. PrintMagicSquare(matrix, n);
    31. return 0;
    32. }
    34. void MagicSquare(vector<vector<int> > &matrix,int n)
    35. {
    36. if (n%2==1) //n is Odd
    37. OddMagicSquare(matrix, n);
    38. else //n is even
    39. if (n%4==0) //doubly even order
    40. DoublyEvenMagicSquare(matrix, n);
    41. else //singly even order
    42. SinglyEvenMagicSquare(matrix, n);
    43. }
    45. void OddMagicSquare(vector<vector<int> > &matrix, int n)
    46. {
    47. int nsqr = n * n;
    48. int i=0, j=n/2; // start position
    50. for (int k=1; k<=nsqr; ++k)
    51. {
    52. matrix[i][j] = k;
    54. i--;
    55. j++;
    57. if (k%n == 0)
    58. {
    59. i += 2;
    60. --j;
    61. }
    62. else
    63. {
    64. if (j==n)
    65. j -= n;
    66. else if (i<0)
    67. i += n;
    68. }
    69. }
    70. }
    72. void DoublyEvenMagicSquare(vector<vector<int> > &matrix, int n)
    73. {
    74. vector<vector<int> > I(n, vector<int> (n, 0));
    75. vector<vector<int> > J(n, vector<int> (n, 0));
    77. int i, j;
    79. //prepare I, J
    80. int index=1;
    81. for (i=0; i<n; i++)
    82. for (j=0; j<n; j++)
    83. {
    84. I[i][j]=((i+1)%4)/2;
    85. J[j][i]=((i+1)%4)/2;
    86. matrix[i][j]=index;
    87. index++;
    88. }
    90. for (i=0; i<n; i++)
    91. for (j=0; j<n; j++)
    92. {
    93. if (I[i][j]==J[i][j])
    94. matrix[i][j]=n*n+1-matrix[i][j];
    95. }
    96. }
    98. void SinglyEvenMagicSquare(vector<vector<int> > &matrix, int n)
    99. {
    100. int p=n/2;
    102. vector<vector<int> > M(p, vector<int> (p, 0));
    103. MagicSquare(M, p);
    105. int i, j, k;
    107. for (i=0; i<p; i++)
    108. for (j=0; j<p; j++)
    109. {
    110. matrix[i][j]=M[i][j];
    111. matrix[i+p][j]=M[i][j]+3*p*p;
    112. matrix[i][j+p]=M[i][j]+2*p*p;
    113. matrix[i+p][j+p]=M[i][j]+p*p;
    114. }
    116. if (n==2)
    117. return;
    119. vector<int> I(p, 0);
    120. vector<int> J;
    122. for (i=0; i<p; i++)
    123. I[i]=i+1;
    125. k=(n-2)/4;
    127. for (i=1; i<=k; i++)
    128. J.push_back(i);
    130. for (i=n-k+2; i<=n; i++)
    131. J.push_back(i);
    133. int temp;
    134. for (i=1; i<=p; i++)
    135. for (j=1; j<=J.size(); j++)
    136. {
    137. temp=matrix[i-1][J[j-1]-1];
    138. matrix[i-1][J[j-1]-1]=matrix[i+p-1][J[j-1]-1];
    139. matrix[i+p-1][J[j-1]-1]=temp;
    140. }
    142. //j=1, i
    143. //i=k+1, k+1+p
    144. i=k;
    145. j=0;
    146. temp=matrix[i][j]; matrix[i][j]=matrix[i+p][j]; matrix[i+p][j]=temp;
    148. j=i;
    149. temp=matrix[i+p][j]; matrix[i+p][j]=matrix[i][j]; matrix[i][j]=temp;
    150. }
    153. void PrintMagicSquare(vector<vector<int> > &matrix, int n)
    154. {
    155. for (int i=0; i<n; i++)
    156. {
    157. for (int j=0; j<n; j++)
    158. printf(" %3d", matrix[i][j]);
    160. printf("\n");
    161. }
    163. printf("\n\n");
    164. }
    Alles anzeigen

  • was ist simply?

    Ich poste dir mal unsere Aufgabenbeschreibung und die Lösung einer Kommilitonin (code ist kürzer und außerdem besser dokumentiert)

    Das Erstellen eines magischen Quadrats zu einem gegebenen ungeraden n kann nach folgendem Verfahren erfolgen.
    * Das mittlere Feld wird mit der Zahl 1 belegt.
    * Die Zahl i + 1 wird links unterhalb von i eingetragen. Falls dieses Feld schon belegt ist, wird i + 1 zwei Felder unter i eingetragen.
    * Das Feld wird an den Rändern als zyklisch geschlossen angenommen.

    Schreiben Sie ein Programm magisch, das ein ungerades n > 0 als Kommandozeilen-
    parameter erwartet und das entsprechende magische Quadrat ausgibt. Verwenden
    Sie dynamischen Speicher zur Verwaltung des zwei-dimensionalen Felds.


    Quellcode

    1. #include <stdio.h>
    2. #include <stdlib.h>
    4. void printArray(int* array, int n);
    6. int main(int argc, char *argv[]) {
    7. int n = atoi(argv[1]);
    8. int* quadrat = calloc(sizeof(int), n*n);
    9. int k, l, i = 1;
    11. /* belege mittleres Feld mit 1 */
    12. quadrat[(n/2) *n + (n/2)] = 1;
    13. /* belege restliches Feld */
    14. for (i=1 ; i<n*n ; i++) {
    15. for (k=0 ; k<n ; k++) {
    16. for (l=0 ; l<n ; l++) {
    17. /* i+1 wird links unterhalb von i eingetragen */
    18. if ((quadrat[k*n+l] == i) && (quadrat[((k+1+n)%n) *n + ((l-1+n)%n)] == 0)) {
    19. quadrat[((k+1+n)%n) *n + ((l-1+n)%n)] = i+1;
    20. }
    21. /* i+1 wird 2 Felder unter i eingetragen (falls Feld links unterhalb von i schon belegt) */
    22. else if ((quadrat[k*n+l] == i) && (quadrat[((k+1+n)%n) *n + ((l-1+n)%n)] != 0)) {
    23. quadrat[((k+2+n)%n) *n + l] = i+1;
    24. }
    25. }
    26. }
    27. }
    28. printArray(quadrat, n);
    29. free(quadrat);
    30. return 0;
    31. }
    33. /* Funktion zur Ausgabe eines zweidimensionalen Arrays */
    34. void printArray(int* array, int n) {
    35. int i, j;
    36. for (i=0 ; i<n ; i++) {
    37. for (j=0 ; j<n ; j++) {
    38. printf("%i\t",array[i*n+j]);
    39. }
    40. printf("\n\n");
    41. }
    42. }
    Alles anzeigen


  • ...einem gegebenen ungeraden n kann nach...


    So wie ich das aber verstanden habe, muss Super das für ein allgemeingültiges n <= 6 machen und nicht nur für ungrade n.
    Der Code von Super sieht ähnlich aus, wie die magic()-Function von MATLAB.
    Wenn man sich die anschaut, ist auch ersichtlich was doubly und singly bedeutet:
    es geht dabei um die Ordnung des Quadrates:
    Sollte n ungrade sein, dann wird die Funktion OddMagicSquare verwendet (klar).
    Sollte n grade sein, wird unterschieden, von welcher Ordnung das ganze ist:
    Es ist nämlich für den Algorithmus wichtig zu wissen, ob das n durch 4 oder nur durch 2 teilbar ist. Dementsprechend berechnet DoublyEvenMagicSquare das Magische Quadrat, wenn "n mod 4 = 0" ist, sprich n ohne Rest durch 4 teilbar ist.
    SinglyEvenMagicSquare wird dann verwendet, wenn n nur durch 2 teilbar ist, aber nicht durch 4.