Java的五子棋实现，java开发面试笔试题

最新推荐文章于 2024-01-30 21:12:06 发布
最新推荐文章于 2024-01-30 21:12:06 发布
阅读量396 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/agoodcoder777/article/details/89575093
版权


我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。
扫描二维码或搜索下图红色VX号，加VX好友，拉你进【程序员面试学习交流群】免费领取。也欢迎各位一起在群里探讨技术。
推荐文章：Java 面试知识点解析；Mysql优化技巧（数据库设计、命名规范、索引优化

 

 

 

Java 五子棋

注：除机器人算法外其余借鉴于MLDN。

package MyFiveChess;

import robot.*;

import java.awt.*;

import javax.swing.*;

public class Gobang {

    public static void main(String[] args) {

        EventQueue.invokeLater(() -> {

            JFrame frame = new MyFiveChessFrame(new StupidRobot());

            frame.setTitle("五子棋");

            frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

            frame.setVisible(true);

        });

    }

}

创建一个名为MyFiveChess的包，类名为Gobang，主方法中调用机器人类(StudipRobot)创建一个JFrame的框架，名为五子棋。

package MyFiveChess;

import robot.*;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

class MyFiveChessFrame extends JFrame

{

   public MyFiveChessFrame(IRobot robot)

   {

      add(new ImageComponent(robot));

      pack();

   }

}

/**

 * A component that displays a tiled image

 */

class ImageComponent extends JComponent implements MouseListener

{

   private static final int DEFAULT_WIDTH = 500;//因为图片的大小为500*500，

   private static final int DEFAULT_HEIGHT = 500;//所以这里设置组件大小也为500*500

   int x;                                 //原图是没有棋盘的，这里我们要自己画

   int y;                                 //棋盘，故需要全局变量来获取棋盘坐标

   int allchess[][] = new int[16][16];    //构造一个数组来存取当前局势情况

   boolean isBlack = true;                //0代表没有棋，1代表黑子，2代表白子

   boolean canPlay = true;//isBlack是用来说明当前应该是黑子或者白子落棋                

   private Image image;   //canPlay是用来设置当游戏结束后不能够再落子

   private IRobot iRobot; //用来存储传入构造器的iRobot

   private String string = "It's Black";  //图片上当前会显示该黑子落棋

   

   public ImageComponent(IRobot iRobot)

   {

       this.iRobot = iRobot;    

       addMouseListener(this); //要实现当点击鼠标就发生响应就必须实现MouseListener接口

       image = new ImageIcon("background.jpg").getImage();

   }                           //背景图在最下面会贴出来的

   public void paint(Graphics g) //构造paint方法

   {

      if (image == null) return;

     

      g.drawImage(image, 0, 0, null);

      

      g.setFont(new Font("宋体", 0, 16));

      g.setFont(new Font("Times New Roman", 0, 27));

      g.drawString(string, 135, 34);

      

      for (int i = 0; i < 16; i++) {//这里是在画棋盘（国际棋盘大小15*15）

        g.drawLine(10, 50 + i*24, 369, 50 + i*24);

        g.drawLine(10 + i*24, 50, 10 + i*24, 410);

    } 

      

      

      for (int i = 0; i < 16; i++) {

        for(int j = 0; j < 16; j++)

        {

            if(allchess[i][j] == 1) {//为1时是黑子，这里需要调用fillOval方法画圆

            int tempx = i * 24 + 10; 

            int tempy = j * 24 + 50;

            g.fillOval(tempx-7, tempy-7, 14, 14);

            }

            if (allchess[i][j] == 2) {//当白子的时候需要画一个白色的圆再添加一个黑色的框

                int tempx = i * 24 + 10;

                int tempy = j * 24 + 50;

                g.setColor(Color.WHITE);

                g.fillOval(tempx-7, tempy-7, 14, 14);

                g.setColor(Color.BLACK);

                g.drawOval(tempx-7, tempy-7, 14, 14);

            }

        }

        

    }

   }

   

