golang 实现华容道

最新推荐文章于 2022-09-26 15:11:34 发布
最新推荐文章于 2022-09-26 15:11:34 发布
阅读量552 收藏 1
点赞数
分类专栏： golang 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27068845/article/details/77879945
版权

游戏介绍

华容道游戏共有10个棋子, 在5*4的棋盘上. 其中曹操占2*2格, 张飞,关羽, 赵云, 黄忠, 马超 占2*1格, 这些棋子有横向和竖向的区别. 4个卒各占1格. 目标: 将曹操这枚棋子移动到棋盘正下方. 棋子不能横跨棋子,每次只移动一格.

设计思路

因为没有图形界面, 于是将每个棋子和移动方向编号.
* 棋子编号: 0.曹操 1.张飞 2.关羽 3.赵云 4.黄忠 5.马超 6.兵 7.卒 8.勇 9.士
* 移动方向编号: 1.上 2.下 3.左 4.右
用户输入两个整数, 第一个选择棋子, 第二个选择方向.
如: 0, 1 将曹操向上移动一格.

将棋盘看作一个对象, 它有5*4的一个二维数组当作棋盘.
有10个棋子组成的map.
棋子结构体定义如下: 

// 棋子
type Chessman struct {
    Name       string   `desc:"棋子的名字"`
    Code       string   `desc:"棋子在棋盘上的标志符"`
    StartPoint [2]int   `desc:"起点"`
    GridNums   int      `desc:"格子数"`
    Direction  int      `desc:"方向, 0 代表竖着, 1 代表横着"`
}

棋盘的定义如下: 

// 华容道
type Klotski struct {
    Array    *[5][4]string  `desc:"5*4的地图"`
    Chessmen map[int]*Chessman  `desc:"存放棋子的字典"`
}

因为棋盘的摆放位置多种多样, 本程序没有模拟这个随机算法.只选取其中一种摆放位置.

// 用于初始化华容道地图
// 初始地图有很多种,所以将这部分提取出来,以后可扩展
func initKlotski() *Klotski {
    return &Klotski{
        Array: &[5][4]string{},
        Chessmen: map[int]*Chessman{
            0: {Name: "曹操", Code: "曹", StartPoint: [2]int{0, 1}, GridNums: 4},
            1: {Name: "张飞", Code: "张", StartPoint: [2]int{0, 0}, GridNums: 2, Direction: 0},
            2: {Name: "关羽", Code: "关", StartPoint: [2]int{2, 1}, GridNums: 2, Direction: 1},
            3: {Name: "赵云", Code: "赵", StartPoint: [2]int{0, 3}, GridNums: 2, Direction: 0},
            4: {Name: "黄忠", Code: "黄", StartPoint: [2]int{2, 0}, GridNums: 2, Direction: 0},
            5: {Name: "马超", Code: "马", StartPoint: [2]int{2, 3}, GridNums: 2, Direction: 0},
            6: {Name: "兵", Code: "兵", StartPoint: [2]int{3, 1}, GridNums: 1},
            7: {Name: "卒", Code: "卒", StartPoint: [2]int{3, 2}, GridNums: 1},
            8: {Name: "勇", Code: "勇", StartPoint: [2]int{4, 0}, GridNums: 1},
            9: {Name: "士", Code: "士", StartPoint: [2]int{4, 3}, GridNums: 1},
        },
    }
}

摆放完棋子后, 要初始化二维数组,一则方便呈现给用户看, 二则可以用来判断棋子的位置, 周围的情况.

