【选作】Poker time 2 (enhanced version)

于 2024-08-10 16:54:17 发布
阅读量565 收藏 4
点赞数 12
分类专栏： C档起步 C语言 文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alexanderabc/article/details/141092427
版权

“我见青山多妩媚，料青山见我应如是”

嗨嗨嗨！有了Poker time基础版做铺垫，小橘相信解决这个enhanced版本也就不是很困难啦。

如果还没有了解过基础版的同学，可以先看看这篇文章（BOSS）Poker time! （20 xp）-CSDN博客

这样再看这题就会易懂得多。

话不多说，咱们进入正题！

题目描述

背景：两个人每人发3张牌（各从一副牌中），每张牌包括花色（红桃(Heart)>黑桃(Spade)>方块(Diamond)>梅花(Club））和大小（从小到大依次是：2-10、J、Q、K、A），胜负规则如下：同花顺（3张同花色的连牌，先比大小，再比花色，后同）>炸弹（3张相同大小的牌）>连牌（3张不同花色的连牌）>对子（两张相同大小的牌）>单牌。例如，红桃QKA>黑桃QKA>梅花567>方块234>AAA（红桃、方块、梅花）>AAA（黑桃、方块、梅花）>JQK（红桃、红桃、方块）>JQK（黑桃、红桃、方块）>AA2（梅花黑桃梅花）>QQJ（红桃梅花方块）>JQA（红桃红桃红桃）。注：A23不算连牌。

输入：A的3张牌（未排序）和B的3张牌（未排序）。（参见用例）

输出：A的3张牌的排序后的输出和B的3张牌的排序后的输出，以及A和B谁获胜。（参见用例）

解题思路

和基础版一样，所谓升级版的题考的其实也是优先级排序问题，换汤不换药。

之前咱们总结说，基础版的难点有三个，那我们就将此题的难点总结为四个：一是对于输入输出时的细节处理，二是对花色和大小的权重赋值处理，三是对'10'的单独处理，四是对同花顺、炸弹、连牌和对子四个特殊情况的再次加权赋值。

整体思路是先对牌的花色和大小分别进行赋值，然后想办法将这两个属性整合到一个数中用于后续排序和比较，先完成A、B的降序排序，排序后针对四种特殊情况进行再次“加权”赋值，然后进行A、B的比较，最终输出结果。即：赋值——>整合——>特殊处理——>比较——>输出。

值得注意的是，与基础版不同，这里大小的权重是要高于花色的。

关键参数

A[3][3],B[3][3]：3×3的二维数组，用于储存输入的三张牌，列为3是由于10的存在，得多留一位。

A_score[3][2],B_score[3][2]：对于每个花色和大小进行重新赋值，方便后续整合比较。大小的优先级高，故将其设为十位数。

A_sum[3],B_sum[3]：是对花色和大小整合后的数值，是比较和排序的依据，也是在特殊情况处理时的关键指标。

难点分析

下面咱们对难点逐一进行分析：

1、输入输出时的细节处理

输入中只有10是特殊的，所以我们希望能将所有的输入都转变成两位的形式，这样方便后续的处理和比较。

注意：输入中无10，第三位为空格；若有10，则将第二位转变为'9'+1，第三位转变为0，并补上空格。

for(i=0;i<3;i++)
    {
        scanf("%c%c%c",&A[i][0],&A[i][1],&A[i][2]);
        if(A[i][1]=='1'&&A[i][2]=='0')
        {
            A[i][1]='9'+1;
            A[i][2]=0;
            if(i!=2)
                scanf(" ");
        }
    }
    scanf("\n");
    for(i=0;i<3;i++)
    {
        scanf("%c%c%c",&B[i][0],&B[i][1],&B[i][2]);
        if(B[i][1]=='1'&&B[i][2]=='0')
        {
            B[i][1]='9'+1;
            B[i][2]=0;
            if(i!=2)
                scanf(" ");
        }
    }

输出时要对第一步处理进行还原，将'9'+1还原为'10'

for(i=0;i<3;i++)
    {
        if(A[i][1]=='9'+1)
        {
            A[i][1]='1';
            A[i][2]='0';
        }
        if(B[i][1]=='9'+1)
        {
            B[i][1]='1';
            B[i][2]='0';
        }
    }
    
//输出结果
    printf("A:"); 
    for(i=0;i<3;i++)
    {
        if(A[i][2]=='0')
            printf(" %c%c%c",A[i][0],A[i][1],A[i][2]);
        else
            printf(" %c%c",A[i][0],A[i][1]);
    }
    printf("\n");
    printf("B:");
    for(i=0;i<3;i++)
    {
        if(B[i][2]=='0')
            printf(" %c%c%c",B[i][0],B[i][1],B[i][2]);
        else
            printf(" %c%c",B[i][0],B[i][1]);
    }
    printf("\n");

2、花色和大小的权重赋值处理

以A为例，对于花色和大小进行赋值。由于大小的优先级更高，故我们将大小权重设置到十位，这样对花色的赋值不会影响到大小。这也是与基础版中要求不同的一点。

A_sum,B_sum即代表整体的分数，后面可以直接拿这个作比较。

switch(A[i][0])
        {
            case 'H':
                A_score[i][0]=4;
                break;
            case 'S':
                A_score[i][0]=3;
                break;
            case 'D':
                A_score[i][0]=2;
                break;
            case 'C':
                A_score[i][0]=1;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        switch(A[i][1])
        {
            case '2':
                A_score[i][1]=10;
                break;
            case '3':
                A_score[i][1]=20;
                break;
            case '4':
                A_score[i][1]=30;
                break;
            case '5':
                A_score[i][1]=40;
                break;
            case '6':
                A_score[i][1]=50;
                break;
            case '7':
                A_score[i][1]=60;
                break;
            case '8':
                A_score[i][1]=70;
                break;
            case '9':
                A_score[i][1]=80;
                break;
            case '9'+1:
                A_score[i][1]=90;
                break;
            case 'J':
                A_score[i][1]=100;
                break;
            case 'Q':
                A_score[i][1]=110;
                break;
            case 'K':
                A_score[i][1]=120;
                break;
            case 'A':
                A_score[i][1]=130;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        A_sum[i]=A_score[i][0]+A_score[i][1];

3、对'10'的单独处理

这个前面都已提到，一个是在输入时将数组由三位转换为两位，输出时在转变回来，另一个则是要注意运算时位数的统一。

4、四种特殊情况的再次加权赋值

按照优先级对四种特殊情况进行再次加权，这里前面设置A_sum[3]、B_sum[3]的好处就体现出来了，一方面经上面排序后数组数值已经是有序状态，便于更改和调用，另一方面后续比较的关键在于数组中的第一个值，故减少了计算量。

    //同花顺
    if(A_sum[0]%10==A_sum[1]%10&&A_sum[1]%10==A_sum[2]%10&&A_sum[0]/10==(A_sum[1]/10+1)&&A_sum[1]/10==(A_sum[2]/10+1))
        A_sum[0]*=10000;    
    //炸弹
    else if(A_sum[0]/10==A_sum[1]/10&&A_sum[1]/10==A_sum[2]/10)
        A_sum[0]*=1000;   
    //连牌
    else if(A_sum[0]/10==(A_sum[1]/10+1)&&A_sum[1]/10==(A_sum[2]/10+1)&&!(A_sum[0]%10==A_sum[1]%10&&A_sum[1]%10==A_sum[2]%10))
        A_sum[0]*=100;
    //对子
    else if(A_sum[0]/10==A_sum[1]/10||A_sum[1]/10==A_sum[2]/10||A_sum[0]/10==A_sum[2]/10)
        A_sum[0]*=10;

    //同花顺
    if(B_sum[0]%10==B_sum[1]%10&&B_sum[1]%10==B_sum[2]%10&&B_sum[0]/10==(B_sum[1]/10+1)&&B_sum[1]/10==(B_sum[2]/10+1))
        B_sum[0]*=10000;
    //炸弹
    else if(B_sum[0]/10==B_sum[1]/10&&B_sum[1]/10==B_sum[2]/10)
        B_sum[0]*=1000;
    //连牌
    else if(B_sum[0]/10==(B_sum[1]/10+1)&&B_sum[1]/10==(B_sum[2]/10+1)&&!(B_sum[0]%10==B_sum[1]%10&&B_sum[1]%10==B_sum[2]%10))
        B_sum[0]*=100;
    //对子
    else if(B_sum[0]/10==B_sum[1]/10||B_sum[1]/10==B_sum[2]/10||B_sum[0]/10==B_sum[2]/10)
        B_sum[0]*=10;

完整代码

#include<stdio.h>

int main()
{
//先比大小，再比花色
    char A[3][3],B[3][3];
    int A_score[3][2],B_score[3][2],A_sum[3],B_sum[3];
    int i,j,temp;
    char ctemp1,ctemp2;

//输入中只有10是特殊的，所以我们希望能将所有的输入都转变成两位的形式，这样方便后续的处理和比较
//注意：输入中无10，第三位为空格；若有10，则将第二位转变为'9'+1，第三位转变为0，并补上空格
    for(i=0;i<3;i++)
    {
        scanf("%c%c%c",&A[i][0],&A[i][1],&A[i][2]);
        if(A[i][1]=='1'&&A[i][2]=='0')
        {
            A[i][1]='9'+1;
            A[i][2]=0;
            if(i!=2)
                scanf(" ");
        }
    }
    scanf("\n");
    for(i=0;i<3;i++)
    {
        scanf("%c%c%c",&B[i][0],&B[i][1],&B[i][2]);
        if(B[i][1]=='1'&&B[i][2]=='0')
        {
            B[i][1]='9'+1;
            B[i][2]=0;
            if(i!=2)
                scanf(" ");
        }
    }


//A_sum,B_sum即代表整体的分数，后面可以直接拿这个作比较
    for(i=0;i<3;i++)
    {
        switch(A[i][0])
        {
            case 'H':
                A_score[i][0]=4;
                break;
            case 'S':
                A_score[i][0]=3;
                break;
            case 'D':
                A_score[i][0]=2;
                break;
            case 'C':
                A_score[i][0]=1;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        switch(A[i][1])
        {
            case '2':
                A_score[i][1]=10;
                break;
            case '3':
                A_score[i][1]=20;
                break;
            case '4':
                A_score[i][1]=30;
                break;
            case '5':
                A_score[i][1]=40;
                break;
            case '6':
                A_score[i][1]=50;
                break;
            case '7':
                A_score[i][1]=60;
                break;
            case '8':
                A_score[i][1]=70;
                break;
            case '9':
                A_score[i][1]=80;
                break;
            case '9'+1:
                A_score[i][1]=90;
                break;
            case 'J':
                A_score[i][1]=100;
                break;
            case 'Q':
                A_score[i][1]=110;
                break;
            case 'K':
                A_score[i][1]=120;
                break;
            case 'A':
                A_score[i][1]=130;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        A_sum[i]=A_score[i][0]+A_score[i][1];

        switch(B[i][0])
        {
            case 'H':
                B_score[i][0]=4;
                break;
            case 'S':
                B_score[i][0]=3;
                break;
            case 'D':
                B_score[i][0]=2;
                break;
            case 'C':
                B_score[i][0]=1;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        switch(B[i][1])
        {
            case '2':
                B_score[i][1]=10;
                break;
            case '3':
                B_score[i][1]=20;
                break;
            case '4':
                B_score[i][1]=30;
                break;
            case '5':
                B_score[i][1]=40;
                break;
            case '6':
                B_score[i][1]=50;
                break;
            case '7':
                B_score[i][1]=60;
                break;
            case '8':
                B_score[i][1]=70;
                break;
            case '9':
                B_score[i][1]=80;
                break;
            case '9'+1:
                B_score[i][1]=90;
                break;
            case 'J':
                B_score[i][1]=100;
                break;
            case 'Q':
                B_score[i][1]=110;
                break;
            case 'K':
                B_score[i][1]=120;
                break;
            case 'A':
                B_score[i][1]=130;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        B_sum[i]=B_score[i][0]+B_score[i][1];
    }

//有了前面的铺垫，这里就是一个简单的冒泡排序，需要关注的就是对于数字和字符的分离但同步的处理
    for(i=0;i<2;i++)
    {
        if(A_sum[i]==A_sum[i+1]||B_sum[i]==B_sum[i+1])
        {
            printf("Input Error!\n");
            return 0;
        }
        for(j=0;j<2-i;j++)
        {
            if(A_sum[j]<A_sum[j+1])
            {
                temp=A_sum[j];
                A_sum[j]=A_sum[j+1];
                A_sum[j+1]=temp;
                
                ctemp1=A[j][0];
                ctemp2=A[j][1];
                A[j][0]=A[j+1][0];
                A[j][1]=A[j+1][1];
                A[j+1][0]=ctemp1;
                A[j+1][1]=ctemp2;
            }
            if(B_sum[j]<B_sum[j+1])
            {
                temp=B_sum[j];
                B_sum[j]=B_sum[j+1];
                B_sum[j+1]=temp;
                
                ctemp1=B[j][0];
                ctemp2=B[j][1];
                B[j][0]=B[j+1][0];
                B[j][1]=B[j+1][1];
                B[j+1][0]=ctemp1;
                B[j+1][1]=ctemp2;
            }
        }      
    }

    //同花顺
    if(A_sum[0]%10==A_sum[1]%10&&A_sum[1]%10==A_sum[2]%10&&A_sum[0]/10==(A_sum[1]/10+1)&&A_sum[1]/10==(A_sum[2]/10+1))
        A_sum[0]*=10000;    
    //炸弹
    else if(A_sum[0]/10==A_sum[1]/10&&A_sum[1]/10==A_sum[2]/10)
        A_sum[0]*=1000;   
    //连牌
    else if(A_sum[0]/10==(A_sum[1]/10+1)&&A_sum[1]/10==(A_sum[2]/10+1)&&!(A_sum[0]%10==A_sum[1]%10&&A_sum[1]%10==A_sum[2]%10))
        A_sum[0]*=100;
    //对子
    else if(A_sum[0]/10==A_sum[1]/10||A_sum[1]/10==A_sum[2]/10||A_sum[0]/10==A_sum[2]/10)
        A_sum[0]*=10;

    //同花顺
    if(B_sum[0]%10==B_sum[1]%10&&B_sum[1]%10==B_sum[2]%10&&B_sum[0]/10==(B_sum[1]/10+1)&&B_sum[1]/10==(B_sum[2]/10+1))
        B_sum[0]*=10000;
    //炸弹
    else if(B_sum[0]/10==B_sum[1]/10&&B_sum[1]/10==B_sum[2]/10)
        B_sum[0]*=1000;
    //连牌
    else if(B_sum[0]/10==(B_sum[1]/10+1)&&B_sum[1]/10==(B_sum[2]/10+1)&&!(B_sum[0]%10==B_sum[1]%10&&B_sum[1]%10==B_sum[2]%10))
        B_sum[0]*=100;
    //对子
    else if(B_sum[0]/10==B_sum[1]/10||B_sum[1]/10==B_sum[2]/10||B_sum[0]/10==B_sum[2]/10)
        B_sum[0]*=10;


    if(A_sum[0]==B_sum[0])
    {
        if(A_sum[1]==B_sum[1])
        {
            if(A_sum[2]==B_sum[2])
            {
                printf("Draw!\n");
            }
            else if(A_sum[2]>B_sum[2])
            {
                printf("Winner is A!\n");
            }
            else
            {
                printf("Winner is B!\n");
            }
        }
        else if(A_sum[1]>B_sum[1])
        {
            printf("Winner is A!\n");
        }
        else
        {
            printf("Winner is B!\n");
        }
    }
    else if(A_sum[0]>B_sum[0])
    {
        printf("Winner is A!\n");
    }
    else if(A_sum[0]<B_sum[0])
    {
        printf("Winner is B!\n");
    }

//这一步也至关重要，是对第一步处理的还原，将'9'+1还原为'10'
    for(i=0;i<3;i++)
    {
        if(A[i][1]=='9'+1)
        {
            A[i][1]='1';
            A[i][2]='0';
        }
        if(B[i][1]=='9'+1)
        {
            B[i][1]='1';
            B[i][2]='0';
        }
    }
    
//输出结果
    printf("A:"); 
    for(i=0;i<3;i++)
    {
        if(A[i][2]=='0')
            printf(" %c%c%c",A[i][0],A[i][1],A[i][2]);
        else
            printf(" %c%c",A[i][0],A[i][1]);
    }
    printf("\n");
    printf("B:");
    for(i=0;i<3;i++)
    {
        if(B[i][2]=='0')
            printf(" %c%c%c",B[i][0],B[i][1],B[i][2]);
        else
            printf(" %c%c",B[i][0],B[i][1]);
    }
    printf("\n");
    return 0;
}

以上就是本次分享的全部内容啦，此题当然还有很多种解法，小橘也还在学习中，水平有限，如有考虑不周之处烦请各位不吝赐教：）

如果各位客官觉得小橘写得还算用心，可以动动发财的小手点赞关注，大家的支持也是我更新的动力，在此谢过各位嘿嘿:>

吃葡萄不吐橘子皮yeah
关注
  • 12
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poker_v2_V2_poker_
09-29
"V2"通常表示Version 2，意味着这是一个升级版，相较于之前的版本可能包含了改进和优化。描述中提到"该代码实现poker检测，经过实际的测试仿真改代码基本可以实现"，这表明我们正在处理的是一个用编程语言编写的程序...
POKER TIME.C
12-16
POKER TIME.C
poker II 常用固件.zip
07-22
标签“poker2”则直接指明了这个资源与Poker II键盘系列有关，方便用户搜索和识别。 在压缩包“poker II 常用固件”中，我们可以期待找到以下几类文件： 1. **固件文件**：通常是.bin或.hex格式，这是可以直接烧录...
New Poker II Firmware 1.03.03.zip
09-07
《New Poker II Firmware 1.03.03：深入解析与应用》 "Poker II"是一款备受扑克爱好者和程序员青睐的小型键盘设备，尤其在编程、游戏和密码输入等领域表现出色。此次更新的固件版本为“New Poker II Firmware 1.03....
201610新poker poker2 独立方向键固件
01-29
新poker 独立方向键固件201610新poker标准版L2524V23201610新poker标准版L2524V23201610新poker标准版L2524V23201610新poker标准版L2524V23201610新poker标准版L2524V23201610新poker标准版L2524V23
Poker II 独立方向键 固件v0.5.zip
04-02
《Poker II 独立方向键 固件v0.5：老款键盘的升级指南》 在计算机硬件世界中，机械键盘以其独特的敲击感和耐用性深受爱好者们的喜爱。Poker II是一款颇受欢迎的60%布局机械键盘，因其小巧便携和高度可定制性而备受...
svelte-poker-2
04-09
苗条+ Vite 该模板将帮助您开始在Vite中使用Svelte进行开发。 推荐的IDE设置 + 。 需要一个正式的Svelte框架吗？ 查看 ，它也由Vite提供支持。 通过无服务器优先的方法在任何地方进行部署，并适应各种平台，提供...
新poker刷错固件导致无法识别固件.zip
04-02
2. **确认设备型号**：确保你正在下载的固件与你的Poker II键盘型号完全匹配，不同型号的设备可能需要不同的固件。 3. **阅读说明**：详细阅读并理解固件更新的指导文档，了解操作步骤和注意事项。 4. **正确操作**...
Onnx Yolov8 Detect - Poker2.rar
09-19
标题中的"Onnx Yolov8 Detect - Poker2.rar"表明这是一个使用ONNX（Open Neural Network Exchange）模型的Yolov8实现，用于检测扑克牌的项目。YOLO（You Only Look Once）是一种实时目标检测系统，而Yolov8是YOLO...
poker2:阿尔卡拉大学编程练习2
05-11
Java扑克 大学实习的快速项目05/04/17 运行项目： mvn exec:java -Dexec.mainClass="es.jimenezhidalgo.uni.programacion.poker2.Main
Static_Poker.rar_poker
09-14
标题中的"Static_Poker.rar_poker"暗示了这是一个与扑克牌和编程相关的任务，具体来说，是一个静态处理扑克牌的算法问题。描述中提到的"54张扑克牌，把最上面的牌插到最下面，每插三张扔掉一张，输出最后一张牌的...
pokeR:使用SignalR规划扑克
05-17
扑克 使用实时规划扑克。 查看！ PokeR是使用.NET Core和Angular构建的实时... docker run -- name poker -- restart always - d - p 80 : 80 halomademeapc / poker概述 您可以选择尚未用作房间号的任何整数。 该号
poker--shuffle.rar_poker
09-24
标题中的“poker--shuffle.rar_poker”暗示了这是一个与扑克牌洗牌和发牌算法相关的C++项目。描述中提到的功能是实现扑克牌的随机发牌并能判断是否出现同花顺这样的特殊牌型。这涉及到编程、概率学以及算法设计。 ...
poker-stats-v2
04-07
扑克统计服务 先决条件 已安装节点（版本8或更高版本） 描述 此仓库用于服务器端，但还包含示例客户端（用REACT编写的FrontEnd） 为了在本地运行服务器... 需要这2个标头来验证每个用户的请求，（有关更多信息，请参
poker-card-dataset.rar
09-19
"poker-card-dataset.rar"是一个专门针对扑克牌的数据库，包含了训练、验证和测试三个部分的数据，对于机器学习和人工智能在扑克牌领域的研究具有重要意义。 一、数据集简介 这个数据集以".rar"压缩格式提供，名为...
png fro Play Cards(Poker)
06-15
2. **Android开发**：在Android平台上，开发者可以使用Android SDK中的ImageView组件，结合Android的Drawable资源，将PNG图片集成到项目中。这样，无论是启动游戏还是进行牌局操作，都能确保图片清晰且流畅地显示。 ...
Poker2Poker:JS为浏览器编写的点对点扑克客户端
07-08
Poker2poker 设置为节点应用程序。 让它工作： 在您的机器上安装节点。 在 poker2poker 目录下，运行npm install安装节点模块。 在同一目录中，运行node server.js以启动应用程序。 该游戏应该可以从。 也可以...
PokerHands:确定最佳手牌给定2套卡
05-10
2个类文件-PokerHand和Card 1测试文件-PokerHandTest包含成功测试的15个测试所使用的排名是按从高到低的顺序排列：皇家同花顺，同花顺，同花四张，满堂红，同花顺，同花，同花三张，两对，一对，高牌'PokerHand.java...
poker 升级版 固件
05-01
《全面解析"Poker升级版固件"：提升键盘性能与体验》 "Poker升级版固件"是一款专为Poker系列键盘设计的软件更新程序，旨在优化和增强键盘的性能，提供更优质、更个性化的输入体验。在本文中，我们将深入探讨固件...
windows poker game
最新发布
01-11
Windows扑克游戏是一种在Windows操作系统上运行的扑克游戏软件，它提供了一种便捷的方式供玩家在电脑上享受扑克游戏的乐趣。 Windows扑克游戏通常拥有丰富的功能和多样的游戏模式，玩家可以选择自己喜欢的扑克变种来进行游戏，如德州扑克、奥马哈扑克等。游戏界面通常简洁明了，玩家可以通过鼠标和键盘来进行操作，进行下注、看牌、加注以及弃牌等各种游戏动作。 除了基本的游戏功能外，Windows扑克游戏也提供了一些额外的功能来增加游戏的娱乐性。例如，一些游戏可能支持在线游戏，玩家可以与其他网络玩家进行多人对战。此外，还可以设置游戏难度级别、游戏速度，或者调整界面布局和皮肤等，使玩家有更好的游戏体验。 Windows扑克游戏不仅仅是一款娱乐软件，还可以作为玩家学习和提高扑克技巧的工具。通过与电脑进行对战，玩家可以了解并熟悉不同的扑克策略和牌型组合。此外，有些游戏还提供了策略分析和提示功能，帮助玩家在游戏中做出更明智的决策。 总之，Windows扑克游戏为没有时间或没有人陪伴进行实地扑克游戏的玩家提供了一个方便和有趣的选择。无论是在家里、办公室还是旅途中，通过这款游戏，玩家可以随时随地与扑克游戏亲密接触，并不断提升自己的技巧水平。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值