   public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }

SuppressWarnings("deprecation")

@Override

public void mouseClicked(MouseEvent e) {//下面就是实现游戏界面右边的几个功能

    // TODO Auto-generated method stub

    if (x>400 && x<470 && y>50 && y<80) {

        int restart = JOptionPane.showConfirmDialog(this, "是否确认重新开始游戏");

        if (restart == 0) {

            allchess = new int[16][16];

            string = "It's Black";

            isBlack = true;     

            this.repaint();

        }

    }

    if (x>400 && x<470 && y>100 && y<130) {

        String input = JOptionPane.showInputDialog("请输入最大下棋时间（单位分），0代表无限制：");//这部分功能没有实现，本来是想用线程来实现一个游戏倒计时功能的，但是因为某些原因就放弃了

    }

    if (x>400 && x<470 && y>150 && y<180) {

        JOptionPane.showMessageDialog(this, "五子棋你都不会下么，如果不会，请参见百度，谢谢!");

    }

    if (x>400 && x<470 && y>250 && y<280) {

        int abandoning = JOptionPane.showConfirmDialog(this, "已经决定了么");

        if (abandoning == 0) {

            if(isBlack) JOptionPane.showMessageDialog(this, "黑方认输");

            canPlay = false;

            System.exit(0);

        }

    

    }

    if (x>400 && x<470 && y>300 && y<330) {

        JOptionPane.showMessageDialog(this, "本软件由杨易大佬与曾鑫开发，若有问题，请自行解决.");

    }

    if (x>400 && x<470 && y>350 && y<380) {

        int Continue = JOptionPane.showConfirmDialog(this, "不再玩一会么");

        if(Continue == 0) {

            JOptionPane.showMessageDialog(this, "大爷再见，欢迎下次再来。");

            System.exit(0);

        }

    }

}

@Override

public void mousePressed(MouseEvent e) {

    // TODO Auto-generated method stub

    //System.out.println("X" + e.getX());//在划线之前要确认坐标，需要输出坐标

    //System.out.println("Y" + e.getY());

        

    if (canPlay == true) { 

        x = e.getX();

        y = e.getY();

        if (x>10 && x<369 && y>49 && y<408) {

            float xxx = (float) 24.0;

            x = Math.round((x - 10)/xxx);//实现坐标的4舍5入

            y = Math.round((y - 49)/xxx);

            if(allchess[x][y] == 0)

            {

                if (isBlack == true) {

                    allchess[x][y] = 1;

                    iRobot.retrieveGameBoard(allchess);//该机器人下棋时，需要将现在棋盘的局势传递过去

                    isBlack = false;

                    string = "It's White";

                    boolean winFlag = this.checkWin();//每下一次棋时都需要检查是否胜出

                    if (winFlag == true) {

                        JOptionPane.showMessageDialog(this, "Game over"+(allchess[x][y]==1 ? "Black" : "White") + "winned");

                        canPlay = false;

                    }

                    RobotAction();//机器人下棋

                    this.repaint();

                }

            }

            else {

                JOptionPane.showMessageDialog(this, "Please play chess in the chessboard");

            }

        }

        

    }

}

void RobotAction(){

    

    Pair pair = iRobot.getDeterminedPos();//机器人类将返回一个pair类回来

    x = pair.x;

    y= pair.y;

    allchess[x][y] = 2;

    isBlack = true;

    string = "It's Black";

    

    boolean winFlag = this.checkWin();

    if (winFlag == true) {

        JOptionPane.showMessageDialog(this, "Game over"+(allchess[x][y]==1 ? "Black" : "White") + " winned");

        canPlay = false;

    }

}

@Override

public void mouseReleased(MouseEvent e) {

    // TODO Auto-generated method stub

    

}

@Override

public void mouseEntered(MouseEvent e) {

    // TODO Auto-generated method stub

    

}

@Override