const BLANK = "  " // 空白
// 根据棋子的位置,初始化华容道对象中的数组
// 将棋子的code填入棋盘上对应的位置中
func (this *Klotski) initArray() {
    arr := this.Array
    // 0-9 棋子
    for i := 0; i < 10; i++ {
        chessman := this.Chessmen[i]
        // 占据2个格子的棋子,根据棋子方向,填入code
        if chessman.GridNums == 2 {
            arr[chessman.StartPoint[0]][chessman.StartPoint[1]] = chessman.Code
            if chessman.Direction == 0 {
                // 总坐标 + 1
                arr[chessman.StartPoint[0] + 1][chessman.StartPoint[1]] = chessman.Code
            }else {
                // 横坐标 + 1
                arr[chessman.StartPoint[0]][chessman.StartPoint[1] + 1] = chessman.Code
            }
        }
        // 占据1个格子的棋子,在起点位置填入code
        if chessman.GridNums == 1 {
            arr[chessman.StartPoint[0]][chessman.StartPoint[1]] = chessman.Code
        }
        // 占据4个格子的棋子,填入code
        if chessman.GridNums == 4 {
            arr[chessman.StartPoint[0]][chessman.StartPoint[1]] = chessman.Code
            arr[chessman.StartPoint[0] + 1][chessman.StartPoint[1]] = chessman.Code
            arr[chessman.StartPoint[0]][chessman.StartPoint[1] + 1] = chessman.Code
            arr[chessman.StartPoint[0] + 1][chessman.StartPoint[1] + 1] = chessman.Code
        }
    }

    // 填入空白
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[0]); j++ {
            if arr[i][j] == "" {
                arr[i][j] = BLANK
            }
        }
    }
}

常量BLANK的目的是代表2个空格, 让棋盘显示的好看一点.

开始游戏前要初始化,返回一个棋盘对象

// 返回一个华容道
func NewKlotski() *Klotski {
    // 1. 初始化棋子的位置
    klotski := initKlotski()
    // 2. 初始化数组
    klotski.initArray()
    return klotski
}

接收到用户的输入后,要移动棋子.
移动棋子时要注意会不会越界, 可不可以移动, 移动后的二维数组又会变成什么样.
move方法没有分解, 代码很长,这里就只给出函数签名, 最后会附上源码.
move时华容道对象的一个方法. 接收棋子的ID和移动方向.返回值是是否移动了棋子.

// 移动棋子的方法
func (this *Klotski) move(chessID, direct int) bool

源码

package main

import (
    "fmt"
    "bytes"
    "os"
)

const BLANK = "  " // 空白

// 棋子
type Chessman struct {
    Name       string   `desc:"棋子的名字"`
    Code       string   `desc:"棋子在棋盘上的标志符"`
    StartPoint [2]int   `desc:"起点"`
    GridNums   int      `desc:"格子数"`
    Direction  int      `desc:"方向, 0 代表竖着, 1 代表横着"`
}


// 华容道
type Klotski struct {
    Array    *[5][4]string  `desc:"5*4的地图"`
    Chessmen map[int]*Chessman  `desc:"存放棋子的字典"`
}

