面试题。

Question

给一个数字n 按照规律打印出上面的正方形 ， n < 10 

Answer 1

好吧，我以为挺简单的，结果花了好长时间。。import java.util.Random;public class SpecialArr {
public static void main(String[] args) {
int size = new Random().nextInt(10) + 1;// 1到10之间随机数
System.out.println("得到的随机数：" + size); int[][] valueArr = new int[size][size];// 初始化数组
int maxValue = size * size;// 数组中，元素最大数（中心点值）
int curValue = 1;// 当前元素值，从1开始 int x = -1, y = 0;// 数组起始下标，x为行标，y为列标//为了保持循环条件一致，x先赋值-1
boolean isUp = true;// x、y是否递增或者递减的标志位

//将数组四周看做围墙，起始从最左侧往下走，因此左侧限制自动为1
int left = 1;
int right = size;//右侧达到最大
int top = 0;//顶部默认为0
int base = size;//底部默认达到最大 // 开始给数组赋值
outer: while (curValue <= maxValue) {
if (isUp) {
//从上往下走，不能“触底”
while (++x < base) {
valueArr[x][y] = curValue;
curValue++;
if (curValue > maxValue) {
break outer;
}
}
x--;// 越界了，要-1
base--;//底上升 //从左往右走，不能“触边”
while (++y < right) {
valueArr[x][y] = curValue;
curValue++;
if (curValue > maxValue) {
break outer;
}
}
y--;// 越界了，要-1
isUp = false;
right--;//右侧左移
} else {
//从下网上走，不能“越过顶部”
while (--x >= (top)) {
valueArr[x][y] = curValue;
curValue++;
if (curValue > maxValue) {
break outer;
}
}
x++;// 越界了，要+1
top++;//顶部下移 //从右往左，不能“越过左边”
while (--y >= left) {
valueArr[x][y] = curValue;
curValue++;
if (curValue > maxValue) {
break outer;
}
}
y++;// 越界了，要+1
isUp = true;
left++;
}
} // 打印结果
System.out.println("得到的数组为：");
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
System.out.print(valueArr[i][j] + "\t");
}
System.out.println();
}
}
}

Answer 2

package com.zf.test;public class Test01 {

public static void print(int n){

int value = 0 ;

int[][] points = new int[n][n];

int x = 0 , y = 0 ;

int qs =  n / 2  ;// 圈数

for (int k = 0; k < qs ; k++) {

int step = n - (k * 2) ; //步数

for (int i = 0; i < step;) {
points[x][y] = ++value ;
if(++i < step)
y++ ;
}

x++ ;
step = step -1 ;
for (int i = 0; i <step; ) {
points[x][y] = ++value ;
if(++i < step)
x++ ;
}


y-- ;
for (int i = 0; i <step; ) {
points[x][y] = ++value ;
if(++i < step)
y-- ;
}


x-- ;
step = step - 1  ;
for (int i = 0; i < step; ) {
points[x][y] = ++value ;
if(++i < step)
x-- ;
}
y++ ;
}

if( n % 2 != 0)
points[x][y] = ++value ;

for (int i = 0; i < points.length; i++) {

for (int j = 0; j < points.length; j++) {
System.out.printf("%02d " , points[j][i]);
}
System.out.println("");
}

}

public static void main(String[] args) {

print(5);

}}
01 16 15 14 13 
02 17 24 23 12 
03 18 25 22 11 
04 19 20 21 10 
05 06 07 08 09 

Answer 3

class Demo 
{
public static void main(String[] args) 
{
int n=6;
int j=0,k=0;
int x=1;
int[][] arr=new int[n][n];
for (int i=0;i<(n+1)/2 ;i++ )
{
for (j=i;j<n-i ;j++ )
{
arr[j][i]=x++;
}
for (k=i+1;k<n-i ;k++ )
{
arr[j-1][k]=x++;
}
for (j=n-i-2;j>=i ;j-- )
{
arr[j][k-1]=x++;
}
for(k=n-i-2;k>=i+1;k--)
{
arr[i][k]=x++;
}
}
for (j=0;j<n ;j++ )
{
for (k=0;k<n ;k++ )
{
System.out.print(arr[j][k]+"\t");
}
System.out.println();
}

}
}
写的不是很好，用了数组来操作

Answer 4

