Java 如果有其他选择

我有一个我正在编写的程序，其工作原理是填充一个二维数组来检查获胜条件，它是零和叉，所以只要点击一个按钮就填充二维数组，1代表一个圆，2代表一个叉，那么checkWin（）将根据这个原理工作，而不是实际的代码

if (myArray[0][0] == 1 && myArray[0][1] == 1 && myArray[0][2] == 1){
    setBoolWinVal = true;
} else {
    if(myArray[0][0] == 2 && myArray[0][1] == 2 && myArray[0][2] == 2){
    setBoolWinVal = true;
}

---

你可以立即看到，对于每一个获胜的条件，这将是混乱的，有没有办法重写这张胜利支票来缩短它一点？

这看起来像是家庭作业，所以我不会完全放弃它。但请注意以下几点：

• 当你在一行、一列或一条对角线上有三个相同的东西时，你就赢了

• 这并不是说你需要检查一行中是否有三个零或三个十字，而是一行中有三个相同的东西

您可以从编写一个函数开始，该函数确定行、列或对角线是否有三个相同类型的元素（并且该元素不是空白单元格）。然后对每一行、每一列和每一对角线调用该函数一次。

充满了家庭作业的味道

小提示-用于循环，它将适用于您想要的任何大小。如果您使用递归，则会获得额外的积分

定义：

---

递归->参见递归

如果数组的长度都相同，那么下面的内容应该会有所帮助

Arrays.equals(myArray[0], {1,1,1})

---

否则，编写一个函数，遍历

myArray[0]

中的所有值。最明显的方法是在行、列或对角线中的3个元素上循环，并检查它们是否相同

另一种方法是使用更紧凑的表示法-例如，int，其中9个单元格由每个2位表示，或两个短字符表示，每个播放器一个。然后使用查找表或按位操作将状态映射为赢-输

如果一个位代表一个单元格，并且您有一个填充位，则每个播放器的分片是3个十六进制数字0-7

对角线为：

cells & 0x421 == 0x421
cells & 0x124 == 0x124

cells & (cells>>4) & (cells>>8) != 0

垂直线为：

cells & 0x421 == 0x421
cells & 0x124 == 0x124

cells & (cells>>4) & (cells>>8) != 0

水平线

cells & (cells>>1) & (cells>>2) != 0

类似的技术使用64位模式来表示国际象棋游戏中可能的动作。

以下是（未经测试的）代码。这当然不是产品质量问题（代码>：）

请注意其他答案中的一些优化：

for循环的使用

我们检查相同的玩家值，而不是特定的玩家值

对角赢必须通过单元格[1][1]

int find_winner（int[]arr）{
//检查行
对于（int i=0；i<3；++i）{
int player=arr[i][0]；
if（player<1）continue；//注意：以前的版本没有检查空单元格
如果（arr[i][1]==玩家和&arr[i][2]==玩家）返回玩家；
}
//检查感冒
对于（int i=0；i<3；++i）{
int player=arr[0][i]；
如果（玩家<1）继续；
如果（arr[1][i]==玩家和&arr[2][i]==玩家）返回玩家；
}
//检查对角线
int player=arr[1][1]；
如果（玩家<1）返回-1；
如果（（arr[0][0]==玩家和&arr[2][2]==玩家）||
（arr[2][0]==玩家和&arr[0][2]==玩家））返回玩家；
//没有找到获胜者
返回-1；
}

给你两个有趣的想法：（我假设底层的1D数组，因为它使生活更轻松。）

首先：对要测试的位置进行编码。例如，如果您有描述字段的1D数组：

diag[] = { { 0, 1, 2}, {3, 4, 5}, {6, 7, 8},
           { 0, 3, 6}, {1, 4, 7}, {2, 5, 8},
           { 0, 4, 8}, {6, 4, 2}};

然后遍历diag：对于它的每个元素，测试三个相应的字段（使用

diag[i]

作为字段数组的索引）

秒：使用位字段表示字段。比如java.util.BitSet。然后将解决方案编码为{1,1,1,0,0,0,0,0,0}、{0,0,0,1,1,0,0,0}等位域。然后，如果

（字段和解决方案[i]==解决方案[i]）

，则可以测试（循环）。对于第二个玩家，只需使用

！if语句中的字段

---

很有趣，不是吗？p、 s:这取决于你如何用它来编写Java代码

因此，如果您仔细考虑，您将检查以下情况：

www   xxx   xxx  wxx
xxx   www   xxx  xwx
xxx   xxx   www  xxw

等

其中，w是检查是否获胜的对象，x是忽略的对象

（0,0）、（0,1）、（0,2）是第一个正确溶液中“w”的位置。 1,0,1,1和1,2是第二个，以此类推

在我看来，它应该是数据而不是代码。 诀窍是，如何有效地输入和存储数据

请注意，此数据开始看起来像数组索引

假设您有一个“解决方案”数组，其中包含8对x，y对（每个表示一个获胜的解决方案组合）

然后，您所要做的就是迭代这个集合，提取三个x，y对并测试它们。所以这和你所拥有的相似，但是在你有数字的地方使用变量

if(myArray[x0][y0] == 2 && myArray[x1][y1] == 2 && myArray[x2][y2] == 2){
    win();

当您对它进行迭代时，索引变量将替换为数据的下一行

---

既然你不想在获胜后报告失败，你就必须稍微调整一下逻辑，以确保循环停止，但对于家庭作业式的问题来说，这可能已经太有帮助了。

这听起来像是一个家庭作业，但我将帮助解决一个简单的问题，即浏览行和列，检查他们是否都满了，对角线稍微难一点，我让你们自己决定。 同样，我认为嵌套for循环是最好的主意：

java.util.Arrays;

public yourClass{

public void findAnswer{

int initialVal = 0;

int copy = 0;

int column = 0;

boolean columnVal = true;

boolean rowVal = false;

for (int j = 0; j< myArray.length; j++){ //presuming myArray and myArray[] are same length

boolean firstRun = true;

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

        initialVal = myArray[i][column];
        if (firstRun == true){
            copy = intialVal; //makes a copy for the first time, to compare
            firstRun = false;
        }
        if (intialVal != copy){
            columnVal = false; //realises this column isnt a full column i.e. 3 1's or 2's in column
            return;
        }else
            columnVal = true;

        }//end nested for loop

    rowVal = findRow(j); 
    if(rowVal = true)
    return;
}

public boolean findRow(int row){

    int[] tempRow1, tempRow2;
    Arrays.fill(tempRow1, 1); 
    Arrays.fill(tempRow2, 2); //fills temp arrays for comparison
    boolean answer = false;
    if (Arrays.equals(myArray[], tempRow1) || Arrays.equals(myArray[], tempRow2) //this tests either, || being logical OR
        answer = true;
    return answer;
}
}

java.util.array；
公共课{
公共无效查找器{
int initialVal=0；
int copy=0；
int列=0；
布尔columnVal=true；
布尔值rowVal=false；
对于（int j=0；j在0..19683（3到9）中将板表示为整数
预先生成赢家板，并确定每个板中谁是赢家，可能是手工操作
在运行时，在预先计算的地图中查找当前板
对于nxn矩阵

//Check all horizontal rows
for(i=0; i<n && !setBoolWinVal; i++) //row
{
    setBoolWinVal = true;
    for(j=0; j<n-1; j++)
    {
        if( myArray[i][j] != myArray[i][j+1] ) //column
        {
            setBoolWinVal = false;
            break;
        }
    }

    if(setBoolWinVal) declareWinner(myArray[i][0]);
}

//Check all vertical columns
if(!setBoolWinVal)
{
    for(i=0; i<n && !setBoolWinVal; i++) //column
    {
        setBoolWinVal = true;
        for(j=0; j<n-1; j++) //row
        {
            if( myArray[j][i] != myArray[j+1][i] ) 
            {
                setBoolWinVal = false;
                break;
            }
        }
    }

    if(setBoolWinVal) declareWinner(myArray[0][i]);
}


//Check forward diagonal
if(!setBoolWinVal)
{
    setBoolWinVal = true;
    for(i=0; i<n-1; i++)
    {
        if( myArray[i][i] != myArray[i+1][i+1])
        {
            setBoolWinVal = false;
            break;
        }
    }

    if(setBoolWinVal) declareWinner(myArray[0][0]);
}

//Check reverse diagonal
if(!setBoolWinVal)
{
    setBoolWinVal = true;
    for(i=0, j=n-1; i<n-1 && j>0; i++, j--)
    {
        if( myArray[i][j] != myArray[i+1][j-1])
        {
            setBoolWinVal = false;
            break;
        }
    }

    if(setBoolWinVal) declareWinner(myArray[0][n-1]);
}

//检查所有水平行
对于（i=0；i你也可以解这个iter
boolean hasWon(int squareIndex) {
    return squarePairs[WINNINGSUM - squareIndex];
}

void update(int squareIndex) {
    for (int i = 1; i <= NUMSQUARES; i++) {
        if (chosenSquares[i]) {     {
            squarePairs[i + squareIndex] = true;
        }
    }
    chosenSquares[squareIndex] = true;
}