// 移动棋子的方法
func (this *Klotski) move(chessID, direct int) bool {
    arr := this.Array
    chessman := this.Chessmen[chessID]
    x, y := chessman.StartPoint[0], chessman.StartPoint[1]
    // 1. 输入校验
    if direct == 1 && x == 0 {
        // 向上移动时,x坐标要大于0
        return false
    }
    if direct == 2 && x == 4 {
        // 向下移动时,x坐标要小于4
        return false
    }
    if direct == 3 && y == 0 {
        // 向左移动时, y的坐标要大于0
        return false
    }
    if direct == 4 && y == 3 {
        // 向左移动时, y的坐标要小于3
        return false
    }

    // 2. 判断是否可以移动, 可以就移动

    // 占据2个格子的棋子,根据棋子方向, 移动
    isMove := false
    if chessman.GridNums == 2 {
        switch direct {
        case 1:  // 上
            if chessman.Direction == 0 {  // 竖着
                if arr[x-1][y] == BLANK {
                    this.switchGrid(x, y, x-1, y)
                    this.switchGrid(x+1, y, x, y)
                    isMove = true
                }
            }else {  // 横着
                if arr[x-1][y] == BLANK && arr[x-1][y+1] == BLANK {
                    this.switchGrid(x, y, x-1, y)
                    this.switchGrid(x, y+1, x-1, y+1)
                    isMove = true
                }
            }
        case 2:  // 下
            if chessman.Direction == 0 {  // 竖着
                if arr[x+2][y] == BLANK {
                    this.switchGrid(x+1, y, x+2, y)
                    this.switchGrid(x, y, x+1, y)
                    isMove = true
                }
            }else {  // 横着
                if arr[x+1][y] == BLANK && arr[x+1][y+1] == BLANK {
                    this.switchGrid(x, y, x+1, y)
                    this.switchGrid(x, y+1, x+1, y+1)
                    isMove = true
                }
            }
        case 3:  // 左
            if chessman.Direction == 0 {  // 竖着
                if arr[x][y-1] == BLANK && arr[x+1][y-1] == BLANK {
                    this.switchGrid(x, y, x, y-1)
                    this.switchGrid(x+1, y, x+1, y-1)
                    isMove = true
                }
            }else {  // 横着
                if arr[x][y-1] == BLANK {
                    this.switchGrid(x, y, x, y-1)
                    this.switchGrid(x, y+1, x, y)
                    isMove = true
                }
            }
        case 4:  // 右
            if chessman.Direction == 0 {  // 竖着
                if arr[x][y+1] == BLANK && arr[x+1][y+1] == BLANK {
                    this.switchGrid(x, y, x, y+1)
                    this.switchGrid(x+1, y, x+1, y+1)
                    isMove = true
                }
            }else {  // 横着
                if arr[x][y+2] == BLANK {
                    this.switchGrid(x, y+1, x, y+2)
                    this.switchGrid(x, y, x, y+1)
                    isMove = true
                }
            }
        }
    }

    // 占据1个格子的棋子, 移动
    if chessman.GridNums == 1 {
        switch direct {
        case 1:  // 上
            if arr[x-1][y] == BLANK {
                arr[x][y], arr[x-1][y] = arr[x-1][y], arr[x][y]
                isMove = true
            }
        case 2:  // 下
            if arr[x+1][y] == BLANK {
                arr[x][y], arr[x+1][y] = arr[x+1][y], arr[x][y]
                isMove = true
            }
        case 3:  // 左
            if arr[x][y-1] == BLANK {
                arr[x][y], arr[x][y-1] = arr[x][y-1], arr[x][y]
                isMove = true
            }
        case 4:  // 右
            if arr[x][y+1] == BLANK {
                arr[x][y], arr[x][y+1] = arr[x][y+1], arr[x][y]
                isMove = true
            }
        }
    }

    // 占据4个格子的棋子, 移动
    if chessman.GridNums == 4 {
        switch direct {
        case 1:  // 上
            if arr[x-1][y] == BLANK && arr[x-1][y+1] == BLANK {
                this.switchGrid(x, y, x-1, y)
                this.switchGrid(x, y+1, x-1, y+1)
                this.switchGrid(x+1, y, x, y)
                this.switchGrid(x+1, y+1, x, y+1)
                isMove = true
            }
        case 2:  // 下
            if arr[x+2][y] == BLANK && arr[x+2][y+1] == BLANK {
                this.switchGrid(x+1, y, x+2, y)
                this.switchGrid(x+1, y+1, x+2, y+1)
                this.switchGrid(x, y, x+1, y)
                this.switchGrid(x, y+1, x+1, y+1)
                isMove = true
            }
        case 3:  // 左
            if arr[x][y-1] == BLANK && arr[x+1][y] == BLANK {
                this.switchGrid(x, y, x, y-1)
                this.switchGrid(x+1, y, x+1, y-1)
                this.switchGrid(x, y+1, x, y)
                this.switchGrid(x+1, y+1, x+1, y)
                isMove = true
            }
        case 4:  // 右
            if arr[x][y+2] == BLANK && arr[x+1][y+2] == BLANK {
                this.switchGrid(x, y+1, x, y+2)
                this.switchGrid(x+1, y+1, x+1, y+2)
                this.switchGrid(x, y, x, y+1)
                this.switchGrid(x+1, y, x+1, y+1)
                isMove = true
            }
        }
    }

    // 3. 如果移动,修改棋子起点位置
    if isMove {
        switch direct {
        case 1:  // 上
            chessman.StartPoint[0] = x - 1
        case 2:  // 下
            chessman.StartPoint[0] = x + 1
        case 3:  // 左
            chessman.StartPoint[1] = y - 1
        case 4:  // 右
            chessman.StartPoint[1] = y + 1
        }
    }

    // 4. 判断用户是否胜利
    if this.Array[4][1] == "曹" && this.Array[4][2] == "曹" {
        fmt.Println("恭喜您胜利了!")
        fmt.Println("游戏退出.")
        os.Exit(0)
    }

    return isMove
}

