unity数独游戏

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class MainMenuPanel : MonoBehaviour
{
    public Button btnPlay; // 开始按钮
    public Slider sldDifficulty; // 难度滑动条

    private void Awake()
    {
        // 监听滑动条滑动事件
        sldDifficulty.onValueChanged.AddListener(OnSliderChange);
        
        // 开始按钮点击事件
        btnPlay.onClick.AddListener(OnPlayGame);
    }
    
    
    void Start()
    {
        // 启动的时候保存难度值
        SudokuGameManager.Instance.difficulty = (int)sldDifficulty.value;
    }

    public void OnSliderChange(float value)
    {
        // 滑动条变化的时候保存难度值
        SudokuGameManager.Instance.difficulty = (int)sldDifficulty.value;
    }
    
    public void OnPlayGame()
    {
        // 调用游戏管理器中的方法来开始一局新的数独游戏
        SudokuGameManager.Instance.OnPlayNewGame();
    }
}

主要功能在该脚本中

在创建正确答案，扣除里面的数字并，把两个比较

重开游戏

算法用到了递归

using System.Collections.Generic;
using UnityEngine;

public class SudokuBoard : MonoBehaviour
{
    // 正确答案
    int[,] gridNumber = new int[SudokuGameManager.girdLength, SudokuGameManager.girdLength];
   
    // 谜题
    int[,] puzzleNumber = new int[SudokuGameManager.girdLength, SudokuGameManager.girdLength];

    // 谜题备份，用于重开本局游戏
    int[,] puzzleBak = new int[SudokuGameManager.girdLength, SudokuGameManager.girdLength];

    public SudokuGrid grid;// 网格体
    public void Init()
    {
        // 创建一个有解的数独
        CreateGrid();
        
        // 根据已经创建的答案 来创建 谜题
        CreatePuzzle();
        
        // 根据谜题来初始化按钮
        InitButtons();

    }
    
    // 清理所有资源
    public void Clear()
    {
        // 清理谜题和答案数据
        gridNumber = new int[SudokuGameManager.girdLength, SudokuGameManager.girdLength];
        puzzleNumber = new int[SudokuGameManager.girdLength, SudokuGameManager.girdLength];
        puzzleBak = new int[SudokuGameManager.girdLength, SudokuGameManager.girdLength];
    }

    // 销毁某个物体下面的所有子物体
    void ClearChildren(Transform trans)
    {
        for (int i = 0; i < trans.childCount; i++)
        {
            Destroy(trans.GetChild(i).gameObject);
        }
    }
    
    // 某列是否包含某个数据
    bool ColumnContainsValue(int col, int value)
    {
        for (int i = 0; i < SudokuGameManager.girdLength; i++)
        {
            if (gridNumber[i, col] == value)
            {
                return true;
            }
        }

        return false;
    }
    
    // 某一行是否包含某个数字
    bool RowContainsValue(int row, int value)
    {
        for (int i = 0; i < SudokuGameManager.girdLength; i++)
        {
            if (gridNumber[row, i] == value)
            {
                return true;
            }
        }

        return false;
    }
    
    // 某一个子网格是否包含某个数字
    bool SquareContainsValue(int row, int col, int value)
    {
        // 遍历子单元格(3X3)
        for (int i = 0; i < SudokuGameManager.subGirdLength; i++)
        {
            for (int j = 0; j < SudokuGameManager.subGirdLength; j++)
            {
                // 通过计算坐标 确定是属于哪个子网格
                if (gridNumber[(row / SudokuGameManager.subGirdLength) * SudokuGameManager.cellLength + i, (col / SudokuGameManager.subGirdLength) * SudokuGameManager.cellLength + j] == value)
                {
                    return true;
                }
            }
        }
        return false;
    }

