C++ 显示可能的象棋在空棋盘中移动

Question

This task asks to display possible bishop moves in a chessboard (8 x 8) as in an example shown below:

x = 4, y = 4
1 0 0 0 0 0 1 0,
0 1 0 0 0 1 0 0,
0 0 1 0 1 0 0 0,
0 0 0 2 0 0 0 0,
0 0 1 0 1 0 0 0,
0 1 0 0 0 1 0 0,
1 0 0 0 0 0 1 0,   
0 0 0 0 0 0 0 1

Image for clear understanding

    #include <iostream>

using namespace std;

int main() {
int array[8][8], x , y;

for (int i = 0; i < 8; i++)
{
    for (int j = 0; j < 8; j++)
    {
        array[i][j] = 0;
    }
}

cout << "Input x coordinate: ";
cin >> x;

cout << "Input y coordinate: ";
cin >> y;

for (int i = 0; i < 8; i++) 
    { // 1st diagonal
        array[x + i][y + i] = 1;
        array[x - i][y - i] = 1;
    }

    for (int i = 0; i < 8; i++) 
    { // 2nd diagonal
        array[x + i][y - i] = 1;
        array[x - i][y + i] = 1;
    }

array[x][y] = 2;

for (int i = 0; i < 8; i++) //Cout
{
    for (int j = 0; j < 8; j++)
    {
        cout << array[i][j];
    }
    cout << endl;
}

return 0;
}

It seems to work only with 1st diagonal

Answer 1

This is more of an algorithm/math answer than C++.

Suppose the grid's bottom left point is the origin (ie i = 0, j = 0 ), and the coordinate of the top right point in the grid is i=7, j=7 .

A bishop that is on i=0, j=0 can hit anything on these two lines:

i = j and i = - j

When you put the bishop at point x, y instead of 0,0 , these lines change to:

i - x = j - y and i - x = - (j - y)

Now, you can iterate all points in the matrix and check which ones satisfy the line equation:

int main() {
  int x, y;

  std::cout << "Input x coordinate: ";
  std::cin >> x;

  std::cout << "Input y coordinate: ";
  std::cin >> y;

  int array[8][8];

  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
      if ((i - x == j - y) || (i - x == -(j - y))) {
        array[i][j] = 1;
      } else {
        array[i][j] = 0;
      }
    }
  }

  array[x][y] = 2;

  // We should print the matrix from top to bottom.
  // j represents the y coordinate, and i represents the x coordinate.
  for (int j = 7; j >= 0; j--) {
    for (int i = 0; i < 8; i++) {
      std::cout << array[i][j];
    }
    std::cout << std::endl;
  }
  return 0;
}

Answer 2

It looks like it's working for both diagonals when I run it. There is a small bug that might mess things up though. You'll want to add bounds checks like this:

    for (int i = 0; i < 8; i++) 
    { // 1st diagonal
        if (x + i < 8 && y + i < 8)
            array[x + i][y + i] = 1;

        if (x - i >= 0 && y - i >= 0)
            array[x - i][y - i] = 1;
    }

    for (int i = 0; i < 8; i++) 
    { // 2nd diagonal
        if (x + i < 8 && y - i >= 0)
            array[x + i][y - i] = 1;

        if (x - i >= 0 && y + i < 8)
            array[x - i][y + i] = 1;
    }

Without these bounds checks you'll be accessing elements outside of the array bounds and could be messing up other entries in the array. There are other ways to do the bounds checking, but this might be the easiest.

To illustrate the issue, assume x = 4 and then in the for loop when i = 5 . When you're indexing into the array with array[x - i] that'll be the same as array[-1] . When you index into an array with a negative value you'll be messing with the wrong memory.

Answer 3

I would start with a very simple case.

Suppose we want to plot the diagonal matrix of size 4x4:

 i  0 1 2 3
j   
0   1 0 0 0
1   0 1 0 0
2   0 0 1 0
3   0 0 0 1

We have a non zero value when:

i = j   (I)

Now, suppose we shift this diagonal horizontally so that the non-zero value of the first line is located at X ₀ . For example, for X ₀ = 1:

      X0

 i' 0 1 2 3
j'  
0   0 1 0 0
1   0 0 1 0
2   0 0 0 1
3   0 0 0 0

The shifted coordinates are:

i' = i + X0 (II)

Doing the same for shifting vertically by Y ₀ :

j' = j + Y0 (III)

With (II) and (III) in (I) we have:

i' - X0 = j' - Y0   (IV)

Now we do the same for the antidiagonal matrix:

 i  0 1 2 3
j   
0   0 0 0 1
1   0 0 1 0
2   0 1 0 0
3   1 0 0 0

We have a non zero value when:

j = 3 - i   (V)

Shifting horizontally by X ₀ we have:

i' = -3 + i + X0    (VI)

Shifting vertically by Y ₀ :

j' = j + Y0         (VII)

With (VI) and (VII) in (V):

j' - Y0 = X0 - i'   (VIII)

The code just needs to check for (IV) and (VIII):

#include <iostream>
using namespace std;

int main()
{
    int array[8][8] = {0,};

    int x = 0;
    int y = 0;
    
    cout << "Input x coordinate: ";
    cin >> x;
    
    cout << "Input y coordinate: ";
    cin >> y;
    
    for (int j = 0; j < 8; j++)
        for (int i = 0; i < 8; i++) 
            if (   i - x == j - y
                || j - y == x - i)
                array[j][i] = 1;
    
    array[y][x] = 2;

    for (int j = 0; j < 8; j++)
    {
        for (int i = 0; i < 8; i++)
            cout << array[j][i];
        cout << endl;
    }
    
    return 0;
}

Note that the matrix is plotted following the convention array[lines][columns] , so to set cartesian coordinates we write array[y][x] .