1

チェス盤の境界線を作ろうとして、上から下に 8-1、左から右に走るのにちょっと行き詰まりました。それを行う方法がよくわかりません。アドバイスとヘルプは大歓迎です！乾杯 ：）

現在の出力は次のとおりです。

BR BKn BB BK BQ BB BKn BR
BP BP BP BP BP BP BP

WP WP WP WP WP WP WP WP
WR WKn WB WK WQ WB WKn WR

以下は Java コードです。

public class ex5 {
public enum Chessmen {
    WHITE_KING,
    WHITE_QUEEN,
    WHITE_ROOK,
    WHITE_BISHOP,
    WHITE_KNIGHT,
    WHITE_PAWN,
    BLACK_KING,
    BLACK_QUEEN,
    BLACK_ROOK,
    BLACK_BISHOP,
    BLACK_KNIGHT,
    BLACK_PAWN,
    EMPTY
}
public static void printBoard (Chessmen [][] chessboard){
    for (int i=0; i<chessboard.length;i++){
        for (int j = 0; j<chessboard.length;j++){
            switch (chessboard [i][j]){
            case WHITE_KING:
                System.out.print("WK\t");
                break;
            case WHITE_QUEEN:
                System.out.print("WQ\t");
                break;
            case WHITE_ROOK:
                System.out.print("WR\t");
                break;
            case WHITE_BISHOP:
                System.out.print("WB\t");
                break;
            case WHITE_KNIGHT:
                System.out.print("WKn\t");
                break;
            case WHITE_PAWN:
                System.out.print("WP\t");
                break;
            case BLACK_KING:
                System.out.print("BK\t");
                break;
            case BLACK_QUEEN:
                System.out.print("BQ\t");
                break;
            case BLACK_ROOK:
                System.out.print("BR\t");
                break;
            case BLACK_BISHOP:
                System.out.print("BB\t");
                break;
            case BLACK_KNIGHT:
                System.out.print("BKn\t");
                break;
            case BLACK_PAWN:
                System.out.print("BP\t");
                break;
            default:
                System.out.print(" " + "\t");
                break;
            }
        }
        System.out.println("");
    }
}



public static void main(String[] args) {
    int Rows = 8;
    int Columns = 8;
    Chessmen [][] chessboard = new Chessmen [Rows][Columns];
    for (int i=0;i<chessboard.length; i++){
        for (int j=0;j<chessboard[0].length;j++){
            if (i==1){
                chessboard [i][j]= Chessmen.BLACK_PAWN;
            }else if (i==6){
                chessboard [i][j]= Chessmen.WHITE_PAWN;
            }else if ((i==0&&j==7)||(i==0&&j==0)){
                chessboard [i][j]= Chessmen.BLACK_ROOK;
            }else if ((i==0&&j==1)||(i==0&&j==6)){
                chessboard [i][j] = Chessmen.BLACK_KNIGHT;
            }else if ((i==0&&j==2)||(i==0&&j==5)){
                chessboard [i][j] = Chessmen.BLACK_BISHOP;
            }else if (i==0&&j==3){
                chessboard [i][j] = Chessmen.BLACK_KING;
            }else if (i==0&&j==4){
                chessboard [i][j] = Chessmen.BLACK_QUEEN;
            }else if ((i==7&&j==0)||(i==7&&j==7)){
                chessboard [i][j]= Chessmen.WHITE_ROOK;
            }else if ((i==7&&j==1)||(i==7&&j==6)){
                chessboard [i][j] = Chessmen.WHITE_KNIGHT;
            }else if ((i==7&&j==2)||(i==7&&j==5)){
                chessboard [i][j] = Chessmen.WHITE_BISHOP;
            }else if (i==7&&j==3){
                chessboard [i][j] = Chessmen.WHITE_KING;
            }else if (i==7&&j==4){
                chessboard [i][j] = Chessmen.WHITE_QUEEN;
        }else {
                chessboard [i][j]= Chessmen.EMPTY;
            }

        }   

    }
        printBoard (chessboard);

}
}
4

4 に答える 4

2

他の人が言ったように、空の行と空の正方形を行に表示する必要があります。また、すべてのマスに同じ量の文字を印刷する必要があるため、黒の夜には BN、黒の王には BK を使用することをお勧めします。N は、キングと区別するために、代数チェス記法でナイトを表すために使用されます。

この問題は C++ で既に解決しているので、以下にコードを掲載します。これを Java で変換するアルゴリズムとして使用できます。次のようなボードが表示されます。

  (Coups reversibles : 0)
  +-X-+---+---+---+---+---+---+-X-+
