魔方阵的C语言算法

合集下载

c++魔方最短还原算法

c++魔方最短还原算法

解决魔方(例如魔方、魔方2x2、4x4、5x5 等)的最短还原算法是一个复杂的问题,通常涉及到组合爬山、广度优先搜索(BFS)、启发式搜索等高级算法。

下面我将简要介绍一种基于广度优先搜索的常见方法,用于找到魔方的最短还原路径。

请注意,这是一个简单的示例,实际应用可能需要更复杂的算法和程序。

这里假设您正在处理标准的3x3魔方,并且您了解魔方的表示方法和操作符(例如R、L、U、D、F、B等),以及如何在编程中模拟这些操作。

1. **状态表示**:首先,您需要定义一个数据结构来表示魔方的状态。

通常,可以使用一个3x3的数组来表示魔方的每个小块的颜色和位置。

2. **初始状态和目标状态**:将初始魔方状态和目标还原状态定义为两个不同的状态。

3. **BFS搜索**:使用广度优先搜索(BFS)算法,从初始状态开始,在每个步骤中生成所有可能的下一步状态,并将它们加入到搜索队列中。

同时,记录每个状态所经过的步骤数。

重复这个过程,直到找到目标还原状态或搜索队列为空。

4. **剪枝**:为了加速搜索,可以使用一些启发式方法来剪枝,减少搜索空间。

例如,您可以计算每个状态到目标状态的估计步数(通常称为启发式函数),并在搜索中优先考虑具有更低估计步数的状态。

5. **路径记录**:一旦找到目标状态,可以回溯以找到从初始状态到目标状态的最短路径,这将是还原魔方的最短步骤序列。

请注意,这只是一个高层次的概述,实现一个完整的魔方最短还原算法需要详细的编程和算法设计。

此外,有许多现成的魔方求解器库和工具可供使用,这些工具已经实现了高效的算法,因此您可能不必从头开始构建自己的算法。

魔方阵C语言设计方法及设计理念

魔方阵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语言实现

魔⽅阵算法及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……)情况两种。

魔方矩阵magic square (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个字节的空间,不足部分用空格在左侧补齐。

输出魔方阵

输出魔方阵
for(i=0;i<n;i++)//各列的和
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语言程序

三阶魔方还原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,&amp;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语言实现魔方阵

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

任意阶魔方阵算法(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语言---魔方阵

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语言魔方阵的三种实现方法

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语言程序
m-&gt;down.s[1][3]=n.back.s[3][1];
m-&gt;down.s[2][3]=n.back.s[2][1];
m-&gt;down.s[3][3]=n.back.s[1][1];
m-&gt;back.s[3][1]=n.up.s[1][3];
m-&gt;back.s[2][1]=n.up.s[2][3];
m-&gt;up.s[1][3]=n.right.s[3][3];
}
}
void R(Cube *m,int i)//将魔方的右面顺时针转i次
{
Cube n;
for(;i&gt;0;i--)
{
n=*m;
clockwise(&amp;m-&gt;right,1);
m-&gt;up.s[1][3]=n.front.s[1][3];
Surface t;
for(;i&gt;0;i--)
{
t=*sur;
sur-&gt;s[1][1]=t.s[3][1];
sur-&gt;s[1][2]=t.s[2][1];
sur-&gt;s[1][3]=t.s[1][1];
sur-&gt;s[2][1]=t.s[3][2];
sur-&gt;s[2][2]=t.s[2][2];
//魔方程序
#include&lt;stdio.h&gt;
#include&lt;stdlib.h&gt;
#include&lt;string.h&gt;

《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语言程序求魔方阵如下:(求奇数幻方)代码一:#include <stdio.h>#define N 16 //这里可以修改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阶魔方阵。

算法:依以下法则,你可以很快的写出奇数阶幻方!当然,这种写法只是其中一个答案,而不是唯一答案。

1)将1填入第一行中间;2)将每个数填在前一个数的右上方。

3)若该位置超出最上行,则改填在最下行的对应位置;4)若该位置超出最右列,则该填在最左列的对应行位置;5)若某元素填在第一行最右列,下一个数填在该数同列的下一行;6)若某数已填好,但其右上角已填了其他数据,则下一个数填在该数同列的下一行位置。

C++面向对象编程:魔方阵习题示例

C++面向对象编程:魔方阵习题示例

所谓魔方阵,指的是1~n*n共n*n个自然数,排列成nXn的方阵,使得该方阵的每行、每列、对角线元素之和相等,并为只与n有关的常数,该常数为(1/2)nX(nXn+1)。

假定阵列的行列下标都从1开始,则魔方阵的生成方法如下:1.在第1行中间置1;2.假定当前元素的下标为(i,j),则对其余的2~n*n个数,基本的放置位置为当前位置的右上方,即下标为(i-1,j+1)。

