在Java中获取超时错误

我正在进行谷歌挑战赛，我必须解决一个难题。对于这个谜题，我必须测试在任何四个面上碰到它的任何数字是否等于一。如果是这样的话，我必须换成相反的。如果是一，那么是零。如果零等于一。当我尝试运行以下代码时，我尝试运行它的代码实验室会显示以下“代码超时”。我检查了它，它看起来不应该是无限的。不管它最终应该返回-1或步骤数。有人能解释一下吗

import java.util.Arrays;

public class FooReal {

    public static boolean[] elementsOn = {false, false};

    public static void main(String args[]) {
        int[][] grid = {{1, 1}, {0, 0,}};
        System.out.println(answer(grid));
    }

    public static int answer(int[][] grid) {
        int steps = 0;

        while (containsOn(grid)) {
            for (int index = 0; index < grid.length; index++) {
                for (int subIndex = 0; subIndex < grid[index].length; subIndex++) {
                    if (grid[index][subIndex] == 1) {
                        elementsOn = isElementOn(grid, new int[] {index, subIndex});
                        if (elementsOn[0] || elementsOn[1]) {
                            steps++;
                            for (int counter = 0; counter < grid.length; counter++) {
                                if (grid[counter][subIndex] == 1) {
                                    grid[counter][subIndex] = 0; 
                                } else {
                                    grid[counter][subIndex] = 1;
                                }
                            }

                            for (int counterTwo = 0; counterTwo < grid[index].length; counterTwo++) {
                                if (grid[index][counterTwo] == 1) {
                                    grid[index][counterTwo] = 0;
                                } else {
                                    grid[index][counterTwo] = 1;
                                }
                            }

                            if (grid[index][subIndex] == 1) {
                                grid[index][subIndex] = 0;
                            } else {
                                grid[index][subIndex] = 1;
                            }
                        }
                    }
                }

                if (steps > 15) {
                    steps = -1;
                    return steps;
                }

            }
        }
        return steps;
    }

    public static boolean[] isElementOn(int[][] grid, int[] elements) {
        boolean[] elementsOn = {false, false};

        //Check if any are on in x row.
        try {
            if (grid[elements[0] + 1][elements[1]] == 1) {
                elementsOn[0] = true;
            }
        } catch (ArrayIndexOutOfBoundsException e) {}
        try {
            if (grid[elements[0] - 1][elements[1]] == 1) {
                elementsOn[0] = true;
            }
        } catch (ArrayIndexOutOfBoundsException e) {}

        //Check if any are on in y row.
        try {
            if (grid[elements[0]][elements[1] + 1] == 1) {
                elementsOn[1] = true;
            }
        } catch (ArrayIndexOutOfBoundsException e) {}
        try {
            if (grid[elements[0]][elements[1] - 1] == 1) {
                elementsOn[1] = true;
            }
        } catch (ArrayIndexOutOfBoundsException e) {}

        return elementsOn;
    }

    public static boolean containsOn(int[][] grid) {
        for (int index = 0; index < grid.length; index++) {
            for (int subIndex = 0; subIndex < grid[index].length; subIndex++) {
                if (grid[index][subIndex] == 1) {
                    return true;
                }
            }
        } return false;
    }

}

导入java.util.array；
公共类食品{
公共静态布尔值[]elementsOn={false，false}；
公共静态void main（字符串参数[]）{
int[][]网格={{1，1}，{0，0，}；
System.out.println（应答（网格））；
}
公共静态int应答（int[][]网格）{
int步数=0；
while（containsOn（网格））{
对于（int index=0；index15）{
步骤=-1；
返回步骤；
}
}
}
返回步骤；
}
公共静态布尔[]isElementOn（int[][]网格，int[]元素）{
boolean[]elementsOn={false，false}；
//检查x行中是否有任何显示。
试一试{
if（网格[元素[0]+1][元素[1]]==1）{
elementsOn[0]=真；
}
}捕获（ArrayIndexOutOfBoundsException e）{}
试一试{
if（网格[元素[0]-1][元素[1]]==1）{
elementsOn[0]=真；
}
}捕获（ArrayIndexOutOfBoundsException e）{}
//检查y行中是否有任何显示。
试一试{
if（网格[元素[0]][元素[1]+1]==1）{
elementsOn[1]=真；
}
}捕获（ArrayIndexOutOfBoundsException e）{}
试一试{
if（网格[元素[0]][元素[1]-1]==1）{
elementsOn[1]=真；
}
}捕获（ArrayIndexOutOfBoundsException e）{}
返回元素；
}
公共静态布尔containsOn（int[][]网格）{
对于（int index=0；index

“我检查过，似乎循环不应该是无限的”=>您是如何检查的？您是否尝试过一步一步地调试代码，以了解它为什么不退出？超时？您是否连接到http服务器、套接字等？似乎嵌套循环的复杂性太高，您可能需要重构。@EleazarEnrique OP正在代码实验室上运行。它可能会限制运行时间和其他特性以避免DoS。正如@TheLaw所说，您必须重构代码以测试原子代码。