    // 检查某个数是否已经存在于 横 列以及某个3X3的网格里
    bool CheckAll(int row, int col, int value)
    {
        if (ColumnContainsValue(col, value)) // 列是否已经包含该数字
        {
            return false;
        }

        if (RowContainsValue(row, value)) // 行是否已经包含该数字
        {
            return false;
        }

        if (SquareContainsValue(row, col, value)) // 当前子九宫是否包含该数字
        {
            return false;
        }

        return true;
    }

    // 网格数字是否有效
    bool IsValid()
    {
        for (int i = 0; i < SudokuGameManager.girdLength; i++)
        {
            for (int j = 0; j < SudokuGameManager.girdLength; j++)
            {
                if (gridNumber[i, j] == 0)
                {
                    return false;
                }
            }
        }

        return true;
    }

    // 创建一个有效的数独网格
    void CreateGrid()
    {
        List<int> rowList = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        List<int> colList = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        
        // 先在00位置随机一个数据
        int value = rowList[Random.Range(0, rowList.Count)];
        gridNumber[0, 0] = value;
        rowList.Remove(value);
        colList.Remove(value);

        // 将其他8个数字随机到第一行中
        for (int i = 1; i < SudokuGameManager.girdLength; i++)
        {
            value = rowList[Random.Range(0, rowList.Count)];
            gridNumber[i, 0] = value;
            rowList.Remove(value);
        }
        
        // 将其他几个数字随机到第一列中
        for (int i = 1; i < SudokuGameManager.girdLength; i++)
        {
            value = colList[Random.Range(0, colList.Count)];
            // 需要判断是否会和第一个子网格有重复
            if (i < 3)
            {
                while (SquareContainsValue(0, 0, value))
                {
                    value = colList[Random.Range(0, colList.Count)]; // reroll
                }
            }

            gridNumber[0, i] = value;
            colList.Remove(value);
        }

        // 再随机对最后一个子网格添加三个合法的数字
        for (int i = 6; i < 9; i++)
        {
            value = Random.Range(1, 10);
            while (SquareContainsValue(0, 8, value) || SquareContainsValue(8, 0, value) ||
                   SquareContainsValue(8, 8, value))
            {
                value = Random.Range(1, 10);
            }

            gridNumber[i, i] = value;
        }
        
        // 先随机生成一个数独的底子，然后对它求解，解出的答案就是完整数独
         SolveSudoku();
    }

    // 对数独求解
    bool SolveSudoku()
    {
        int row = 0;
        int col = 0;
        
        // 如果已经生成完毕 就返回结果
        if (IsValid())
        {
            return true;
        }
        
        // 找到还没有生成数字的位置
        for (int i = 0; i < SudokuGameManager.girdLength; i++)
        {
            for (int j = 0; j < SudokuGameManager.girdLength; j++)
            {
                if (gridNumber[i, j] == 0)
                {
                    row = i;
                    col = j;
                    break;
                }
            }
        }
        
        // 循环 找到合适的数字，满足所有的规则
        for (int i = 1; i <= SudokuGameManager.girdLength; i++)
        {
            if (CheckAll(row, col, i))
            {
                gridNumber[row, col] = i;
                
                // 递归找解 这里很重要，因为是对自身的递归，如果随机的数字正好全部都满足就结束了
                if (SolveSudoku())
                {
                    return true;
                }
                else //如果某次递归找不到解 就会将该位置之 
                {
                    gridNumber[row, col] = 0;
                }
            }
        }

        return false;
    }

