好好玩的螺旋算法No.69

看到一个小伙伴分享这么一个东西，觉得蛮好玩的。先上图。我觉得蛮好玩的，就心心念念想着分享给你们也玩玩，顺便自己实现了一遍。

好，现在开始说是怎么玩的。

首先我观察到的一个科学的知识。我们假设为 size 为 N 的我们叫做 N 阶螺旋矩阵。如果 N = 1。直接输出就行了。如果 N 为偶数，那么最大值在左下角。如果 N 为奇数，那么最大值在右上角。

那么怎么去形成这样一个圈圈呢？可好玩了。

我们先在初始化的位置放一个小蕉，最大值 Math.pow(N,2) 。然后给它定义这么一些简单的一个指令，然后放小蕉自己去跑就行了。

如果N为偶数，那么第一步向右走。

如果N为奇数，那么第一步向左走。

向右走的时候如果撞到边界或其他数字了，向上走。否则继续向右走。

向上走的时候如果撞到边界或其他数字了，向左走。否则继续向上走。

向左走的时候如果撞到边界或其他数字了，向下走。否则继续向左走。

向下走的时候如果撞到边界或其他数字了，向右走。否则继续向下走。

每次走的时候都把当前的位置填上。

详细代码在这，常打小玩具手不生。

自己拿去玩玩吧~掰掰。欢迎交流。

import org.junit.Test;
import utils.Printer;

/**
 * Created by callmedj on 17/11/14.
 */
public class Scroll {


@Test
    public void print(){
for(int i = 1 ; i < 10 ;i++){
            scroll(i);
            Printer.println("");
        }
    }

public void scroll(int num){
int size = num;
int initX,initY;
int currentNum = (int)Math.pow(size,2) ;

int maxLength = String.valueOf(currentNum).length();
        Integer[][] target = new Integer[size][size];


        Position current = new Position();

if(size == 1){
            target[0][0] = 1;
            Printer.printArray(target,maxLength);
return;
        }
else if(size % 2 ==0){
            initX = size-1;
            initY = 0;
            current.setX(initX).setY(initY);
            current.setDirection(Direction.RIGHT);

        }else{
            initX = 0;
            initY = size-1;
            current.setX(initX).setY(initY);
            current.setDirection(Direction.LEFT);
        }
          target[current.getX()][current.getY()] = currentNum--;

for(int i = 1 ; i < Math.pow(size,2);i++){
            current =   move(target,current,currentNum--);
// Printer.printArray(target);
        }

        Printer.printArray(target,maxLength);
    }



private Position move(Integer[][] target , Position currentPosition,int num){
int row = target.length;
int column = target[0].length;

int nextX = 0,nextY = 0;

         Direction direction = currentPosition.getDirection();
         Position next = new Position();
switch (direction){
case LEFT:
if(currentPosition.getY()-1 >= 0 && target[currentPosition.getX()][currentPosition.getY()-1] == null){
                    nextX = currentPosition.getX();
                    nextY = currentPosition.getY()-1;
                    next.setDirection(Direction.LEFT);
                }else{
                    nextX = currentPosition.getX()+1;
                    nextY = currentPosition.getY();
                    next.setDirection(Direction.DOWN);
                }


break;
case RIGHT:

if(currentPosition.getY()+1 <= column - 1 && target[currentPosition.getX()][currentPosition.getY()+1] == null){
                    nextX = currentPosition.getX();
                    nextY = currentPosition.getY()+1;
                    next.setDirection(Direction.RIGHT);
                }else{
                    nextX = currentPosition.getX()-1;
                    nextY = currentPosition.getY();
                    next.setDirection(Direction.UP);
                }

break;

case UP:

if(currentPosition.getX()-1 >= 0  && target[currentPosition.getX()-1][currentPosition.getY()] == null){
                    nextX = currentPosition.getX()-1;
                    nextY = currentPosition.getY();
                    next.setDirection(Direction.UP);
                }else{
                    nextX = currentPosition.getX();
                    nextY = currentPosition.getY()-1;
                    next.setDirection(Direction.LEFT);
                }



break;

case DOWN:

if(currentPosition.getX()+1 <= row-1  && target[currentPosition.getX()+1][currentPosition.getY()] == null){
                    nextX = currentPosition.getX()+1;
                    nextY = currentPosition.getY();
                    next.setDirection(Direction.DOWN);
                }else{
                    nextX = currentPosition.getX();
                    nextY = currentPosition.getY()+1;
                    next.setDirection(Direction.RIGHT);
                }

break;
        }

        next.setX(nextX).setY(nextY);
        target[nextX][nextY] = num;

return next;
    }

private enum   Direction{
LEFT,RIGHT,UP,DOWN
    }





private class Position{
private int x;
private int y;
private Direction direction;

        Position(){}
        Position(int x,int y){
this.x = x;
this.y = y;
        }

public int getX() {
return x;
        }

public Position setX(int x) {
this.x = x;
return this;
        }

public int getY() {
return y;
        }

public Position setY(int y) {
this.y = y;
return this;
        }

public Direction getDirection() {
return direction;
        }

public Position setDirection(Direction direction) {
this.direction = direction;
return this;
        }
    }
}

public class Printer<V> {
public static void println(Object object){
        System.out.println(object);
    }
public static void print(Object object){
        System.out.print(object);
    }

public  void printList(List<V> objectList){
for(V object : objectList){
println(object);
        }
    }

public static void printArray(Object[][] target,int maxLength){
if(target == null || target.length==0){
return;
        }
int row = target.length;
int column = target[0].length;
for(int i = 0 ; i < row;i++){
for(int j=0;j<column;j++){
                String current = target[i][j]+"";
int needToAddZero = maxLength - current.length();
for(int k = 0 ; k < needToAddZero ; k++){
print(0);
                }
print(current+" ");
            }
println("");
        }
    }


}

赞赏代表认可