魔方阵算法及C语言实现
《C语言程序》课程设计报告书-魔方阵程序设计
吉林工程技术师范学院《C语言程序》课程设计报告书设计题目：魔方阵程序设计专业：计算机科学与技术班级：1054学生姓名：学号：21指导教师：xx2011年1月信息工程学院摘要我的实验题目是对C语言程序设计——魔方阵的编写，主要的功能是实现每一行，每一列以及对角线的相加结果相同，而且每一个数字均不相等。
本次实验能够充分的考核我们对C语言的学习程度以及动手操作能力，对我们提高C语言的能力有极大的帮助，所以这次实验也是十分有必要的。
我的设计内容就是利用循环语句，以及判断条件等函数的合理使用，通过不断的运行，调试，输出，对本程序进行合理的解决，对魔方阵进一步的了解掌握。
关键字：C语言魔方阵程序设计目录摘要................................................. 第1章概述 (1)第2章系统分析 (2)2.1 技术分析 (2)2.2 功能分析 (2)第3章总体设计与详细设计 (3)3.1 系统总体设计 (3)3.2 详细设计 (4)第4章编码实现 (6)4.1 数据输入部分代码设计 (6)4.2 运算部分代码设计 (6)4.3 输出部分代码设计 (7)第5章系统调试 (9)5.1 程序运行结果 (9)5.2 调试过程中的问题与对策 (10)第6章设计总结 (10)参考资料 (12)致谢 (12)附录：1 源代码 (13)2 附图 (14)第1章概述本次实验报告十分有意义，对巩固C语言的学习有很大的帮助。
作用：我的实验课题是魔方阵（魔方阵是一个奇数行列式方阵），主要是实现一行，一列，对角线的和都相等。
意义、帮助：1、能够熟练掌握if、if…else、if…else if语句格式及使用方法，掌握if语句中的嵌套关系和匹配原则，利用if语句实现分支选择结构。
2、能够熟练掌握while语句和for语句格式及使用方法，掌握循环控制语句的循环过程以及循环结构的嵌套，利用循环语句实现循环结构。
魔方阵C语言设计方法及设计理念
與奇數魔術方陣相同，在於求各行、各列與各對角線的和相等，而這次方陣的維度是4的倍數。
先來看看4X4方陣的解法：簡單的說，就是一個從左上由1依序開始填，但遇對角線不填，另一個由左上由16開始填，但只填在對角線，再將兩個合起來就是解答了；如果N大於2，則以4X4為單位畫對角線：至於對角線的位置該如何判斷，有兩個公式，有興趣的可以畫圖印證看看，如下所示：if(i%4==j%4||(i%4+j%4==3)//zaiduijiaoxianshangC方陣的維度整體來看是偶數，但是其實是一個奇數乘以一個偶數，例如6X6，其中6=2X3，我們也稱這種方陣與單偶數方陣。
如果您會解奇數魔術方陣，要解這種方陣也就不難理解，首先我們令n=2(2m+1)，並將整個方陣看作是數個奇數方陣的組合，如下所示：首先依序將A、B、C、D四個位置，依奇數方陣的規則填入數字，填完之後，方陣中各行的和就相同了，但列與對角線則否，此時必須在A-D與C- B之間，作一些對應的調換，規則如下：1.將A中每一列(中間列除外)的頭m個元素，與D中對應位置的元素調換。
2.將A的中央列、中央那一格向左取m格，並與D中對應位置對調3.將C中每一列的倒數m-1個元素，與B中對應的元素對調舉個實例來說，如何填6X6方陣，我們首先將之分解為奇數方陣，並填入數字，如下所示：接下來進行互換的動作，互換的元素以不同顏色標示，如下：由於m-1的數為0，所以在這個例子中，C-B部份並不用進行對調。
C將1到n(為奇數)的數字排列在nxn的方陣上，且各行、各列與各對角線的和必須相同，如下所示：填魔術方陣的方法以奇數最為簡單，第一個數字放在第一行第一列的正中央，然後向右(左)上填，如果右(左)上已有數字，則向下填，如下圖所示：一般程式語言的陣列索引多由0開始，為了計算方便，我們利用索引1到n的部份，而在計算是向右(左)上或向下時，我們可以將索引值除以n值，如果得到餘數為1就向下，否則就往右(左)上，原理很簡單，看看是不是已經在同一列上繞一圈就對了。
魔方阵算法及C语言实现
魔⽅阵算法及C语⾔实现1 魔⽅阵概念是指由1，2，3……n2填充的，每⼀⾏、每⼀列、对⾓线之和均相等的⽅阵，阶数n = 3，4，5…。
魔⽅阵也称为幻⽅阵。
例如三阶魔⽅阵为：魔⽅阵有什么的规律呢？魔⽅阵分为奇幻⽅和偶幻⽅。
⽽偶幻⽅⼜分为是4的倍数（如4，8，12……）和不是4的倍数（如6，10，14……）两种。
下⾯分别进⾏介绍。
2 奇魔⽅的算法2.1 奇魔⽅的规律与算法奇魔⽅（阶数n = 2 * m + 1，m =1，2，3……）规律如下：1. 数字1位于⽅阵中的第⼀⾏中间⼀列；2. 数字a（1 < a ≤ n2）所在⾏数⽐a-1⾏数少1，若a-1的⾏数为1，则a的⾏数为n；3. 数字a（1 < a ≤ n2）所在列数⽐a-1列数⼤1，若a-1的列数为n，则a的列数为1；4. 如果a-1是n的倍数，则a（1 < a ≤ n2）的⾏数⽐a-1⾏数⼤1，列数与a-1相同。
2.2 奇魔⽅算法的C语⾔实现1 #include <stdio.h>2// Author: /3// N为魔⽅阶数4#define N 1156int main()7 {8int a[N][N];9int i;10int col,row;1112 col = (N-1)/2;13 row = 0;1415 a[row][col] = 1;1617for(i = 2; i <= N*N; i++)18 {19if((i-1)%N == 0 )20 {21 row++;22 }23else24 {25// if row = 0, then row = N-1, or row = row - 126 row--;27 row = (row+N)%N;2829// if col = N, then col = 0, or col = col + 130 col ++;31 col %= N;32 }33 a[row][col] = i;34 }35for(row = 0;row<N;row++)36 {37for(col = 0;col < N; col ++)38 {39 printf("%6d",a[row][col]);40 }41 printf("\n");42 }43return0;44 }3 偶魔⽅的算法偶魔⽅的情况⽐较特殊，分为阶数n = 4 * m（m =1，2，3……）的情况和阶数n = 4 * m + 2（m = 1，2，3……）情况两种。
C语言实现魔方阵
（1）魔方阵 ①问题描述魔方阵是一个古老的智力问题，它要求在一个m ×m 的矩阵中填入1～m 2的数字（m 为奇数），使得每一行、每一列、每条对角线的累加和都相等，如图1所示。
②基本要求● 输入魔方阵的行数m ，要求m 为奇数，程序对所输入的m 作简单的判断，如m 有错，能给出适当的提示信息。
● 实现魔方阵。
● 输出魔方阵。
③实现提示本实验使用的数据结构是数组。
解魔方阵问题的方法很多，这里采用如下规则生成魔方阵。
● 由1开始填数，将1放在第0行的中间位置。
● 将魔方阵想象成上下、左右相接，每次往左上角走一步，会有下列情况：✧ 左上角超出上方边界，则在最下边相对应的位置填入下一个数字； ✧ 左上角超出左边边界，则在最右边相应的位置填入下一个数字； ✧ 如果按上述方法找到的位置已填入数据，则在同一列下一行填入下一个数字。
以3×3魔方阵为例，说明其填数过程，如图2所示。
图2 三阶魔方阵的生成过程由三阶魔方阵的生成过程可知，某一位置(x,y)的左上角的位置是(x-1,y-1),如果x-1≥0，不用调整，否则将其调整为x-1+m ；同理，如果y-1≥0，不用调整，否则将其调整为y-1+m 。
所以，位置(x,y)的左上角的位置可以用求模的方法获得，即：x=(x-1+m)%my=(y-1+m)%m如果所求的位置已经有数据了，将该数据填入同一列下一行的位置。
这里需要注意的是。
此时的x和y已经变成之前的上一行上一列了，如果想变回之前位置的下一行同一列，x需要跨越两行，y需要跨越一列，即：x=(x+2)%my=(y+1)%m源代码：#include<stdio.h>void mofangzhen(int m){int a[100][100];int b,x,y;for(x=0;x<m;x++){for(y=0;y<m;y++)a[x][y]=0;}x=0;y=(m-1)/2;a[x][y]=1;for(b=2;b<=m*m;b++){if(x-1<0) x=(x-1+m)%m;else x=x-1;if(y-1<0) y=(y-1+m)%m;else y=y-1;if(a[x][y]!=0){x=(x+2)%m;y=(y+1)%m;}a[x][y]=b;}for(x=0;x<m;x++){for(y=0;y<m;y++)printf("%4d",a[x][y]);printf("\n");}}void main(){int m;m=0;while(m%2!=1){printf("请输入矩阵阶数m（奇数)：");scanf("%d",&m);if(m%2!=1)printf("m输入错误\n");}mofangzhen(m);}。
C语言实现奇数阶魔方阵的方法
C语⾔实现奇数阶魔⽅阵的⽅法本⽂实例讲述了C语⾔实现奇数阶魔⽅阵的⽅法。
分享给⼤家供⼤家参考。
具体实现⽅法如下：复制代码代码如下:#include "stdio.h"#include "string.h"#include "stdlib.h"#define N 5void main(){int a[N][N]={0};int i,j;int k;i = 0;j = N/2;a[0][j]=1;for(k = 2; k <= N*N; k++){if( i == 0 && j == N-1 ){//先判断前⼀个数是不是最右上⾓的数，若是后⼀个数直接填在前⼀个数下⽅i=i+1;a[i][j] = k;continue;}i = (i-1+N)%N;//计算前⼀个数右上⾓的坐标j = (j+1)%N;if(a[i][j] != 0){//若前⼀个数的右上⾓有元素，后⼀个数直接填在前⼀个数下⽅i = ((i+1)%N+1)%N;//恢复坐标j = (j-1+N)%N;a[i][j] = k;}else{//上述条件均不满⾜，后⼀个数放在前⼀个数的右上⾓a[i][j] = k;}}for(i = 0; i < N; i++){for(j = 0; j < N; j++){printf("M",a[i][j]);}printf("\n");}}测试数据如下：N = 38 1 63 5 74 9 2希望本⽂所述对⼤家的C语⾔程序设计有所帮助。
魔方矩阵magic square (C语言程序)
/*#include<stdio.h>#define N 7*/#include<iostream>using namespace std;int main(){int N;cout<<"请输入魔方矩阵的阶数N："<<endl;cin>>N;int matrix[N][N];int row,col;int i,m,n;//0.初始化数组元素全部为0for(row=0;row<N;row++){for(col=0;col<N;col++){matrix[row][col]=0;}}//1.定位1的初始位置row=0;col=(N-1)/2;matrix[row][col]=1;//2.将2...N*N每个数插入到相应位置for(i=2;i<=N*N;i++){int r,c;r=row;c=col;row=(row+N-1)%N; //行列坐标的计算，算法难点。
col=(col+N+1)%N; //后一个数位于前一个数的上一行下一列if(0==matrix[row][col]) //该处无数，无冲突，直接插入该数matrix[row][col]=i;else //此处已经插入了树，则插入到这个位置的下一行{r=(r+1)%N;matrix[r][c]=i;row=r; //重新定位此时的行和列数col=c;}}//3.输出魔方矩阵printf("\n%d阶魔方矩阵如下：\n",N);for(m=0;m<=N;m++){printf("===="); //每个位置占用4个字节}printf("\n");for(m=0;m<N;m++){for(n=0;n<N;n++)printf("%4d",matrix[m][n]); //%4d输出占用4个字节的空间,不足部分用空格在左侧补齐。
魔方阵 C语言
一、幻方按照阶数可分成了三类，即奇数阶幻方、双偶阶幻方、单偶阶幻方。
二、奇数阶幻方（劳伯法）奇数阶幻方最经典的填法是罗伯法。
填写的方法是：把1（或最小的数）放在第一行正中；按以下规律排列剩下的(n×n－1)个数：（1）每一个数放在前一个数的右上一格；（2）如果这个数所要放的格已经超出了顶行那么就把它放在底行，仍然要放在右一列；（3）如果这个数所要放的格已经超出了最右列那么就把它放在最左列，仍然要放在上一行；（4）如果这个数所要放的格已经超出了顶行且超出了最右列，那么就把它放在底行且最左列；（5）如果这个数所要放的格已经有数填入，那么就把它放在前一个数的下一行同一列的格内。
例，用该填法获得的5阶幻方：三、单偶数阶幻方（斯特拉兹法）所谓单偶阶幻方就是当n不可以被4整除时的偶阶幻方，即4K+2阶幻方。
如(n=6，10，14……)的幻方。
单偶数阶幻方最经典的填法是斯特拉兹法。
填写的方法是：以10阶幻方为例。
这时，k=2。
（1）把魔方阵分为A，B，C，D四个象限，这样每一个象限肯定是奇数阶。
用罗伯法，依次在A象限，D象限，B象限，C象限按奇数阶幻方的填法填数。
（2）在A象限的中间行、中间格开始，按自左向右的方向，标出k格。
A象限的其它行则标出最左边的k格。
将这些格，和C象限相对位置上的数互换位置。
（3）在B象限所有行的中间格，自右向左，标出k－1格。
(注：6阶幻方由于k－1=0，所以不用再作B、D象限的数据交换)，将这些格，和D象限相对位置上的数互换位置。
四、源代码如下，已加详细注释#include<stdio.h>#include<stdlib.h>int array[15][15];intinit(int degree) //初始化{inti;int j;for(i=0; i<=degree+1; i++)for(j=0; j<=degree+1; j++)array[i][j] = 0;return 0;}inttest_print(int x, int y, int w, int h) //测试用的，输出以（x，y）为原点，宽为w，高为h，这个区域的数值{inti;int j;for(i=y; i<=y+h-1; i++){for(j=x; j<=x+w-1; j++){printf("%2d ",array[i][j]);}printf("\n");}return 0;}intlao_bo_er(int degree, int x, int y, intnum) //劳伯法{inti;int j;int k;i = y;j = degree/2 + x;for(k=num; k<=num+degree*degree-1; k++){array[i][j] = k;if((k-num+1)%degree == 0){ //如果这个数所要放的格已经有数填入i = (i-y+1)%degree+y;}else{ //每一个数放在前一个数的右上一格i = (i-y-1+degree)%degree+y;j = (j-x+1)%degree+x;}}return 0;}intseq_range(int degree) //把数字按顺序填{inti;int j;intnum;num = 1;for(i=1; i<=degree; i++){for(j=1; j<=degree; j++){array[i][j] = num++;}}return 0;}intsi_te_la_zi(int degree, int x, int y, intnum) //斯特拉兹法{intdeg;int k;int temp;inti;int j;deg = degree/2;lao_bo_er(deg, x, y, num); //用罗伯法，依次在A象限，D象限，B象限，C象限按奇数阶幻方的填法填数lao_bo_er(deg, x+deg, y, num+2*deg*deg);lao_bo_er(deg, x, y+deg, num+3*deg*deg);lao_bo_er(deg, x+deg, y+deg, num+deg*deg);k = (degree-2)/4;for(i=1; i<=deg; i++){ //A象限和C象限对换数据for(j=1; j<=k; j++){temp = array[i][j];array[i][j] = array[i+deg][j];array[i+deg][j]=temp;}for(j=deg+deg/2+1; j>=deg+deg/2-k+3; j--){temp = array[i][j];array[i][j] = array[i+deg][j];array[i+deg][j]=temp;}}for(i=j=1; j<=deg/2+k; j++){ //B象限和D象限对换数据temp = array[i+deg/2][j];array[i+deg/2][j] = array[i+deg+deg/2][j];array[i+deg+deg/2][j]=temp;}return 0;}inthai_er_fa(int degree) //海尔法{inti;int j;int complement;intdeg;seq_range(degree);complement = degree*degree+1;deg = degree/4;for(i=0; i<deg; i++){for(j=0; j<deg; j++){ //对角线上的数字换成和它互补的数array[i*4+1][j*4+1] = complement -array[i*4+1][j*4+1];array[i*4+1][j*4+4] = complement -array[i*4+1][j*4+4];array[i*4+4][j*4+1] = complement -array[i*4+4][j*4+1];array[i*4+4][j*4+4] = complement -array[i*4+4][j*4+4];array[i*4+2][j*4+2] = complement -array[i*4+2][j*4+2];array[i*4+2][j*4+3] = complement -array[i*4+2][j*4+3];array[i*4+3][j*4+2] = complement -array[i*4+3][j*4+2];array[i*4+3][j*4+3] = complement -array[i*4+3][j*4+3];}}return 0;}int main(){int degree;printf("please input the degree\n");scanf("%d",°ree);init(degree);if(degree%2 == 1){ //奇数阶幻方lao_bo_er(degree,1,1,1);test_print(1,1,degree,degree);}else if(degree%4 == 2){ //双偶阶幻方si_te_la_zi(degree, 1, 1, 1);test_print(1,1,degree,degree);}else{ //单偶阶幻方hai_er_fa(degree);test_print(1,1,degree,degree);}return 0;}。
输出魔方阵
for(j=0;j<n;j++)a[n][i]+=a[j][i];
for(i=0;i<n;i++)a[n][n]+=a[i][i];//主对角线的和
}
void main()
{
int n;
int a[M][M]={0};
printf("魔方阵的阶数n=");//n为大于2的任意整数
}
}
//三、当n为单偶数(n=4k+2)时，可把方阵分为4个2k+1的小方阵，编号如下：
//1.各小方阵按奇数阶算法依次填入A(1…[2k+1]2)、B([2k+1]2+1…2[2k+1]2)、C(…)、D(…4[2k+1]2)；
//2.将A与D换：A中间格始向右取k格；A最左边的k列(除中行)；
//3.将C与B互换：从C的中间列开始向左数k-1列。
MagicOdd(a,0,m,2*m*m+1,m);//C阵(右上)
MagicOdd(a,m,0,3*m*m+1,m);//D阵(左下)
for(j=k;j<m-1;j++){//从A的中间格开始向右数k格...
t=a[k][j];
a[k][j]=a[k+m][j];//...与D对应位置交换
a[k+m][j]=t;
}
void MagicSev(int a[M][M],int st,int n)//单偶4k+2阶魔方阵,起始数st
{
int m=n/2,k=m/2;//将原矩阵分为2×2的方阵
【C语言】魔方阵
【C语⾔】魔⽅阵打印魔⽅阵，所谓魔⽅阵是指这样的⽅阵，它的每⼀⾏、每⼀列和对⾓线之和均相等。
例如，三阶魔⽅阵为： 8 1 63 5 74 9 2要求打印出由1到n2的⾃然数构成的魔⽅阵（n为奇数）。
魔⽅阵中各数的排列规律如下：（1）将1放在第⼀⾏中间⼀列；（2）从2开始直到n×n，各数依次按下列规律存放：每⼀个数存放的⾏⽐前⼀个数的⾏数减1，列数加1；（3）如果上⼀个数的⾏数为1，则下⼀个数的⾏数为n（指最下⼀⾏）；（4）当上⼀个数的列数为n时，下⼀个数的列数应为1，⾏数减1；（5）如果按上⾯规则确定的位置上已有数，或上⼀个数是第1⾏第n列时，则把下⼀个数放在上⼀个数的下⾯。
**输⼊数据格式："%d"**输出格式要求："%3d"程序的运⾏⽰例如下：请输⼊n（0<n<=15，n是奇数）：5矩阵阶数是：517 24 1 8 1523 5 7 14 164 6 13 20 2210 12 19 21 311 18 25 2 91 #include<stdio.h>23int main() {4int a[15][15],i=0,j=0,k=0,p=0,n=0;5 p=1;6while(p==1) {7 printf("请输⼊n（0<n<=15，n是奇数）：\n");8 scanf("%d",&n);9if ((n>=0) && (n<=15) && (n%2!=0))10 p=0;11 }12 printf("矩阵阶数是：%d\n",n);13for(i=1; i<=n; i++) { //初始化操作14for(j=1; j<=n; j++)15 a[i][j]=0;16 }17 j=n/2+1;18 a[1][j]=1;19for(k=2; k<=n*n; k++) {20 i=i-1;21 j=j+1;22if((i<1)&&(j>n)) {23 i=i+2;24 j=j-1;25 } else {26if(i<1)27 i=n;28if(j>n)29 j=1;30 }31if(a[i][j]==0) {32 a[i][j]=k;33 } else {34 i=i+2;35 j=j-1;36 a[i][j]=k;37 }38 }39for (i=1; i<=n; i++) {40int sum=0;41for (j=1; j<=n; j++) {42 printf("%3d",a[i][j]);43 sum+=a[i][j];44 }45 printf("\n");46 }47 printf("\n\n");48return0;49 }。
魔方阵 实验报告
<< 魔方阵>>实验报告一．实验目的1.设计数据结构；2.设计算法完成任意n阶魔方阵的填数；3.分析算法的时间复杂度。
二．实验内容魔方阵，又叫幻方阵，在我国古代称为“纵横图”。
它是在一个n*n的矩阵中填入1到n*n的数字(n为奇数)，使得每一行，每一列，每条对角线的累加和都相等。
三．程序代码源程序：#include<iostream.h>void Square(int n){ int a[9][9];int p=0, q=(n-1)/2;a[0][q]=1; //在第0行的中间位置填1for (int i=2; i<=n*n; i++){p=(p-1+n) % n; //求i所在行号q=(q-1+n) % n; //求i所在列号if (a[p][q]>0){p=(p+2)%n; q=(q+1)%n; //这两句进行了修改，否者得不到正确的答案，切记切记！！！！}//如果位置(p, q)已经有数，填入同一列下一行a[p][q]=i;}for(p=0; p<n; p++ ){for(q=0; q<n;q++)cout<<a[p][q]<<" ";cout<<'\n';}}void main(){int n;cout<<"请输入魔方矩阵的阶数n=(n为奇数且<=9):";cin>>n;cout<<"魔方阵的排列结果为：\n";Square(n);}四．结果与心得体会1.程序的测试结果是什么?答：n=3时n=5时2.在调试的过程中遇到了什么问题,是如何解决的？答：在调试的过程中遇到了以下几个问题：1.Square函数的形式参数不可以是（int a[][], int n）,因为程序是在编译时就会为数组分配内存，而那样的形式参数是不合理的。
三阶魔方还原C语言程序
三阶魔方还原C语言程序//魔方程序#include<stdio.h>#include<stdlib.h>#include<string.h>#include<conio.h>//数据结构：typedef enum colors{blue=1,red,yellow,green,white,orange}Colors;//6种颜色typedef struct surface{Colors s[4][4];}Surface;//每个面有3*3个小格，从下标1开始表示，每一面的颜色是固定的typedef struct cube{Surface up,down,front,back,left,right;}Cube;//魔方的6个面typedef struct snode{char *chbuf;int times;struct snode *next;}SNode;typedef struct sequence{SNode *head;//存储魔方转换序列int num;//魔方转换的次数}Sequence;Sequence CD;//程序：void SaveChBuf(char *sur,int i)//将cb序列存入chbuf中{char *str;int len=strlen(sur);SNode *p,*q;if(i%4){str=(char *)malloc(sizeof(char)*(len+2));if(!str){printf("内存不足!\n");exit(0);}strcpy(str,sur);q=(SNode *)malloc(sizeof(SNode));if(!q){printf("内存不足!\n");exit(0);}q->chbuf=str;q->times=i;q->next=NULL;if(CD.head==NULL){CD.head=q;CD.num++;}else{for(p=CD.head;p->next;p=p->next);if(!strcmp(p->chbuf,q->chbuf)){p->times=(p->times+q->times)%4; free(q->chbuf);free(q);if(!(p->times)){if(p==CD.head){CD.head=NULL;free(p->chbuf);free(p);CD.num--;}else{for(q=CD.head;q->next!=p;q=q->next); q->next=NULL;free(p->chbuf);free(p);CD.num--;}}}else{p->next=q;CD.num++;}}}}void clockwise(Surface *sur,int i)//将sur面顺时针旋转i次{Surface t;for(;i>0;i--){t=*sur;sur->s[1][1]=t.s[3][1];sur->s[1][2]=t.s[2][1];sur->s[1][3]=t.s[1][1];sur->s[2][1]=t.s[3][2];sur->s[2][2]=t.s[2][2];sur->s[2][3]=t.s[1][2];sur->s[3][1]=t.s[3][3];sur->s[3][2]=t.s[2][3];sur->s[3][3]=t.s[1][3];}}void F(Cube *m,int i)//将魔方的正面顺时针转i次{Cube n;for(;i>0;i--){n=*m;clockwise(&m->front,1);m->right.s[1][1]=n.up.s[3][1];m->right.s[2][1]=n.up.s[3][2];m->right.s[3][1]=n.up.s[3][3];m->down.s[1][1]=n.right.s[3][1];m->down.s[1][2]=n.right.s[2][1];m->down.s[1][3]=n.right.s[1][1];m->left.s[1][3]=n.down.s[1][1];m->left.s[2][3]=n.down.s[1][2];m->left.s[3][3]=n.down.s[1][3];m->up.s[3][1]=n.left.s[3][3];m->up.s[3][2]=n.left.s[2][3];m->up.s[3][3]=n.left.s[1][3];}}void B(Cube *m,int i)//将魔方的背面顺时针转i次{Cube n;for(;i>0;i--){n=*m;clockwise(&m->back,1);m->right.s[1][3]=n.down.s[3][3];m->right.s[2][3]=n.down.s[3][2];m->right.s[3][3]=n.down.s[3][1];m->down.s[3][2]=n.left.s[2][1];m->down.s[3][3]=n.left.s[3][1];m->left.s[1][1]=n.up.s[1][3];m->left.s[2][1]=n.up.s[1][2];m->left.s[3][1]=n.up.s[1][1];m->up.s[1][1]=n.right.s[1][3];m->up.s[1][2]=n.right.s[2][3];m->up.s[1][3]=n.right.s[3][3];}}void R(Cube *m,int i)//将魔方的右面顺时针转i次{Cube n;for(;i>0;i--){n=*m;clockwise(&m->right,1);m->up.s[1][3]=n.front.s[1][3];m->up.s[2][3]=n.front.s[2][3];m->up.s[3][3]=n.front.s[3][3];m->front.s[1][3]=n.down.s[1][3];m->front.s[2][3]=n.down.s[2][3];m->front.s[3][3]=n.down.s[3][3];m->down.s[1][3]=n.back.s[3][1];m->down.s[2][3]=n.back.s[2][1];m->down.s[3][3]=n.back.s[1][1];m->back.s[2][1]=n.up.s[2][3];m->back.s[1][1]=n.up.s[3][3];}}void L(Cube *m,int i)//将魔方的左面顺时针转i次{Cube n;for(;i>0;i--){n=*m;clockwise(&m->left,1);m->up.s[1][1]=n.back.s[3][3];m->up.s[2][1]=n.back.s[2][3];m->up.s[3][1]=n.back.s[1][3];m->back.s[1][3]=n.down.s[3][1];m->back.s[2][3]=n.down.s[2][1];m->back.s[3][3]=n.down.s[1][1];m->down.s[1][1]=n.front.s[1][1];m->down.s[2][1]=n.front.s[2][1];m->down.s[3][1]=n.front.s[3][1];m->front.s[1][1]=n.up.s[1][1];m->front.s[2][1]=n.up.s[2][1];m->front.s[3][1]=n.up.s[3][1];}}void U(Cube *m,int i)//将魔方的上面顺时针转i次{Cube n;for(;i>0;i--){n=*m;clockwise(&m->up,1);m->front.s[1][1]=n.right.s[1][1];m->front.s[1][2]=n.right.s[1][2];m->front.s[1][3]=n.right.s[1][3];m->right.s[1][1]=n.back.s[1][1];m->right.s[1][2]=n.back.s[1][2];m->right.s[1][3]=n.back.s[1][3];m->back.s[1][1]=n.left.s[1][1];m->back.s[1][2]=n.left.s[1][2];m->back.s[1][3]=n.left.s[1][3];m->left.s[1][1]=n.front.s[1][1];m->left.s[1][2]=n.front.s[1][2];m->left.s[1][3]=n.front.s[1][3];}}void D(Cube *m,int i)//将魔方的底面顺时针转i次{Cube n;for(;i>0;i--){n=*m;clockwise(&m->down,1);m->front.s[3][1]=n.left.s[3][1];m->front.s[3][2]=n.left.s[3][2];m->front.s[3][3]=n.left.s[3][3];m->left.s[3][1]=n.back.s[3][1];m->left.s[3][2]=n.back.s[3][2];m->left.s[3][3]=n.back.s[3][3];m->back.s[3][1]=n.right.s[3][1];m->back.s[3][2]=n.right.s[3][2];m->back.s[3][3]=n.right.s[3][3];m->right.s[3][1]=n.front.s[3][1];m->right.s[3][2]=n.front.s[3][2];m->right.s[3][3]=n.front.s[3][3];}}void MR(Cube *m,int i)//将魔方的左面和右面之间的面以右面为基准顺时针旋转1次{Cube n;for(;i>0;i--){n=*m;m->up.s[1][2]=n.front.s[1][2];m->up.s[2][2]=n.front.s[2][2];m->up.s[3][2]=n.front.s[3][2];m->front.s[1][2]=n.down.s[1][2];m->front.s[2][2]=n.down.s[2][2];m->front.s[3][2]=n.down.s[3][2];m->down.s[1][2]=n.back.s[3][2];m->down.s[2][2]=n.back.s[2][2];m->down.s[3][2]=n.back.s[1][2];m->back.s[3][2]=n.up.s[1][2];m->back.s[2][2]=n.up.s[2][2];m->back.s[1][2]=n.up.s[3][2];}}void MF(Cube *m,int i)//将魔方的前面和后面之间的面以前面为基准顺时针旋转i次{Cube n;for(;i>0;i--){n=*m;m->right.s[1][2]=n.up.s[2][1];m->right.s[2][2]=n.up.s[2][2];m->right.s[3][2]=n.up.s[2][3];m->up.s[2][1]=n.left.s[3][2];m->up.s[2][2]=n.left.s[2][2];m->up.s[2][3]=n.left.s[1][2];m->left.s[1][2]=n.down.s[2][1];m->left.s[2][2]=n.down.s[2][2];m->left.s[3][2]=n.down.s[2][3];m->down.s[2][1]=n.right.s[3][2];m->down.s[2][2]=n.right.s[2][2];m->down.s[2][3]=n.right.s[1][2];}}void MU(Cube *m,int i)//将魔方的上面和底面之间的面以上面为基准顺时针旋转i次{Cube n;for(;i>0;i--){n=*m;m->front.s[2][1]=n.right.s[2][1];m->front.s[2][2]=n.right.s[2][2];m->front.s[2][3]=n.right.s[2][3];m->right.s[2][1]=n.back.s[2][1];m->right.s[2][2]=n.back.s[2][2];m->right.s[2][3]=n.back.s[2][3];m->back.s[2][1]=n.left.s[2][1];m->back.s[2][2]=n.left.s[2][2];m->back.s[2][3]=n.left.s[2][3];m->left.s[2][1]=n.front.s[2][1];m->left.s[2][2]=n.front.s[2][2];m->left.s[2][3]=n.front.s[2][3];}}void MoveCube(Cube *m,char *sur,int i)//根据序列cb转换魔方m{SaveChBuf(sur,i);//将魔方转换序列存入chbuf中if(!strcmp(sur,"f"))F(m,i);//将魔方的正面顺时针旋转i次if(!strcmp(sur,"b"))B(m,i);//将魔方的背面顺时针旋转i次if(!strcmp(sur,"r"))R(m,i);//将魔方的右面顺时针旋转i次if(!strcmp(sur,"l"))L(m,i);//将魔方的左面顺时针旋转i次if(!strcmp(sur,"u"))U(m,i);//将魔方的上面顺时针旋转i次if(!strcmp(sur,"d"))D(m,i);//将魔方的底面顺时针旋转i次if(!strcmp(sur,"mr"))MR(m,i);//将魔方的左面和右面之间的面以右面为基准顺时针旋转i次if(!strcmp(sur,"mf"))MF(m,i);//将魔方的前面和后面之间的面以前面为基准顺时针旋转i次if(!strcmp(sur,"mu"))MU(m,i);//将魔方的上面和底面之间的面以上面为基准顺时针旋转i次}void InputSurface(Surface *sur){int i,j,a;for(i=1;i<=3;i++)for(j=1;j<=3;j++){scanf("%d",&a);sur->s[i][j]=(Colors)a;}}void Input(Cube *magiccube)//存储魔方{printf("Input the colors of the Magiccube:\n");printf("Blue--------1\tRed---------2\tYellow------3\n");printf("Green-------4\tWhite-------5\tOrange------6\n\n");printf("Input the colors of Up:\n");InputSurface(&(magiccube->up));//储存顶面printf("Input the colors of Down:\n");InputSurface(&(magiccube->down));//储存底面printf("Input the colors of Front:\n");InputSurface(&(magiccube->front));//储存前面printf("Input the colors of Back:\n");InputSurface(&(magiccube->back));//储存后面printf("Input the colors of Left:\n");InputSurface(&(magiccube->left));//储存左面printf("Input the colors of Right:\n");InputSurface(&(magiccube->right));//储存右面}void DownCross(Cube *magiccube)//将底面拼出一个十字{while(!((magiccube->down.s[1][2]==magiccube->down.s[2][2]&&magiccube->front.s[3][2]==magi ccube->front.s[2][2])&&(magiccube->down.s[2][1]==magiccube->down.s[2][2] &&magiccube->left.s[3][2]==magiccube->left.s[2][2]) &&(magiccube->down.s[2][3]==magiccube->down.s[2][2] &&magiccube->right.s[3][2]==magiccube->right.s[2][2]) &&(magiccube->down.s[3][2]==magiccube->down.s[2][2] &&magiccube->back.s[3][2]==magiccube->back.s[2][2]))) {Surface*sur[4]={&magiccube->front,&magiccube->left,&magiccube-> back,&magiccube->right};char *s[4]={"f","l","b","r"};int subscript_of_down[4][2]={{1,2},{2,1},{3,2},{2,3}};int subscript_of_up[4][2]={{3,2},{2,1},{1,2},{2,3}};char ch[3];int n;for(int i=0;i<4;i++){if(magiccube->down.s[subscript_of_down[i][0]][subscript_of _down[i][1]]==magiccube->down.s[2][2]&&sur[i]->s[3][2]!=sur[i]->s[2][2]){strcpy(ch,s[i]);MoveCube(magiccube,ch,2);}//底面棱块为底面色位置不对if(magiccube->up.s[subscript_of_up[i][0]][subscript_of_up[i][ 1]]==magiccube->down.s[2][2]){n=0;while(sur[(i+n)%4]->s[2][2]!=sur[(i+n)%4]->s[1][2]){MoveCube(magiccube,"u",1);n++;}strcpy(ch,s[(i+n)%4]);MoveCube(magiccube,ch,2);}//以上是底面棱块在顶面的情况if(sur[i]->s[1][2]==magiccube->down.s[2][2])//侧面上棱是底面色的情况{n=0;while(sur[(i+n+1)%4]->s[2][2]!=magiccube->up.s[subscript_ of_up[(i+n)%4][0]][subscript_of_up[(i+n)%4][1]]){MoveCube(magiccube,"u",1);n++;}strcpy(ch,s[(i+n)%4]);MoveCube(magiccube,ch,3);strcpy(ch,s[(n+1+i)%4]);MoveCube(magiccube,ch,1);strcpy(ch,s[(i+n)%4]);MoveCube(magiccube,ch,1);}if(sur[i]->s[2][1]==magiccube->down.s[2][2])//侧面左棱是底面色的情况{strcpy(ch,s[(i+1)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);}if(sur[i]->s[2][3]==magiccube->down.s[2][2])//侧面右棱是底面色的情况{strcpy(ch,s[(i+3)%4]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);}if(sur[i]->s[3][2]==magiccube->down.s[2][2])//侧面底棱是底面色的情况{strcpy(ch,s[i]);MoveCube(magiccube,ch,1);strcpy(ch,s[(i+1)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);strcpy(ch,s[i]);MoveCube(magiccube,ch,3);}//以上是侧面棱块色是底面色的情况}}}void DownCornerRestore(Cube *magiccube)//底角还原{while(!((magiccube->down.s[1][1]==magiccube->down.s[2] [2]&&magiccube->front.s[3][1]==magiccube->front.s[2][2]&& magiccube->left.s[3][3]==magiccube->left.s[2][2])&&(magiccube->down.s[1][3]==magiccube->down.s[2][2] &&magiccube->front.s[3][3]==magiccube->front.s[2][2]&&ma giccube->right.s[3][1]==magiccube->right.s[2][2])&&(magiccube->down.s[3][1]==magiccube->down.s[2][2] &&magiccube->right.s[3][1]==magiccube->right.s[2][2]&&magiccube->back.s[3][3]==magiccube->back.s[2][2])&&(magiccube->down.s[3][3]==magiccube->down.s[2][2] &&magiccube->back.s[3][1]==magiccube->back.s[2][2]&&ma giccube->right.s[3][3]==magiccube->right.s[2][2])))//直到底角全部归位{Surface*sur[4]={&magiccube->front,&magiccube->left,&magiccube-> back,&magiccube->right};char *s[4]={"f","l","b","r"};int subscript_of_down[4][2]={{1,1},{3,1},{3,3},{1,3}};int subscript_of_up[4][2]={{3,1},{1,1},{1,3},{3,3}};char ch[3];int n;for(int i=0;i<4;i++){if(magiccube->down.s[subscript_of_down[i][0]][subscript_of _down[i][1]]==magiccube->down.s[2][2]&&(sur[i]->s[3][1]!=sur[i]->s[2][2]||sur[(i+1)%4]->s[3][3]!=sur[(i +1)%4]->s[2][2])){strcpy(ch,s[i]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);}//底面角块颜色归位但是位置不对if(magiccube->up.s[subscript_of_up[i][0]][subscript_of_up[i][ 1]]==magiccube->down.s[2][2]){n=0;while(sur[(i+n)%4]->s[1][1]!=sur[(i+n+1)%4]->s[2][2]){MoveCube(magiccube,"u",1);n++;}strcpy(ch,s[(i+n)%4]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",2);}//顶面有底角色块的情况if(sur[i]->s[1][1]==magiccube->down.s[2][2])//侧面左上角是底面色的情况{n=0;while(sur[(i+n+1)%4]->s[2][2]!=sur[(i+n+1)%4]->s[1][3]){MoveCube(magiccube,"u",1);n++;}strcpy(ch,s[(n+i)%4]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);}if(sur[i]->s[1][3]==magiccube->down.s[2][2])//侧面右上角是底面色的情况{n=0;while(sur[(i+n+3)%4]->s[2][2]!=sur[(i+n+3)%4]->s[1][1])MoveCube(magiccube,"u",1);n++;}strcpy(ch,s[(n+i)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,1);}if(sur[i]->s[3][1]==magiccube->down.s[2][2])//侧面左下角是底面色的情况{strcpy(ch,s[i]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);}if(sur[i]->s[3][3]==magiccube->down.s[2][2])//侧面右下角是底面色的情况{strcpy(ch,s[i]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,1);}//侧面有底面色块}}}void CentreEdgeRestore(Cube *magiccube)//中棱归位while(!((magiccube->front.s[2][1]==magiccube->front.s[2][ 2]&&magiccube->front.s[2][3]==magiccube->front.s[2][2]) &&(magiccube->left.s[2][1]==magiccube->left.s[2][2]&&m agiccube->left.s[2][3]==magiccube->left.s[2][2])&&(magiccube->back.s[2][1]==magiccube->back.s[2][2]& &magiccube->back.s[2][3]==magiccube->back.s[2][2]) &&(magiccube->right.s[2][1]==magiccube->right.s[2][2]& &magiccube->right.s[2][3]==magiccube->right.s[2][2]))){Surface*sur[4]={&magiccube->front,&magiccube->left,&magiccube-> back,&magiccube->right};char *s[4]={"f","l","b","r"};int subscript_of_up[4][2]={{3,2},{2,1},{1,2},{2,3}};char ch[3];int n;for(int i=0;i<4;i++){if(!(sur[i]->s[2][1]==sur[i]->s[2][2]&&sur[(i+1)%4]->s[2][3]= =sur[(i+1)%4]->s[2][2])&&(sur[i]->s[2][1]!=magiccube->up.s[2][2]&&sur[(i+1)%4]->s[2][3]!=magiccube->up.s[2][2])){strcpy(ch,s[i]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",2);}if(sur[i]->s[1][2]!=magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[i][0]][subscript_of_up[ i][1]]!=magiccube->up.s[2][2]){n=0;while(sur[(i+n)%4]->s[1][2]!=sur[(i+n)%4]->s[2][2]){n++;MoveCube(magiccube,"u",1);}if(magiccube->up.s[subscript_of_up[(i+n)%4][0]][subscript_ of_up[(i+n)%4][1]]==sur[(i+n+3)%4]->s[2][2]){strcpy(ch,s[(i+n)%4]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);}if(magiccube->up.s[subscript_of_up[(i+n)%4][0]][subscript_ of_up[(i+n)%4][1]]==sur[(i+n+1)%4]->s[2][2]){strcpy(ch,s[(i+n)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);}}}}}void UpCross(Cube *magiccube)//顶面十字{while(!(magiccube->up.s[1][2]==magiccube->up.s[2][2]&& magiccube->up.s[2][1]==magiccube->up.s[2][2]&&magiccube->up.s[2][3]==magiccube->up.s[2][2]&&ma giccube->up.s[3][2]==magiccube->up.s[2][2])){Surface*sur[4]={&magiccube->front,&magiccube->left,&magiccube->back,&magiccube->right};char *s[4]={"f","l","b","r"};int subscript_of_up[4][2]={{3,2},{2,1},{1,2},{2,3}};char ch[3];if(magiccube->up.s[1][2]!=magiccube->up.s[2][2]&&magic cube->up.s[2][1]!=magiccube->up.s[2][2]&&magiccube->up.s[2][3]!=magiccube->up.s[2][2]&&magi ccube->up.s[3][2]!=magiccube->up.s[2][2]){MoveCube(magiccube,"f",1);MoveCube(magiccube,"r",1);MoveCube(magiccube,"u",1);MoveCube(magiccube,"r",3);MoveCube(magiccube,"u",3);MoveCube(magiccube,"f",3);}for(int i=0;i<4;i++){if(magiccube->up.s[subscript_of_up[(i+1)%4][0]][subscript_ of_up[(i+1)%4][1]]==magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+2)%4][0]][subscript _of_up[(i+2)%4][1]]==magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[i][0]][subscript_of_up[ i][1]]!=magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+3)%4][0]][subscript _of_up[(i+3)%4][1]]!=magiccube->up.s[2][2]){//形成一个倒"L"strcpy(ch,s[i]);MoveCube(magiccube,ch,1);strcpy(ch,s[(i+3)%4]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);strcpy(ch,s[i]);MoveCube(magiccube,ch,3);}if(magiccube->up.s[subscript_of_up[(i+1)%4][0]][subscript_ of_up[(i+1)%4][1]]==magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+3)%4][0]][subscript _of_up[(i+3)%4][1]]==magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[i][0]][subscript_of_up[ i][1]]!=magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+2)%4][0]][subscript _of_up[(i+2)%4][1]]!=magiccube->up.s[2][2]){//形成一个横"一"strcpy(ch,s[i]);MoveCube(magiccube,ch,1);strcpy(ch,s[(i+3)%4]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);strcpy(ch,s[i]);MoveCube(magiccube,ch,3);}}}}void UpSurfaceCornerRestore(Cube *magiccube)//顶角面位{while(!(magiccube->up.s[1][1]==magiccube->up.s[2][2]&& magiccube->up.s[1][3]==magiccube->up.s[2][2]&&magiccube->up.s[3][1]==magiccube->up.s[2][2]&&ma giccube->up.s[3][3]==magiccube->up.s[2][2])){Surface*sur[4]={&magiccube->front,&magiccube->left,&magiccube-> back,&magiccube->right};char *s[4]={"f","l","b","r"};int subscript_of_up[4][2]={{3,1},{1,1},{1,3},{3,3}};char ch[3];int n;for(int i=0;i<4;i++){if((magiccube->up.s[1][1]!=magiccube->up.s[2][2]&&magic cube->up.s[1][3]!=magiccube->up.s[2][2]&&magiccube->up.s[3][1]!=magiccube->up.s[2][2]&&magi ccube->up.s[3][3]!=magiccube->up.s[2][2])&&(sur[i]->s[1][1]==magiccube->up.s[2][2]&&sur[i]->s[1][ 3]==magiccube->up.s[2][2])){//十字型（前左右与上同色）n=0;while(sur[(i+n)%4]->s[1][2]!=sur[(i+n)%4]->s[2][2]){MoveCube(magiccube,"u",1);n++;strcpy(ch,s[(i+n+3)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",2);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);}if(magiccube->up.s[subscript_of_up[(i+3)%4][0]][subscript_ of_up[(i+3)%4][1]]==magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[i][0]][subscript_of_up[ i][1]]!=magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+1)%4][0]][subscript _of_up[(i+1)%4][1]]!=magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+2)%4][0]][subscript _of_up[(i+2)%4][1]]!=magiccube->up.s[2][2]){//鱼头朝右下的鱼if(sur[i]->s[1][1]!=magiccube->up.s[2][2])//前左与上异色{strcpy(ch,s[(i+3)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",2);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);else//前左与上同色{MoveCube(magiccube,"u",3);strcpy(ch,s[(i+3)%4]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",2);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);}}if(magiccube->up.s[subscript_of_up[(i+1)%4][0]][subscript_ of_up[(i+1)%4][1]]==magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[i][0]][subscript_of_up[ i][1]]!=magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+3)%4][0]][subscript _of_up[(i+3)%4][1]]!=magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+2)%4][0]][subscript _of_up[(i+2)%4][1]]==magiccube->up.s[2][2]){//大炮型if(sur[i]->s[1][1]==magiccube->up.s[2][2]&&sur[i]->s[1][3] ==magiccube->up.s[2][2]){//前左右与上同色strcpy(ch,s[(i+1)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",2);MoveCube(magiccube,ch,1);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);}else{//前左右与上异色strcpy(ch,s[(i+2)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",2);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);}}if(magiccube->up.s[subscript_of_up[(i+3)%4][0]][subscript_ of_up[(i+3)%4][1]]==magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[i][0]][subscript_of_up[ i][1]]!=magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+1)%4][0]][subscript _of_up[(i+1)%4][1]]==magiccube->up.s[2][2]&&magiccube->up.s[subscript_of_up[(i+2)%4][0]][subscript _of_up[(i+2)%4][1]]!=magiccube->up.s[2][2]){//双凌型MoveCube(magiccube,"u",3);strcpy(ch,s[(i+3)%4]);MoveCube(magiccube,ch,3);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);}}}}void UpCornerRestore(Cube *magiccube)//顶角还原{while(magiccube->front.s[1][1]!=magiccube->front.s[2][2]) MoveCube(magiccube,"u",1);while(!((magiccube->front.s[1][1]==magiccube->front.s[2][ 2]&&magiccube->front.s[1][3]==magiccube->front.s[2][2]) &&(magiccube->left.s[1][1]==magiccube->left.s[2][2]&&m agiccube->left.s[1][3]==magiccube->left.s[2][2])&&(magiccube->back.s[1][1]==magiccube->back.s[2][2]& &magiccube->back.s[1][3]==magiccube->back.s[2][2]) &&(magiccube->right.s[1][1]==magiccube->right.s[2][2]& &magiccube->right.s[1][3]==magiccube->right.s[2][2]))) {Surface *sur[4]={&magiccube->front,&magiccube->left,&magiccube-> back,&magiccube->right};char *s[4]={"f","l","b","r"};int n;char ch[3];for(int i=0;i<4;i++){n=0;if(sur[i]->s[1][1]==sur[i]->s[1][3]){while(sur[(i+n)%4]->s[1][1]!=sur[(i+n)%4]->s[2][2]) {MoveCube(magiccube,"u",1);n++;}break;}}strcpy(ch,s[(i+n+3)%4]);MoveCube(magiccube,ch,1);strcpy(ch,s[(i+n+2)%4]);MoveCube(magiccube,ch,3);strcpy(ch,s[(i+n+3)%4]);MoveCube(magiccube,ch,1);strcpy(ch,s[(i+n)%4]);MoveCube(magiccube,ch,2);strcpy(ch,s[(i+n+3)%4]);MoveCube(magiccube,ch,3);strcpy(ch,s[(i+n+2)%4]);MoveCube(magiccube,ch,1);strcpy(ch,s[(i+n+3)%4]);MoveCube(magiccube,ch,1);strcpy(ch,s[(i+n)%4]);MoveCube(magiccube,ch,2);strcpy(ch,s[(i+n+3)%4]);MoveCube(magiccube,ch,2);while(magiccube->front.s[1][1]!=magiccube->front.s[2][2]) MoveCube(magiccube,"u",1);}}void UpEdgeRestore(Cube *magiccube)//顶棱还原{while(magiccube->front.s[1][1]!=magiccube->front.s[2][2]) MoveCube(magiccube,"u",1);while(!(magiccube->front.s[1][2]==magiccube->front.s[2][2 ]&&magiccube->left.s[1][2]==magiccube->left.s[2][2] &&magiccube->back.s[1][2]==magiccube->back.s[2][2]&& magiccube->right.s[1][2]==magiccube->right.s[2][2])) {Surface *sur[4]={&magiccube->front,&magiccube->left,&magiccube->back,&magiccube->rig ht};char *s[4]={"f","l","b","r"};int n;char ch[3];for(int i=0;i<4;i++){n=0;if(sur[i]->s[1][1]==sur[i]->s[1][2]&&sur[i]->s[1][2]==sur[i]->s[1][3]){while(sur[(i+n)%4]->s[1][1]!=sur[(i+n)%4]->s[2][2]){MoveCube(magiccube,"u",1);n++;}break;}}strcpy(ch,s[(i+n+1)%4]);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",1);MoveCube(magiccube,ch,1);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,3);MoveCube(magiccube,"u",3);MoveCube(magiccube,ch,2);while(magiccube->front.s[1][1]!=magiccube->front.s[2][2]) MoveCube(magiccube,"u",1);}}void printsurface(Surface sur)//输出某一面的颜色{int i,j;for(i=1;i<=3;i++){for(j=1;j<=3;j++)printf("%d ",(int)sur.s[i][j]);printf("\n");}void PrintMagicCube(Cube m){printf("\nThe Colors of Up:\n");printsurface(m.up);printf("\nThe Colors of Down:\n");printsurface(m.down);printf("\nThe Colors of Front:\n");printsurface(m.front);printf("\nThe Colors of Back:\n");printsurface(m.back);printf("\nThe Colors of Left:\n");printsurface(m.left);printf("\nThe Colors of Right:\n");printsurface(m.right);}void PrintBuf(){SNode *p;int i;printf("The Sequence of the change of the Magiccube is:\n"); for(p=CD.head,i=1;p;p=p->next,i++){printf("%s%d\t",p->chbuf,p->times);if(i==5){putchar('\n');。
C语言实现魔方阵
C语言实现魔方阵魔方阵（Magic Square）是一个古老且有趣的数学问题，它是一个正方形矩阵，其中每行、每列以及对角线上的元素之和都相等。
例如，下面是一个3阶魔方阵：```816357492```实现魔方阵的算法有多种，下面我们将介绍一种基于C语言的实现方法。
首先，我们需要设计一个函数来检查生成的矩阵是否是魔方阵。
这个函数的输入是一个二维数组和魔方阵的阶数，输出是一个布尔值，表示输入的矩阵是否是魔方阵。
下面是这个函数的实现：```c#include <stdbool.h>bool checkMagicSquare(int **matrix, int n)int sum = n * (n * n + 1) / 2;//检查每行的和for (int i = 0; i < n; i++)for (int j = 0; j < n; j++) rowSum += matrix[i][j];}if (rowSum != sum)return false;}}//检查每列的和for (int i = 0; i < n; i++) int colSum = 0;for (int j = 0; j < n; j++) colSum += matrix[j][i];}if (colSum != sum)return false;}}//检查主对角线的和for (int i = 0; i < n; i++)diagSum += matrix[i][i];}if (diagSum != sum)return false;}//检查副对角线的和int antiDiagSum = 0;for (int i = 0; i < n; i++) antiDiagSum += matrix[i][n - 1 - i]; }if (antiDiagSum != sum)return false;}return true;```接下来，我们使用一个递归函数来生成魔方阵。
任意阶魔方阵算法(c语言)
任意阶魔方阵算法2009-03-19 11:45:00| 分类：我的文章|字号大中小订阅我一直就对魔方阵很感兴趣，特别是知道了奇数阶魔方阵的罗伯特算法后，就特别想知道偶数阶魔方阵应有什么算法。
当时书上说偶数阶魔方阵比较复杂。
都没有什么说明。
因此这个问题一直搁在我心里很久，已差不多快忘记了。
今天突然又想到了这个问题。
于是我开始在网上搜寻，看能不能找到什么好的算法。
记得在高中的时候，我就做过魔方阵，当时我从三阶一直做到过八阶方阵，不过用的是人工的方法。
到大学的时候我知道了罗伯特算法后，我就用程序将算法写了出来。
于是我今天准备把偶数阶的魔方阵也写出来。
在网上终于找到了一个比较好的算法。
将该算法用C写了出来。
供大家分亨。
1、奇数阶幻方n为奇数(n=3，5，7，9，11……) (n=2*k+1，k=1，2，3，4，5……)奇数阶幻方最经典的填法是罗伯特法(也有人称之为楼梯方)。
填写方法是这样：把1(或最小的数)放在第一行正中；按以下规律排列剩下的n*n-1个数：(1)、每一个数放在前一个数的右上一格；(2)、如果这个数所要放的格已经超出了顶行那么就把它放在底行，仍然要放在右一列；(3)、如果这个数所要放的格已经超出了最右列那么就把它放在最左列，仍然要放在上一行；(4)、如果这个数所要放的格已经超出了顶行且超出了最右列，那么就把它放在前一个数的下一行同一列的格内；(5)、如果这个数所要放的格已经有数填入，处理方法同(4)。
这种写法总是先向“右上”的方向，象是在爬楼梯。
2、双偶阶幻方n为偶数，且能被4整除(n=4，8，12，16，20……) (n=4k，k=1，2，3，4，5……)先说明一个定义：互补：如果两个数字的和，等于幻方最大数和最小数的和，即n*n+1，称为互补。
先看看4阶幻方的填法：将数字从左到右、从上到下按顺序填写：1 2 3 45 6 7 89 10 11 1213 14 15 16这个方阵的对角线，已经用蓝色标出。
C语言---魔方阵
C语⾔---魔⽅阵魔⽅阵的定义：在n*n的⽅阵中，每⼀⾏的和=每⼀列的和=对⾓线的和。
（本⽂中涉及的n为⼤于3的奇数）。
例如3*3的魔⽅阵为：5*5的魔⽅阵为：如何写魔⽅阵呢？1.数字1位于第⼀⾏的正中间2.下⼀个数放到上⼀个数的右上⾓（即上⼀⾏下⼀列），若⽆上⼀⾏则放到最后⼀⾏，若⽆下⼀列则放到第⼀列3.若新位置已经放了数，则将其放⼊该数的正下⽅（即下⼀⾏的同⼀列）C语⾔代码：1int magicMatrix() {2 printf("请输⼊你想⽣成的魔⽅阵阶数：（⼤于3的奇数）\n");3int i,c,r;4 scanf("%d",&i);5int arr[i][i];6for(int n=0; n<i; n++) {7for(int m=0; m<i; m++) {8 arr[n][m]=0;9 }10 }11 c=0;12 r=i/2;13 arr[c][r] = 1;// 魔⽅阵的第⼀⾏最中间的数为114int k=i*i;15for(int j=2; j<=k; j++) {16int h=c,l=r; //记录原来的位置17if(c==0) {18 c=i-1;19 } else {20 c=c-1;21 }22if(r==i-1) {23 r=0;24 } else {25 r=r+1;26 }27if(arr[c][r]!=0) {28 c=h+1;29 r=l;30 }31 printf("c=%d,r=%d,j=%d\n",c,r,j);32 arr[c][r]=j;33 }34 printf("\n");35for(int n=0; n<i; n++) {36for(int m=0; m<i; m++) {37 printf("%d\t",arr[n][m]);38 }39 printf("\n");40 }41 }计算下⼀个数字的位置时，如果位置已经被占，就在该数的下⼀⾏同⼀列，所以代码中每次计算要记录该数的位置。
C语言魔方阵的三种实现方法
C语⾔魔⽅阵的三种实现⽅法⽬录魔⽅阵：1.奇数阶魔⽅阵2.偶数阶魔⽅阵（n=4K)3.偶数阶魔⽅阵（n=4K+2)魔⽅阵：把1到n*n排成n⾏n列⽅阵，使⽅阵中的每⼀⾏、每⼀列以及对⾓线上的数之和都相同，即为n阶魔⽅阵。
根据魔⽅阵的规律，我将它分为三种情况。
1.奇数阶魔⽅阵规律：第⼀个数放在第⼀⾏的中间，下⼀个数放在上⼀个数的上⼀⾏下⼀列，若该位置已经有了数字即放在上个数的下⾯⼀⾏的相同列⽤C语⾔编程如下：⽰例：n=5;#include<stdio.h>#include<stdlib.h>#include<assert.h>void Magic1(){#define ROW 5#define COL ROWassert(ROW % 2 != 0); //判断n是否为奇数int arr[ROW][COL] = { 0 }; //定义⼆维数组int currow = 0;int curcol = COL / 2;arr[currow][curcol] = 1;for (int i = 2; i <= ROW * COL; i++){if (arr[(currow - 1 + ROW) % ROW][(curcol + 1) % COL] == 0) //按照规律赋值{currow = (currow - 1 + ROW) % ROW;curcol = (curcol + 1) % COL;}else{currow = (currow + 1) % ROW;}arr[currow][curcol] = i;}for (int i = 0; i < ROW; i++) //打印魔⽅阵{for (int j = 0; j < COL; j++){printf("%-3d", arr[i][j]);}printf("\n");}}int main(){Magic1();return 0;}结果：2.偶数阶魔⽅阵（n=4K)规律：按数字从⼩到⼤，即1，2，3……n顺序对魔⽅阵从左到右，从上到下进⾏填充；将魔⽅阵分成若⼲个4×4⼦⽅阵(如：8阶魔⽅阵可分成四个4×4⼦⽅阵)，将⼦⽅阵对⾓线上的元素取出；将取出的元素按从⼤到⼩的顺序依次填充到n×n⽅阵的空缺处。
c语言魔方阵课程设计
c语言魔方阵课程设计一、课程目标知识目标：1. 理解魔方阵的概念，掌握其基本性质和特点；2. 学会使用C语言实现魔方阵的生成、显示和验证；3. 掌握魔方阵相关算法，如：奇数阶魔方阵的生成方法、行列、对角线求和等；4. 了解魔方阵在实际应用中的价值，如：数学游戏、密码学等。
技能目标：1. 能够运用C语言编写程序，生成指定阶数的魔方阵；2. 能够分析魔方阵算法的时间复杂度和空间复杂度；3. 能够运用所学知识解决魔方阵相关实际问题，提高编程能力；4. 能够通过魔方阵编程实践，培养解决问题的策略和逻辑思维能力。
情感态度价值观目标：1. 培养学生对C语言编程的兴趣，激发学习热情；2. 培养学生合作探究、积极参与的精神，增强团队协作能力；3. 培养学生勇于克服困难、面对挑战的信心，提高自主学习能力；4. 引导学生认识到编程在生活中的应用价值，激发学生创新意识和实践能力。
课程性质：本课程为C语言编程实践课程，旨在让学生通过魔方阵编程实践，巩固C语言知识，提高编程能力。
学生特点：学生具备一定的C语言基础，对编程有兴趣，但可能缺乏实际编程经验。
教学要求：注重理论与实践相结合，强调动手实践，培养学生编程思维和解决问题的能力。
通过本课程的学习，使学生能够将所学知识运用到实际编程中，提高编程水平。
二、教学内容1. 魔方阵基本概念与性质- 魔方阵的定义与特点- 魔方阵的数学性质：行列、对角线求和等2. C语言编程基础回顾- 数据类型与变量- 控制结构：顺序、选择、循环- 数组的使用3. 魔方阵生成算法- 奇数阶魔方阵生成方法- 魔方阵生成程序的编写与调试4. 魔方阵显示与验证- 魔方阵的格式化输出- 验证魔方阵的正确性：行列、对角线求和检验5. 魔方阵编程实践- 编写生成指定阶数魔方阵的程序- 分析算法的时间复杂度和空间复杂度- 解决魔方阵相关实际问题6. 教学案例分析与讨论- 分析实际编程案例，总结编程技巧- 讨论编程中遇到的问题及解决方法7. 创新思维与实践- 探讨魔方阵在其他领域的应用- 鼓励学生进行创新编程实践，提高编程能力教学内容安排与进度：1. 基本概念与性质（1课时）2. C语言编程基础回顾（1课时）3. 魔方阵生成算法（2课时）4. 魔方阵显示与验证（1课时）5. 魔方阵编程实践（2课时）6. 教学案例分析与讨论（1课时）7. 创新思维与实践（1课时）教材章节关联：本教学内容与教材中关于数组、循环控制结构、函数等章节相关，通过魔方阵编程实践，使学生将所学理论知识应用于实际问题中，提高编程能力。
c语言魔方阵课程设计
c语言魔方阵课程设计一、教学目标本课程的目标是让学生掌握C语言编程基础，学会使用C语言编写魔方阵，并培养学生的逻辑思维能力和编程实践能力。
具体目标如下：1.知识目标：–掌握C语言的基本语法和数据类型。
–学会使用C语言进行条件判断和循环控制。
–理解函数的定义和调用。
–学习魔方阵的生成原理和算法。
2.技能目标：–能够使用C语言编写简单的程序。
–学会使用C语言编写魔方阵程序。
–培养学生的编程实践能力和问题解决能力。
3.情感态度价值观目标：–培养学生的学习兴趣和主动性。
–培养学生的团队合作意识和沟通能力。
–培养学生的创新思维和自我探索精神。
二、教学内容本课程的教学内容主要包括C语言的基本语法和数据类型、条件判断和循环控制、函数的定义和调用，以及魔方阵的生成原理和算法。
具体安排如下：1.C语言的基本语法和数据类型：介绍C语言的基本语法规则，包括变量声明、数据类型、运算符、表达式等。
2.条件判断和循环控制：介绍条件语句（if-else）和循环语句（for、while）的使用，以及它们的嵌套和应用。
3.函数的定义和调用：介绍函数的定义、声明和调用方式，以及函数的参数传递和返回值。
4.魔方阵的生成原理和算法：介绍魔方阵的定义和生成原理，以及常用的魔方阵生成算法。
三、教学方法本课程的教学方法采用讲授法、案例分析法和实验法相结合的方式。
具体方法如下：1.讲授法：通过教师的讲解和演示，让学生掌握C语言的基本语法和数据类型、条件判断和循环控制、函数的定义和调用等知识。
2.案例分析法：通过分析具体的魔方阵案例，让学生理解魔方阵的生成原理和算法，并学会使用C语言编写魔方阵程序。
3.实验法：通过编程实验，让学生亲自动手编写程序，培养学生的编程实践能力和问题解决能力。
四、教学资源本课程的教学资源包括教材、参考书、多媒体资料和实验设备。
具体资源如下：1.教材：选用《C程序设计语言》作为主要教材，介绍C语言的基本语法和数据类型、条件判断和循环控制、函数的定义和调用等内容。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
魔方阵算法及C语言实现1 魔方阵概念魔方阵是指由1，2，3……n2填充的，每一行、每一列、对角线之和均相等的方阵，阶数n = 3，4，5…。
魔方阵也称为幻方阵。
例如三阶魔方阵为：魔方阵有什么的规律呢？魔方阵分为奇幻方和偶幻方。
而偶幻方又分为是4的倍数（如4，8，12……）和不是4的倍数（如6，10，14……）两种。
下面分别进行介绍。
2 奇魔方的算法2.1 奇魔方的规律与算法奇魔方（阶数n = 2 * m + 1，m =1，2，3……）规律如下：1.数字1位于方阵中的第一行中间一列；2.数字a（1 < a ≤ n2）所在行数比a-1行数少1，若a-1的行数为1，则a的行数为n；3.数字a（1 < a ≤ n2）所在列数比a-1列数大1，若a-1的列数为n，则a的列数为1；4.如果a-1是n的倍数，则a（1 < a ≤ n2）的行数比a-1行数大1，列数与a-1相同。
2.2 奇魔方算法的C语言实现1 #include <stdio.h> 2// Author: / 3// N为魔方阶数 4#define N 115 6int main()7{8int a[N][N]; 9int i;10 int col,row;1112 col = (N-1)/2;13 row = 0;1415a[row][col] = 1;1617for(i = 2; i <= N*N; i++)18 {19if((i-1)%N == 0 )20 {21 row++;22 }23else24 {25// if row = 0, then row = N-1, or row = row - 126 row--;27 row = (row+N)%N;2829// if col = N, then col = 0, or col = col + 130 col ++;31 col %= N;32 }33 a[row][col] = i;34 }35for(row = 0;row<N;row++)36 {37for(col = 0;col < N; col ++)38{39 printf("%6d",a[row][col]);40 }41printf("\n");42 }43return0;44 }3 偶魔方的算法偶魔方的情况比较特殊，分为阶数n = 4 * m（m =1，2，3……）的情况和阶数n = 4 * m + 2（m = 1，2，3……）情况两种。
3.1 阶数n = 4 * m（m =1，2，3……）的魔方（双偶魔方）算法1：阶数n = 4 * m（m =1，2，3……）的偶魔方的规律如下：1.按数字从小到大，即1，2，3……n2顺序对魔方阵从左到右，从上到下进行填充；2.将魔方中间n/2列的元素上、下进行翻转；3.将魔方中间n/2行的元素左、右进行翻转。
C语言实现1 #include <stdio.h> 2// Author: / 3// N为魔方阶数， 4#define N 12 5 6int main() 7{ 8int a[N][N];//存储魔方 9 int i, temp;//临时变量10int col, row;//col 列，row 行1112//初始化13 i = 1;14for(row = 0;row < N; row++)15 {16for(col = 0;col < N; col ++)17 {18 a[row][col] =i;19 i++;20 }21 }2223//翻转中间列24for(row = 0; row < N/2; row ++)25 {26for(col = N/4;col < N/4*3;col ++)27 {28 temp = a[row][col];29 a[row][col] =a[N-row-1][col];30 a[N-row-1][col] =temp;31 }32 }3334//翻转中间行35for(col = 0; col < N/2; col ++)36 {37for(row = N/4;row < N/4* 3;row ++)38 {39 temp = a[row][col];40 a[row][col] =a[row][N-col-1];41 a[row][N-col-1] =temp;42 }43 }4445for(row = 0;row < N; row++)46{47for(col = 0;col < N; col ++)48 {49printf("%5d",a[row][col]);50 }51printf("\n");52 }53return0;54 }算法2：阶数n = 4 * m（m =1，2，3……）的偶魔方的规律如下：1.按数字从小到大，即1，2，3……n2顺序对魔方阵从左到右，从上到下进行填充；2.将魔方阵分成若干个4×4子方阵，将子方阵对角线上的元素取出；3.将取出的元素按从大到小的顺序依次填充到n×n方阵的空缺处。
C语言实现1 #include <stdio.h> 2// Author: / 3// N为魔方阶数 4#define N 12 5 6int main() 7{ 8int a[N][N];//存储魔方 9 int temparray[N*N/2];//存储取出的元素10int i;//循环变量11int col, row;// col 列，row 行1213//初始化14 i = 1;15 for(row = 0;row < N; row++)16 {17for(col = 0;col < N; col ++)18 {19 a[row][col] = i;20i++;21 }22 }23//取出子方阵中对角线上的元素，且恰好按从小到大的顺序排放24 i = 0;25for(row = 0;row < N; row++)26 {27for(col = 0;col < N; col ++)28 {29if((col % 4== row % 4) || ( 3== ( col % 4+ row % 4)))30 {31 temparray[i] = a[row][col];32i++;33 }34 }35 }36//将取出的元素按照从大到小的顺序填充到n×n方阵中37 i = N*N/2 -1;38for(row = 0;row < N; row++)39 {40for(col = 0;col < N; col ++)41 {42 if((col % 4== row % 4) || ( 3== ( col % 4+ row % 4)))43 {44 a[row][col] = temparray[i];45i--;46 }47 }48 }49//输出方阵50for(row = 0;row < N; row++)51 {52for(col = 0;col < N; col ++)53 {54printf("%5d",a[row][col]);55 }56printf("\n");57 }58return0;59 }3.2 阶数n = 4 * m + 2（m =1，2，3……）的魔方（单偶魔方）算法设k = 2 * m + 1；单偶魔方是魔方中比较复杂的一个。
1.将魔方分成A、B、C、D四个k阶方阵，如下图这四个方阵都为奇方阵，利用上面讲到的方法依次将A、D、B、C填充为奇魔方。
2.交换A、C魔方元素，对魔方的中间行，交换从中间列向右的m列各对应元素；对其他行，交换从左向右m列各对应元素。
3.交换B、D魔方元素，交换从中间列向左m – 1列各对应元素。
C语言实现#include <stdio.h>// Author: /// N为魔方阶数#define N 10int main(){int a[N][N] = { {0} };//存储魔方int i,k,temp;int col,row;// col 列，row 行//初始化k = N / 2;col = (k-1)/2;row = 0;a[row][col] = 1;//生成奇魔方Afor(i = 2; i <= k*k; i++){if((i-1)%k == 0 )//前一个数是3的倍数 {row++;}else{// if row = 0, then row = N-1, or row = row - 1row--;row = (row+k)%k;// if col = N, then col = 0, or col = col + 1col ++;col %= k;}a[row][col] = i;}//根据A生成B、C、D魔方for(row = 0;row < k; row++){for(col = 0;col < k; col ++){a[row+k][col+k] = a[row][col] + k*k;a[row][col+k] = a[row][col] + 2*k*k;a[row+k][col] = a[row][col] + 3*k*k;}}// Swap A and Cfor(row = 0;row < k;row++){if(row == k / 2)//中间行，交换从中间列向右的m列，N = 2*(2m+1) {for(col = k / 2; col < k - 1; col++){temp = a[row][col];a[row][col] = a[row + k][col];a[row + k][col] = temp;}}else//其他行，交换从左向右m列,N = 2*(2m+1) {for(col = 0;col < k / 2;col++){temp = a[row][col];a[row][col] = a[row + k][col];a[row + k][col] = temp;}}}// Swap B and Dfor(row = 0; row < k;row++)//交换中间列向左m-1列，N = 2*(2m+1) { for(i = 0;i < (k - 1)/2 - 1;i++){temp = a[row][k+ k/2 - i];a[row][k+ k /2 -i] = a[row + k][k+k/2 -i];a[row + k][k+k/2 -i] = temp;}}//输出魔方阵for(row = 0;row < N; row++){for(col = 0;col < N; col ++){printf("%5d",a[row][col]);}printf("\n");}return0;}＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝》#include <stdio.h>#define N 16 //这里可以修改N的值，并且N只能为奇数int main(){int a[N][N]={0},i,j,k,p,m,n;p=1;while(p==1）{printf("Enter n（1~%d): ",N-1）；/*可以输入小于等于N-1的奇数*/ scanf("%d",&n);if((n!=0)&&(n<N)&&(n%2!=0)) p=0;}i=n+1;j=n/2+1; /*建立魔方阵*/a[1][j]=1;for(k=2;k<=n*n;k++){i=i-1;j=j+1;if((i<1）&&(j>n)){i=i+2;j=j-1;}else{if(i<1）i=n;if(j>n) j=1;}if(a[i][j]==0) a[i][j]=k;else{i=i+2;j=j-1;a[i][j]=k;}}for(i=1;i<=n;i++)/*输出魔方阵*/{for(j=1;j<=n;j++)printf("%4d",a[i][j]);printf("\n");}}将1～n的平方这几个数构成一个n阶魔方阵。