C语言高级教程-C语言数组(七)：数组综合实例之井字棋游戏问题

news2025/1/16 4:56:56

C语言高级教程-C语言数组（七）：数组综合实例之井字棋游戏问题

  • 一、本文的编译环境
  • 二、井字棋游戏的问题
  • 三、井字棋游戏的分析
  • 四、井字棋游戏的程序编写步骤
    • 4.1、添加主要的游戏循环和显示这个方格
    • 4.2、让玩家选择-一个方格， 并确定那个方格是否有效
    • 4.3、添加检查获胜线
    • 4.4、显示格子上最后各个标记的位置
  • 五、井字棋游戏程序运行结果
    • 5.1、有玩家获胜的棋局
    • 5.2、没有玩家获胜的棋局
  • 六、井字棋游戏程的完整程序代码
    • 6.1、Main.h头文件
    • 6.2、Main.c源文件
  • 七、总结

在这里插入图片描述

一、本文的编译环境

本文的编译环境使用的是集成开发环境：Visual Studio 2019
在这里插入图片描述

Visual Studio 2019官网链接如下

Visual Studio 2019官网链接
在这里插入图片描述

Visual Studio 2019集成的开发环境的特点有

  • Visual Studio 2019默认安装Live Share代码协作服务。
  • 帮助用户快速编写代码的新欢迎窗口、改进搜索功能、总体性能改进。
  • Visual Studio IntelliCode AI帮助。
  • 更好的Python虚拟和Conda支持。
  • 以及对包括WinForms和WPF在内的.NET Core 3.0项目支持等 。

二、井字棋游戏的问题

把计算机当作对手来编写一-个游戏超出了前面介绍的范围，所以下面编写的程序是让两个人在计算机上玩井字游戏(也称为圈叉游戏)。

三、井字棋游戏的分析

井字棋游戏的分析如下所示

  • 井字游戏是一一个3X3的方格。
  • 两个人轮流在方格中输入标记X或O。
  • 谁先使自己的3个标记连接成水平、垂直或对角线，谁就是赢家。

知道了这个游戏怎么玩，如何将它设计成程序?这需要:

  • 一个3X3的方格，存储两个人交替输入的标记。这很简单，使用一个3行3列的二维数组即可。轮到一个玩家输 入标记时，需要一种方法标记选择出来的方格。可以用1~9的数字标记这9个方格。 玩家只需输入要选择的方格数字。
  • 有一种让两个玩家轮流输入标记的方法。 可以将两个玩家识别为1 和2，编号1的玩家先玩。然后根据轮流的次数决定输入标记的玩家号码。轮到奇数号时，就由玩家1输入标记。轮到偶数号时，就由玩家2输入标记。
  • 指定将玩家的标记放在哪个方格中，并检查它是否有效。一个有效的选择是1~9的数字。如果用1、2、3标记方格的第一行，用4、5、6标记第二行，用7、8、9标记第三行，就可以从方格数字中计算出列和行的索引。假定玩家的选择存储在变量choice中。
  • 如果将玩家选择的方格数字减1,方格数就是0-8。

如图下图所示

在这里插入图片描述

表达式choice/3会得到行数。

如图下图所示

在这里插入图片描述

表达式choice%3 会得到列数。

如图下图所示

在这里插入图片描述

  • 找出其中一位玩家获胜。每次轮完后，都需检查方格上的列、行或对角线是否有相同的标志。如果有，后一位玩家就赢了。
  • 确定游戏的结束。因为板上有9个方格，所以游戏是在有人获胜或轮玩9次后结束。

四、井字棋游戏的程序编写步骤

在这里插入图片描述

4.1、添加主要的游戏循环和显示这个方格

