请教一个有难度的好题。高手来帮忙看看

Question

我写了一半，从1算到10还行，11以上就不对了，请高手看看吧。package mypackage;public class Main {
    
    public Main() {
    }
    
    public static void main(String[] args) {
        
        int n=4; //计算n阶方阵
        int i=0,j=0;
        int[][] d = new int[n][n];
        boolean ic=false;
        d[0][0]=1;
        for (int k=2;k<=10;k++){ 
        //上面这行的“10”应该是n ，从左上角开始，计算到“左下-右上”的主对角线是正确的。
        //右下方不能填充。高手看看能否解决。
            if (ic){
                i++; if (i>=n-1) {i=n-1;ic=false;}
                j--; if (j<0) {j=0;ic=false;}
            }
            else {
                i--; if (i<0) {i=0;ic=true;}
                j++; if (j>=n-1) {j=n-1;ic=true;}
            }
            d[i][j]=k;
        }
        
        for(int k1=0;k1<n; k1++){
            for (int k2=0; k2<n; k2++){
                System.out.print("\t" + d[k1][k2]);
            }
            System.out.println();
        }
        
        // TODO code application logic here
    }
    
}

Answer 1

更正：for (int k=2;k<=10;k++){ 
     //上面这行的“10”应该是n*n ，从左上角开始，计算到“左下-右上”的主对角线是正确的。
                              ^

Answer 2

站在前人的肩膀上～呵呵～
完成后半部分的输出！/********************************************/
package mypackage;public class matrix {
/**
 * To implement the matrix 
 * For yiyu2004 (依隅) question
 * @author jany0654
 */
    
    public matrix() {
    }
    
    public static void main(String[] args) {
        
        int n=6; 
        //计算n阶方阵
        int[][] matrix = new int[n][n];
        boolean ic=false;
        matrix[0][0]=1;  
        matrix[n-1][n-1]= n*n;
        
        int i=0,j=0;
        for (int k=2; k<=((n*(n+1))/2); k++){ 
        //(n*(n+1))/2 ，从左上角开始，计算到“左下-右上”的主对角线是正确的。
            if (ic){
                i++; 
                if (i>=n-1) {
                 i=n-1;
                 ic=false;
                 }
                j--; 
                if (j<0) {
                 j=0;
                 ic=false;
                 }
            }
            else {
                i--; 
                if (i<0) {               
                 i=0;
                 ic=true;
                 }
                j++; 
                if (j>=n-1) {
                 j=n-1;
                 ic=true;
                 }
            }
            matrix[i][j]=k;
        }
        
        i=0;
        j=0;
        ic=false;
        for (int k=((n*n)-1);k>=((n*(n+1))/2);k--){
         if (ic){
                i++; 
                if (i>=(n-1)) {
                 i=n-1;
                 ic=false;
                 }
                j--; 
                if (j<0) {
                 j=0;
                 ic=false;
                 }
            }else {
                i--; 
                if (i<0) {               
                 i=0;
                 ic=true;
                 }
                j++; 
                if (j>=n-1) {
                 j=n-1;
                 ic=true;
                 }
            }
            matrix[n-i-1][n-j-1]=k;
        }
        
        for(int outX = 0; outX<n; outX++){
            for (int outY=0; outY<n; outY++){           
                System.out.print("\t" + matrix[outX][outY]);
            }
            System.out.println();
        }
        
        // TODO code application logic here
    }
    
}
/*******************************************************/
n=6 的输出结果         1 2 6 7 15 16
3 5 8 14 17 26
4 9 13 18 25 27
10 12 19 24 28 33
11 20 23 29 32 34
21 22 30 31 35 36

Answer 3

俺也模仿着楼猪的扩展一下，呵呵
package cn.edu.xjtu.bmyjava;
import java.util.Scanner;
class PrintMatrix {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n=scanner.nextInt();
int i = 0, j = 0;
int[][] d = new int[n][n];
boolean ic = false;
d[0][0] = 1;
d[n - 1][n - 1] = n * n;
int k=2,kk=n*n-1,kkk=(n*n-n)/2+n;;
while(k<=kkk) {
if (ic) {
i++;
if (i >= n - 1) {
i = n - 1;
ic = false;
}
j--;
if (j < 0) {
j = 0;
ic = false;
}
} else {
i--;
if (i < 0) {
i = 0;
ic = true;
}
j++;
if (j >= n - 1) {
j = n - 1;
ic = true;
}
}
d[i][j] = k;
k++;
}
int ii = n - 1, jj = n - 1;
boolean flag = false;
while(kk>kkk) {
if (flag) {
ii--;
if (ii <= 1) {
ii = 1;
flag = false;
}
jj++;
if (jj > n - 1) {
jj = n - 1;
flag = false;
}
} else {
ii++;
if (ii > n - 1) {
ii = n - 1;
flag = true;
}
jj--;
if (jj <= 1) {
jj = 1;
flag = true;
}
}
d[ii][jj] = kk;
kk--;
}
for (int w = 0; w < n; w++) {
for (int s = 0; s < n; s++) {
System.out.printf("%3d",d[w][s]);
System.out.print(" ");
}
System.out.println();
}
}
}
运行结果：
11（此数从控制台输入）
  1   2   6   7  15  16  28  29  45  46  66 
  3   5   8  14  17  27  30  44  47  65  67 
  4   9  13  18  26  31  43  48  64  68  85 
 10  12  19  25  32  42  49  63  69  84  86 
 11  20  24  33  41  50  62  70  83  87 100 
 21  23  34  40  51  61  71  82  88  99 101 
 22  35  39  52  60  72  81  89  98 102 111 
 36  38  53  59  73  80  90  97 103 110 112 
 37  54  58  74  79  91  96 104 109 113 118 
 55  57  75  78  92  95 105 108 114 117 119 
 56  76  77  93  94 106 107 115 116 120 121