// 交换数组中的(a, b) 和 (c, d)
func (this *Klotski) switchGrid(a, b, c, d int) {
    this.Array[a][b], this.Array[c][d] = this.Array[c][d], this.Array[a][b]
}

// 将华容道地图变成可打印的字符串
func (this *Klotski) String() string {
    var buffer bytes.Buffer
    for i := 0; i < 5; i++ {
        for j := 0; j < 4; j++ {
            buffer.WriteString(this.Array[i][j])
            buffer.WriteString(" ")
        }
        buffer.WriteString("\n")
    }
    return buffer.String()
}

// 返回一个华容道
func NewKlotski() *Klotski {
    // 1. 初始化棋子的位置
    klotski := initKlotski()
    // 2. 初始化数组
    klotski.initArray()
    return klotski
}

// 用于初始化华容道地图
// 初始地图有很多种,所以将这部分提取出来,以后可扩展
func initKlotski() *Klotski {
    return &Klotski{
        Array: &[5][4]string{},
        Chessmen: map[int]*Chessman{
            0: {Name: "曹操", Code: "曹", StartPoint: [2]int{0, 1}, GridNums: 4},
            1: {Name: "张飞", Code: "张", StartPoint: [2]int{0, 0}, GridNums: 2, Direction: 0},
            2: {Name: "关羽", Code: "关", StartPoint: [2]int{2, 1}, GridNums: 2, Direction: 1},
            3: {Name: "赵云", Code: "赵", StartPoint: [2]int{0, 3}, GridNums: 2, Direction: 0},
            4: {Name: "黄忠", Code: "黄", StartPoint: [2]int{2, 0}, GridNums: 2, Direction: 0},
            5: {Name: "马超", Code: "马", StartPoint: [2]int{2, 3}, GridNums: 2, Direction: 0},
            6: {Name: "兵", Code: "兵", StartPoint: [2]int{3, 1}, GridNums: 1},
            7: {Name: "卒", Code: "卒", StartPoint: [2]int{3, 2}, GridNums: 1},
            8: {Name: "勇", Code: "勇", StartPoint: [2]int{4, 0}, GridNums: 1},
            9: {Name: "士", Code: "士", StartPoint: [2]int{4, 3}, GridNums: 1},
        },
    }
}

// 根据棋子的位置,初始化华容道对象中的数组
// 将棋子的code填入棋盘上对应的位置中
func (this *Klotski) initArray() {
    arr := this.Array
    // 0-9 棋子
    for i := 0; i < 10; i++ {
        chessman := this.Chessmen[i]
        // 占据2个格子的棋子,根据棋子方向,填入code
        if chessman.GridNums == 2 {
            arr[chessman.StartPoint[0]][chessman.StartPoint[1]] = chessman.Code
            if chessman.Direction == 0 {
                // 总坐标 + 1
                arr[chessman.StartPoint[0] + 1][chessman.StartPoint[1]] = chessman.Code
            }else {
                // 横坐标 + 1
                arr[chessman.StartPoint[0]][chessman.StartPoint[1] + 1] = chessman.Code
            }
        }
        // 占据1个格子的棋子,在起点位置填入code
        if chessman.GridNums == 1 {
            arr[chessman.StartPoint[0]][chessman.StartPoint[1]] = chessman.Code
        }
        // 占据4个格子的棋子,填入code
        if chessman.GridNums == 4 {
            arr[chessman.StartPoint[0]][chessman.StartPoint[1]] = chessman.Code
            arr[chessman.StartPoint[0] + 1][chessman.StartPoint[1]] = chessman.Code
            arr[chessman.StartPoint[0]][chessman.StartPoint[1] + 1] = chessman.Code
            arr[chessman.StartPoint[0] + 1][chessman.StartPoint[1] + 1] = chessman.Code
        }
    }

    // 填入空白
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[0]); j++ {
            if arr[i][j] == "" {
                arr[i][j] = BLANK
            }
        }
    }
}