class Demo 
{
public static void main(String[] args) 
{
int n=6;
int j=0,k=0;
int x=1;
int[][] arr=new int[n][n];
for (int i=0;i<(n+1)/2 ;i++ )
{
for (j=i;j<n-i ;j++ )
{
arr[j][i]=x++;
}
for (k=i+1;k<n-i ;k++ )
{
arr[j-1][k]=x++;
}
for (j=n-i-2;j>=i ;j-- )
{
arr[j][k-1]=x++;
}
for(k=n-i-2;k>=i+1;k--)
{
arr[i][k]=x++;
}
}
for (j=0;j<n ;j++ )
{
for (k=0;k<n ;k++ )
{
System.out.print(arr[j][k]+"\t");
}
System.out.println();
}

}
}
第一次传，刚没传好

Answer 5

一层循环就可以搞定的，，，
public class Test { public static void main(String[] args) {
int n = 5;
int[][] result = new int[n][n];
int i = 0, j = 0, top = 0, right = n - 1, left = 0, bottom = n - 1, sig = 0;
for (int k = 1; k <= n * n; k++) {
result[i][j] = k;
if (i == top && j == right && sig != 3) {
sig = 3;
right--;
} else if (i == top && j == left && sig != 0) {
sig = 0;
if (j != 0) {
top++;
}
} else if (i == bottom && j == left && sig != 1) {
sig = 1;
left++;
} else if (i == bottom && j == right && sig != 2) {
sig = 2;
bottom--;
}
if (sig == 0) {
i++;
} else if (sig == 1) {
j++;
} else if (sig == 2) {
i--;
} else {
j--;
} }
i = 0;
j = 0;
for (; i < n; i++) {
for (; j < n; j++) {
System.out.print(result[i][j] + " ");
}
System.out.println();
j = 0;
}
}}

Answer 6

package com.wshh.list;public class Demo {
int sign = 0;
int value = 1;
int max = 0;
int[][] arr = null;
private void down(int n){
int j = sign;
for(int i = sign;i<n-sign;i++){
arr[i][j] = value;
if(value >= max)break;
value++;
if(i == n-1-sign){
right(n);
break;
}
}
}
private void right(int n) {
int i = n-1-sign;
for(int j = 1+sign;j<n-sign;j++){
arr[i][j] = value;
if(value >= max)break;
value++;
if(j == n-1-sign){
up(n);
break;
}
}

}
private void up(int n) {
int j = n-1-sign;
for(int i=n-2-sign;i>=sign;i--){
arr[i][j] = value;
if(value >= max)break;
value++;
if(i == sign){
left(n);
break;
}
}
}
private void left(int n) {
int i =sign;
for(int j = n-2-sign;j>=1+sign;j--){
arr[i][j] = value;
if(value >= max)break;
value++;
if(j == 1+sign){
sign++;
down(n);
break;
}
}
}
public void print(int n){
arr = new int[n][n];
max = n*n;
down(n);
String s = "";
for(int i = 0;i<n;i++){
for(int j = 0;j<n;j++){
if(arr[i][j]<10)
s = " "+arr[i][j];
else
s= arr[i][j]+"";
System.out.print(s+" ");
}
System.out.println();
}
}
public static void main(String[] args) {
Demo d = new Demo();
d.print(6);
}}
 1 20 19 18 17 16 
 2 21 32 31 30 15 
 3 22 33 36 29 14 
 4 23 34 35 28 13 
 5 24 25 26 27 12 
 6  7  8  9 10 11 

Answer 7

代码很多了，功能虽然实现了，但是思路比较复杂，各种循环写入，看得有点晕，有几个写法不适合n较大时候。
提供一个思路比较清晰的解法吧（适合任何大小的n）：
1，判断（n*n）%4==0或者（n*n）%4==1，下面先说下n%4==0的解法
2，（n*n）%4==0时，分解为n/2层。每次完成一层的赋值，完成一层就很简单了，可以用一个函数完成，该函数需传入起始参数有4个，开始写入的第一个值，开始写入数组的下标（x和y），当前层的每一行的大小，然后每次写“ 外层元素个数-1” 个，四次写完一层。
3，用一个循环，调用2中的函数从最外层依次写里面的一层，每次循环调用的函数可以很容易得到（xy是现成的，层数来自for循环控制参数，其实写入参数在当前x+1，y对应的数组元素），（n*n）%4==1时，看下一步。
4，对于（n*n）%4==1时，外加写入中心元素[(n-1)/2][(n-1)/2]就是。
5，循环输出这个2维数组，搞定。