    void CreatePuzzle()
    {
        // 根据事先完成的答案 创建谜题
        // 先将答案复制一份出来
        System.Array.Copy(gridNumber, puzzleNumber, gridNumber.Length);

       //移除数字，制造难度
        for (int i = 0; i < SudokuGameManager.Instance.difficulty; i++)
        {
            int row = Random.Range(0, SudokuGameManager.girdLength);
            int col = Random.Range(0, SudokuGameManager.girdLength);
        
            // 循环随机，直到随到一个没有处理过的位置
            while (puzzleNumber[row, col] == 0)
            {
                row = Random.Range(0, SudokuGameManager.girdLength);
                col = Random.Range(0, SudokuGameManager.girdLength);
            }
        
            puzzleNumber[row, col] = 0;
        }

        // 确保最少要出现8个不同的数字 才能保证唯一解
        List<int> onBoard = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        RandomizeList(onBoard);

        for (int i = 0; i < SudokuGameManager.girdLength; i++)
        {
            for (int j = 0; j < SudokuGameManager.girdLength; j++)
            {
                for (int k = 0; k < onBoard.Count - 1; k++)
                {
                    if (onBoard[k] == puzzleNumber[i, j])
                    {
                        onBoard.RemoveAt(k);
                    }
                }
            }
        }

        // 如果剩余的数量大于1 说明没有8个不同的数字 那么就还原几个数字回来
        while (onBoard.Count - 1 > 1)
        {
            int row = Random.Range(0, SudokuGameManager.girdLength);
            int col = Random.Range(0, SudokuGameManager.girdLength);

            if (gridNumber[row, col] == onBoard[0])
            {
                puzzleNumber[row, col] = gridNumber[row, col];
                onBoard.RemoveAt(0);
            }
        }
        
        // 将谜题备份用于重开本局游戏
        System.Array.Copy(puzzleNumber, puzzleBak, gridNumber.Length);
    }

    // 初始化可填写的按钮布局
    void InitButtons()
    {
        for (int i = 0; i < SudokuGameManager.girdLength; i++)
        {
            for (int j = 0; j < SudokuGameManager.girdLength; j++)
            {
                var cell = grid.GetCellByPosition(i,j);
                if (cell != null)
                {
                    cell.InitValues(puzzleNumber[i,j]);
                }
                
            }
        }
    }
    
    //重开本局游戏
    public void RestartGame()
    {
        System.Array.Copy(puzzleBak, puzzleNumber, gridNumber.Length);
        InitButtons();
    }
    
    // 打乱一个List
    void RandomizeList(List<int> l)
    {
        for (var i = 0; i < l.Count - 1; i++)
        {
            // 随机交换两个位置
            int rand = Random.Range(i, l.Count);
            (l[i], l[rand]) = (l[rand], l[i]);
        }
    }
    
    // 将玩家输入更新到谜题中
    public void UpdatePuzzle(int row, int col, int value)
    {
        puzzleNumber[row, col] = value;
    }

    /// <summary>
    /// 判定游戏是否完成
    /// </summary>
    /// <returns></returns>
    public bool CheckComplete()
    {
        // 检查填入的内容和谜底内容是否吻合
        for (int i = 0; i < SudokuGameManager.girdLength; i++)
        {
            for (int j = 0; j < SudokuGameManager.girdLength; j++)
            {
                if (puzzleNumber[i, j] != gridNumber[i, j])
                {
                    return false;
                }
            }
        }
        return true;
    }
    
}

using System;
using System.Collections;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.UI;

public class SudokuCell : MonoBehaviour
{
    public Vector2Int coordinate; // 在大网格里坐标
    public SudokuSubGrid subGrid;
    int value = 0; // 当前格子的值
    public TextMeshProUGUI txtNumber;// 数字控件
    public Button btnNum;// 按钮控件

    void Awake()
    {
        btnNum = GetComponent<Button>();
        txtNumber = GetComponentInChildren<TextMeshProUGUI>();
        btnNum.onClick.AddListener(ButtonClicked);
    }


    // 给网格设置数字
    public void InitValues(int value)
    {
        // 初始化的时候，不为0表示该位置是系统提供的数字，否则就是玩家应该输入的数字
        if (value != 0)
        {
            txtNumber.text = value.ToString();
            txtNumber.color = new Color32(119, 110, 101, 255);
            btnNum.enabled = false;
        }
        else
        {
            btnNum.enabled = true;
            txtNumber.text = " ";
            txtNumber.color = new Color32(0, 102, 187, 255);
        }
    }

    // 设置行列坐标
    public void SetCoordinate(int row, int col)
    {
        coordinate = new Vector2Int(row, col);
        name = row.ToString() + col.ToString();
    }