与此同时,若当前的数是n的倍数,则放在当前位置的正下方,即下标为(i+1,j);若i-1小于1,则将这个数放在本列的最下端;若j+1大于n,则将这个数放在本行的最左端。

#include "stdafx.h"#include <malloc.h>#include <stdlib.h>void Array(int n);void main(){int n;printf("Set n,please:\n");scanf("%d",&n);Array(n);system("PAUSE");}void Array(int n){int i, j, no, num, max;int *mtrx;if (n % 2 == 0){n = n + 1;}max = n * n;/*C数组时基于0的*/mtrx = (int*)malloc(max);mtrx[n / 2] = 1;i = 0;j = n / 2;for (num = 2; num <= max; num ++){i = i - 1;j = j + 1;if ((num - 1) % n == 0){i = i + 2;j = j - 1;}if (i < 0){i = n - 1;}if(j > n - 1){j = 0;}no = i * n + j;mtrx[no] = num;}/*显示魔阵的元素*/printf("The charming matrix is :"); no = 0;for (i = 0; i < n; i ++){printf("\n");for(j = 0; j < n; j ++){printf("%3d",mtrx[no]);no ++;}}}。

C语言实现魔方阵

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语⾔】魔⽅阵打印魔⽅阵,所谓魔⽅阵是指这样的⽅阵,它的每⼀⾏、每⼀列和对⾓线之和均相等。

例如,三阶魔⽅阵为: 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 }。

魔方程序C语言代码

魔方程序C语言代码

#include <windows.h>#include <gl/gl.h>#include <gl/glu.h>#include <gl/glut.h>//小方块的结构,包括小方块在x,y,z上的旋转角度,颜色数组下标,小方块的三维坐标。

struct rcube{int xr;int yr;int zr;int cl[6];GLfloat x;GLfloat y;GLfloat z;};struct rcube rc[3][3][3];struct rcube *temp[3][3];//颜色数组GLfloat color[6][3]={{1.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,1.0},{1.0,1.0,0.0},{1.0,0.0,1.0},{0.0,1.0,1.0}};int tempc[3][3][6];//有关旋转的一些变量GLfloat xRot = 10.0f;GLfloat yRot = 10.0f;int rotateType=0;int rotateOK=0;int rotateRate=50;int rotate=0;/////////////////////////////////////////////////////////////////////////////// //画小方块void drawcube(int cl[6]){glBegin(GL_QUADS);//右面glColor3fv(color[cl[0]]);glVertex3f(0.14f,-0.14f,-0.14f);glVertex3f(0.14f,0.14f,-0.14f);glVertex3f(0.14f,0.14f,0.14f);glVertex3f(0.14f,-0.14f,0.14f);//左面glColor3fv(color[cl[1]]);glVertex3f(-0.14f,-0.14f,0.14f);glVertex3f(-0.14f,0.14f,0.14f);glVertex3f(-0.14f,0.14f,-0.14f);glVertex3f(-0.14f,-0.14f,-0.14f);//前面glColor3fv(color[cl[2]]);glVertex3f(-0.14f,0.14f,0.14f);glVertex3f(-0.14f,-0.14f,0.14f);glVertex3f(0.14f,-0.14f,0.14f);glVertex3f(0.14f,0.14f,0.14f);//后面glColor3fv(color[cl[3]]);glVertex3f(-0.14f,0.14f,-0.14f);glVertex3f(0.14f,0.14f,-0.14f);glVertex3f(0.14f,-0.14f,-0.14f);glVertex3f(-0.14f,-0.14f,-0.14f);//上面glColor3fv(color[cl[4]]);glVertex3f(-0.14f,0.14f,-0.14f);glVertex3f(-0.14f,0.14f,0.14f);glVertex3f(0.14f,0.14f,0.14f);glVertex3f(0.14f,0.14f,-0.14f);//下面glColor3fv(color[cl[5]]);glVertex3f(-0.14f,-0.14f,-0.14f);glVertex3f(0.14f,-0.14f,-0.14f);glVertex3f(0.14f,-0.14f,0.14f);glVertex3f(-0.14f,-0.14f,0.14f);glEnd();glFlush();}//窗口刷新时被调用。

旋转方阵 c语言 思路

旋转方阵 c语言 思路

旋转方阵介绍旋转方阵是计算机科学中一个常见的问题,涉及到在二维矩阵中对数据进行旋转操作。

本文将探讨旋转方阵的算法和实现方式。

问题描述给定一个n x n的方阵,设计一个算法,将方阵顺时针旋转90度。

算法思路对于给定的方阵,我们可以通过以下步骤进行顺时针旋转90度的操作:1.首先将矩阵分为四个边界:左边界(lb),右边界(rb),上边界(ub)和下边界(db)。