添加主要的游戏循环和显示这个方格的代码如下所示

	/// <summary>
    /// 变量定义
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    int player = 0;                       // 当前玩家编号- 1或2
    int winner = 0;                       // 中奖选手号码

    char board[3][3] = {                  // The board
                {'1','2','3'},            // 初始值为字符“1”到“9”
                {'4','5','6'},            // 用于选择一个空白的方格
                {'7','8','9'}             // 轮到一个玩家了。
    };

    /// <summary>
    /// 主要的游戏循环。游戏将持续9个回合
    /// 只要没有赢家
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    for (unsigned int i = 0; i < 9 && winner == 0; ++i)
    {
        /// <summary>
        ///  展示棋局
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        printf("\n");
        printf(" %c | %c | %c\n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[2][0], board[2][1], board[2][2]);
    }
  • 这里声明了以下变量:
  • i是循环变量; player, 存储目前玩家的识别码1或2; winner,含有获胜者的识别码;数组board，它的类型是char。
  • 因为这个数组把标记X或0放在，方格中。这个数组用方格的识别数字作为初始值。游戏的主循环只要循环条件为就会继续执行。如果winner的值不等于0(表示找到获胜者)，或循环计数器的值大于等于9(表示方格板上的9格全部填满)，循环条件就是false。
  • 在循环中显示方格时，使用“|”和“_”字符绘制方框。 玩家选择了一个方格时，玩家的标志将会取代这个字符。

4.2、让玩家选择-一个方格， 并确定那个方格是否有效

让玩家选择-一个方格， 并确定那个方格是否有效的代码如下所示

	/// <summary>
    /// 变量定义
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    int player = 0;                       // 当前玩家编号- 1或2
    int winner = 0;                       // 中奖选手号码
    int choice = 0;                       // 选择广场
    unsigned int row = 0;                 // 正方形的行索引
    unsigned int column = 0;              // 正方形的列索引
    unsigned int line = 0;                // 检查循环中的行或列索引

    char board[3][3] = {                  // The board
                {'1','2','3'},            // 初始值为字符“1”到“9”
                {'4','5','6'},            // 用于选择一个空白的方格
                {'7','8','9'}             // 轮到一个玩家了。
    };

    /// <summary>
    /// 主要的游戏循环。游戏将持续9个回合
    /// 只要没有赢家
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    for (unsigned int i = 0; i < 9 && winner == 0; ++i)
    {
        /// <summary>
        ///  展示棋局
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        printf("\n");
        printf(" %c | %c | %c\n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[2][0], board[2][1], board[2][2]);

        /// <summary>
        /// 选择玩家
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        player = i % 2 + 1;                   

        /// <summary>
        /// 获得有效的玩家方块选择
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        do
        {
            printf("玩家% d，请输入有效的数字，"
                "对于你想要放置 % c的位置: ",
                player, (player == 1) ? 'X' : 'O');
            scanf("%d", &choice);

            row = --choice / 3;                 // 获取square的行索引
            column = choice % 3;                // 获取square的列索引
        } while (choice < 0 || choice > 9 || board[row][column] > '9');

        /// <summary>
        /// 插入玩家符号
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        board[row][column] = (player == 1) ? 'X' : 'O';
    }
  • 在do-while循环中提示当前的玩家输入标记，并且把方格数字读入choice变量。这个值将使用前面给出的表达式计算数组中列和行的索引值。行和列的索引值分别保存在变量row和column中。
  • do-while的循环条件确认选择的方格是有效的。
  • 有3种可能导致选择无效:
    1. 输入的方格数小于 0
    1. 输入的方格数大于 8
    1. 选择已包含 X或O的方格
  • 在后一种情况下，方格的内容将大于字符’9’，因为X和0的字符码都大于9的字符码。如果输入的choice属于以上任一种情况，必须要求玩家再选择-一个方 格。

4.3、添加检查获胜线

添加检查获胜线的代码如下所示

	/// <summary>
    /// 变量定义
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    int player = 0;                       // 当前玩家编号- 1或2
    int winner = 0;                       // 中奖选手号码
    int choice = 0;                       // 选择广场
    unsigned int row = 0;                 // 正方形的行索引
    unsigned int column = 0;              // 正方形的列索引
    unsigned int line = 0;                // 检查循环中的行或列索引

    char board[3][3] = {                  // The board
                {'1','2','3'},            // 初始值为字符“1”到“9”
                {'4','5','6'},            // 用于选择一个空白的方格
                {'7','8','9'}             // 轮到一个玩家了。
    };

    /// <summary>
    /// 主要的游戏循环。游戏将持续9个回合
    /// 只要没有赢家
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    for (unsigned int i = 0; i < 9 && winner == 0; ++i)
    {
        /// <summary>
        ///  展示棋局
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        printf("\n");
        printf(" %c | %c | %c\n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[2][0], board[2][1], board[2][2]);

        /// <summary>
        /// 选择玩家
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        player = i % 2 + 1;                   

        /// <summary>
        /// 获得有效的玩家方块选择
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        do
        {
            printf("玩家% d，请输入有效的数字，"
                "对于你想要放置 % c的位置: ",
                player, (player == 1) ? 'X' : 'O');
            scanf("%d", &choice);

            row = --choice / 3;                 // 获取square的行索引
            column = choice % 3;                // 获取square的列索引
        } while (choice < 0 || choice > 9 || board[row][column] > '9');

        /// <summary>
        /// 插入玩家符号
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        board[row][column] = (player == 1) ? 'X' : 'O';

        /// <summary>
        /// 先用对角线看是否有获胜的线
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        if ((board[0][0] == board[1][1] && board[0][0] == board[2][2]) ||
            (board[0][2] == board[1][1] && board[0][2] == board[2][0]))
            winner = player;
        else
        {
            /// <summary>
            /// 检查行和列，找出获胜的行
            /// </summary>
            /// <param name=""></param>
            /// <returns></returns>
            for (line = 0; line <= 2; ++line)
            {
                if ((board[line][0] == board[line][1] && board[line][0] == board[line][2]) ||
                    (board[0][line] == board[1][line] && board[0][line] == board[2][line]))
                    winner = player;
            }
        }
    }
  • 检查获胜线时，可以用线上的一个元素比较线上的其他两个元素，确定它们是否相同。如果3个都相同，就有一个获胜线。用if表达式检查board数组中的两个对角线，如果任一条对角线中的3个标志完全相同，就把winner设定成当前的玩家。
  • 当前的玩家一定是赢家，因为他是最后一个在方格中放置标志的。如果两个对角线都没有相同的标志，就在else子句中用一个for 循环去检查列和行。这个for循环含有一个if语句，它检查列和行是否有相同的元素。如果有，就把winner设定成当前的玩家。当然，如果winner设定为一个值，主循环的条件就是false，所以结束循环，继续执行主循环后的代码。

4.4、显示格子上最后各个标记的位置

最后的任务是显示格子上最后各个标记的位置，显示比赛结果。如果winner是0,这局就是平手:否则winner含有获胜者的号码。代码如下所示

	/// <summary>
    /// 变量定义
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    int player = 0;                       // 当前玩家编号- 1或2
    int winner = 0;                       // 中奖选手号码
    int choice = 0;                       // 选择广场
    unsigned int row = 0;                 // 正方形的行索引
    unsigned int column = 0;              // 正方形的列索引
    unsigned int line = 0;                // 检查循环中的行或列索引

    char board[3][3] = {                  // The board
                {'1','2','3'},            // 初始值为字符“1”到“9”
                {'4','5','6'},            // 用于选择一个空白的方格
                {'7','8','9'}             // 轮到一个玩家了。
    };

    /// <summary>
    /// 主要的游戏循环。游戏将持续9个回合
    /// 只要没有赢家
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    for (unsigned int i = 0; i < 9 && winner == 0; ++i)
    {
        /// <summary>
        ///  展示棋局
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        printf("\n");
        printf(" %c | %c | %c\n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[2][0], board[2][1], board[2][2]);

        /// <summary>
        /// 选择玩家
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        player = i % 2 + 1;                   

        /// <summary>
        /// 获得有效的玩家方块选择
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        do
        {
            printf("玩家% d，请输入有效的数字，"
                "对于你想要放置 % c的位置: ",
                player, (player == 1) ? 'X' : 'O');
            scanf("%d", &choice);

            row = --choice / 3;                 // 获取square的行索引
            column = choice % 3;                // 获取square的列索引
        } while (choice < 0 || choice > 9 || board[row][column] > '9');

        /// <summary>
        /// 插入玩家符号
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        board[row][column] = (player == 1) ? 'X' : 'O';

        /// <summary>
        /// 先用对角线看是否有获胜的线
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        if ((board[0][0] == board[1][1] && board[0][0] == board[2][2]) ||
            (board[0][2] == board[1][1] && board[0][2] == board[2][0]))
            winner = player;
        else
        {
            /// <summary>
            /// 检查行和列，找出获胜的行
            /// </summary>
            /// <param name=""></param>
            /// <returns></returns>
            for (line = 0; line <= 2; ++line)
            {
                if ((board[line][0] == board[line][1] && board[line][0] == board[line][2]) ||
                    (board[0][line] == board[1][line] && board[0][line] == board[2][line]))
                    winner = player;
            }
        }
    }

    /// <summary>
    /// 游戏结束，展示最后的棋盘
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    printf("\n");
    printf(" %c | %c | %c\n", board[0][0], board[0][1], board[0][2]);
    printf("---+---+---\n");
    printf(" %c | %c | %c\n", board[1][0], board[1][1], board[1][2]);
    printf("---+---+---\n");
    printf(" %c | %c | %c\n", board[2][0], board[2][1], board[2][2]);

    /// <summary>
    /// 显示结果信息
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    if (winner)
        printf("\n恭喜玩家%d，你是赢家!\n", winner);
    else
        printf("\n多无聊啊，是平局吗？\n");

五、井字棋游戏程序运行结果

井字棋游戏程序运行结果如下所示

5.1、有玩家获胜的棋局

在这里插入图片描述

 1 | 2 | 3
---+---+---
 4 | 5 | 6
---+---+---
 7 | 8 | 9
玩家 1，请输入有效的数字，对于你想要放置 X的位置: 1

 X | 2 | 3
---+---+---
 4 | 5 | 6
---+---+---
 7 | 8 | 9
玩家 2，请输入有效的数字，对于你想要放置 O的位置: 2

 X | O | 3
---+---+---
 4 | 5 | 6
---+---+---
 7 | 8 | 9
玩家 1，请输入有效的数字，对于你想要放置 X的位置: 5

 X | O | 3
---+---+---
 4 | X | 6
---+---+---
 7 | 8 | 9
玩家 2，请输入有效的数字，对于你想要放置 O的位置: 3

 X | O | O
---+---+---
 4 | X | 6
---+---+---
 7 | 8 | 9
玩家 1，请输入有效的数字，对于你想要放置 X的位置: 9

 X | O | O
---+---+---
 4 | X | 6
---+---+---
 7 | 8 | X

恭喜玩家1，你是赢家!
请按任意键继续. . .

5.2、没有玩家获胜的棋局

在这里插入图片描述

 1 | 2 | 3
---+---+---
 4 | 5 | 6
---+---+---
 7 | 8 | 9
玩家 1，请输入有效的数字，对于你想要放置 X的位置: 1

 X | 2 | 3
---+---+---
 4 | 5 | 6
---+---+---
 7 | 8 | 9
玩家 2，请输入有效的数字，对于你想要放置 O的位置: 5

 X | 2 | 3
---+---+---
 4 | O | 6
---+---+---
 7 | 8 | 9
玩家 1，请输入有效的数字，对于你想要放置 X的位置: 2

 X | X | 3
---+---+---
 4 | O | 6
---+---+---
 7 | 8 | 9
玩家 2，请输入有效的数字，对于你想要放置 O的位置: 3

 X | X | O
---+---+---
 4 | O | 6
---+---+---
 7 | 8 | 9
玩家 1，请输入有效的数字，对于你想要放置 X的位置: 7

 X | X | O
---+---+---
 4 | O | 6
---+---+---
 X | 8 | 9
玩家 2，请输入有效的数字，对于你想要放置 O的位置: 4

 X | X | O
---+---+---
 O | O | 6
---+---+---
 X | 8 | 9
玩家 1，请输入有效的数字，对于你想要放置 X的位置: 6

 X | X | O
---+---+---
 O | O | X
---+---+---
 X | 8 | 9
玩家 2，请输入有效的数字，对于你想要放置 O的位置: 8

 X | X | O
---+---+---
 O | O | X
---+---+---
 X | O | 9
玩家 1，请输入有效的数字，对于你想要放置 X的位置: 9

 X | X | O
---+---+---
 O | O | X
---+---+---
 X | O | X

多无聊啊，是平局吗？
请按任意键继续. . .

六、井字棋游戏程的完整程序代码

井字棋游戏程的完整程序代码如下所示

6.1、Main.h头文件

#ifndef MAIN_H
#define MAIN_H

#include <stdio.h>
#include <stdlib.h>

#endif

6.2、Main.c源文件

#define _CRT_SECURE_NO_WARNINGS

#include "Main.h"

int main(void)
{
    system("color 3E");

    /// <summary>
    /// 变量定义
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    int player = 0;                       // 当前玩家编号- 1或2
    int winner = 0;                       // 中奖选手号码
    int choice = 0;                       // 选择广场
    unsigned int row = 0;                 // 正方形的行索引
    unsigned int column = 0;              // 正方形的列索引
    unsigned int line = 0;                // 检查循环中的行或列索引

    char board[3][3] = {                  // The board
                {'1','2','3'},            // 初始值为字符“1”到“9”
                {'4','5','6'},            // 用于选择一个空白的方格
                {'7','8','9'}             // 轮到一个玩家了。
    };

    /// <summary>
    /// 主要的游戏循环。游戏将持续9个回合
    /// 只要没有赢家
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    for (unsigned int i = 0; i < 9 && winner == 0; ++i)
    {
        /// <summary>
        ///  展示棋局
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        printf("\n");
        printf(" %c | %c | %c\n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c\n", board[2][0], board[2][1], board[2][2]);

        /// <summary>
        /// 选择玩家
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        player = i % 2 + 1;                   

        /// <summary>
        /// 获得有效的玩家方块选择
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        do
        {
            printf("玩家% d，请输入有效的数字，"
                "对于你想要放置 % c的位置: ",
                player, (player == 1) ? 'X' : 'O');
            scanf("%d", &choice);

            row = --choice / 3;                 // 获取square的行索引
            column = choice % 3;                // 获取square的列索引
        } while (choice < 0 || choice > 9 || board[row][column] > '9');

        /// <summary>
        /// 插入玩家符号
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        board[row][column] = (player == 1) ? 'X' : 'O';

        /// <summary>
        /// 先用对角线看是否有获胜的线
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        if ((board[0][0] == board[1][1] && board[0][0] == board[2][2]) ||
            (board[0][2] == board[1][1] && board[0][2] == board[2][0]))
            winner = player;
        else
        {
            /// <summary>
            /// 检查行和列，找出获胜的行
            /// </summary>
            /// <param name=""></param>
            /// <returns></returns>
            for (line = 0; line <= 2; ++line)
            {
                if ((board[line][0] == board[line][1] && board[line][0] == board[line][2]) ||
                    (board[0][line] == board[1][line] && board[0][line] == board[2][line]))
                    winner = player;
            }
        }
    }

    /// <summary>
    /// 游戏结束，展示最后的棋盘
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    printf("\n");
    printf(" %c | %c | %c\n", board[0][0], board[0][1], board[0][2]);
    printf("---+---+---\n");
    printf(" %c | %c | %c\n", board[1][0], board[1][1], board[1][2]);
    printf("---+---+---\n");
    printf(" %c | %c | %c\n", board[2][0], board[2][1], board[2][2]);

    /// <summary>
    /// 显示结果信息
    /// </summary>
    /// <param name=""></param>
    /// <returns></returns>
    if (winner)
        printf("\n恭喜玩家%d，你是赢家!\n", winner);
    else
        printf("\n多无聊啊，是平局吗？\n");

    system("pause");
    return 0;
}

七、总结

在这里插入图片描述

本文主要介绍了C语言高级编程的数组的综合实例：井字棋游戏的编程。

  • 本文到这里就结束啦！！！
  • 希望本文的C语言数组综合实例之井字游戏。
  • 能对你有所帮助。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/198243.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Android 设置可抓包

Android 设置可抓包

在ren目录下新建xml文件夹&#xff0c;在xml下新建network_security_config.xml<?xml version"1.0" encoding"utf-8"?><!--<network-security-config>--><!-- <base-config cleartextTrafficPermitted"true" />--&…
阅读更多...
MySQL面试：MySQL事务，内附详细视频教程，以及sql事务演示

MySQL面试：MySQL事务，内附详细视频教程，以及sql事务演示

文章目录一、事务&#xff08;提出事务&#xff09;二、四个特性&#xff08;事务要实现的特性&#xff09;三、一致性问题&#xff08;事务可以解决这些问题&#xff09;四、解决&#xff08;事务解决部分或全部一致性问题&#xff09;五、实现&#xff08;事务实现ACID的机制…
阅读更多...
Python setattr()、getattr()、hasattr()函数用法详解

Python setattr()、getattr()、hasattr()函数用法详解

Python hasattr()函数hasattr() 函数用来判断某个类实例对象是否包含指定名称的属性或方法。该函数的语法格式如下&#xff1a;hasattr(obj, name)其中 obj 指的是某个类的实例对象&#xff0c;name 表示指定的属性名或方法名。同时&#xff0c;该函数会将判断的结果&#xff0…
阅读更多...
差值结构不对称部分的约化质心

差值结构不对称部分的约化质心

( A, B )---5*30*2---( 1, 0 )( 0, 1 ) 做一个网络&#xff0c;输入为5个点&#xff0c;训练集A,B各有两张图片。让B的两张图片全是0.排列组合A&#xff0c;记录迭代次数平均值的变化。 迭代了1024组&#xff0c;共收集到33组不同的数据&#xff0c;其中对称的部分有17组&…
阅读更多...
Java volatile学习

Java volatile学习

面试题&#xff1a; 1、请谈谈你对volatile的理解&#xff1f; volatile是Java虚拟机提供的轻量级的同步机制1.保证可见性2.不保证原子性3.禁止指令重排 2、JMM你谈谈?3、你在哪些地方用到过volatile?一、概述 JMM(Java内存模型 Java Memory Model&#xff0c;简称JMM) 本身是…
阅读更多...
JSP 概述（三）

JSP 概述（三）

JSP 的处理过程&JSP 与其他服务器端脚本语言的比较1. JSP 的处理过程2. JSP 与其他服务器端脚本语言的比较2.1 CGI2.2 ASP2.3 PHP2.4 ASP.NET结束语1. JSP 的处理过程 当客户端浏览器向服务器发出请求要访问一个 JSP 页面时&#xff0c;服务器根据该请求加载相应的 JSP 页…
阅读更多...
微信小程序里面的js文件分为哪几类？

微信小程序里面的js文件分为哪几类？

1.小程序中的.js的分类 小程序中的JS文件分为三大类&#xff0c;分别是&#xff1a; 1.app.js 是整个小程序项目的入口文件&#xff0c;通过调用App()函数来启动整个小程序 2.页面的.js文件 是页面的入口文件&#xff0c;通过调用 Page&#xff08;&#xff09;函数来创建并运行…
阅读更多...
Java基础语法（基础篇 适合小白）

Java基础语法（基础篇 适合小白）

Hello World public 访问修饰符 static 关键字 void 返回类型 String 类 args字符串数组 public class HelloWorld {/* 第一个Java程序* 它将输出字符串 Hello World*/public static void main(String[] args) {System.out.println("Hello World"); // 输出 Hello Wo…
阅读更多...
Odoo | 7个步骤搭建的“在线表格组件”，十分丝滑~

Odoo | 7个步骤搭建的“在线表格组件”，十分丝滑~

X-SpreadSheet是一个类似于google sheet的在线表格组件&#xff0c;很多场景都能借助它来搭建在线表格。 集成过程 1、下载X-SpreadSheet源码到本地 下载地址 x-spreadsheet.css&#xff1a; https://unpkg.com/x-data-spreadsheet1.0.13/dist/xspreadsheet.css x-spread…
阅读更多...
Tomcat的安装及配置

Tomcat的安装及配置

Tomcat介绍&#xff1a;Tomcat简单地说就是一个运行JAVA的网络服务器&#xff0c;底层是Socket的一个程序&#xff0c;它也是JSP和Serlvet的一个容器疑问&#xff1a;一个电脑中可以安装多个版本的Tomcat吗&#xff1f;同一台电脑可以同时安装多个Tomcat服务器。安装及配置&…
阅读更多...
【Spark分布式内存计算框架——Spark 基础环境】2. 快速入门（上）环境准备

【Spark分布式内存计算框架——Spark 基础环境】2. 快速入门（上）环境准备

第三章 快速入门 目前Spark最新稳定版本&#xff1a;2.4.x系列&#xff0c;官方推荐使用的版本&#xff0c;也是目前企业中使用较多版本&#xff0c;网址&#xff1a;https://github.com/apache/spark/releases Spark 2.4.x依赖其他语言版本如下&#xff0c;其中既支持Scala …
阅读更多...
代码随想录算法训练营第三十一天_第八章_贪心算法 | 理论基础、455.分发饼干、376. 摆动序列、53.最大子数组和

代码随想录算法训练营第三十一天_第八章_贪心算法 | 理论基础、455.分发饼干、376. 摆动序列、53.最大子数组和

理论基础 LeetCode 455.分发饼干 视频讲解https://www.bilibili.com/video/BV1MM411b7cq/?spm_id_from333.788&vd_sourcef98f2942b3c4cafea8907a325fc56a48文章讲解https://programmercarl.com/0455.%E5%88%86%E5%8F%91%E9%A5%BC%E5%B9%B2.html 思路&#xff1a;代码&…
阅读更多...
开唐贡献榜(凌烟阁二十四功臣)

开唐贡献榜(凌烟阁二十四功臣)

唐贞观十七年&#xff0c;太宗李世民为表彰唐初的开国功臣 建造凌烟阁 绘制二十四功臣像以示纪念 第一位 威能服物&#xff0c;智能动众。力安社稷&#xff0c;一代奸雄。 赵国公 长孙无忌 第二位 挺身陷阵&#xff0c;勇冠三军。飞虎将军&#xff0c;十三太保。 河间王 李孝…
阅读更多...
【C语言】文件操作函数

【C语言】文件操作函数

文件操作函数1.文件的打开和关闭1.1fopen1.2close2.文件的顺序读写2.1fgetc和fputc2.1.1fputc2.1.2fgetc2.2fgets和fputs2.2.1fputs2.2.2fgets2.3fscanf和fprintf2.3.1fprintf2.3.2fscanf2.4fread和fwrite2.4.1fwrite2.4.2fread2.5总结2.6拓展&#xff08;sscanf和sprintf&…
阅读更多...
【面试题】async/await、promise和setTimeout的执行顺序

【面试题】async/await、promise和setTimeout的执行顺序

从一道题目出发今天看到一道面试题&#xff0c;是关于async/await、promise和setTimeout的执行顺序&#xff0c;题目如下&#xff1a;asyncfunctionasync1() {console.log(async1 start);awaitasync2();console.log(asnyc1 end); } asyncfunctionasync2() {console.log(async2)…
阅读更多...
kafka官方文档中文翻译（kafka参数解释）

kafka官方文档中文翻译（kafka参数解释）

目录 入门 1.1简介 kafka™是一个分布式流媒体平台。这到底意味着什么&#xff1f; 1.2使用案例 1.3快速入门 1.4生态系统 1.5从以前的版本升级 2. API 2.1生产者API 2.2消费者API 2.3 Streams API 2.4连接API 2.5遗留API 3.配置 3.1Broker配置 3.2生产者配置 …
阅读更多...
Exynos 4412 看门狗定时器中断

Exynos 4412 看门狗定时器中断

如果想弄懂看门狗定时器中断&#xff0c;要掌握下面两个知识点&#xff1a; 1 懂寄存器 Cortex A9采用的是ARM官方规定的中断处理机制 有两大类寄存器决定了中断工作状态 1) exynos 4412 特有的寄存器(在第26章) 2) Cortex A9 规定的工作寄存器(在第9章和第10章) 2 懂中断处理过…
阅读更多...
【memcached】下载、安装、、出错一分钟全搞定

【memcached】下载、安装、、出错一分钟全搞定

各位小伙伴在看黑马程序员springboot的时候可能会遇到的情况&#xff1a;memcached如何安装&#xff1f;官网地址&#xff1a;https://www.runoob.com/memcached/window-install-memcached.html找到合适的下载即可&#xff0c;占用内容很小&#xff0c;几秒就下载好了开启服务安…
阅读更多...
SpringBoot + jackson + redis 序列化、反序列化 配置正确姿势

SpringBoot + jackson + redis 序列化、反序列化 配置正确姿势

文章目录1.背景2. 原来项目配置3.正确配置4.小结1.背景 最近项目上 使用 SpringBoot 2.7.7 jackson redis 框架实现将javaBean 序列化和反序列化到 redis 中。但是最近在做登陆的时候将LoginUser 序列化到redis 中没问题&#xff0c;不重启服务的话反序列化成对象也没有问题…
阅读更多...
【Java多线程】同步代码块处理线程安全问题

【Java多线程】同步代码块处理线程安全问题

题&#xff1a;创建三个窗口卖票&#xff0c;总票数为100张 1.问题&#xff1a;买票过程中&#xff0c;出现了重票&#xff0c;错票 --> 出现了线程的安全问题 2.问题出现的原因&#xff1a;当某个线程操作车票的过程中&#xff0c;尚未操作完成时&#xff0c;其他线程参与进…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023