8 |=R=|=N=|=B=|=Q=|=K=|=B=|=N=|=R=|
  +---+---+---+---+---+---+---+---+
7 |=P=|=P=|=P=|=P=|=P=|=P=|=P=|=P=|
  +---+---+---+---+---+---+---+---+
6 |   | . |   | . |   | . |   | . |
  +---+---+---+---+---+---+---+---+
5 | . |   | . |   | . |   | . |   |
  +---+---+---+---+---+---+---+---+
4 |   | . |   | . |   | . |   | . |
  +---+---+---+---+---+---+---+---+
3 | . |   | . |   | . |   | . |   |
  +---+---+---+---+---+---+---+---+
2 | P | P | P | P | P | P | P | P |
  +---+---+---+---+---+---+---+---+
1 | R | N | B | Q | K | B | N | R |
=>+-X-+---+---+---+---+---+---+-X-+
    a   b   c   d   e   f   g   h

それには、いくつかの興味深い機能があると思います。ピースのない黒い四角形は、中央にドットがあります。ボードの下部または上部にある矢印は、次に移動する側をユーザーに示します。「X」またはその不在は、ルークがキャスティングできるかどうかを示します。列の下にある矢印「^」は、その列のポーンを「アンパッサン」で取得できることを示します。

コードは次のとおりです（エラーがある可能性があります。フランス語から識別子とコメントを翻訳しただけで、再度コンパイルする必要はありません）：

///////////////////////////////////////////////////////////////////////////
   std::ostream& operator << (std::ostream& out, const CPlanche& planche)
   {
      static const string piecesNames[] = {"   ","   ",
                                            " P ","=P=",
                                            " N ","=N=",
                                            " K ","=K=",
                                            "   ","   ",
                                            " B ","=B=",
                                            " R ","=R=",
                                            " Q ","=Q="};

      // We display how many revirsable moves have been playes
      out <<"  (Coups reversibles : " <<board.RecersiblesMoves() <<")\n";

      // If it's black to move we display an arrow
      if (board.ColorToMove() == BLACK)
      {
         out <<"=>";
      }
      else
      {
         out <<"  ";
      }

      // We display the top line
      out <<"+-" <<(Board.Castling(Black, QueenSideCastling)?'X':'-') <<"-+---+---+---+---+---+---+-" <<(board.Castling(Black, LingSideCastling)?'X':'-') <<"-+\n";

      // We display all 8 lines
      for (int line = 0; line < 8; line++)
      {
        out <<(char)('8' - line) <<' ';

        // for each column
        for (int column = 0; column < 8; column++)
        {
          out <<'|';

          if (board[56 - 8 * line + column] != EMPTY)
          {
             out <<piecesNames[board[56 - 8 * iLigne + column]];
          }
          else
          {
            // If both the line and column are even OR if both are odds
            if (!((line | column) & 1) || (line & column & 1))
            {
               out <<"   ";
            }
            else
            {
               out <<" . ";
            }
          }
        }

        out <<"|\n";

        if (line != 7)
        {
          out <<"  +---+---+---+---+---+---+---+---+\n";
        }
      }

      // If it's white to move we display an arrow
      if (board.ColorToMove() == WHITE)
      {
         out <<"=>";
      }
      else
      {
         out <<"  ";
      }

      // We display the bottom line
      out <<"+-" <<(planche.Castling(WHITE, CastlingQueenSide)?'X':'-') <<"-+---+---+---+---+---+---+-" <<(Board.Castling(WHITE, CastlingKingSide)?'X':'-') <<"-+\n";

      // Whe display the arrow for the prise en passant if there is one.
      if (board.ColumnPriseEnPassant() != NO_PRISE_EN_PASSANT)
      {
         for (int i = 0; i < (board.ColumnPriseEnPassant() + 1); i++)
         {
            out <<"    ";
         }
         out <<"^\n";
      }

      // We display the columns letters
      out <<"    a   b   c   d   e   f   g   h\n";

      return out;
   }

これが役立つことを願っています。

mp

于 2011-10-07T11:57:49.110 に答える
2

System.out.println("+--------------------------------+")外側のレンダリング ループの前後に呼び出します。

System.out.print("|")内部レンダリング ループの前後に呼び出します。

少し微調整する必要があります。

于 2011-10-05T16:16:30.990 に答える
0