Answer 4

由此想到的：但给你一序列： 1   2   6   7  15  16  28  29  45  46  66 
                      或： 1  3   4    10   11   21  22  36  37  55 56
问你后面的数是什么, 这种Case还是有的。

Answer 5

public class SnakeMatrix {
/**
 * To implement the matrix 
 * For yiyu2004 (依隅) question
 * @author jany0654, rower203改写
 */
    private int matrixNum;

    public SnakeMatrix(int n) {
     matrixNum = n;
    }
    
    public int[][] getMatrix(){
        //计算n阶方阵
        int[][] matrix = new int[matrixNum][matrixNum];
        boolean ic=false;
        matrix[0][0]=1;  
        matrix[matrixNum-1][matrixNum-1]= matrixNum*matrixNum;
        
        int i=0,j=0;
        for (int k=2; k<=((matrixNum*(matrixNum+1))/2); k++){ 
        //(n*(n+1))/2 ，从左上角开始，计算到“左下-右上”的主对角线是正确的。
            if (ic){
                i++; 
                if (i>=matrixNum-1) {
                 i=matrixNum-1;
                 ic=false;
                 }
                j--; 
                if (j<0) {
                 j=0;
                 ic=false;
                 }
            }
            else {
                i--; 
                if (i<0) {               
                 i=0;
                 ic=true;
                 }
                j++; 
                if (j>=matrixNum-1) {
                 j=matrixNum-1;
                 ic=true;
                 }
            }
            matrix[i][j]=k;
        }
        
        i=0;
        j=0;
        ic=false;
        for (int k=((matrixNum*matrixNum)-1);k>=((matrixNum*(matrixNum+1))/2);k--){
         if (ic){
                i++; 
                if (i>=(matrixNum-1)) {
                 i=matrixNum-1;
                 ic=false;
                 }
                j--; 
                if (j<0) {
                 j=0;
                 ic=false;
                 }
            }else {
                i--; 
                if (i<0) {               
                 i=0;
                 ic=true;
                 }
                j++; 
                if (j>=matrixNum-1) {
                 j=matrixNum-1;
                 ic=true;
                 }
            }
            matrix[matrixNum-i-1][matrixNum-j-1]=k;
        }
        return matrix;
    }
    
    public void outputResult(int[][] matrix, int n, boolean isRotation){
        for (int outY = 0; outY < matrixNum; outY++){  
         int x = n - 1, y = outY;
         if(isRotation){
         y = x;
         x = outY;
         }
            System.out.print("\t" + matrix[x][y]);
        }
        System.out.println();
    }
    
    public void outputResult(int[][] matrix, int n){
     outputResult(matrix, n, false);
    }
    
    public void outputResult(int[][] matrix){
        for(int outX = 0; outX < matrixNum; outX++){
         outputResult(matrix, outX + 1, false);
        }
    }
    