public void mouseExited(MouseEvent e) {

    // TODO Auto-generated method stub

    

}

private boolean checkWin() {//检测当前是否由五子连线的方法，简述一下，这个方法其实很简单，只要我们在每一次落子的时候检查是否由五子连线就可以确保一旦有人胜出，我们就可以马上发现。先检查横线和竖线，再检查左右斜线。

        

    boolean flag = false; //设置的标志，当由五子连线时就返回flag=false

    int count = 1;        //计数当前由几颗棋子相连

    int color = allchess[x][y];

    int i = 1;

    

    while(((x+i)<16)&&color == allchess[x+i][y]) {

        count++;

        i++;

        }

    i = 1;

    while(((x-i)>=1)&&color == allchess[x-i][y]) {

        count++;

        i++;

        }

    if(count>=5)

        {flag = true;}

    //?????ж?

    int count2 = 1;

    int i2 = 1;

    while(((y+i2)<16)&&color == allchess[x][y+i2]) {

        count2++;

        i2++;

        }

    i = 1;

    while(((y-i2)>=1)&&color == allchess[x][y-i2]) {

        count2++;

        i2++;

        }

    if(count2>=5)

        {flag = true;}

    

    int count3 = 1;

    int i3 = 1;

    while(((y-i3)>=1)&&((x+i3)<16)&&color == allchess[x+i3][y-i3]) {

        count3++;

        i3++;

        }

    i = 1;

    while(((x-i3)>=1)&&((y+i3)<16)&&color == allchess[x-i3][y+i3]) {

        count3++;

        i3++;

        }

    if(count3>=5)

        {flag = true;}

    int count4 = 1;

    int i4 = 1;

    while(((y-i4)>=1)&&((x-i4)>=1)&&color == allchess[x-i4][y-i4]) {

        count4++;

        i4++;

        }

    i = 1;

    while(((x+i4)<16)&&((y+i4)<16)&&color == allchess[x+i4][y+i4]) {

        count4++;

        i4++;

        }

    if(count4>=5)

        {flag = true;}

    

    return flag;

    

   }

}

这段代码有点长，但是并不难，大家仔细看下就会明白的。

下面贴出机器人的代码：

package robot;

import java.util.Random;

public interface IRobot {

    static final Random rand = new Random();

    /**

     * There we provide a default implementation to simulate robot's behavior

     *

     * @return a {@code robot.Pair} which contains a valid (x,y) position

     */

    default Pair getDeterminedPos() {

        return new Pair(rand.nextInt(15) + 1, rand.nextInt(15) + 1);

    }

    /**

     * This method is used to retrieve game board such that robot can determine its (x,y) position

     * @param gameBoard the 2-dimension array to represent the game board

     */

    void retrieveGameBoard(int[][] gameBoard);

}
package robot;

public class Pair {

    public int x;

    public int y;

    public Pair(){}

    public Pair(int x, int y) {

        this.x = x;

        this.y = y;

    }

}
package robot;

public class StupidRobot implements IRobot {

    private static final int BOARD_SIZE = 15;

    private static final int ROLE_OPPONENT = 1;

    private static final int ROLE_ROBOT = 2;

    private static final int ROLE_NON = 0;

    private static final int ORIENTATION_LR = 0;

    private static final int ORIENTATION_UD = 1;

    private static final int ORIENTATION_LT_RD = 2;

    private static final int ORIENTATION_RT_LD = 3;

    private int[][] boardRef = null;

    /**

     * There we provide a default implementation to simulate robot's behavior

     *

     * @return a {@code robot.Pair} which contains a valid (x,y) position

     */

    @Override

