精华内容
下载资源
问答
  • 自动井字游戏 无需事先知道规则即可玩井字游戏的AI。 它通过玩足够的游戏并被告知结果来学习规则
  • 盗版井字游戏-源码

    2021-02-21 06:30:19
    初始井字游戏规则 根据,初始/最终井字游戏的规则定义为:每个3×3小井字游戏板均称为本地板,而较大的3×3井字游戏板称为全球板。 游戏从在81个空位中的任意位置播放X开始。 此举将其对手“发送”到其相对位置。 ...
  • 经典井字游戏 规则: 玩家选择X或O开始与计算机(或其他玩家)对战。 游戏的目的是以垂直,水平或对角线方式将3个相同字母(X或O)放置在相邻的盒子中以赢得游戏。 玩家还必须在此过程中阻止对方的字母。
  • 井字游戏

    2020-07-14 23:43:17
    以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符"O",且第二个玩家总是放字符"X"。 "X"和"O"只允许放置在空位中,不允许对已放有字符的位置进行填充。 当有N个相同(且非空)的...

    设计一个算法,判断玩家是否赢了井字游戏。输入是一个 N x N 的数组棋盘,由字符" ","X"和"O"组成,其中字符" "代表一个空位。

    以下是井字游戏的规则:

    玩家轮流将字符放入空位(" ")中。
    第一个玩家总是放字符"O",且第二个玩家总是放字符"X"。
    "X"和"O"只允许放置在空位中,不允许对已放有字符的位置进行填充。
    当有N个相同(且非空)的字符填充任何行、列或对角线时,游戏结束,对应该字符的玩家获胜。
    当所有位置非空时,也算为游戏结束。
    如果游戏结束,玩家不允许再放置字符。
    如果游戏存在获胜者,就返回该游戏的获胜者使用的字符("X"或"O");如果游戏以平局结束,则返回 "Draw";如果仍会有行动(游戏未结束),则返回 "Pending"。

    示例 1:

    输入: board = ["O X"," XO","X O"]
    输出: "X"
    示例 2:

    输入: board = ["OOX","XXO","OXO"]
    输出: "Draw"
    解释: 没有玩家获胜且不存在空位
    示例 3:

    输入: board = ["OOX","XXO","OX "]
    输出: "Pending"
    解释: 没有玩家获胜且仍存在空位
    提示:

    1 <= board.length == board[i].length <= 100
    输入一定遵循井字棋规则
    通过次数2,536提交次数5,942

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/tic-tac-toe-lcci
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

     

     

    package org.dai.io.cmd.command;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.TreeMap;
    
    /**
     * 设计一个算法,判断玩家是否赢了井字游戏。输入是一个 N x N 的数组棋盘,由字符" ","X"和"O"组成,其中字符" "代表一个空位。
     * 
     * 以下是井字游戏的规则:
     * 
     * 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符"O",且第二个玩家总是放字符"X"。
     * "X"和"O"只允许放置在空位中,不允许对已放有字符的位置进行填充。
     * 当有N个相同(且非空)的字符填充任何行、列或对角线时,游戏结束,对应该字符的玩家获胜。 当所有位置非空时,也算为游戏结束。
     * 如果游戏结束,玩家不允许再放置字符。 如果游戏存在获胜者,就返回该游戏的获胜者使用的字符("X"或"O");如果游戏以平局结束,则返回
     * "Draw";如果仍会有行动(游戏未结束),则返回 "Pending"。
     * 
     * 示例 1:
     * 
     * 输入: board = ["O X"," XO","X O"] 输出: "X" 示例 2:
     * 
     * 输入: board = ["OOX","XXO","OXO"] 输出: "Draw" 解释: 没有玩家获胜且不存在空位 示例 3:
     * 
     * 输入: board = ["OOX","XXO","OX "] 输出: "Pending" 解释: 没有玩家获胜且仍存在空位 提示:
     * 
     * 1 <= board.length == board[i].length <= 100 输入一定遵循井字棋规则
     * 
     * 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/tic-tac-toe-lcci
     * 著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
     * 
     * @author daipl
     *
     */
    public class Solution10 {
    
    	public static void main(String[] args) {
    		boolean[] xi = new boolean[3];
    		System.out.println(xi);
    		Solution10 so3 = new Solution10();
    		String[] nums = new String[] { "   X O  O ", " X X    O ", "X  X    O ", "X    OX O ", "X   XO  O ",
    				"X  X O  O ", "O  X O  O ", "     O  OX", "     O  O ", "   X XXXO " };
    		String rs = so3.tictactoe(nums);
    		System.out.println(rs);
    
    	}
    
    	public String tictactoe(String[] board) {
    		int length = board.length;
    		if (length == 1) {
    			return board[0];
    		}
    		// 把字符串转成字符数组,速度更快
    		char[][] cs = new char[length][length];
    		// x行,是否赢了
    		boolean[] xi = new boolean[length];
    		// y列是否赢了
    		boolean[] yi = new boolean[length];
    		// 设置默认值
    		Arrays.fill(xi, true);
    		Arrays.fill(yi, true);
    		// 左斜线是否赢了
    		boolean xie = true;
    		// 又斜线是否赢了
    		boolean youxie = true;
    		// 是否有空的
    		boolean hasEm = false;
    		for (int i = 0; i < length; i++) {
    			cs[i] = board[i].toCharArray();
    		}
    		//从位置1,开始,判断从0到i,的每行,每列是否赢了,如果没有赢,设置对应的标记为false
    		for (int i = 1; i < length; i++) {
    			if (xie) {//判断斜线,是否赢了
    				xie = cs[i][i] == cs[i - 1][i - 1] && cs[i][i] != ' ';
    			}
    			if (youxie) {
    				youxie = cs[length - i - 1][i] == cs[length - i][i - 1] && cs[length - i - 1][i] != ' ';
    			}
    			//判断前i-1行列,在加入新的i行后,是否依然一样
    			for (int j = 0; j < i; j++) {
    				if (xi[j]) {
    					xi[j] = cs[j][i] == cs[j][i - 1] && cs[j][i] != ' ';
    				}
    				if (yi[j]) {
    					yi[j] = cs[i][j] == cs[i - 1][j] && cs[i][j] != ' ';
    				}
    			}
    			//对新加入的i行列,需要对前面的每一个都判断一下是否一样
    			for (int j = 1; j <= i; j++) {
    				xi[i] = cs[i][j] == cs[i][j - 1] && cs[i][j] != ' ';
    				if (!xi[i]) {
    					break;
    				}
    			}
    			for (int j = 1; j <= i; j++) {
    				yi[i] = cs[j][i] == cs[j - 1][i] && cs[j][i] != ' ';
    				if (!yi[i]) {
    					break;
    				}
    			}
    			//标记是否还有空白字符
    			if (!hasEm) {
    				for (int j = 0; j <= i; j++) {
    					hasEm = cs[j][i] == ' ' || ' ' == cs[j][i];
    					if (hasEm) {
    						break;
    					}
    				}
    			}
    		}
    
    		if (xie) {
    			return String.valueOf(cs[0][0]);
    		}
    		if (youxie) {
    			return String.valueOf(cs[length - 1][0]);
    		}
    
    		for (int i = 0; i < length; i++) {
    			if (xi[i]) {
    				return String.valueOf(cs[i][0]);
    			}
    			if (yi[i]) {
    				return String.valueOf(cs[0][i]);
    			}
    		}
    
    		if (hasEm) {
    			return "Pending";
    		}
    
    		return "Draw";
    	}
    }

     

    展开全文
  • Leetcode 794 有效的井字游戏

    千次阅读 2019-09-23 14:34:50
    Leetcode794 有效的井字游戏 题目 用字符串数组作为井字游戏的游戏板 board。...以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符 “X”,且第二个玩家总是放字...

    Leetcode794 有效的井字游戏

    题目

    用字符串数组作为井字游戏的游戏板 board。当且仅当在井字游戏过程中,玩家有可能将字符放置成游戏板所显示的状态时,才返回 true。

    该游戏板是一个 3 x 3 数组,由字符 " ",“X” 和 “O” 组成。字符 " " 代表一个空位。

    以下是井字游戏的规则:

    玩家轮流将字符放入空位(" ")中。
    第一个玩家总是放字符 “X”,且第二个玩家总是放字符 “O”。
    “X” 和 “O” 只允许放置在空位中,不允许对已放有字符的位置进行填充。
    当有 3 个相同(且非空)的字符填充任何行、列或对角线时,游戏结束。
    当所有位置非空时,也算为游戏结束。
    如果游戏结束,玩家不允许再放置字符。
    示例 1:
    输入: board = ["O ", " ", " "]
    输出: false
    解释: 第一个玩家总是放置“X”。

    示例 2:
    输入: board = [“XOX”, " X ", " "]
    输出: false
    解释: 玩家应该是轮流放置的。

    示例 3:
    输入: board = [“XXX”, " ", “OOO”]
    输出: false

    示例 4:
    输入: board = [“XOX”, “O O”, “XOX”]
    输出: true
    说明:

    游戏板 board 是长度为 3 的字符串数组,其中每个字符串 board[i] 的长度为 3。
    board[i][j] 是集合 {" ", “X”, “O”} 中的一个字符。

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/valid-tic-tac-toe-state
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

    分析:

    leetcode将此题编入递归类型当中,确实有点晕,看起来本题没什么技巧在其中,所以我们就想一想各种情况(对的or错的)
    根据题意:错误的情况有以下几种:
    1.如果x的个数(x_count)和o的个数(o_count)有关系:x_count !=o_count && x_count-1!=o_count 那么就是错误的;
    后面几种情况是看别人的思路理解的,总结的很好
    2.如果x_count=o_count 那么错误的情况就是目前棋盘的局面是x获胜
    3.如果x_count-1=o_count 那么错误的情况就是目前棋盘的局面是o获胜
    上面两个失败的情况也可以理解为:如果x获胜,那么x_count-1=o_count
    如果o获胜,那么x_count=o_count
    所以还需要在另写一个函数,判断x或者o目前是否是获胜的状态:
    参数为字符串数组和一个字符(x或者o),获胜的情况很容易罗列出来,用for循环来检测横行竖行是否有三个字符相同,还有直接罗列对角线上的两种获胜情况即可。

    代码:

    class Solution {
    public:
        bool validTicTacToe(vector<string>& board) {
            //统计X和O出现的次数,进行初步的true和false的验证
            int x_count=0;
            int o_count=0;
            for(int i=0;i<3;i++){
                for(int j=0;j<3;j++){
                    if(board[i][j]=='X'){
                        x_count++;
                }
                    if(board[i][j]=='O'){
                        o_count++;
                    }
            }
        }
            if(x_count!=o_count && x_count-1!=o_count){
                return false;
            }
            //然后就是验证其他两种false情况:
            //1.如果x_count=o_count 且 x获胜,则为false
            //2.如果x_count-1=o_count 且o获胜,则为false
            if(x_count==o_count && iswin(board,'X') ){
                return false;
            }
            if(x_count-1==o_count && iswin(board,'O')){
                return false;
            }
            return true;
    }
        bool iswin(vector<string>& board,char p){
            //判断p(x或者o)是否赢了
            for(int i=0;i<3;i++){
                if(board[i][1]==p && board[i][0]==p && board[i][2]==p){
                    return true;
                }
                if(board[0][i]==p && board[1][i]==p && board[2][i]==p){
                    return true;
                }
            }
            if(board[0][0]==p && board[1][1]==p && board[2][2]==p){
                return true;
            }
            if(board[0][2]==p && board[1][1]==p && board[2][0]==p){
                return true;
            }
            return false;
        }
    };
    

    最开始做此题时,一直在想怎么用递归或者有没有技巧性的思路,搞了半天看别人都是直接罗列清楚可能的情况来判断true or false。做此题又没有独立写出,而是参考了别人的思路。菜鸡要加油啊!呜呜呜

    另外在拷贝一下python代码,此题就是从某个大神的python代码中理解的

    class Solution:
        def validTicTacToe(self, board: List[str]) -> bool:
            x_count=0
            o_count=0
            for i in range(3):
                for j in range(3):
                    if board[i][j]=='X':
                        x_count +=1
                    if board[i][j]=='O':
                        o_count +=1
            
            if x_count!=o_count and x_count-1 !=o_count:
                return False;
            if x_count == o_count and self.win(board,'X'):
                return False;
            if x_count-1 == o_count and self.win(board,'O'):
                return False;
            return True;
        
        def win(self,board:List[str],p):
            for i in range(3):
                if all(board[i][j]==p for j in range(3)):return True;
                if all(board[j][i]==p for j in range(3)):return True;
            if board[0][0]==board[1][1]==board[2][2]==p:return True;
            if board[0][2]==board[1][1]==board[2][0]==p:return True;
            return False;
        
                
    
    展开全文
  • 力扣 井字游戏

    千次阅读 2020-06-05 20:49:28
    以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符"O",且第二个玩家总是放字符"X"。 "X"和"O"只允许放置在空位中,不允许对已放有字符的位置进行填充。 当有N个相同(且非空)的...

    面试题 16.04. 井字游戏

    难度中等6收藏分享切换为英文关注反馈

    设计一个算法,判断玩家是否赢了井字游戏。输入是一个 N x N 的数组棋盘,由字符" ","X"和"O"组成,其中字符" "代表一个空位。

    以下是井字游戏的规则:

    • 玩家轮流将字符放入空位(" ")中。
    • 第一个玩家总是放字符"O",且第二个玩家总是放字符"X"。
    • "X"和"O"只允许放置在空位中,不允许对已放有字符的位置进行填充。
    • 当有N个相同(且非空)的字符填充任何行、列或对角线时,游戏结束,对应该字符的玩家获胜。
    • 当所有位置非空时,也算为游戏结束。
    • 如果游戏结束,玩家不允许再放置字符。

    如果游戏存在获胜者,就返回该游戏的获胜者使用的字符("X"或"O");如果游戏以平局结束,则返回 "Draw";如果仍会有行动(游戏未结束),则返回 "Pending"。

    示例 1:

    输入: board = ["O X"," XO","X O"]
    输出: "X"
    

    示例 2:

    输入: board = ["OOX","XXO","OXO"]
    输出: "Draw"
    解释: 没有玩家获胜且不存在空位
    

    示例 3:

    输入: board = ["OOX","XXO","OX "]
    输出: "Pending"
    解释: 没有玩家获胜且仍存在空位
    

    提示:

    • 1 <= board.length == board[i].length <= 100
    • 输入一定遵循井字棋规则

     

    思路:一开始想着去搜索,但是后面想了一下,其实就有四种情况,就是横,竖,还有两条对角线。所以。我遍历整个图,遇到X就置为1,遇到O就置为-1,遇到“ ”就置为0。遍历完了,然后搜着四种情况,判断值得可能性,在输出相应得结果

    package 字符串;
    //面试题 16.04. 井字游戏
    public class No1604 {
        public String tictactoe(String[] board) {
            int[][] num=new int[board.length][board[0].length()];
            int n=board.length;
            int flag=0;
            for(int i=0;i<board.length;i++){
                for(int j=0;j<board[i].length();j++){
                    if(board[i].charAt(j)=='X')
                        num[i][j]=1;
                    else if(board[i].charAt(j)=='O')
                        num[i][j]=-1;
                    else
                        num[i][j]=0;
                }
            }
            int num1=0,num2=0,num3=0,num4=0;
            for(int i=0;i<board.length;i++) {
                num1=0;
                for (int j = 0; j < board[i].length(); j++) {
                    num1 += num[i][j];
                    if(num[i][j]==0)
                        flag=1;
                }
                if(num1==n||num1==-n)
                    break;
            }
            for(int i=0;i<board.length;i++){
                num2=0;
                for(int j=0;j<board[i].length();j++) {
                    num2 += num[j][i];
                }
                if(num2==n||num2==-n)
                    break;
            }
            for(int i=0;i<board.length;i++){
                num3+=num[i][i];
            }
            for(int i=board.length-1;i>=0;i--){
                num4+=num[n-1-i][i];
                //System.out.println("num[i][i]  "+num[i][i]+"  num4"+num4);
            }
            //System.out.println(n+" "+num1+" "+num2+" "+num3+" "+num4);
            if(num1==n||num2==n||num3==n||num4==n){
                if((num1==-n)||(num2==-n)||(num3==-n)||(num4==-n)){
                    if(flag==0) {
                        return "Draw";
                    }
                    else
                        return "Pending";
                }
                else{
                    return "X";
                }
            }
            else{
                if(num1==-n||num2==-n||num3==-n||num4==-n){
                    return "O";
                }
                else{
                    if(flag==0)
                        return "Draw";
                    else
                        return "Pending";
                }
            }
    
        }
    }
    

     

    展开全文
  • JavaScript 井字游戏

    2021-07-26 08:00:52
    在本教程中,我们将学习如何开发高级 JavaScript井字游戏。在井字棋是很常见的游戏,是很容易玩。游戏规则简单而广为人知。 在本教程中,我们将开发基于 Web 的 Tic Tac Toe 游戏。在这个游戏中,提示用户选择网格...

    在本教程中,我们将学习如何开发高级 JavaScript井字游戏。在井字棋是很常见的游戏,是很容易玩。游戏规则简单而广为人知。

    在本教程中,我们将开发基于 Web 的 Tic Tac Toe 游戏。在这个游戏中,提示用户选择网格中的九个方格之一。玩家选择的网格然后由玩家的相应标志显示。第一个玩家标记X,第二个玩家标记O

    JavaScript 井字游戏

    创建一个名为JavaScript-Tic-Tac-Toe的文件夹作为项目工作区,我们将在此文件夹中创建所有项目文件。

    1. index.html

    让我们创建index.html并向其添加以下代码:

    <!DOCTYPE html>
    <html lang="en">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <meta http-equiv="X-UA-Compatible" content="ie=edge">
            <link rel="stylesheet" href="style.css">
            <script src="script.js" defer></script>
            <title>Document</title>
        </head>
        <body>
            <div class="board" id="board">
                <div class="cell" data-cell></div>
                <div class="cell" data-cell></div>
                <div class="cell" data-cell></div>
                <div class="cell" data-cell></div>
                <div class="cell" data-cell></div>
                <div class="cell" data-cell></div>
                <div class="cell" data-cell></div>
                <div class="cell" data-cell></div>
                <div class="cell" data-cell></div>
            </div>
            <div class="winning-message" id="winningMessage">
                <div data-winning-message-text></div>
                <button id="restartButton">Restart</button>
            </div>
        </body>
    </html>

    2. script.js

    让我们创建名为script.js的 JavaScript 文件,并向其中添加以下 JavaScript 代码:

    const X_CLASS = 'x'
    const CIRCLE_CLASS = 'circle'
    const WINNING_COMBINATIONS = [
        [0, 1, 2],
        [3, 4, 5],
        [6, 7, 8],
        [0, 3, 6],
        [1, 4, 7],
        [2, 5, 8],
        [0, 4, 8],
        [2, 4, 6]
    ]
    const cellElements = document.querySelectorAll('[data-cell]')
    const board = document.getElementById('board')
    const winningMessageElement = document.getElementById('winningMessage')
    const restartButton = document.getElementById('restartButton')
    const winningMessageTextElement = document.querySelector('[data-winning-message-text]')
    let circleTurn
    
    startGame()
    
    restartButton.addEventListener('click', startGame)
    
    function startGame() {
        circleTurn = false
        cellElements.forEach(cell => {
            cell.classList.remove(X_CLASS)
            cell.classList.remove(CIRCLE_CLASS)
            cell.removeEventListener('click', handleClick)
            cell.addEventListener('click', handleClick, {once: true})
        })
        setBoardHoverClass()
        winningMessageElement.classList.remove('show')
    }
    
    function handleClick(e) {
        const cell = e.target
        const currentClass = circleTurn ? CIRCLE_CLASS : X_CLASS
        placeMark(cell, currentClass)
        if (checkWin(currentClass)) {
            endGame(false)
        } else if (isDraw()) {
            endGame(true)
        } else {
            swapTurns()
            setBoardHoverClass()
        }
    }
    
    function endGame(draw) {
        if (draw) {
            winningMessageTextElement.innerText = 'Draw!'
        } else {
            winningMessageTextElement.innerText = `${circleTurn ? "O's" : "X's"} Wins!`
        }
        winningMessageElement.classList.add('show')
    }
    
    function isDraw() {
        return [...cellElements].every(cell => {
            return cell.classList.contains(X_CLASS) || cell.classList.contains(CIRCLE_CLASS)
        })
    }
    
    function placeMark(cell, currentClass) {
        cell.classList.add(currentClass)
    }
    
    function swapTurns() {
        circleTurn = !circleTurn
    }
    
    function setBoardHoverClass() {
        board.classList.remove(X_CLASS)
        board.classList.remove(CIRCLE_CLASS)
        if (circleTurn) {
            board.classList.add(CIRCLE_CLASS)
        } else {
            board.classList.add(X_CLASS)
        }
    }
    
    function checkWin(currentClass) {
        return WINNING_COMBINATIONS.some(combination => {
            return combination.every(index => {
                return cellElements[index].classList.contains(currentClass)
            })
        })
    }

    3.style.css

    让我们创建一个名为style.css的 CSS 文件,并向其中添加以下 CSS 代码:

    *, *::after, *::before {
        box-sizing: border-box;
    }
    
    :root {
        --cell-size: 100px;
        --mark-size: calc(var(--cell-size) * .9);
    }
    
    body {
        margin: 0;
    }
    
    .board {
        width: 100vw;
        height: 100vh;
        display: grid;
        justify-content: center;
        align-content: center;
        justify-items: center;
        align-items: center;
        grid-template-columns: repeat(3, auto)
    }
    
    .cell {
        width: var(--cell-size);
        height: var(--cell-size);
        border: 1px solid black;
        display: flex;
        justify-content: center;
        align-items: center;
        position: relative;
        cursor: pointer;
    }
    
    .cell:first-child,
    .cell:nth-child(2),
    .cell:nth-child(3) {
        border-top: none;
    }
    
    .cell:nth-child(3n + 1) {
        border-left: none;
    }
    
    .cell:nth-child(3n + 3) {
        border-right: none;
    }
    
    .cell:last-child,
    .cell:nth-child(8),
    .cell:nth-child(7) {
        border-bottom: none;
    }
    
    .cell.x,
    .cell.circle {
        cursor: not-allowed;
    }
    
    .cell.x::before,
    .cell.x::after,
    .cell.circle::before {
        background-color: black;
    }
    
    .board.x .cell:not(.x):not(.circle):hover::before,
    .board.x .cell:not(.x):not(.circle):hover::after,
    .board.circle .cell:not(.x):not(.circle):hover::before {
        background-color: lightgrey;
    }
    
    .cell.x::before,
    .cell.x::after,
    .board.x .cell:not(.x):not(.circle):hover::before,
    .board.x .cell:not(.x):not(.circle):hover::after {
        content: '';
        position: absolute;
        width: calc(var(--mark-size) * .15);
        height: var(--mark-size);
    }
    
    .cell.x::before,
    .board.x .cell:not(.x):not(.circle):hover::before {
        transform: rotate(45deg);
    }
    
    .cell.x::after,
    .board.x .cell:not(.x):not(.circle):hover::after {
        transform: rotate(-45deg);
    }
    
    .cell.circle::before,
    .cell.circle::after,
    .board.circle .cell:not(.x):not(.circle):hover::before,
    .board.circle .cell:not(.x):not(.circle):hover::after {
        content: '';
        position: absolute;
        border-radius: 50%;
    }
    
    .cell.circle::before,
    .board.circle .cell:not(.x):not(.circle):hover::before {
        width: var(--mark-size);
        height: var(--mark-size);
    }
    
    .cell.circle::after,
    .board.circle .cell:not(.x):not(.circle):hover::after {
        width: calc(var(--mark-size) * .7);
        height: calc(var(--mark-size) * .7);
        background-color: white;
    }
    
    .winning-message {
        display: none;
        position: fixed;
        top: 0;
        left: 0;
        right: 0;
        bottom: 0;
        background-color: rgba(0, 0, 0, .9);
        justify-content: center;
        align-items: center;
        color: white;
        font-size: 5rem;
        flex-direction: column;
    }
    
    .winning-message button {
        font-size: 3rem;
        background-color: white;
        border: 1px solid black;
        padding: .25em .5em;
        cursor: pointer;
    }
    
    .winning-message button:hover {
        background-color: black;
        color: white;
        border-color: white;
    }
    
    .winning-message.show {
        display: flex;
    }

    在浏览器中打开 index.html

    让我们在浏览器中打开index.html文件,您将能够看到以下屏幕:

     

    展开全文
  • 井字游戏规则 游戏在3平方乘3平方的网格上进行。 您是X,您的朋友(或计算机)是O。玩家轮流将自己的标记放到空白的方块中。 连续第三个获得其分数(上,下,对角或对角线)的球员是获胜者。 当所有9个方格都满...
  • 井字游戏-源码

    2021-02-23 04:36:38
    井字游戏 在这个项目中,我们使用Ruby实现了Tic Tac Toe的版本。 用Ruby构建 先决条件 Ruby 2.6(或更高版本) 入门 使用终端将仓库复制到本地计算机: $ git clone https://github.com/CacheMeGifYouCan/TicTacToe...
  • LeetCode–井字游戏

    2020-08-07 20:04:45
    LeetCode–井字游戏 博客说明 文章所涉及的资料来自互联网整理和个人总结,意在于个人学习和经验汇总,如有什么地方侵权,请联系本人删除...以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第
  • Java实现 LeetCode 794 有效的井字游戏 (暴力分析)

    万次阅读 多人点赞 2020-05-05 17:14:24
    794. 有效的井字游戏 用字符串数组作为井字游戏的游戏板 board。...以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符 “X”,且第二个玩家总是放字符 “O”。 “X”...
  • 有效的井字游戏

    2020-02-06 10:43:11
    用字符串数组作为井字游戏的游戏板 board。...以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符 “X”,且第二个玩家总是放字符 “O”。 “X” 和 “O” 只允许放置在...
  • python编写井字棋 Programming computer games may be the most technically challenging (and possibly the best paying) job that a programmer can have. Top level games require the best from both ...
  • javascript 游戏In this tutorial, I will tell you how to build a basic tic tac toe game ... 在本教程中,我将告诉您如何使用HTML,CSS和JavaScript构建基本的井字游戏。 Most of the people know that when we...
  • 井字游戏使用强化学习 问题陈述 井字游戏是有史以来最受欢迎和最持久的游戏之一。 该游戏通常被用作数学分析决策过程的开始示例。 井字游戏有多种变体。 最经典的是X和O,每个玩家都希望将他们的三个标记放置在3x3...
  • leetcode-井字游戏

    2020-07-05 21:09:04
    以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符"O",且第二个玩家总是放字符"X"。 "X"和"O"只允许放置在空位中,不允许对已放有字符的位置进行填充。 当有N个相同(且非空)的字符...
  • 31 有效的井字游戏

    2020-09-22 22:42:07
    以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符 “X”,且第二个玩家总是放字符 “O”。 “X” 和 “O” 只允许放置在空位中,不允许对已放有字符的位置进行填充。 当有 3 个...
  • 设计一个Java程序,利用二维数组实现井字游戏。这个游戏的具体规则是:在一个3×3的方阵中,两个人轮流在空白处做符号标记,例如,一个人做√标记,另一个人做标记,先将同一种标记在一行、一列或者两个对角线上...
  • 井字游戏"(TicTacToe) 是一种在3x3格子上进行的连珠游戏,和五子棋比较类似,由于棋盘一般不画边框,格线排成井字故得名。(摘抄自百度百科) (还记得以前经常跟同桌一起在本子上玩这个呢,哈哈哈~~~(/捂脸)) ...
  • 以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符 “X”,且第二个玩家总是放字符 “O”。 “X” 和 “O” 只允许放置在空位中,不允许对已放有字符的位置进行填充。 当有 3 个相
  • 794. 有效的井字游戏

    千次阅读 2019-06-14 07:51:16
    用字符串数组作为井字游戏的游戏板board。当且仅当在井字游戏过程...以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符 “X”,且第二个玩家总是放字符 “O”。 “X” 和 “O” 只...
  • 井字游戏(shell高级版)

    2015-03-04 15:31:15
    井字游戏(shell高级版)    大家小时候大概都玩过井字游戏,就是双方在九宫格里面轮流下棋 ,先构成三点一线(横线、竖线或者斜线)的一方取胜。有点经验的人都知道,这样简单的游戏根本是不分胜负的,除非就是某...
  • 【数组】井字游戏

    2020-06-25 13:42:52
    以下是井字游戏规则: 玩家轮流将字符放入空位(" “)中。 第一个玩家总是放字符"O”,且第二个玩家总是放字符"X"。 "X"和"O"只允许放置在空位中,不允许对已放有字符的位置进行填充。 当有N个相同(且非空)的...
  • 当我一年级的时候,我认为自己是世界上最好的井字游戏选手。 我打败了我的朋友,后者不久前就教我如何打球。 对我来说不幸的是,那种天才的感觉并没有持续很长时间。 我亲爱的朋友,我已经不记得他的名字了,他开始...
  • 184、有效的井字游戏

    2019-07-31 11:18:57
    题目描述: 用字符串数组作为井字游戏的游戏板 board。...以下是井字游戏规则: 玩家轮流将字符放入空位(" ")中。 第一个玩家总是放字符 “X”,且第二个玩家总是放字符 “O”。 “X” 和 “O” ...
  • 井字棋盘游戏

    2021-02-07 20:23:17
    井字棋盘游戏规则:一共有三行三列的位置,在这九个位置中如果有其中一行或者一列是相同的则下该棋子的人获胜 你的游戏对手是ai package game; public class Main { public static void main(String[] args) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,095
精华内容 838
关键字:

井字游戏规则