精华内容
下载资源
问答
  • Java幻方程序

    2011-12-25 16:43:10
    一个用java语言写的幻方程序,输入一个正整数m,就会显示出m*m的幻方
  • java 幻方的实现

    千次阅读 2018-08-23 10:20:42
    最近小孩在小学数学培训,需要做一个完成幻方的做法 幻方的口诀 口诀: 1 居上行正中央, 依次斜填切莫忘, 上出框界往下写, 右出框时左边放, 重复便在下格填, 出角重复一个样。   附上java的实现  ...

    最近小孩在小学数学培训,需要做一个完成幻方的做法

    幻方的口诀

    口诀:
    1 居上行正中央,

    依次斜填切莫忘,

    上出框界往下写,

    右出框时左边放,

    重复便在下格填,

    出角重复一个样。

     

    附上java的实现 

    package com.sf.test;
    
    public class huanfang {
    
    	
    	public static void main(String[] args) {
    		
    		try {
    			getHF(3,1,1);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	/**
    	 * size为 自然数且为奇数,设置一个(2N+1)的幻方 begin 为开始数 ,步长为 step 的连续数,填写size*size的魔方
    	 * 
    	 * @param args
    	 */
    	public static  int[][] getHF(int size,int begin,int step) throws Exception{
    		
    		if(size<0||size%2==0){
    			throw new  Exception("size must be odd number ");
    		}
    		if(begin<=0){
    			throw new  Exception("the first number must beyong zero ");
    		}
    		
    		if(step<=0){
    			throw new  Exception("the step number must beyong zero ");
    		}
    		
    		int n = size/2;
    		int j = 0;
    		int k = 0;
    		int temp = 0;
    		int length = (2 * n + 1) * (2 * n + 1);
    		int array[][] = new int[2 * n + 1][2 * n + 1];
    		array[0][n] = begin;
    
    		j = 0;
    		k = n;
    		temp = begin;
    		for (int i = 0; i < length - 1; i++) {
    			int nextJ = j - 1;
    			int nextK = k + 1;
    			System.out.println(i + "  the x " + nextJ + "  the y " + nextK);
    			// 对角线出线
    			if (nextJ == -1 && nextK == 2 * n + 1) {
    				nextJ = 1;
    				nextK = 2 * n;
    			}
    
    			// 如果出现了J 出线的且不是对角线,则转到下个
    			if (nextJ < 0 && nextK != 2 * n + 1) {
    				nextJ = 2 * n;
    			}
    			// 如果出现了K 出线的且不是对角线,则转到下个
    			if (nextJ >= 0 && nextK == 2 * n + 1) {
    				nextK = 0;
    			}
    			// 如果右上角有数,则下移
    			if (nextJ >= 0 && nextK <= 2 * n) {
    				if (array[nextJ][nextK] != 0) {
    					nextJ = j + 1;
    					nextK = k;
    				}
    			}
    
    			System.out.println(i + " firt  the x " + nextJ + "  the y " + nextK);
    			array[nextJ][nextK] = temp + step;
    			System.out.println(i + " next  the x " + nextJ + "  the y " + nextK);
    			System.out.println(i + " next  value " + array[nextJ][nextK]);
    			j = nextJ;
    			k = nextK;
    			temp = temp + step;
    			System.out.println("***********************************************");
    			for (int l = 0; l < (2 * n + 1); l++) {
    				for (int m = 0; m < (2 * n + 1); m++) {
    					System.out.print((array[l][m] < 10 ? "0" : "")+ array[l][m] + ",");
    				}
    				System.out.println();
    			}
    			System.out.println("***********************************************");
    		}
    
    	
    		return array;
    	}
    
    }
    

     

    展开全文
  • java 奇数阶幻方

    2010-06-18 16:51:43
    java 奇数阶幻方 java 奇数阶幻方 java 奇数阶幻方
  • java实现幻方构造

    千次阅读 2019-04-18 18:09:30
    作者:刘亮 幻方(MagicSquare)是一种将数字安排在正方形格子中,使每行、列和对角线上的数字和都相等的方法。...本篇主聊高阶幻方构造方法的java实现 数据结构:以二维数组存放数字 例:上面...

     

    作者:刘亮

    幻方(Magic Square)是一种将数字安排在正方形格子中,使每行、列和对角线上的数字和都相等的方法。

    幻方也是一种中国传统游戏。旧时在官府、学堂多见。它是将从一到若干个数的自然数排成纵横各为若干个数的正方形,使在同一行、同一列和同一对角线上的几个数的和都相等。

    三阶幻方

    本篇主聊高阶幻方构造方法的java实现

     

    数据结构:以二维数组存放数字

    例:上面的三阶幻方数组数据如下(不考虑幻方阶次较高,最大值超过int最大值)

    int[][] square = {
    
        {8,1,6},
    
        {3,5,7},
    
        {4,9,2}
    
    };

    数据结构有了,怎么去验证一个二阶数组的数据是不是一个有效的幻方构造数据呢?

    具体思路就是反证法,默认数据符合幻方数据内容:

    /**验证一个二阶数组里的数是不是符合一个幻方的要求*/
    
    public static boolean isValidSquare(int[][] nums){
    
    try {
    
    //i阶次幻方
    
    int i = nums.length;
    
    //行列斜的和为
    
    int s = (i*i+1)*i/2;
    
    //数据完整性校验数组
    
    int[] check = new int[i*i+1];
    
    //校验每一行/每一列的和是不是等于s
    
    for (int x = 0; x < i; x++) {
    
    int lineSum = 0;
    
    int colSum = 0;
    
    for (int y = 0; y < i; y++) {
    
    check[nums[x][y]]=nums[x][y];
    
    lineSum += nums[x][y];
    
    colSum += nums[y][x];
    
    }
    
    if (lineSum!=s || colSum!=s) {
    
    return false;
    
    }
    
    }
    
    //校验两个对角线的和是否等于s
    
    int s1Sum = 0;
    
    int s2Sum = 0;
    
    for (int x = 0; x < i; x++) {
    
    s1Sum += nums[x][x];
    
    s2Sum += nums[i-x-1][x];
    
    }
    
    if (s1Sum!=s || s2Sum!=s) {
    
    return false;
    
    }
    
    //校验check数组中是否包含1到i*i中的每一个数
    
    for (int j = 0; j < check.length; j++) {
    
    if (j!=check[j]) {
    
    return false;
    
    }
    
    }
    
    } catch (Exception e) {
    
    e.printStackTrace();
    
    //默认符合幻方规则,任意数组越界等错误都认为是不合格的数据
    
    return false;
    
    }
    
    return true;
    
    }

     

    下面开讲n(>=3)阶幻方的构造及实现

     

    奇数阶幻方

     

    拉-卢贝尔算法

    这个算法又称“阶梯法”。算法如下:

    1. 将1置于第一行中间。
    2. 将下一个数字置于当前数字的右上角。如果已经处于方阵的边界,则放在方阵的对边(如图1中的2和4)。
    3. 若出现下面两种情况,则将下一个数字放于当前数字的下方:

    ①当前位置的右上角已经有一个数字(如图2中的6和11)。

    ②当前位置已经是方阵的右上方(如图2中的16)。

    1. 结束,如下图3

     

     

    Java实现:

    /**
    
     * k=2*n+1
    
     * 拉-卢贝尔算法
    
     * 阶梯法
    
     */
    
    public static int[][] getSquare2k1LenF1(int k) throws Exception{
    
    int[][] res = new int[k][k];
    
    int x = 0;
    
    int y = k/2;
    
    int total = k*k;
    
    for (int i = 1; i <= total; i++) {
    
    res[x][y] = i;
    
    int m = (x-1+k)%k;
    
    int n = (y+1)%k;
    
    if (res[m][n]>0) {
    
    x = (x+1)%k;
    
    }else{
    
    x= m;
    
    y= n;
    
    }
    
    }
    
    return res;
    
    }

     

    菱形算法

    另一种由康韦(J.H.Conway)建立的算法被称为“菱形算法”,步骤如下(以5x5为例):

    1. 从左边中间开始,将奇数在方阵内填成一个菱形。
    2. 将方阵分成5条对角线,每条对角线上有5个方格。如果图1所示。
    3. 从第一条对角线开始将偶数填入剩余的空格内,图2中填满了前两条对角线。
    4. 结束,如图3。

     

     

     

    Java实现:

    /**
    
     * 菱形算法
    
     * k=2*n+1
    
     */
    
    public static int[][] getSquare2k1LenF2(int k) throws Exception{
    
    int[][] res = new int[k][k];
    
    //初始化奇数空间
    
    int n = k/2;
    
    
    
    //奇数起点坐标
    
    int baseX = n,baseY = 0;
    
    //起点走向,true向右 false向下
    
    boolean type = true;
    
    //奇数计数
    
    int count = 1;
    
    //当前奇数坐标
    
    int x = baseX;
    
    int y = baseY;
    
    while(true){
    
    res[x][y] = count;
    
    count = count+2;
    
    x--;y++;
    
    if (y>=x-n && y<=x+n) {
    
    
    
    }else{
    
    if (type) {
    
    baseY++;
    
    }else{
    
    baseX++;
    
    }
    
    type = !type;
    
    if (baseX==k-1 && baseY==n+1) {
    
    break;
    
    }
    
    x = baseX;
    
    y = baseY;
    
    }
    
    }
    
    
    
    //偶数起点坐标
    
    int baseP = -1;
    
    int baseQ = n+1;
    
    //起点走向,true向右 false向下
    
    type = false;
    
    //偶数计数
    
    count = 2;
    
    //当前奇数坐标
    
    int p = baseP;
    
    int q = baseQ;
    
    while(true){
    
    p = (p+k)%k;
    
    q = (q+k)%k;
    
    res[p][q] = count;
    
    count = count+2;
    
    p = (p-1+k)%k;
    
    q = (q+1)%k;
    
    if (res[p][q]!=0) {
    
    if (type) {
    
    baseQ++;
    
    }else{
    
    baseP++;
    
    }
    
    type = !type;
    
    if (baseP==n && baseQ==k) {
    
    break;
    
    }
    
    p = baseP;
    
    q = baseQ;
    
    
    
    }
    
    }
    
    
    
    
    
    return res;
    
    }

     

    杨辉法

    九子斜排 上下对易 左右相更 四维挺出 戴九履一 左三右七 二四为肩 六八为足

     

    举个例子:9个数斜着排,上下的两个数1,9,左右的两个数3,7互相换一下,四个角上的2,4,6,8就移到那四个角上去,这样就填好了一个三阶幻方了.

     

    再给一个7阶的构造填数过程,具体规则大家自己揣摩

     

     

    Java实现:

    /**
    
     * 九子斜排 上下对易 左右相更 四维挺出 戴九履一 左三右七 二四为肩 六八为足
    
     * k=2*n+1
    
     */
    
    public static int[][] getSquare2k1LenF3(int k) throws Exception{
    
    int[][] res = new int[k][k];
    
    //初始构造一个菱形空间
    
    int[][] dia = new int[2*k-1][2*k-1];
    
    //把1到k*k个数填入菱形空间
    
    for (int i = 1; i <= k*k; i++) {
    
    //计算i在菱形空间的坐标
    
    //批次
    
    int p = (i+(k-1))/k;
    
    //偏移量
    
    int q = i%k==0?k:i%k;
    
    q--;
    
    dia[p-1+q][k-p+q] = i;
    
    }
    
    //填充中心
    
    int m = (k-1)/2;
    
    for (int i = m; i <m+k ; i++) {
    
    for (int j = m; j < m+k; j++) {
    
    if (dia[i][j]==0) {
    
    if (i<j) {
    
    if(i+j<2*k-1){
    
    dia[i][j] = dia[i+k][j];
    
    }else{
    
    dia[i][j] = dia[i][j-k];
    
    }
    
    }else{
    
    if (i+j<2*k-1) {
    
    dia[i][j] = dia[i][j+k];
    
    }else{
    
    dia[i][j] = dia[i-k][j];
    
    }
    
    }
    
    
    
    }
    
    //往结果集赋值
    
    res[i-m][j-m] = dia[i][j];
    
    }
    
    }
    
    
    
    return res;
    
    }

     

    单偶数阶幻方

     

    侓克斯算法

    这个算法也是由康韦给出的。思想是将方阵分成多个2x2的小方阵,小方阵按照位置分成L、U、X三种类型。然后在大体上按照卢-拉贝尔算法来走,在每个小方阵中根据小方阵的类型来填数。具体算法如下:

    1. 将方阵分成(2i+1)个(2x2)的小方阵,小方阵的分类这样确定:前i+1行是L类型,后面一行是U类型,最后的i-1行是X类型,然后交换第i+1行和第i+2行中间小方阵的类型。对于10x10的方阵如图1。
    2. L、U、X的填法如图2。
    3. 最终结果如图3。

     

     

    Java实现:

    /**
    
     * k=4*n+2
    
     * 侓克斯算法
    
     * 
    
     * L: 4 1 U: 1 4 X: 1 4
    
     *  2 3 2 3 3 2
    
     * 
    
     * 前i+1行是L类型,后面一行是U类型,最后的i-1行是X类型,然后交换第i+1行和第i+2行中间小方阵的类型
    
     */
    
    public static int[][] getSquare4k2LenF1(int k) throws Exception{
    
    int[][] res = new int[k][k];
    
    int x = 0;
    
    int y = k/2-1;
    
    int total = k*k/4;
    
    for (int i = 1; i <= total; i++) {
    
    //定型
    
    //1:L 0:U -1:X
    
    int type = 1;
    
    if ((x== k/2+1 && y!=k/2-1) || (x==k/2-1 && y==k/2-1)) {
    
    type = 0;
    
    }
    
    if (x>= k/2+3) {
    
    type = -1;
    
    }
    
    //填充
    
    switch (type) {
    
    case 1:
    
    res[x][y] = 4*i;
    
    res[x][y+1] = 4*i-3;
    
    res[x+1][y] = 4*i-2;
    
    res[x+1][y+1] = 4*i-1;
    
    break;
    
    case 0:
    
    res[x][y] = 4*i-3;
    
    res[x][y+1] = 4*i;
    
    res[x+1][y] = 4*i-2;
    
    res[x+1][y+1] = 4*i-1;
    
    break;
    
    default:
    
    res[x][y] = 4*i-3;
    
    res[x][y+1] = 4*i;
    
    res[x+1][y] = 4*i-1;
    
    res[x+1][y+1] = 4*i-2;
    
    break;
    
    }
    
    //定位
    
    int m = (x-2+k)%k;
    
    int n = (y+2)%k;
    
    if (res[m][n]>0) {
    
    x = (x+2)%k;
    
    }else{
    
    x= m;
    
    y= n;
    
    }
    
    }

    return res;

    }

     

    加法算法

    将一个幻方加上另外一个幻方所得的和仍然具有幻方的特性,只是可能会有重复项,这是幻方的加法特性。下面的方法就是根据这个特性设计的,首先建立两个方阵A、B,具有幻方的特性(横、纵、斜和相同),然后让A加上B的i倍,就得到一个幻方。假如我们要作一个4i+2阶幻方(此处以14为例)。具体算法如下:

    先作一个14(4i+2)阶的方阵A,这个方阵分成4个7(2i+1)阶小方阵,每个小方阵是一个奇数阶的幻方,奇数阶幻方构造方法已经有了。如图1。

     

    1. 先作一个14(4i+2)阶的方阵A,这个方阵分成4个7(2i+1)阶小方阵,每个小方阵是一个奇数阶的幻方,奇数阶幻方构造方法已经有了。如图1。
    2. 再作一个14(4i+2)阶的方阵B,这个方阵只由0、1、2、3构成,具体作法如下:

    ①第一列:3(i)个3,4(i+1)个0,5(i+2)个2,2(i-1)个1

    ②前7(2i+1)列与都与第一列相同,只有第4(i+1)列例外,该列第一个3和第一 个0交换位置。

    ③后7(2i+1)列与前7(2i+1)列相同,不过3和0交换,1和2交换。

    ④结果如图2。

    1. 构造幻方C=A+i2B。如图3,C即所求。

     

    Java实现:

    /**
    
     * 加法算法
    
     * k=4*n+2
    
     */
    
    public static int[][] getSquare4k2LenF2(int k) throws Exception{
    
    int[][] res = new int[k][k];
    
    //幻方A初始化
    
    int[][] sA = new int[k][k];
    
    int[][] temp = getSquare2k1LenF1(k/2);
    
    for (int i = 0; i < k; i++) {
    
    for (int j = 0; j < k; j++) {
    
    sA[i][j] = temp[i%(k/2)][j%(k/2)];
    
    }
    
    }
    
    //幻方B初始化
    
    int[][] sB = new int[k][k];
    
    int n = (k-2)/4;
    
    for (int i = 0; i < k; i++) {
    
    for (int j = 0; j < k; j++) {
    
    if (i<k/2 && j<n || i>=k/2 && j>=n && j<k/2) {
    
    sB[i][j]=3;
    
    }
    
    if(i<k/2 && j>=k/2 && j<3*n+3 || i>=k/2 && j>=3*n+3){
    
    sB[i][j]=2;
    
    }
    
    if (i<k/2 && j>=3*n+3 || i>=k/2 && j>=k/2 && j<3*n+3) {
    
    sB[i][j]=1;
    
    }
    
    }
    
    }
    
    sB[n][0] = 0;
    
    sB[n][n] = 3;
    
    sB[3*n+1][0] = 3;
    
    sB[3*n+1][n] = 0;
    
    //幻方A和幻方B相加
    
    //RES = A + B*k*k/4
    
    for (int i = 0; i < k; i++) {
    
    for (int j = 0; j < k; j++) {
    
    res[i][j] = sA[i][j]+sB[i][j]*k*k/4;
    
    }
    
    }
    
    return res;
    
    }

     

    双偶数阶幻方

     

    分割算法

    1. 将方阵分成16个小方阵,如图1。
    2. 先在A、C、E、G、I方阵中填入数字,其他方阵跳过,如图2。
    3. 再逆序(从右下往左上)赶往余下的数字,如图3。
    4. 结束,如图3

     

     

    下面是一个8次的方阵:

    
    Java实现:
    
    /**
    
     * k=4*n
    
     * 分割算法
    
     */
    
    public static int[][] getSquare4kLenF1(int k) throws Exception{
    
    int[][] res = new int[k][k];
    
    //分割数据临时数组
    
    int[] temp = new int[k*k/2];
    
    int index = 0;
    
    //预填充
    
    for (int i = 0; i < k; i++) {
    
    for (int j = 0; j < k; j++) {
    
    //符合分割条件
    
    int m = i%4;
    
    int n = j%4;
    
    if (m!=n && m+n!=3) {
    
    temp[index++] = i*k+j+1;
    
    res[i][j]= 0;
    
    }else{
    
    res[i][j] = i*k+j+1;
    
    }
    
    }
    
    }
    
    //分割出的数据排序
    
    Arrays.sort(temp);
    
    int tempIndex = temp.length-1;
    
    //再填充
    
    for (int i = 0; i < k; i++) {
    
    for (int j = 0; j < k; j++) {
    
    if (res[i][j]==0) {
    
    res[i][j] = temp[tempIndex--];
    
    }
    
    }
    
    }
    
    
    
    return res;
    
    }
    
    

    对角线算法

    1. 将数字顺序填入方阵内,如图1。
    2. 将方阵分成四个相同大小的方阵。并找出每个小方阵的对角线,如图1阴影部分。
    3. 将阴影部分旋转180度,如图2。

     

    Java实现:

    /**
    
     * 对角线算法
    
     * k=4*n
    
     */
    
    public static int[][] getSquare4kLenF2(int k) throws Exception{
    
    int[][] res = new int[k][k];
    
    for (int i = 0; i < k; i++) {
    
    for (int j = 0; j < k; j++) {
    
    //坐标i,j是否处在对角线规则内
    
    int m = i%4;
    
    int n = j%4;
    
    if (m==n || m+n==3) {
    
    res[i][j] = (k-1-i)*k+(k-1-j)+1;
    
    }else{
    
    res[i][j] = i*k+j+1;
    
    }
    
    }
    
    }
    
    return res;
    
    }
    
    
    
    

     

     

    展开全文
  • n阶幻方java代码

    2018-04-27 21:31:00
    n阶幻方的求法(java代码版)。由于现在网上还没有系统的求n阶幻方java代码,所以写出来供大家参考!
  • JAVA幻方

    2020-10-03 10:04:05
    幻方 我国古籍很早就记载着 2 9 4 7 5 3 6 1 8 这是一个三阶幻方。每行每列以及对角线上的数字相加都相等。 下面考虑一个相反的问题。 可不可以用 1~9 的数字填入九宫格。 使得:每行每列每个对角线上的数字和都...

    反幻方

    我国古籍很早就记载着

    2 9 4
    7 5 3
    6 1 8

    这是一个三阶幻方。每行每列以及对角线上的数字相加都相等。

    下面考虑一个相反的问题。
    可不可以用 1~9 的数字填入九宫格。
    使得:每行每列每个对角线上的数字和都互不相等呢?

    这应该能做到。
    比如:
    9 1 2
    8 4 3
    7 5 6

    1 2 3
    4 5 6
    7 8 9
    你的任务是搜索所有的三阶反幻方。并统计出一共有多少种。
    旋转或镜像算同一种。

    比如:
    9 1 2
    8 4 3
    7 5 6

    7 8 9
    5 4 1
    6 3 2

    2 1 9
    3 4 8
    6 5 7

    等都算作同一种情况。

    请提交三阶反幻方一共多少种。这是一个整数,不要填写任何多余内容。

    import java.util.Arrays;
    
    public class 反幻方 {
    	static int count = 0;
    	static int[] arr2 = new int[8];
    	static int[] arr = {1,2,3,4,5,6,7,8,9};
    public static void main(String[] args) {
    	
    	
    	
    	f(0, arr.length-1);
    	System.out.println(count/8);
    	
    	
    	
    	
    }
    //全排列
    public static void f(int start,int end){
    	if(start == end){
    	//判断
    		if(isLan(arr)){
    		
    			count++;
    		}
    		return;
    		
    	}
    		
    	for (int i = start; i <= end; i++) {
    		int temp = arr[start];
    		arr[start] = arr[i];
    		arr[i] = temp;
    		
    		f(start+1,end);
    		
    		arr[i] = arr[start];
    		arr[start] = temp;
    	}
    	
    }
    
    //8个值 上下左右对角
    public static boolean isLan(int[]arr){
    	arr2[0] = arr[0]+arr[1]+arr[2];
    	arr2[1] = arr[3]+arr[4]+arr[5];
    	arr2[2] = arr[6]+arr[7]+arr[8];
    	arr2[3] = arr[0]+arr[3]+arr[6];
    	arr2[4] = arr[1]+arr[4]+arr[7];
    	arr2[5] = arr[2]+arr[5]+arr[8];
    	arr2[6] = arr[0]+arr[4]+arr[8];
    	arr2[7] = arr[2]+arr[4]+arr[6];
    	
    //8个值进行比较 如果存在相等返回false否则返回true
    	for (int i = 0; i < arr2.length; i++) {
    		for (int j = i+1; j < arr2.length; j++) {
    			if(arr2[i]==arr2[j]){
    				return false;
    			}
    		}
    	}
    	return true;
    }
    }
    
    
    展开全文
  • n阶幻方Java代码

    2018-04-27 22:25:25
    n阶幻方java代码,请注意使用eclipse时将编码格式调为UTF-8的格式,否则中文会显示乱码
  • 如图12-1的幻方,引起数学家们的极大兴趣,人们自然会想到,存不存在更为复杂的幻方呢?如每边上的数字个数是4,5,6······?其次,能否利用杨辉的作法来作出更复杂的幻方呢?答案是肯定的。一、杨辉与幻方...

    40122662_201904062136550758242673.png

    如图12-1的幻方,引起数学家们的极大兴趣,人们自然会想到,存不存在更为复杂的幻方呢?如每边上的数字个数是4,5,6······?其次,能否利用杨辉的作法来作出更复杂的幻方呢?答案是肯定的。

    一、杨辉与幻方

    对于每边数的个数为n的n×n纵横图来说,其数字总数为n2。杨辉利用等差数列求和的方法计算得这n2个数的总和

    40122662_201904062138580772969357.png 为,用n除这个数,就得到每行(每列)n个数的和相等时各行各列数字之和为

    40122662_201904062139450287863210.png。如n=3时,和为15;n=4时,其和为34;n=5时,其和为65。

    1、n为奇数时幻方制作和填图方法

    下面看n=5时5×5纵横图的作法:

    作25个数的斜排,如图12-2-1

    40122662_201904072200230860828677.png

    图12-2-1

    如图12-2-2中每个方形对角线两顶点上的数字互换,1和25,21和5,11和15,23和3,12和14,18和8互换。结果如图12-2-3,这其实用的仍然是杨辉“九子斜排,上下对易,左右相更,四维挺出”的构造幻方的方法。

    40122662_201904072204260093963063.png  

    40122662_201904080017440108997618.png

    图12-2-2                                                图12-2-3

    “四维挺出”即是把图12-2-4中“+”字上的数字“挺出”到剪头所指的位置,就成就一幻方,如图12-2-5

    40122662_201904080016010374893704.png            

    40122662_201904080037280983724567.png

    图12-2-4                                                    图12-2-5

    2、n为偶数时幻方制作和填图方法

    以四阶幻方为例

    法一:杨辉的四阶幻方有一种是按照“易换法”制作的。制作过程如下:将1-16的16个数按顺序填入空格中,如图12-3-1。

    将外四角4个数对换:1和16对换,4和13对换,如图12-3-2;

    40122662_201904080051510311241419.png

    图12-3-1                      图12-3-2                       图12-3-3接着内四角四个数对换:6和11对换,7和10对换,如图12-3-3。

    这样就得到了一个纵列、横行、对角线上和数之和均为34的四阶幻方。把这个幻方旋转、对称翻转又能得到不同的幻方。法二:“求等法”制作纵横图把16个数字按大小顺序排成两列,如图12-4-1,其特点是每行两数之和为17。再分成四列,如图12-4-2,每行四个数的和都是定数34。

    40122662_201904080109120939268791.png            

    40122662_201904080112230408430046.png

    图12-4-1                      图12-4-2

    其次来调整列,在不破坏各行四个数之和为34的前提下,使得和列四个数之和也为34,为此把二三行依竖中线翻转,得到图12-4-3。再不破坏行列各数之和为34的条件下,使得对角线上四数之和为34,为此,把三四列依横中线翻转,如图12-4-4。这样就作出了合格的纵横图了。

    40122662_201904080121070908996513.png            

    40122662_201904080124090393235404.png

    图12-4-3                             图12-4-4

    杨辉共作出了二十几个纵横图,有方形的,还有别的形状的,有的阶数相当大。杨辉还设计过如图12-5和12-6这样的纵横图。

    40122662_201904080134480080504209.png   

    40122662_201904080135120174399455.png

    图12-5                        图12-6

    纵横图所包含的数学原理十分深奥,我国数学家们发挥他们的聪明才智,将复杂的问题简化了,并且找到许多有趣而且具有实际意义的规律和方法,这些成为组合数学历史研究的珍贵资料。直到近代,人们才发现它与组合数有关,在程序设计、图论、人工智能、对策论等方面都有广泛的应用前景。

    展开全文
  • I didn't want to have to ask, but I can not figure out this assignment, and neither could the TA when I asked for help.I have to take input from a text file, feed the integers in the file into an arra...
  • Java实现蓝桥杯 九宫幻方

    万次阅读 多人点赞 2019-05-30 22:09:35
    九宫幻方 D: 今天做一道题目 九宫幻方 小明最近在教邻居家的小朋友小学奥数,而最近正好讲述到了三阶幻方这个部分。 三阶幻方指的是将1~9不重复的填入一个3*3的矩阵当中,使得每一行、每一列和每一条对角线的和都...
  • JAVA写的幻方

    2012-06-21 19:45:30
    很不错的幻方哦~~~可以输入任意的奇数,输出幻方
  • Java奇数阶幻方实现代码

    千次阅读 2017-04-29 16:05:35
    一,奇数阶换幻方简介奇数阶幻方是指由一个行数和列数都相等的数据(一组连续的数:如三阶阵数据就是1到9)组成的一个方阵。即一个nxn的方阵,n是奇数。并且要求每行,每列和对角线上的数据之和相等。下表是一个三阶...
  • 幻方java

    2020-07-12 15:04:36
    幻方 我国古籍很早就记载着 2 9 4 7 5 3 6 1 8 这是一个三阶幻方。每行每列以及对角线上的数字相加都相等。 下面考虑一个相反的问题。 可不可以用 1~9 的数字填入九宫格。 使得:每行每列每个对角线上的数字和...
  • java蓝桥杯练习 九宫幻方 资源限制 时间限制:1.0s 内存限制:256.0MB 问题描述  小明最近在教邻居家的小朋友小学奥数,而最近正好讲述到了三阶幻方这个部分,三阶幻方指的是将1~9不重复的填入一个3*3的矩阵当中,...
  • Swing 幻方

    2012-10-17 21:46:21
    java 幻方制作 奇数算法 比较适合初学者接触swing
  • 幻方矩阵java源码

    2014-01-21 10:37:28
    中国科学技术大学软件学院《算法设计与分析》实验题目二
  • 设方阵C=(cij)nn(1i,jn)含数集N={1,2,……,n2}的全部元素,若C的每行、每列及主、副(含折断)对角线中的每一线上诸元素之和等于n(n2+1)/2(幻和),称方阵C为n阶全对角线幻方.定义1设B=(bij)pq(1ip,1jq)含数集N={1,2,3,...
  • java —— 神奇的幻方

    2021-01-14 19:14:47
    java —— 神奇的幻方 题目详情: 幻方是一种很神奇的NN矩阵:它由数字1,2,3,……,NN构成,且每行、每列及两条对角线上的数字之和都相同。 当N为奇数时,我们可以通过以下方法构建一个幻方: 首先将1写在第一行的...
  • 六角幻方java

    2020-10-29 10:51:55
    标题:六角幻方 把 1 2 3 ... 19 共19个整数排列成六角形状,如下: * * * * * * * * * * * * * * * * * * * 要求每个直线上的数字之和必须相等。共有15条直线哦! 再给点线索吧!我们预先填好了2个数字,...
  • java——构造幻方

    2018-10-13 10:50:06
    import java.util.Scanner; public class Main {  public static void main(String[] arg) {  Scanner sc = new Scanner(System.in);  System.out.println(&...输入一个奇数构造幻方:");  int n=sc.next...
  • 奇数幻方和双偶幻方java实现)奇数幻方
  • 四阶幻方java

    2020-07-12 13:01:12
    四阶幻方 把1~16的数字填入4x4的方格中,使得行、列以 及两个对角线的和都相等,满足这样的特征时称 为:四阶幻方。 四阶幻方可能有很多方案。如果固定左上角为1 ,请计算一共有多少种方案。 比如: 1 2 15 16...
  • java实现第七届蓝桥杯反幻方

    万次阅读 多人点赞 2019-07-29 18:11:54
    幻方 题目描述 我国古籍很早就记载着 2 9 4 7 5 3 6 1 8 这是一个三阶幻方。每行每列以及对角线上的数字相加都相等。 下面考虑一个相反的问题。 可不可以用 1~9 的数字填入九宫格。 使得:每行每列每个对角线上的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,659
精华内容 3,063
关键字:

java幻方

java 订阅