    public Pair getDeterminedPos() {

        int[][] situationRobot  = new int[boardRef.length][boardRef[0].length];

        int[][] situationOpponent  = new int[boardRef.length][boardRef[0].length];

        int maxRobotScore = 0;

        Pair maxRobotPoint = new Pair();

        int maxOpponentScore = 0;

        Pair maxOpponentPoint = new Pair();

        for(int i=0;i<BOARD_SIZE;i++){

            for(int k=0;k<BOARD_SIZE;k++){

                if(boardRef[i][k]!=ROLE_NON){

                    situationOpponent[i][k]=situationRobot[i][k]=0;

                }else{

                    boardRef[i][k] = ROLE_OPPONENT;

                    situationOpponent[i][k] = evaluateScore(ROLE_OPPONENT,i,k);

                    boardRef[i][k]=ROLE_NON;

                    if(situationOpponent[i][k]>maxOpponentScore){

                        maxOpponentScore = situationOpponent[i][k];

                        maxOpponentPoint.x = i;

                        maxOpponentPoint.y = k;

                    }

                    boardRef[i][k]=ROLE_ROBOT;

                    situationRobot[i][k]=evaluateScore(ROLE_ROBOT,i,k);

                    boardRef[i][k]=ROLE_NON;

                    if(situationRobot[i][k]>maxRobotScore){

                        maxRobotScore = situationRobot[i][k];

                        maxRobotPoint.x = i;

                        maxRobotPoint.y = k;

                    }

                }

            }

        }

        if(maxRobotScore > maxOpponentScore || maxRobotScore==Integer.MAX_VALUE){

            return maxRobotPoint;

        }else{

            return maxOpponentPoint;

        }

    }

    /**

     * This method is used to retrieve game board such that robot can determine its (x,y) position

     *

     * @param gameBoard the 2-dimension array to represent the game board

     */

    @Override

    public void retrieveGameBoard(int[][] gameBoard) {

        boardRef = gameBoard;

    }

    /**

     * The policy of evaluating was referred to https://www.cnblogs.com/maxuewei2/p/4825520.html

     * @param role the role of current player

     * @param x position x

     * @param y position y

     * @param orientation orientation of determining line

     * @return

     */