Java の N クイーン問題でこれを行いました。したがって、クイーン以外の部分を印刷しようとしている場合は、それに応じてコードを調整してください。この問題に慣れていない場合は、2 つのクイーンが互いにチェックしないように、N x N のチェス盤に N 個のクイーンを配置するという課題です。これはあなたが質問を投稿してから何年も経っていることは知っていますが、将来誰かが使用できるようにコードスニペットをここに置くと思いました.

とにかく、最初のステップは、チェス盤のスペースと現在盤上にある駒の値を表す N x N 配列を作成することです。これは Java であるため、ボードは 0 ベースであることに注意してください (各行のスペースには 1 ～ 8 ではなく、0 ～ 7 の番号が付けられています)。

public static final int N = 8;
public static char [][] board = new char[N][N];
//initialize every space to a space
for(int i = 0; i < N; i++){
    for(int j = 0; j < N; j++){
        board[i][j] = ' ';
    }
}

すべてのスポットをスペースに初期化して、クイーンの位置に対して持っているベクトルを反復処理し、クイーンを配置する必要があるスポットのみを変更できるようにします。

解のベクトルの例を次に示します[1 6 2 5 7 4 0 3]。このベクトルが で表されると仮定しましょうint[] vector = new int[N]。要素の数は、ボードの行の数と同じです。ベクトルのインデックスは行に対応し、値自体はその行にあるクイーンの列番号に対応します。したがって、これらをループして、それに応じてボード配列を更新します。

for(int j = 0; j < N; j++){
    board[j][vector[j]] = 'Q';
}

問題が実際のチェスの試合に関係している場合は、すべての駒を繰り返し処理し、同様の方法で盤上の位置を更新する必要があります。

このボードの作り方を説明する前に、先ほどのベクトルに対応するボードをお見せしましょう。余談ですが、どのクイーンもチェックしていないことに注意してください。遺伝的アルゴリズムを使用してこの問題を解決しました。

+---+---+---+---+---+---+---+---+
|   | Q |   |   |   |   |   |   | 
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   | Q |   | 
+---+---+---+---+---+---+---+---+
|   |   | Q |   |   |   |   |   | 
+---+---+---+---+---+---+---+---+
|   |   |   |   |   | Q |   |   | 
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   | Q | 
+---+---+---+---+---+---+---+---+
|   |   |   |   | Q |   |   |   | 
+---+---+---+---+---+---+---+---+
| Q |   |   |   |   |   |   |   | 
+---+---+---+---+---+---+---+---+
|   |   |   | Q |   |   |   |   | 
+---+---+---+---+---+---+---+---+

次のステップは、行の間 (および上下) に境界線を作成することです。各行をフォーマットされた文字列として扱います。スペース行とボーダー行があるため、行配列のサイズは 2 * N + 1 です。

String[] row = new String[2*N + 1];
String border = "";
//must be the length of board
for(int i = 0; i < N; i++){
    border += "+---";
}
border += "+";
//every other row is a border row
for(int i = 0; i < 2*N +1; i+=2){
    row[i] = border;
}
//must include the bottom
row[2*N] = border;

次に、ボード スペース自体の文字列を作成します。これらはすでに board[][] にあるので、フォーマットするだけです。

for(int i = 0; i < N; i++){
    //left bar
    String spaces = "| ";
    //place enclosing right bar and spaces so next char goes in middle of next space
    for(int j = 0; j < N; j++){
        spaces += board[i][j];
        spaces += " | ";
    }
    //add the spaces string to the rows at the odd indices
    row[2*k +1 ] = spaces;

}

あとはそのボードを印刷するだけです。

for(int i = 0; i < 2*N +1; i++){
    System.out.println(row[i]);
}

これが誰かに役立つことを願っています!

于 2014-03-20T01:09:55.953 に答える
0

[編集] あなたのコメントに応えて...

あなたが望むのは実際には10x10のグリッドだと思います。ロジックを調整して、ゲームエリアを10x10内の8x8としてのみ印刷し、外側の四角形(角を含まない)を使用して文字と数字を印刷する必要があります。[編集終了]

あなたのデフォルトは空ではなく、何もありません。スイッチで EMPTY ケースをキャッチし、タブを印刷すると、すべての空のスペースが表示されます

言い換えれば、代わりに

case BLACK_PAWN:
            System.out.print("BP\t");
            break;
        default:
            System.out.print(" " + "\t");
            break;
        }

あなたがしたい：

case BLACK_PAWN:
            System.out.print("BP\t");
            break;
        case EMPTY:
            System.out.print(" " + "\t");
            break;
        }
于 2011-10-05T16:21:11.680 に答える