Answer 8

这个是我前几天的螺旋矩阵的方法，虽然结果和楼主的那个有一点差别（逆时针与顺时针），也贴出来给大家看一下。public class SpiralMartrix {
/**
 * 螺旋矩阵的算法
 */
public static void main(String[] args) {
System.out.print("Please input the row number of a spiralMartrix:");
//输入矩阵的行数
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
if(x < 1){
System.out.println("Error number");
return;
}
int [][]arr =new int[x][x];
int a = 0;
int m =0, n = 0;
int len = arr.length;
for(int i=1;i<=x*x;i++){
if(arr.length == 1){ //条件1      说明1
arr[0][0]=x*x;
}else {
if(m==a && n<len-(1+a) && arr[m][n]==0){//条件2
arr[m][n]=i;
n++;
}else if(n==len-(1+a) && m<len-(1+a) && arr[m][n]==0){//条件3
arr[m][n]=i;
m++;
}else if(m==len-(1+a) && n>a && arr[m][n]==0){//条件4
arr[m][n]=i;
n--;
}else if(n==a && m>a && arr[m][n]==0){//条件5
arr[m][n]=i;
m--;
}else if(arr[m][n]!=0 && arr[m+1][n+1]==0){//条件6
m++;
n++;
a++;
i--;//说明2
if(m+1>len/2){//说明3
len=len+1;
}
}else{
//
}
}//else
}//for
//打印螺旋矩阵
for(int i=0;i<x;i++){
for(int j=0;j<x;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println();
System.out.println();
}
}
}
/**
 * 说明1：
 * 如果没有条件1，直接从条件2开始执行，那么里面的判断条件n<len-(1+a)讲不能被执行到
 * 考虑到arr[1][1]={1}本身就是一个螺旋矩阵，所以添加了条件1
 * 
 * 说明2：
 * 程序到把这个else if执行完以后会执行i++，然后执行合适的else if
 * 但是这个方法体内并没给数组arr[][]赋值，即漏掉一次i的赋值
 * 为了保持arr[][]数组的值得连贯性，可以先执行i--，之后再执行i++，这样i的值就不会被漏掉
 * 
 * 说明3：
 * 当arr.length是奇数时，数组的值咋赋到最后一圈是（此时只有最后一个数没有赋值），此时有
 * n=a=arr.length/2，若arr.length =5,arr.length/2=n=a=m=2;有m+1>len/2
 * 条件2的else if的条件n<len-(1+a)不能做出有效的判断，为了能完成最后一次的操作，可以
 * len=len+1;
 * */
这里是结果Please input the row number of a spiralMartrix:4
1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7

Answer 9

来个简洁的
package test;public class Test {  public static void main(final String[] args) throws Exception {
    int n = 6;
    int[][] arr = new int[n][n];    int[][] direction = new int[][]{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};    int dir = 0, x = 0, y = 0, dx = 0, dy = 1;    for (int i = 0; i < n * n; i++, x += dx, y += dy) {
      arr[x][y] = i + 1;      if (x + dx == -1 || y + dy == -1 || x + dx == n || y + dy == n || arr[x + dx][y + dy] != 0) {
        dir = (dir + 1) % 4;
        dx = direction[dir][0];
        dy = direction[dir][1];
      }
    }    for (int iY = 0; iY < n; iY++) {
      for (int iX = 0; iX < n; iX++)
        System.out.print(arr[iX][iY] + "\t");
      System.out.println();
    }
  }
}

Answer 10

/**
 * 1 16 15 14 13
 * 2 17 24 23 12 
 * 3 18 25 22 11
 * 4 19 20 21 10
 * 5 6  7  8  9
 */
public static void print(int n){

int[][] xy = new int[n][n];
int circle = n / 2;//圈数
int x = 0;
int y = 0;
int start = 0;
for(int i = 0; i < circle; i++){
int step = n - i*2;//步数
//左
for(int k = 0; k < step;k++){
xy[x][y] = ++start;
if(k < step -1){
++y;
}
}

//下右都是一样的步数
step = step - 1;

//横坐标向右移一位
++x;
//下
for(int k = 0; k < step; k++){
xy[x][y] = ++start;
if(k < step - 1){
++x;
}
}

//纵坐标向上移一位
--y;
//右
for(int k = step; k > 0; k--){
xy[x][y] = ++start;
if(k != 1){
--y;
}
}

//横坐标向左移一位
--x;
//上
step = step - 1;
for(int k = step; k > 0; k--){
xy[x][y] = ++start;
if(k != 1){
--x;
}
}
//移位到下一圈
++y;
}

if(n % 2 > 0){
xy[x][y] = ++start;
}

for(int i = 0; i < xy.length; i++){
for(int j = 0; j < xy.length; j++){
System.out.printf("%02d ",xy[j][i]);
}
System.out.println("");
}
}

public static void main(String[] args) {
Test2.print(5);
}

Answer 11

public class Test { public static void main(String[] args) {
int m = 1, n = 1, num = 9;
int[][] point = new int[num + 2][num + 2];
int control[] = { 1, 0 };
for (int i = 0; i < num + 2; i++) {
point[0][i] = 1;
point[num + 1][i] = 1;
point[i][0] = 1;
point[i][num + 1] = 1;
}
for (int i = 1; i <= num * num; i++) {
int a, b;
point[m][n] = i;
a = m + control[0];
b = n + control[1];
if (point[a][b] != 0) {
turnLeft(control);
}
m += control[0];
n += control[1];
}
for (int i = 1; i <= num; i++) {
for (int j = 1; j <= num; j++) {
System.out.printf("%02d", point[i][j]);
System.out.print(" ");
}
System.out.println();
} } static void turnLeft(int[] control) {
int temp = control[1];
control[1] = control[0];
control[0] = 0 - temp;
}
}01 32 31 30 29 28 27 26 25 
02 33 56 55 54 53 52 51 24 
03 34 57 72 71 70 69 50 23 
04 35 58 73 80 79 68 49 22 
05 36 59 74 81 78 67 48 21 
06 37 60 75 76 77 66 47 20 
07 38 61 62 63 64 65 46 19 
08 39 40 41 42 43 44 45 18 
09 10 11 12 13 14 15 16 17 

Answer 12

大神，我没看懂你的throw跟final，求解释

Answer 13

import java.awt.Point;
import java.io.PrintStream;public class PrintMatrix {
  
  public static void main(String[] args) {
    
    for(int n=1; n<10; n++)
      print(fill(n), System.out);
  }
  
  static int[][] fill(int n) {
    
    int[][] matrix = new int[n][n];
    Point p = new Point(0, 0);
    Direction d = Direction.Down;
    
    for (int i = 1; check(p, n, matrix); i++, d = d.move(p, n, matrix))
      matrix[p.y][p.x] = i;
    
    return matrix;
  }
  
  static void print(int[][] matrix, PrintStream ps) {
    
    for(int[] row : matrix) {
      
      for(int cell : row)
        ps.printf("%-3d", cell);
      ps.println();
    }
    ps.println();
  }
  
  static boolean check(Point p, int n, int[][] matrix) {
      
    return p.x >= 0 && p.x < n && 
           p.y >= 0 && p.y < n && matrix[p.y][p.x] == 0;
  }
  
  private static enum Direction {
    
    Down {
      
      @Override void forwards(Point p) { p.y++; }
      @Override void backwards(Point p) { p.y--; }
    },
    Right {
      
      @Override void forwards(Point p) { p.x++; }
      @Override void backwards(Point p) { p.x--; }
    },
    Up {
      
      @Override void forwards(Point p) { p.y--; }
      @Override void backwards(Point p) { p.y++; }
    },
    Left {
      
      @Override void forwards(Point p) { p.x--; }
      @Override void backwards(Point p) { p.x++; }
    },
    ;
    
    Direction move(Point p, int n, int[][] matrix) {
      
      forwards(p);
      if( !check(p, n, matrix) ) {
        
        backwards(p);
        next().forwards(p);
        return next();
      }
      else return this;
    }
    
    abstract void forwards(Point p);
    abstract void backwards(Point p);
    Direction next() { return values()[(ordinal()+1) % values().length]; }
  }
}
匿了

Answer 14

果然还是高手多的啊。学习ing

Answer 15

final参数是好习惯，给参数变量赋值会让程序难懂。throw Exception是因为这个Test类是我专门拿来解决CSDN上问题的测试类，有时候用到的函数会要求try/catch异常，我就直接写在main上图个省事。这里并不需要，可以忽略

Answer 16

书上看到这样一种解法import java.util.Scanner;
public class Panel_qipang {
public static void main(String[] args) {
int[][] a = new int[10][10];
int n,x,y,tot = 0;
Scanner sc = new Scanner(System.in);
n =sc.nextInt();
for(int i = 0;i < 10;i++) {
for(int j = 0;j < 10;j++) {
a[i][j] = 0;
}
}
tot = a[x = 0][y = 0] = 1;
while(tot < n * n) {

while(x + 1 < n && a[x + 1][y] == 0) a[++x][y] = ++tot;
while(y - 1 >= 0 && a[x][y - 1] == 0) a[x][--y] = ++tot;
while(x - 1 >= 0 && a[x - 1][y] == 0) a[--x][y] = ++tot;
while(y + 1 < n && a[x][y + 1] == 0) a[x][++y] = ++tot;
}
for(x = 0;x < n;x++) {
for(y = 0;y < n;y++) {
System.out.print(a[x][y] + " ");
}
System.out.println();
}
}
}我感觉很不错 很容易懂！

Answer 17

吐槽一下：
         for(int i = 0;i < 10;i++) {
            for(int j = 0;j < 10;j++) {
                a[i][j] = 0;
            }
        }
Java规范中早已规定，新建的int默认值为0，所以这一段代码画蛇添足。另外方向好像错了，不过思想是对的。类似我那个解法，我只是把4个while用一个directions数组合并在了for循环里。我来总结一下吧：这里解法有两派：看路派（如8楼和附近的几楼），还有撞墙派（凡是含有 result[x][y] == 0或者!=0 的都属于撞墙派）。假设一个框里有人绕圈走，第一种解法是这个人始终知道自己的墙壁在哪，后一种解法是这人非得往上一撞，有石头了才拐弯。相比之下第一种解法效率较高（没做过实验，不过自然是撞墙的跑得慢）。是因为相较于看路派在拐弯的时候多了一次数组取值（不要小看这一次取值，数组存在于堆内存中，二维数组取一次值相当于内存访问两次，慢得紧！）

Answer 18

吐槽一下：
         for(int i = 0;i < 10;i++) {
            for(int j = 0;j < 10;j++) {
                a[i][j] = 0;
            }
        }
Java规范中早已规定，新建的int默认值为0，所以这一段代码画蛇添足。另外方向好像错了，不过思想是对的。类似我那个解法，我只是把4个while用一个directions数组合并在了for循环里。我来总结一下吧：这里解法有两派：看路派（如8楼和附近的几楼），还有撞墙派（凡是含有 result[x][y] == 0或者!=0 的都属于撞墙派）。假设一个框里有人绕圈走，第一种解法是这个人始终知道自己的墙壁在哪，后一种解法是这人非得往上一撞，有石头了才拐弯。相比之下第一种解法效率较高（没做过实验，不过自然是撞墙的跑得慢）。是因为相较于看路派在拐弯的时候多了一次数组取值（不要小看这一次取值，数组存在于堆内存中，二维数组取一次值相当于内存访问两次，慢得紧！）总结的真不错

Answer 19

final参数是好习惯，给参数变量赋值会让程序难懂。throw Exception是因为这个Test类是我专门拿来解决CSDN上问题的测试类，有时候用到的函数会要求try/catch异常，我就直接写在main上图个省事。这里并不需要，可以忽略
汗，我把final当做finally了最近刚学，有点晕

Answer 20

import java.util.Scanner;public class juzhen2Test {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int[][] juzhen;
System.out.println("请输入一个矩阵的边长：");
int a=input.nextInt();
juzhen=new int[a][a];
int i=0,j=0;
int n=1;
int direction=1;
for (int ceng=0;ceng<=(a-1)/2;n++)
{
juzhen[i][j]=n;
switch (direction)
{
case 1:
if (i<a-ceng-1)
{
i++;
break;
}
else
{
direction=2;
}
case 2:
if (j<a-ceng-1)
{
j++;
break;
}
else
{
direction=3;
}
case 3:
if (i>ceng)
{
i--;
break;
}
else
{
direction=4;
}

case 4:
j--;
if (j<=ceng+1)
{
ceng++;
direction=1;
}
}
}
for (i=0;i<a;i++)
{
for (j=0;j<a;j++)
{
System.out.print((juzhen[i][j]<10?" ":"")+juzhen[i][j]+" ");
}
System.out.println();
}
}
}结果：
请输入一个矩阵的边长：
5
 1 16 15 14 13 
 2 17 24 23 12 
 3 18 25 22 11 
 4 19 20 21 10 
 5  6  7  8  9 
Sorry,本人习惯C#了，大括号都占一行