    private int patternRecognition(int role, int x,int y,int orientation){

        StringBuilder sb = new StringBuilder();

        if(orientation==ORIENTATION_LR){

            int leftBound = (x - 4)>=0?x-4:0;

            int rightBound = (x +4)<BOARD_SIZE?x+4:BOARD_SIZE-1;

            for(int i=leftBound;i<=rightBound;i++){

                sb.append(boardRef[i][y]);

            }

        }else if(orientation == ORIENTATION_UD){

            int bottomBound = (y+4)<BOARD_SIZE?y+4:BOARD_SIZE-1;

            int topBound = (y-4)>=0?y-4:0;

            for(int i=topBound;i<=bottomBound;i++){

                sb.append(boardRef[x][i]);

            }

        }else if(orientation== ORIENTATION_LT_RD){

            int leftBound = 0,rightBound = 0,bottomBound = 0,topBound = 0;

            

           for(int i=1;i<=4;i++){

               leftBound = x-i;

               topBound = y-i;

               if(leftBound<0||topBound<0){

                   leftBound++;

                   topBound++;

                   break;

               }

           }

           for(int k=1;k<=4;k++){

               rightBound = x+k;

               bottomBound = y+k;

               if(rightBound>BOARD_SIZE||bottomBound>BOARD_SIZE){

                   rightBound--;

                   bottomBound--;

                   break;

               }

           }

            for(int i=topBound,k=leftBound;i<=bottomBound && k<=rightBound;i++,k++){

                sb.append(boardRef[k][i]);

            }

        }else if(orientation== ORIENTATION_RT_LD){

            int leftBound = 0,rightBound = 0,bottomBound = 0,topBound = 0;

            for(int i=1;i<=4;i++){

                rightBound = x+i;

                topBound = y-i;

                if(rightBound>BOARD_SIZE||topBound<0){

                    rightBound--;

                    topBound++;

                    break;

                }

            }

            for(int k=1;k<=4;k++){

                leftBound = x-k;

                bottomBound = y+k;

                if(leftBound<0||bottomBound>BOARD_SIZE){

                    leftBound++;

                    bottomBound--;

                    break;

                }

            }

            for(int i=topBound,k=rightBound;i<=bottomBound && k>=leftBound;i++,k--){

                sb.append(boardRef[k][i]);

            }

        }

        String str = sb.toString();

        if(str.contains(role == ROLE_ROBOT ? "22222" : "11111")){

            return Integer.MAX_VALUE;

        }

        if(str.contains(role == ROLE_ROBOT ? "022220" : "011110")){

            return 300000;

        }

        if(str.contains(role == ROLE_ROBOT ? "22202" : "11101") ||

                str.contains(role == ROLE_ROBOT ? "20222" : "10111")){

            return 3000;

        }

        if(str.contains(role == ROLE_ROBOT ? "0022200" : "0011100")){

            return 3000;

        }

        if(str.contains(role == ROLE_ROBOT ? "22022" : "11011")){

            return 2600;

        }

        if(str.contains(role == ROLE_ROBOT ? "22220" : "11110")||

            str.contains(role == ROLE_ROBOT ? "02222" : "01111")){

            return 2500;

        }

        if(str.contains(role == ROLE_ROBOT ? "020220" : "010110")||

                str.contains(role == ROLE_ROBOT ? "022020" : "011010")){

            return 800;

        }

        if(str.contains(role == ROLE_ROBOT ? "00022000" : "00011000")){

            return 650;

        }

        if(str.contains(role == ROLE_ROBOT ? "20022" : "10011")||

                str.contains(role == ROLE_ROBOT ? "22002" : "11001")){

            return 600;

        }

        if(str.contains(role == ROLE_ROBOT ? "20202" : "10101")){

            return 550;

        }

        if(str.contains(role == ROLE_ROBOT ? "22200" : "11100")||

                str.contains(role == ROLE_ROBOT ? "00222" : "00111")){

            return 500;

        }

        if(str.contains(role == ROLE_ROBOT ? "0020200" : "0010100")){

            return 250;

        }

        if(str.contains(role == ROLE_ROBOT ? "020020" : "010010")){

            return 200;

        }

        if(str.contains(role == ROLE_ROBOT ? "22000" : "11000")||

                str.contains(role == ROLE_ROBOT ? "00022" : "00011")){

            return 150;

        }

        return 0;

    }

    private int evaluateScore(int role,int x, int y){

        int a = patternRecognition(role,x,y,ORIENTATION_RT_LD);

        int b = patternRecognition(role,x,y,ORIENTATION_LT_RD);

        int c = patternRecognition(role,x,y,ORIENTATION_UD);

        int d = patternRecognition(role,x,y,ORIENTATION_LR);

        return Math.max(Math.max(Math.max(a,b),c),d);

    }

}

好吧，机器人类的代码不是我写的，所以我没有发言权，如果大家想实现的是人机对棋就研究一下这段代码，如果不是那就可以跳过了，只要修改下我最开始贴出的代码就好了。╮(╯-╰)╭


以下是再Eclipse和打包成exe上运行的结果：





 


转载：https://www.cnblogs.com/DevLegal/p/8831894.html

推荐内容：
JAVA多线程和并发基础面试问答
JAVA多线程和并发基础面试题
java执行Shell命令
40个Java多线程面试问题
java面试题整理
Java在常见的spring面试问题TOP50
最新Java校招面试题及答案
Java面试题——中级（下）
JAVA工程师面试题库
JAVA面试相关

 