// 游戏开始提示
func init() {
    fmt.Println("华容道游戏开始...")
    fmt.Println("操作提示: 输入棋子的序号和移动方向,然后回车. 如 0 1 代表将曹操向上移动一格. 输入0 0或其他字符退出游戏.")
    fmt.Println("0.曹操 1.张飞 2.关羽 3.赵云 4.黄忠 5.马超 6.兵 7.卒 8.勇 9.士")
    fmt.Println("1.上 2.下 3.左 4.右")
    fmt.Println()
}

// 用户输入
func input() (int, int) {

    fmt.Print("(棋子序号, 移动方向): ")
    chessID, direct := 0, 0
    fmt.Scan(&chessID, &direct)

    // 判断游戏是否结束
    if chessID == 0 && direct == 0 {
        fmt.Println("游戏退出.")
        os.Exit(0)
    }

    fmt.Println(chessID, direct)
    return chessID, direct
}

func main() {

    klotski := NewKlotski()
    fmt.Println(klotski.String())

    fmt.Println()

    for {
        chessID, direct := input()
        isMove := klotski.move(chessID, direct)
        if isMove {
            fmt.Println(klotski.String())
        }else {
            fmt.Println("被包围了,不能移动")
        }
    }
}

设计一个文件格式保存华容道?

  1. 使用json, 将华容道klotski这个对象进行序列化.
    golang的json模块可以做到.
  2. txt文件, 保存棋子的ID和起点位置. 注: 起点位置是棋子最左上角的坐标.

如何自动完成处于某个状态的华容道游戏?

华容道游戏的下棋步骤分支很多, 有点像树的结构. 因为游戏是要尽可能找到最少步骤, 要求出最优解.所以分支限界算法可以处理这个问题.