    public static void main(String[] args) {
     SnakeMatrix sm = new SnakeMatrix(11);
//     sm.outputResult(sm.getMatrix());
     sm.outputResult(sm.getMatrix(), 1, true);
    }
    
}

Answer 6

由此想到的：但给你一序列： 1   2   6   7  15  16  28  29  45  46  66 
                      或： 1  3   4    10   11   21  22  36  37  55 56
问你后面的数是什么, 这种Case还是有的。
======================================================================不用程序，也不难。（1）：
1   2   6   7  15  16  28  29  45  46  66 
(1  2) (6   7)(15  16)(28  29)(45  46)(66  ?)......
答案：67（2）：
1  (3 4)  (10 11)  (21  22)  (36  37)  (55 56) (x  y)......
 \   / \    /   \    /     \   /    \   /    \  /
   +2    +6       +10        +14      +18     +22？
答案： x=78,   y=79

Answer 7

它的数学原型就是上面的SnakeMatrix。

Answer 8

由此想到的：但给你一序列： 1   2   6   7  15  16  28  29  45  46  66 
                      或： 1  3   4    10   11   21  22  36  37  55 56
问你后面的数是什么, 这种Case还是有的。
======================================================================不用程序，也不难。（1）：
1   2   6   7  15  16  28  29  45  46  66 
(1  2) (6   7)(15  16)(28  29)(45  46)(66  ?)......
答案：67（2）：
1  (3 4)  (10 11)  (21  22)  (36  37)  (55 56) (x  y)......
 \   / \    /   \    /     \   /    \   /    \  /
   +2    +6       +10        +14      +18     +22？
答案： x=78,   y=79

Answer 9

那么：
    public static void main(String[] args) {
     SnakeMatrix sm = new SnakeMatrix(11);
//     sm.outputResult(sm.getMatrix());
     sm.outputResult(sm.getMatrix(), 3, true);
    }
6 8 13 19 24 34 39 53 58 75 77 呢？你的规律就不太好找了！

Answer 10

今天总算做出来了，贴出来先
public class TestRec{

public static int[][] createRec(int n){
int[][] a = new int[n][n];
int m=1;
int b=add(n)+1;
for(int k=0;k<=2*n-2;k++){
if(k<n){
for(int i=0,j=k;i<=k;i++,j--,m++){
if(k%2==0){
a[j][i]=m;
}
if(k%2==1){
a[i][j]=m;
}
}
}
if(k>=n){
for(int i=k-n+1,j=n-1;i<n;i++,j--,b++){
if(k%2==0){
a[i][j]=b;
}
if(k%2==1){
a[j][i]=b;
}
}
}
}
return a;
}

public static int add(int n){
int c=0;
for(int i=1;i<=n;i++){
c+=i;
}
return c;
}

public static String printArray(int[][] a){
String result = "";
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
if(a[i][j]<=9){
result += " " + a[i][j] + " ";
}else{
result += a[i][j] + " ";
}
}
result += "\n";
}
return result;
}

public static void main(String[] args){
System.out.println(printArray(createRec(4)));
}
}

Answer 11

我的思路是最原始的那种，就是平行曲线那种，创建一个数组在一个一个赋值，走的路线也分为前后两半，取得坐标不一样，createRec方法就是完成这个功能的；在这个方法里k代表了平行线的ID，数组元素赋值是根据平行线ID的奇偶数来决定赋值是上行还是下行，还有就是传入的参数决定了矩阵的大小，也就是我的方法不局限于4*4add方法是用来为数组下一半的走向赋值用的，因为为前一半赋初值的m只作用于if(k<n)块中，也就是前一半循环的块printArray就没什么好说的了，就是将数组元素提取出来放进字符串中，只是有一点为了打印整齐在小于10的元素都需要加一个空格，就是下面这段
if(a[i][j]<=9){
result += " " + a[i][j] + " ";
}else{
result += a[i][j] + " ";
}
}我把这几个函数都设成了static型，为的是在main中调用方便，在main中的输出语句createRec(4)中的4可以改成任意维数关于这个算法的效率我就不太好说了，数据结构关于效率这块学得不好，不过在我机器上超过100*100的输出就会变得很慢还有就是我觉得我写的程序更具有面向对象特性和通用性，所有操作都封装在方法里面了