agoodcoder777
关注
专栏目录
2024华为OD机试真题目录 B+C+D+E卷，使用Java语言进行解答（560道）
KJ.JK
09-20 4万+
本文是华为OD机试真题（Java 语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
华为OD机试真题目录汇总（Java语言）2024 B+C+D+E卷 （560道）
热门推荐
KJ.JK
08-20 6万+
本文是2023华为OD机试真题(Java 语言) B卷专栏的目录贴（定期更新2023华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用Java语言进行更新解答，包含真题，思路分析，代码参考，每个题目的思路分析都非常详细，超过百字欢迎大家订阅学习，代码可以直接运行使用，全网限时最低价，持续更新）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。
五子棋的简单实现
Code__rookie的博客
12-12 895
五子棋的简单实现 这个是在网上找的资源，出处记不得了，记录一下。 程序的总体结构，很简单的： 代码如下： ArrComparator.java类 import java.util.Comparator; /** * 排序 Comparator */ class ArrComparator implements Comparator<Object> { int col...
Java的五子棋实现
adeq28027的博客
04-14 156
Java 五子棋 注：除机器人算法外其余借鉴于MLDN。 package MyFiveChess; import robot.*; import java.awt.*; import javax.swing.*; public class Gobang { public static void main(String[] args) { EventQueue.i...
java基础五子棋练习题
qq_44427661的博客
08-01 703
java基础五子棋练习题 我将5子棋分成4中连接每种连接方式都可以看成竖一种k（斜率）相同的直线函数4种方式为： （1） 横向扫描： （2） 竖向扫描 （3） 斜杠扫描 （4） 反斜杠扫描 package com.zy.Demo; import java.util.Scanner; /* * 五子棋，可以通过直线函数实现 */ public class Demo2 { public static void main(String[] args) { // TODO Auto-gen
Java基础练习题3--(在交互输出界面实现一个简单的五子棋)
从零开始的异世界JAVA学习
04-13 388
使用二维数组实现一个简单的五子棋游戏;黑白棋轮流落子;判断输赢. import java.util.Scanner; public class Chess001 { static char[] num = {'⒈', '⒉', '⒊', '⒋', '⒌', '⒍', '⒎', '⒏', '⒐', '⒑', '⒒', '⒓', '⒔', '⒕', '⒖'}; //黑棋 static char black = '○'; //白棋 static char white =
Java数组实现五子棋功能
weixin_34335458的博客
10-30 136
package ch4; import java.io.*; /** * Created by Jiqing on 2016/11/9. */ public class Gobang { // 定义棋盘的大小 private static int BOARD_SIZE = 15; // 定义一个二维数组来充当棋盘 p...
java五子棋课程设计报告摘要，看完没有不懂的
m0_56675572的博客
07-10 492
复习过程 项目准备； leetcode：刷完剑指之后每天会刷2-4道leetcode java基础： 主要刷面经、重点掌握垃圾回收机制 操作系统： 之前没学过，用几天时间看了一下最重要的进程线程、死锁、消费者生产者、哲学家问题、银行家算法 计算机网络：花几天时间复习了一下，重点复习tcp（三次握手四次挥手拥塞控制流量控制）、udp、https 数据库： 重点了解了索引的实现以及引擎的区别 数据结构和算法： 主要通过剑指offer和leetcode进行复习 其他：期间也做过大大小小好几次笔试，还有一些往届练
华为OD机试|华为od题库|华为od机考|2024真题目录Java实现|C卷D卷E卷
最新发布
u014481728的博客
01-30 5万+
华为OD机试|华为od题库|华为od机考|2024真题目录Java实现|C卷D卷E卷|华为OD机试|华为od题库|华为od机考|2024真题目录Java实现|C卷D卷E卷|华为OD机试|华为od题库|华为od机考|2024真题目录Java实现|C卷D卷E卷|华为OD机试|华为od题库|华为od机考|2024真题目录Java实现|C卷D卷E卷|华为OD机试|华为od题库|华为od机考|2024真题目录Java实现|C卷D卷E卷
2024华为OD机试题库-(A卷+B卷+C卷+D卷+E)-(JAVA、Python、C++)
goldarmour的博客
03-28 4万+
博主是一名资深后端开发人员，精通C++，Python，Java，乐于分享面试经验，已帮助千余名同学通过OD机考！这些题目博主每一道都刷了至少两遍，每一行代码都蕴含了博主从业以来所积累的所有经验和技巧，可谓干货满满！
腾讯CDC面试题之五子棋 - dom版（ES6）
weixin_34126557的博客
07-18 302
废话不多说上代码！完整项目地址：GitHub项目地址 class Gobang { constructor(options) { this.options = options this.gobang = document.getElementById...
面试题----使用二维数组判断五子棋胜负（C++）
Wangguang_的博客
07-25 2211
用自己熟悉的语言编写一个函数：输入是一个n*n的二维数组。该数组可以看做是一个五子棋的棋盘。其中某个元素为1代表该位置摆放的是黑子，-1表示白子，0表示没有任何棋子。函数的返回值是判断该五子棋盘的状态，一共三种可能：黑棋赢、白棋赢、不分胜负。其中某一种颜色的棋子在横线、竖线、或斜线方向超过5个子即为胜利
网易2017春招[编程题]涂棋盘@Java
zjkC050818的博客
09-14 572
链接：https://www.nowcoder.com/questionTerminal/79ed2f61eef7448aab10ef9677382e7e 来源：牛客网 [编程题]涂棋盘 热度指数：5347时间限制：1秒空间限制：32768K算法知识视频讲解 小易有一块n*n的棋盘，棋盘的每一个格子都为黑色或者白色，小易现在要用他喜欢的红色去涂画棋盘。小易会找出棋盘
Java大厂技术面试题汇总！象棋游戏java编程
m0_57286472的博客
07-08 207
一、 电面： 自我介绍 项目情况： 对你来说影响最大的一个项目（该面试中有关项目问题都针对该项目展开）？ 为什么会想做这个项目？这个项目的ideal是谁提出来的？ 项目中如何实现的大数据的传输和存储 项目中哪一部分最难攻克？如何攻克？ 基础知识考察： 模块化的好处 Htttp协议 hashmap和concurrenthashmap区别及两者的优缺点 对MySQL的了解，和oracle的区别 对设计模式的看法和认知 有哪些设计模式 如何实现分布式缓存 多线程如何避免死锁 Java的垃圾回收机制 对Run
腾讯前端面试题：一言不合就写个五子棋
weixin_30307267的博客
06-02 261
近日接到腾讯 CDC 前端开发团队的求职意向询问，在微信上简单地聊了下技术，然后抛给我一道面试题。题目内容是编写一个单机五子棋，用原生 web 技术实现，兼容 Chrome 即可，完成时间不作限制。同时还有几个要求： 实现胜负判断，并给出赢棋提示。任意一方赢棋，锁定棋盘。 尽可能考虑游戏的扩展性，界面可用 DOM/ Canvas 实现，并且切换实现方式代价最小。 实现悔棋和撤销悔棋功...
java实现简单的五子棋（样式简陋，但具备游戏的基本规则）
qq_36486085的博客
04-07 568
package com.softeem.array2;import java.util.Scanner;/** * 五子棋,棋盘,下棋,坐标（coordinate）,判断 * @author Administrator * */public class Checkerboard { public static void checkerboard(char[][] array){ //显示棋盘 ...
java五子棋老师经常问的问题,java做五子棋的问题，请教高手
weixin_35455175的博客
03-21 355
package day716;import java.awt.BorderLayout;import java.awt.Graphics;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.MouseAdapter;import java.awt.event.Mou...
腾讯cdc php面试,腾讯CDC面试题之五子棋 - dom版（ES6）
weixin_39621860的博客
03-21 107
废话不多说上代码！完整项目地址：GitHub项目地址class Gobang {constructor(options) {this.options = optionsthis.gobang = document.getElementById(options.canvas || 'gobang')this.chessboard = this.gobang.children[0]this.chess...
Java Swing实现五子棋游戏开发详解
描述“主要为大家详细介绍了Java Swing五子棋的实现方法，Java开发图形界面程序五子棋的实现方式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下”表明该文章将详细介绍Java Swing五子棋的实现方法，并提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值