风格色
关注
专栏目录
【浅析华容道之二】华容道问题搜索求解策略
t247555529的博客
10-02 9473
求解华容道问题，需要补充人工智能的一些基础知识 举一个例子介绍状态空间表示法及搜索策略
实现华容道
u013015430的专栏
12-12 2021
看到文章  http://coolshell.cn/articles/10476.html 文章对应代码在： https://github.com/chenshuo/recipes/blob/master/puzzle/huarong.cc 学习C++， 也自己实现一个华容道。 脑袋一拍就出来下面的代码 class chessboard; class chess; class ch
Golang 语法 知识点提要
天作棋盘星作子
11-24 517
结构 package main  //包名  package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包 import "fmt" /* 程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数*/ func main() {  
数字华容道关键算法（有序随机数生成）
qq_40872999的博客
12-17 7015
关于数字华容道的随机数据参数 玩过数字华容道的都知道，随机数是由原来的顺序排列通过随机移动块产生的，但是如果把块扣出来重新组合就会导致可能永远不会回到初始状态 例如： 1   2   3   1   2   3 4   5   6    4   5   6 7   8        8   7 正常结果只能是左边这个，而右边这个肯定是错误的，是一个永远也回不去的方法，所以避免这种情况发生，我特...
GoLang实现接口的方式
Addroc_Sue的博客
09-26 2254
GoLang实现接口的方式
golang 实现快速排序
SunnWang的博客
12-08 1858
golang算法实现 golang 实现一个快排 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 概要golang算法实现思想实现 思想 大而化小, 分而治之 将列表看成, 左边, 中值, 右边, 三部分, 使用递归的思想.所有的中值都会排好序, 数列就会排好序 提示：以下是本篇文章正文内容，下面案例可供参考 实现 package main import "fmt" var testList = make([]int, 10) func quickSort(unSortLi
golang实现简易Raft
qq_49723651的博客
12-12 2294
golang实现简易Raft 文章目录golang实现简易RaftRaft简介官方动画golang实现raft Raft简介 随着大型网站的各种高并发访问、海量数据处理等场景越来越多，如何实现网站的高可用、易伸缩、可扩展、安全等目标就显得越来越重要。 为了解决这样一系列问题，大型网站的架构也在不断发展。提高大型网站的高可用架构，不得不提的就是分布式。任何一个分布式系统都无法同时满足 Consistency（一致性），Availability（可用性），Partition tolerance（分区容错性
循环鼠标自动点击功能- Golang实现
04-10
在本文中，我们将深入探讨如何利用Golang实现这个功能，并了解相关的核心知识点。 首先，我们需要了解的是Golang的图形用户界面（GUI）库。虽然Golang的标准库并没有内置GUI支持，但社区提供了多个第三方库，如`go-...
用于分布式速率限制的滑动窗口算法的Golang实现。-Golang开发
05-26
滑动窗口算法的分布式窗口限速的Golang实现。 安装$ go get -u github.com/RussellLuo/slidingwindow设计slidewindow是t slidewindowow的一种实现，Golang是滑动窗口算法的一种实现，用于分布式速率限制。 安装$ go ...
golang实现海康相机抓拍demo
最新发布
04-30
golang 实现海康相机抓拍，目前只支持球机。需要在代码中设置用户名和密码。 如何调试？用vscode打开，安装golang插件，即可直接调试运行。 编译与运行：运行go build命令，将HKnet.exe拷贝到build\Windows下，运行...
2.1.7 使用Golang实现万人同服的游戏服务器@袁锋峰.pdf
09-13
本文将详细介绍使用Golang实现万人同服的游戏服务器，涵盖游戏服务器开发面临的挑战、游戏服务器设计面临的挑战、高并发TPS、高可用玩家对服务的可用性、低延迟忍受度、数据读写频度高、安全检查、高并发之道、高...
golang实现单点登录系统（go-sso）
01-19
golang语言：go1.13.3+ 、 数据库：mysql5.7 缓存：redis3.0 项目地址 https://github.com/guyan0319/ … 依赖包： github.com/dgrijalva/jwt-go github.com/gin-gonic/gin github.com/go-xorm/xorm github.com/
Python游戏开发：数字华容道
C与Python实战
07-23 1万+
1、布局设计 2、算法设计 2.1 创建并初始化数组 2.2 移动算法 2.3 是否胜利检测算法 3、实现 3.1 框架搭建 3.2 数字方块实现 3.3 将数字转换成方块添加到布局 3.4 初始化布局 3.5 按键检测 3.6 试玩测试 3.7 改进完善 4、完整代码 5、总结 今年年初，新一季的《最强大脑》开播了，第一集选拔的时候大家做了一个数字游戏，名叫《数字华容道》，当...
golang -- slice元素去重
热门推荐
风格色的博客
08-19 4万+
合并两个整型切片，返回没有重复元素的切片，有两种去重策略1. 通过双重循环来过滤重复元素（时间换空间）// 通过两重循环过滤重复元素 func RemoveRepByLoop(slc []int) []int { result := []int{} // 存放结果 for i := range slc{ flag := true for j := r
golang 错误: cannot use XXX literal (type XXX) as type XXX in assignment:XXX does not implement XXX
风格色的博客
01-17 2万+
出错代码如下： package main import ( "fmt" ) type Speaker interface { Hello() } type User struct { Name string Age int } func (this *User) Hello() { fmt.Println("hello my name is", t...
【golang】优雅且安全的并发写slice或map
风格色的博客
07-18 1万+
并发写 slice和map是不安全的 【golang面试准备】验证map&slice并发不安全 怎么能高并发写入？ slice&map并发不安全，都是在写的时候发生的，那么就要保证同一时间只有一个gorutine来写这个slice或者map。 有两种方式实现： 加锁方式：n个goroutine都有可能执行写入操作，保证同一时间只能有一个在执行写操作。 加锁操作简单，适用于性能...
golang 实现简单DNS服务器
风格色的博客
03-01 3941
简单的DNS服务器 提供一个简单的可以查询域名和反向查询的DNS服务器。 dig命令主要用来从 DNS 域名服务器查询主机地址信息。 查找www.baidu.com的ip （A记录）： 命令：dig @127.0.0.1 www.baidu.com 根据ip查找对应域名 （PTR记录）： 命令：dig @127.0.0.1 -x 220.181.38.150 源码 ： package mai...
Golang实现链表数据结构
"这篇资源是关于Golang语言实现链表的数据结构。主要涵盖了链表的基本操作，包括创建链表、获取链表长度、添加元素、查找元素以及获取指定位置的元素。" 在Golang中，链表是一种常用的数据结构，它不依赖于内存的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值