2.初始化lb、rb、ub和db的值分别为0、n-1、0和n-1。

3.在每一次循环中,从左上角开始,按顺时针方向将每个元素移动到旋转后的位置。

–首先将lb列的元素移动到ub行上相应的位置。

–然后将ub行的元素移动到rb列上相应的位置。

–接着将rb列的元素移动到db行上相应的位置。

–最后将db行的元素移动到lb列上相应的位置。

4.更新lb、rb、ub和db的值,将它们分别加1、减1、加1和减1。

5.循环执行步骤3和步骤4,直到lb大于等于rb或ub大于等于db。

代码实现下面是一个使用C语言实现旋转方阵的代码示例:#include <stdio.h>#define N 4void rotateMatrix(int matrix[N][N]) {int lb = 0; // 左边界int rb = N - 1; // 右边界int ub = 0; // 上边界int db = N - 1; // 下边界while (lb < rb && ub < db) {int prev = matrix[ub + 1][lb];// 移动lb列的元素到ub行for (int i = lb; i <= rb; i++) { int temp = matrix[ub][i];matrix[ub][i] = prev;prev = temp;}ub++; // 更新上边界// 移动ub行的元素到rb列for (int i = ub; i <= db; i++) { int temp = matrix[i][rb];matrix[i][rb] = prev;prev = temp;}rb--; // 更新右边界// 移动rb列的元素到db行for (int i = rb; i >= lb; i--) { int temp = matrix[db][i];matrix[db][i] = prev;prev = temp;}db--; // 更新下边界// 移动db行的元素到lb列for (int i = db; i >= ub; i--) { int temp = matrix[i][lb];matrix[i][lb] = prev;prev = temp;}lb++; // 更新左边界}}void printMatrix(int matrix[N][N]) { for (int i = 0; i < N; i++) {for (int j = 0; j < N; j++) {printf("%d ", matrix[i][j]);}printf("\n");}}int main() {int matrix[N][N] = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12},{13, 14, 15, 16}};printf("Original Matrix:\n");printMatrix(matrix);rotateMatrix(matrix);printf("\nRotated Matrix:\n");printMatrix(matrix);return 0;}测试结果输入一个4x4的方阵,运行以上代码后,得到如下测试结果:Original Matrix:1 2 3 45 6 7 89 10 11 1213 14 15 16Rotated Matrix:13 9 5 114 10 6 215 11 7 316 12 8 4总结通过以上算法和代码实现,我们成功地将给定的方阵顺时针旋转90度。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
第2步:
将第一列上下平移换位
35 1 6 16 19 24 30 5 7 21 23 25 31 9 2 22 27 20 8 28 33 17 10 15 3 32 34 12 14 16 4 36 29 13 18 11
第 3 步:
将第二列中的 5 和 32 换位
8 1 6 16 19 24 3 32 7 21 23 25 4 9 2 22 27 20 35 28 33 17 10 15 30 5 34 12 14 16 31 36 29 13 18 11
/* { t=a[i][j]; a[i][j]=a[N-i-1][j];
a[N-i-1][j]=t; } */ }
void Magic4Kplus2(int N) /*阶数 N 是 4K+2 的魔方阵*/ { /* 田字鏡射法(4k+2 階)
本法僅能填製 4k+2(即 6、10、14、18...等)的魔方陣。
for(j=m+k+2;j<N;j++) for(i=0;i<m;i++) swap(&a[i][j],&a[i+m][j]); /* { t=a[i][j]; a[i][j]=a[i+m][j]; a[i+m][j]=t; } */
/*将元素 a[k][0]和 a[k+m][0]换回*/
swap(&a[k][0],&a[k+m][0]); /*
if(i<=N/4-1+N/2 &&i>N/4-1) for(j=N-1;j>=0;j--) { a[i][j]=k; k++; }
}
/*将标记位进行整体翻转换位*/
for(j=N/4;j<(N/4+N/2);j++) for(i=0;i<N/2;i++) swap(&a[i][j],&a[N-i-1][j]);
x16 35x 4x2
第 7 步:数 7 应向 6 的右上角填但是没地方了就移到 6 下边
x16 357 4x2
第 8 步:数 8 应向 7 的右上角填但是没地方了就移到 3 上边
816 357 4x2
第 9 步:数 9 应向 8 的右上角填但是没地方了就移到 5 下边
816 357 492
详情请参看:.tw/oddest/index.htm
魔方阵的 c 语言算法
#include "stdio.h" #define Q 100 int a[Q][Q]; FILE *fp;
void swap(int *a,int *b)/*交换函数*/
{ int t; t=*a; *a=*b; *b=t; } void Magic2Kplus1(int t,int H,int L,int N) { /*
详情请参看:
.tw/oddest/index.htm */
int t=N*N/4; int m=N/2; int k=(N-2)/4; int i,j; Magic2Kplus1(1,0,0,m); Magic2Kplus1(t+1,m,m,m); Magic2Kplus1(2*t+1,0,m,m); Magic2Kplus1(3*t+1,m,0,m);
*/ int i=H,k=t; int j=(N-1)/2+L; a[i][j]=k; while(1) { if(i-1<H&&j+1>=N+L) { i++; a[i][j]=++k; continue; }
if(i-1<H) i=N+H-1; else i--;
if(j+1>=N+L)j=L; else j++;
的數字對調,魔方陣完成。
第 1 步:
將整個方陣劃成田字型的四個 2k+1 階的奇數階小方陣
并按阶数是奇数魔方填充方法进行填充 8 1 6 16 19 24 3 5 7 21 23 25 4 9 2 22 27 20 35 28 33 17 10 15 30 32 34 12 14 16 31 36 29 13 18 11
次橫向,故名雙向翻轉法。
本法僅能填製 4k 階的魔方陣,其填製方法共分三步驟:
第一步:將數字由左而右、由上而下順序填入方陣。
第二步:將中央部分半數的列,所有數字左右翻轉。
第三步:將中央部分半數的行,所有數字上下翻轉。
如果仔細揣摩數字的分布,其實要將數字由 1 到 n2 一口氣連續填入
方陣,並不是難事!
本法填製魔方陣時,先將整個方陣劃成田字型的四個 2k+1
階的奇數階小方陣,並以下法做註記:
1. 右半兩個小方陣中大於 k+2 的列。
2. 左半兩個小方陣中(k+1,k+1)的格位。
3. 左半兩個小方陣中除了(1,k+1)的格位之外小於 k +1 的列。
以簡捷連續填製法依左上、右下、右上、左下的順序
分別填製這四個小方陣。將上半及下半方陣中有註記
第 1 步:先將數字由左而右、由上而下順序置放方陣中。 1234 5678 9 10 11 12 13 14 15 16
第 2 步:將第 2、3 列的數字左右翻轉。
1234 8765 12 11 10 9 13 14 15 16
第 3 步:將第 2、3 行的數字垂直翻轉。
1 14 15 4 8 11 10 5 12 7 6 9 13 2 3 16
详情请参看:.tw/oddest/index.htm
*/
int i,j,k=1; /* int t; */ for(i=0;i<N;i++) {
if(i<=N/4-1||i>N/4-1+N/2) for(j=0;j<N;j++) { a[i][j]=k; k++; }
/*将标记位进行整体平移换位*/
for(j=0;j<k;j++) for(i=0;i<m;i++) swap(&a[i][j],&a[i+m][j]);
/* { t=a[i][j]; a[i][j]=a[i+m][j]; a[i+m][j]=t; }
*/
/*将右半兩個小方陣中的 m+k+2 列到 N-1 列进行上下平移换位*/
t=a[k][0]; a[k][0]=a[k+m][0]; a[k+m][0]=t; */
/*将元素 a[k][0]和 a[k+m][0]换位*/
swap(&a[k][k],&a[k+m][k]); /*
t=a[k][k]; a[k][k]=a[k+m][k]; a[k+m][k]=t; */ } void FprintMagic(int N) { int i,j; if(N>20) { printf("Magic matrix already has stored a file which named Magic.txt, plese check it.\n",N); return; } for(i=0;i<N;i++)
x1x xxx xx2
第 3 步:数 3 应向 2 的右上角填但是没地方了就移到 2 上一行的最左边
x1x 3xx xx2
第 4 步:数 4 应向 3 的右上角填但是这个地方已经有数字 1 了就移到 3
下边
x1x 3xx 4x2
第 5 步:数 5 向 4 的右上角填
x1x 35x 4x2
第 6 步 数 6 向 5 的右上角填
if(a[i][j]=='\0') a[i][j]=++k; else { i+=2; j--; a[i][j]=++k; } if(k==N*N+t-1) break; } } void Magic4K(int N)/*阶数 N 是 4K 的魔方阵*/ { /* 雙向翻轉法(4k 階)
本法先將數字順序填入方陣之後,再施以兩階段的翻轉,一次縱向、一
阶数 N 是奇数魔方阵
其中 int t,表示:从 t 开始向魔方阵ቤተ መጻሕፍቲ ባይዱ填数
int H,int L 分别表示从从魔方阵中的哪个位置开始填数
int N 表示魔方阵的阶数
下面举例子说明以 3 阶魔方阵为例
第 1 步: 中间填 1
x1x xxx xxx
第 2 步:数 2 应向 1 的右上角填但是没地方了就移到右下角
相关文档
最新文档