java - 迭代给定原点的对角线和轴 - java

Question

我遇到了一个问题，我想知道一些如何解决它的想法。我有一个二维矩阵，给定该矩阵上的一个点，我需要向上、向下、向右、向左以及对角线移动查找十个单元格(参见下图)。

我正在做的是选择 i 和 j 的值作为要相乘的值通过位置坐标并给出我在每种情况下想要的方向。例如:

• 对角线 A:i=1 j=-1，因为 i 增加而 j 减少
• 对角线 B:i=1 j=1，因为两者都增加

对于垂直和水平移动，i 和 j 将取值 1 或 0。

有了这两个值，我可以取中心并向其添加一个值，从该值开始为 1，然后增加它直到达到极限 (10)。如果中心是 (2,4) 并且我在对角线 A 中，我将为具有以下值的每个坐标添加从 1 开始乘以 i 和 j 的值结果:

• (3,3) (4,2) (5,1) (6,0)

现在我有兴趣计算 i 和 j，以便它们获取对角线和轴所需的所有值。我的循环内的java代码如下:

            GS.r++;
            if (GS.r > 10) {
                GS.r = 0;
                if (GS.iteration) {
                    int i = 0, j = 0;
                    if (GS.i == 1) {
                        i = -1;
                    } else if (GS.i == -1) {
                        i = 0;
                        j = 1;
                    }
                    if (GS.j == 1) {
                        j = -1;
                    } else if (GS.j == -1) {
                        j = 0;
                        i = 1;
                    }
                    GS.i = i;
                    GS.j = j;
                    if (GS.i == 1 && GS.j == 0) {
                        GS.iteration = false;
                        GS.i = -1;
                        GS.j = -1;
                    }
                } else {
                    if (GS.i == 1 && GS.j == 1) {
                        GS.iteration = true;
                        GS.i = 1;
                        GS.j = 0;
                    } else {
                        if (GS.i == 1)
                            GS.j *= -1;
                        GS.i *= -1;
                    }
                }

            }

GS.i 和 GS.j 初始化为 -1。通过这段代码，我首先得到对角线，因为 GS.i 和 GS.j 的值将是 (-1,-1) (1, -1) (-1, 1) (1, 1) 然后轴具有以下值:(-1, 0) (1, 0) (0, -1) (0, 1) 。

我想知道是否有更好的方法来生成 i 和 j，因为我的代码不是那么干净。

谢谢!

Answer 1

我要做的是为您可以移动的所有四个方向创建一个枚举，即对角线右上、对角线右下、对角线左上和对角线左下。

示例代码:

public enum Direction {
    DIAGONAL_RIGHT_UP(1,1),
    DIAGONAL_RIGHT_DOWN(1,-1),
    DIAGONAL_LEFT_UP(-1,1),
    DIAGONAL_LEFT_DOWN(-1,-1);

    public int x;
    public int y;

    private Direction(int xCoordinateChange,int yCoordinateChange) {
         x=xCoordinateChange;
         y=yCoordinateChange;
    }
}

然后用这个来遍历。

public class CartesianCoordinate {
    private long xCoordinate;
    private long yCoordinate;

    public CartesianCoordinate(long xCoordinate,long yCoordinate) {
        this.xCoordinate=xCoordinate;
        this.yCoordinate=yCoordinate;
    }

    public long getXCoordinate() {
        return xCoordinate;
    }

    public long getYCoordinate() {
        return yCoordinate;
    }

    public void moveCoordinateByStepSize(Direction direction,long stepSize) {
        xCoordinate+=direction.x*stepSize;
        yCoordinate+=direction.y*stepSize;
    }

    @Override
    public int hashCode() {
        int hashCode=0;
        hashCode += (int)(xCoordinate-yCoordinate)*31;
        hashCode += (int)(yCoordinate+xCoordinate)*17;
        return hashCode;
    }

    @Override
    public boolean equals(Object object) {
        if(object == null || !(object instanceof CartesianCoordinate)) {
            return false;
        }
        if( this == object) {
            return true;
        }
        CartesianCoordinate cartesianCoordinateObject = (CartesianCoordinate)object;
        if(xCoordinate == cartesianCoordinateObject.getXCoordinate() && yCoordinate == cartesianCoordinateObject.getYCoordinate()) {
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "["+xCoordinate+","+yCoordinate+"]";
    }

    public CartesianCoordinate getAClone() {
       return new CartesianCoordinate(xCoordinate,yCoordinate);
    }
}

现在假设您有一个点 (1,3) 作为起点。您可以做的是在特定行中进行 100 次迭代。

CartesianCoordinate startingPoint = new CartesianCoordinate(1,3);
CartesianCoordinate rightUpDiag = startingPoint.getAClone(),leftUpDiag = startingPoint.getAClone(),rightDownDiag = startingPoint.getAClone(),leftDownDiag = startingPoint.getAClone();
for(int counter = 0 ;counter < 100; counter ++) {
   System.out.println(rightUpDiag.moveCoordinateByStepSize(Direction.DIAGONAL_RIGHT_UP,1));
   System.out.println(leftUpDiag.moveCoordinateByStepSize(Direction.DIAGONAL_LEFT_UP,1));
   System.out.println(rightDownDiag.moveCoordinateByStepSize(Direction.DIAGONAL_RIGHT_DOWN,1));
   System.out.println(leftDownDiag.moveCoordinateByStepSize(Direction.DIAGONAL_LEFT_DOWN,1));
}