    // 设置其归属的子网格
    public void SetSubGridParent(SudokuSubGrid sub)
    {
        subGrid = sub;
    }

    /// <summary>
    /// 按钮事件
    /// 将当前的数字输入和指定的Cell进行绑定
    /// </summary>
    public void ButtonClicked()
    {
        SudokuGameManager.Instance.ActivateInputButton(this);
    }

    /// <summary>
    /// 更新单元格内的数字
    /// </summary>
    /// <param name="newValue"></param>
    public void UpdateValue(int newValue)
    {
        value = newValue;

        if (value != 0)
        {
            txtNumber.text = value.ToString();
        }
        else
        {
            txtNumber.text = "";
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.UI;

/// <summary>
/// 数独游戏的管理器
/// </summary>
public class SudokuGameManager : MonoBehaviour
{
    public static int girdLength = 9;// 网格的宽高
    public static int subGirdLength = 3;// 子网格的宽高
    // 子网格中 Cell的宽高
    public static int cellLength = SudokuGameManager.girdLength / SudokuGameManager.subGirdLength;
    
    public SudokuCell SudokuCell_Prefab; // 单元格的预制体
    
    // get; private set; 的写法是一种语法糖，表示这个值别的类可以读取和使用，但只有自己才能设置它
    public static SudokuGameManager Instance { get; private set; }
    
    public MainMenuPanel mainMenu;// 主界面相关逻辑
    public SudokuPlayPanel sudokuPlay; // 数独的游戏界面
    
    // 按照9X9的格子来算，一共是81个有效数字，如果已知的数字越多，那么未知的数字就越好推导
    // 所以难度的表达方式就是，设定一个数字，在数独创建完成之后，隐藏掉这些数字来增加难度
    public int difficulty = 20; // 默认的难度值
    
    public Image ipButtonsPanel; // 游戏输入按钮

    public List<Button>btnNums = new List<Button>(); // 数字输入

    // 记录上一次点击的格子 以便数字进行输入
    SudokuCell lastCell;
    
    private void Awake()
    {
        //单例模式
        Instance = this;
        for (int i = 0; i < btnNums.Count; i++)
        {
                       
            // 需要将i的地址传递出来 
            int index = i;
            // 为当前遍历到的按钮添加点击监听器
            // 当按钮被点击时，调用OnNumBtnClicked方法，并将index（即按钮的索引）作为参数传递
            btnNums[i].onClick.AddListener(delegate(){ OnNumBtnClicked(index);});
        }
    }

    private void Start()
    {
        // 程序启动的时候，默认显示开始界面
        OnBackToMenu();
    }
    
    // 返回到开始菜单
    public void OnBackToMenu()
    {
        // 程序启动的时候，默认显示开始界面
        mainMenu.gameObject.SetActive(true);
        sudokuPlay.gameObject.SetActive(false);
        
        // 执行游戏清理
        sudokuPlay.Clear();
    }
    
    // 开始游戏
    public void OnPlayNewGame()
    {
        // 隐藏开始界面 显示游戏界面
        mainMenu.gameObject.SetActive(false);
        sudokuPlay.gameObject.SetActive(true);
        
        // 隐藏数字输入面板
        ipButtonsPanel.gameObject.SetActive(false);
        
        // 执行游戏初始化
        sudokuPlay.Init();
    }
    
    /// <summary>
    /// 将当前的数字输入和指定的Cell进行绑定
    /// </summary>
    /// <param name="cell"></param>
    public void ActivateInputButton(SudokuCell cell)
    {
        ipButtonsPanel.gameObject.SetActive(true);
        lastCell = cell;
    }
    
    /// <summary>
    /// 点击了某个数字按钮
    /// </summary>
    /// <param name="num"></param>
    public void OnNumBtnClicked(int num)
    {
        // 更新上一次选中的格子的数值为当前被点击的数字按钮的值
        lastCell.UpdateValue(num);
        // 在数独游戏的逻辑板上更新相应的格子数值，使用lastCell的坐标和被点击的数字
        sudokuPlay.board.UpdatePuzzle(lastCell.coordinate.x, lastCell.coordinate.y, num);
        // 隐藏数字输入面板
        ipButtonsPanel.gameObject.SetActive(false);
    }
    
}


using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 数独的大网格
/// </summary>
public class SudokuGrid : MonoBehaviour
{
    // 所有的子网格 需要处理成二维数组
    public SudokuSubGrid[,] subGrids { get; private set; }// 子网格
    public SudokuCell[] cells;// 所有的单元格
    
    void Awake()
    {
        // 获取所有子网格体
        var grid = GetComponentsInChildren<SudokuSubGrid>();
        
        // 建立子网格的二维数组
        subGrids = new SudokuSubGrid[SudokuGameManager.subGirdLength, SudokuGameManager.subGirdLength];
        
        // 通过循环将二维数组分配到指定位置
        int index = 0;
        for (int i = 0; i < SudokuGameManager.subGirdLength; i++)
        {
            for (int j = 0; j < SudokuGameManager.subGirdLength; j++)
            {
                subGrids[i, j] = grid[index++];
                subGrids[i, j].SetCoordinate(i,j);// 设置坐标
                subGrids[i, j].InitCells();// 初始化网格
            }
        }
        cells = GetComponentsInChildren<SudokuCell>();
    }
    
    /// <summary>
    /// 根据坐标获取Cell
    /// </summary>
    /// <param name="row"></param>
    /// <param name="col"></param>
    /// <returns></returns>
    public SudokuCell GetCellByPosition(int row,int col)
    {
        foreach (var cell in cells)
        {
            if (cell.coordinate.x == row && cell.coordinate.y == col)
            {
                return cell;
            }
        }

        return null;
    }
    
    
}

using System;
using System.Collections;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.PlayerLoop;
using UnityEngine.Serialization;
using UnityEngine.UI;

public class SudokuPlayPanel : MonoBehaviour
{
    public Button btnBackToMenu;// 返回主界面按钮
    public Button btnBackToMenuInWinPanel;// 获胜面板上的返回主界面按钮
    public Button btnNewLevel;// 新建一个关卡
    public Button btnReplay; // 重新开始本次关卡
    public Button btnComplete; // 完成关卡
    public TextMeshProUGUI txtWrongTips; // 结果错误提示
    public Image imgWinPanel; // 获胜界面
    public TextMeshProUGUI txtTimer;// 计时器
    float levelStartTime = 0f; // 关卡开始的时间，用于计时器的计算

    public SudokuBoard board;// 游戏核心逻辑
    
    private void Awake()
    {
        // 返回主菜单
        btnBackToMenu.onClick.AddListener(OnBtnBackToMenuClicked);
        btnBackToMenuInWinPanel.onClick.AddListener(OnBtnBackToMenuClicked);
        
        // 新建关卡
        btnNewLevel.onClick.AddListener(OnBtnNewClicked);
        
        // 重新开始本关卡
        btnReplay.onClick.AddListener(OnbtnReplayClicked);
        
        // 完成关卡
        btnComplete.onClick.AddListener(OnbtnCompleteClicked);
    }
    
    private void Update()
    {
        // 计时器
        CountTimer();
    }
    
    /// <summary>
    /// 初始化游戏
    /// </summary>
    public void Init()
    {
        // 隐藏错误提示
        txtWrongTips.gameObject.SetActive(false);
        
        // 隐藏获胜面板
        imgWinPanel.gameObject.SetActive(false);
        
        // 记录当前的时间戳
        levelStartTime = Time.realtimeSinceStartup;
        
        // 核心逻辑初始化
        board.Init();
    }


    public void Clear()
    {
        levelStartTime = 0;// 清除计时器开始时间
        
        // 核心逻辑清理
        board.Clear();
    }
    
    /// <summary>
    /// 计时器逻辑
    /// </summary>
    void CountTimer()
    {
        float t = Time.realtimeSinceStartup - levelStartTime;
        int seconds = (int)(t % 60);
        t /= 60;
        int minutes = (int)(t % 60);

        txtTimer.text = string.Format("{0}:{1}", minutes.ToString("00"), seconds.ToString("00"));
    }
    
    /// <summary>
    /// 返回主菜单
    /// </summary>
    public void OnBtnBackToMenuClicked()
    {
        // 清理游戏
        Clear();
        
        // 返回主菜单
        SudokuGameManager.Instance.OnBackToMenu();
    }
    
    /// <summary>
    /// 开始新关卡
    /// </summary>
    public void OnBtnNewClicked()
    {
        // 先清理再初始化
        Clear();
        Init();
    }
    
    /// <summary>
    /// 重玩本关卡
    /// </summary>
    public void OnbtnReplayClicked()
    {
        // 调用核心逻辑的重玩本局
        board.RestartGame();
    }
    
    /// <summary>
    /// 完成游戏
    /// </summary>
    public void OnbtnCompleteClicked()
    {
        // 检查是否完成游戏
        if (board.CheckComplete())
        {
            imgWinPanel.gameObject.SetActive(true);
        }
        else
        {
            txtWrongTips.gameObject.SetActive(true);
            // 3秒后 错误提示消失
            StartCoroutine(HideWrongText());
        }
    }

    IEnumerator HideWrongText()
    {
        yield return new WaitForSeconds(3.0f);
        txtWrongTips.gameObject.SetActive(false);
    }
    
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 大网格下的小网格
/// </summary>
public class SudokuSubGrid : MonoBehaviour
{
    public Vector2Int coordinate; //子网格所属的坐标
    public SudokuCell[,] cells { get; private set; }
    
    // 创建所属的单元格
    private void Awake()
    {
        cells = new SudokuCell[SudokuGameManager.cellLength, SudokuGameManager.cellLength];
    }

    // 设置行列坐标
    public void SetCoordinate(int row, int col)
    {
        coordinate = new Vector2Int(row, col);
    }
    
    // 初始化网格
    public void InitCells()
    {
        for (int i = 0; i < SudokuGameManager.cellLength; i++)
        {
            for (int j = 0; j < SudokuGameManager.cellLength; j++)
            {
                cells[i,j] = Instantiate(SudokuGameManager.Instance.SudokuCell_Prefab,transform);
                cells[i,j].SetCoordinate(coordinate.x * SudokuGameManager.cellLength + i,coordinate.y * SudokuGameManager.cellLength +j);
                cells[i,j].SetSubGridParent(this);
                cells[i,j].InitValues(1);
            }
        }
        
        
       
        
       
       
    }
    
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

RabbitMQ实践——利用一致性Hash交换器做带权重的调度

RabbitMQ实践——利用一致性Hash交换器做带权重的调度

在《RabbitMQ实践——利用一致性Hash交换器做负载均衡》一文中&#xff0c;我们介绍了如何开启一致性hash交换器&#xff0c;并实现了消息的负载均衡&#xff0c;以达到横向扩展消费者数量的能力。 但是现实中&#xff0c;可能存在这样的场景&#xff1a;一些队列所在的机器配置…
阅读更多...
【vue】终端 常用代码 和其他注意

【vue】终端 常用代码 和其他注意

&#x1f951;这里目录 一、【安装】1. 搜版本2.卸载3.安装 带版本4. 纯安装&#xff08;自动最新&#xff09; 二、【官网】官网源码及用法讲解1.【npm】2.【printjs】打印 一、【安装】 以下全拿 qrcode.vue 举例 1. 搜版本 例子&#xff1a;搜 qrcode.vue的版本代码&…
阅读更多...
电子行业实施MES管理系统的时机是什么

电子行业实施MES管理系统的时机是什么

随着信息技术的飞速发展&#xff0c;MES生产管理系统逐渐成为电子企业实现自动化生产和信息化管理的必备工具。那么&#xff0c;何时是电子企业实施MES管理系统的最佳时机呢&#xff1f; 1.生产过程中出现了问题&#xff0c;需要优化和改进。 2.企业需要提高产品交付和响应速…
阅读更多...
短视频矩阵系统/源码搭建---拆解热门视频功能开发上线

短视频矩阵系统/源码搭建---拆解热门视频功能开发上线

短视频矩阵系统/源码搭建 一、短视频矩阵系统源码开发需要用到以下技术&#xff1a; 1.前端技术&#xff1a;HTML、CSS、JavaScript、Vue.js等前端框架。 2.后端技术&#xff1a;Java、Python、PHP等后端语言及相关框架&#xff0c;如Spring Boot、Django、Laravel等。 3.移…
阅读更多...
算法day26

算法day26

第一题 429. N 叉树的层序遍历 本题的要求我们可以通过队列来辅助完成层序遍历&#xff1b; 如下图的n叉树&#xff1a; 步骤一&#xff1a; 我们定义一个队列&#xff0c;先进行根节点入队列操作&#xff1b; 步骤二&#xff1a; 我们进行当前队列每一个元素的出队列操作&…
阅读更多...
(科学:某天是星期几)泽勒一致性是由克里斯汀·泽勒开发的用于计算某天是星期几的算法。

(科学:某天是星期几)泽勒一致性是由克里斯汀·泽勒开发的用于计算某天是星期几的算法。

(科学:某天是星期几)泽勒一致性是由克里斯汀泽勒开发的用于计算某天是星期几的算法。这个公式是: 其中: h是一个星期中的某一天(0 为星期六;1 为星期天;2 为星期一;3 为星期二;4 为 星期三;5 为星期四;6为星期五)。 q 是某月的第几天。 m 是月份(3 为三月&#xff0c;4 为四月,…
阅读更多...
[数据集][目标检测]减速带检测数据集VOC+YOLO格式5400张1类别

[数据集][目标检测]减速带检测数据集VOC+YOLO格式5400张1类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;5400 标注数量(xml文件个数)&#xff1a;5400 标注数量(txt文件个数)&#xff1a;5400 标注…
阅读更多...
去掉eslint

去掉eslint

1、在vue.config.js文件里加上下面的代码&#xff0c;然后重启就可以了&#xff01; 2、vue.config.js文件代码&#xff1a; const { defineConfig } require(vue/cli-service) module.exports defineConfig({transpileDependencies: true,lintOnSave: false })
阅读更多...
Python基础教程（二十）：SMTP发送邮件

Python基础教程（二十）：SMTP发送邮件

&#x1f49d;&#x1f49d;&#x1f49d;首先&#xff0c;欢迎各位来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里不仅可以有所收获&#xff0c;同时也能感受到一份轻松欢乐的氛围&#xff0c;祝你生活愉快&#xff01; &#x1f49d;&#x1f49…
阅读更多...
MySQL -- 事务

MySQL -- 事务

MySQL事务是数据库操作的一个重要概念&#xff0c;事务是指一组操作要么全部完成&#xff0c;要么全部不完成&#xff0c;是数据库的一个逻辑工作单元。事务的主要目的是确保数据库的一致性和可靠性。 事务是一组SQL语句的执行&#xff0c;要么全部成功&#xff0c;要么全部失…
阅读更多...
【踩坑】解决运行一段时间GPU计算后忽然变得很慢

【踩坑】解决运行一段时间GPU计算后忽然变得很慢

转载请注明出处&#xff1a;小锋学长生活大爆炸[xfxuezhagn.cn] 如果本文帮助到了你&#xff0c;欢迎[点赞、收藏、关注]哦~ 目录 发现问题 问题分析 修复思路 思路一 思路二 思路二对应代码 这个问题真的找了我好久&#xff0c;但说起来其实也简单&#xff0c;就是GPU温…
阅读更多...
JDK8-17新特性

JDK8-17新特性

一、JDK8新特性:Lambda表达式 1.Lambda表达式及其使用举例 Lambda是一个匿名函数&#xff0c;我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格&#xff0c;使Java的语言表达能力…
阅读更多...
17个有用的CLI命令

17个有用的CLI命令

作为前端开发工程师&#xff0c;我们需要了解哪些命令&#xff1f;如果您熟悉这些命令&#xff0c;它们将大大提高您的工作效率。 1. tree 你们知道如何列出一个目录的文件结构吗&#xff1f;它在显示文件之间的目录关系方面做得很好 commands ├── a.js ├── b.js ├── …
阅读更多...
PyTorch计算机视觉入门：从官方数据集到自定义数据集的获取

PyTorch计算机视觉入门：从官方数据集到自定义数据集的获取

一、PyTorch与计算机视觉简介 PyTorch是一个开源的深度学习框架&#xff0c;其动态图的特性非常适合快速实验和模型原型设计。在计算机视觉任务中&#xff0c;如图像分类、目标检测、图像分割等&#xff0c;PyTorch提供了丰富的API和预训练模型&#xff0c;帮助开发者快速搭建…
阅读更多...
C++ 不定参数模版

C++ 不定参数模版

使用不定参数模版遇到一个小问题&#xff0c;做个记录 测试代码如下&#xff1a; template<typename T, typename ...Args> void pushToVectorIfParamIsStr(std::vector<std::string>& vec, T &&value,Args&&... args) {const bool is std:…
阅读更多...
大模型中的计算精度——FP32, FP16, bfp16之类的都是什么？？？

大模型中的计算精度——FP32, FP16, bfp16之类的都是什么？？？

大模型中的计算精度——FP32, FP16, bfp16之类的都是什么&#xff1f;&#xff1f;&#xff1f; 这些精度是用来干嘛的&#xff1f;&#xff1f;混合精度 mixed precision training什么是混合精度&#xff1f;怎么转换呢&#xff1f; 为什么大语言模型通常使用FP32精度训练量化…
阅读更多...
调试了一下午，终于把tailwindcss搞进Blazor了

调试了一下午，终于把tailwindcss搞进Blazor了

在Vue和Uniapp项目中使用tailwindcss后&#xff0c;实在是太香了&#xff0c;非常符合我这从XAML走过来的老程序员的手感&#xff0c;所以老想着在Blazor项目中引入。看了几个老外大佬的视频&#xff0c;调试了一下午&#xff0c;终于是捣鼓成功了。由于咱们Blazor项目不在node…
阅读更多...
【c语言】文件操作，解开你的疑惑

【c语言】文件操作，解开你的疑惑

文件操作 为什么使用文件什么是文件文件的分类文件名 二进制文件和文本文件文件的打开与关闭流与标准流流标准流 文件指针文件的打开与关闭 文件的顺序读写文件的随机读写文件读取结束的判定文件缓冲区 为什么使用文件 我们程序运行的数据是运行在内存中的&#xff0c;当成程序…
阅读更多...
链表经典题目：环形链表问题（LeetCode141.环形链表、LeetCode142.环形链表Ⅱ）

链表经典题目：环形链表问题（LeetCode141.环形链表、LeetCode142.环形链表Ⅱ）

&#x1f4c7;文章目录 &#x1f4dc; LeetCode141. 环形链表&#x1f536;题目描述&#x1f537;思路分析✔️代码实现 &#x1f4dc; LeetCode142.环形链表Ⅱ&#x1f536;题目描述&#x1f537;思路①✔️代码实现&#x1f537;思路② &#x1f4d2;总结 &#x1f4dc; Leet…
阅读更多...
神经网络学习2

神经网络学习2

张量&#xff08;Tensor&#xff09;是深度学习和科学计算中的基本数据结构&#xff0c;用于表示多维数组。张量可以看作是一个更广义的概念&#xff0c;涵盖了标量、向量、矩阵以及更高维度的数据结构。具体来说&#xff0c;张量的维度可以是以下几种形式&#xff1a; 标量&am…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站