经典纸牌游戏：24点游戏

最新推荐文章于 2021-05-10 20:24:34 发布
最新推荐文章于 2021-05-10 20:24:34 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 编程 文章标签： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang12369/article/details/89279660
版权

                                经典纸牌游戏：24点游戏

从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。

基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。

注：此程序篇幅较长，但原理较容易理解。

过程解析：

一、取四个在1~13里边的随机数，并把对应的数字改为扑克牌对应的字母；

二、将四个符号放入一个char数组中，以便之后使用；

三、列举四个数字所能出现的所有状况，并将其一一对应的列举出来，并把数字和符号放在一起做一个函数；

四、算数步骤由于有三个符号，所以默认会有三个步骤，将三个步骤一一划分，并在每次运算完成后都给式子带上括号，这样首先不存在由于运算顺序导致的算数值出错；

五、将所有数字所能出现的情况做一个整合，并用函数和三个步骤的运算结合在一起，得出运算式子。

源程序：

package zhipai;

import java.util.Random;

public class you {

static char[] operator= {'+','-','*','/'};

static int z[]=new int[4]; //随机数所要进入的数组

static int se=0;//判断运算能不能得到24的值

public static void suiji(int z[])

{

Random r=new Random();

int a1=r.nextInt(13)+1;

int a2=r.nextInt(13)+1;

int a3=r.nextInt(13)+1;

int a4=r.nextInt(13)+1;

z[0]=a1;

z[1]=a2;

z[2]=a3;

z[3]=a4;//四个随机数的产生

}

public static void main(String[] args) {

int b[]=new int[4];

suiji(b);

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

if(b[i]==1) {

System.out.println("A");

}

else if(b[i]==11) {

System.out.println("J");

}

else if(b[i]==12) {

System.out.println("Q");

}

else if(b[i]==13) {

System.out.println("K");

}//根据扑克牌的规定将数字改为扑克牌的数值

else

System.out.println(b[i]);

 

}

for(int j=0;j<4;j++) {

z[j]=b[j];//将随机数赋值给全局数组

}

paixu();

 

}

public static int fu(int a , int b,char operator)

{

if(operator=='+') 

{

return  a+b;

}

 

else if((operator=='-')&&(a>b)) {

return a-b;

}

else if(operator=='*') {

return a*b;

}

else if((operator=='/')&&(b!=0)&&(a%b==0)&&(a>b)) {

return a/b;

}//各个符号所代表的意义

else

return -1;

}

public static void suan(int a,int b,int c,int d) {

 for(int i=0;i<4;i++)

 {

char  operator1=operator[i];

int v1=fu(a,b,operator1);

int v2=fu(b,c,operator1);

int v3=fu(c,d,operator1);//第一步的运算

 

 for(int j=0;j<4;j++) {

 char operator2=operator[j];

 int v12=fu(v1,c,operator2);

 int v13=fu(c,d,operator2);

 int v21=fu(a,v2,operator2);

 int v23=fu(v2,d,operator2);

 int v32=fu(b,v3,operator2);//第二步运算

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

 char operator3=operator[k];//第三步运算

 if(fu(v12,d,operator3)==24) {

 System.out.println("(("+a+operator1+b+")"+operator2+c+")"+operator3+d);

se=1;

 

 }

 if(fu(v1,v13,operator3)==24) {

 System.out.println("("+a+operator1+b+")"+operator3+"("+c+operator2+d+")");

         se=1;

 }

 if(fu(v21,d,operator3)==24) {

 System.out.println(""+a+operator3+"(("+b+operator1+c+")"+operator2+d+")");

 se=1;

 }

 if(fu(a,v32,operator3)==24) {

 System.out.println(""+a+operator3+"("+b+operator2+"("+c+operator1+d+"))");

se=1;

 }//输出所有可以得到24的式子

 }

 }

 }

}

public static void paixu() {//由于不同的随机数可能会有不同的排列组合，所以根据情况将随机数的排列列出来

if(z[0]==z[1]&&z[1]==z[2]&&z[2]==z[3]) {

suan(z[0],z[1],z[2],z[3]);

}

 

if(z[0]==z[1]&&z[1]!=z[2]&&z[2]!=z[3]&&z[1]!=z[3]) {

suan(z[0],z[0],z[2],z[3]);

suan(z[0],z[0],z[3],z[2]);

suan(z[0],z[2],z[0],z[3]);

suan(z[0],z[2],z[3],z[0]);

suan(z[0],z[3],z[0],z[2]);

suan(z[0],z[3],z[2],z[0]);

suan(z[2],z[0],z[0],z[3]);

suan(z[2],z[0],z[3],z[0]);

suan(z[2],z[3],z[0],z[0]);

suan(z[3],z[0],z[0],z[2]);

suan(z[3],z[0],z[2],z[0]);

suan(z[3],z[2],z[0],z[0]);

 

}

 

if(z[0]==z[2]&&z[2]!=z[1]&&z[2]!=z[3]&&z[1]!=z[3]) {

suan(z[0],z[0],z[1],z[3]);

suan(z[0],z[0],z[3],z[1]);

suan(z[0],z[1],z[0],z[3]);

suan(z[0],z[1],z[3],z[0]);

suan(z[0],z[3],z[0],z[1]);

suan(z[0],z[3],z[1],z[0]);

suan(z[1],z[0],z[0],z[3]);

suan(z[1],z[0],z[3],z[0]);

suan(z[1],z[3],z[0],z[0]);

suan(z[3],z[0],z[0],z[1]);

suan(z[3],z[0],z[1],z[0]);

suan(z[3],z[1],z[0],z[0]);

}

 

                if(z[0]==z[3]&&z[0]!=z[1]&&z[0]!=z[2]&&z[1]!=z[2]) {

                 suan(z[0],z[0],z[1],z[2]);

suan(z[0],z[0],z[2],z[1]);

suan(z[0],z[1],z[0],z[2]);

suan(z[0],z[1],z[2],z[0]);

suan(z[0],z[2],z[0],z[1]);

suan(z[0],z[2],z[1],z[0]);

suan(z[1],z[0],z[0],z[2]);

suan(z[1],z[0],z[2],z[0]);

suan(z[1],z[2],z[0],z[0]);

suan(z[2],z[0],z[0],z[1]);

suan(z[2],z[0],z[1],z[0]);

suan(z[2],z[1],z[0],z[0]);

}

                

                if(z[0]==z[1]&&z[2]==z[3]&&z[0]!=z[2]) {

                 suan(z[0],z[0],z[2],z[2]);

                 suan(z[0],z[2],z[0],z[2]);

                 suan(z[0],z[2],z[2],z[0]);

                 suan(z[2],z[2],z[0],z[0]);

                 suan(z[2],z[0],z[2],z[0]);

                 suan(z[2],z[0],z[0],z[2]);

                }

            

                if(z[0]==z[2]&&z[1]==z[3]&&z[1]!=z[2]) {

                 suan(z[0],z[0],z[1],z[1]);

                 suan(z[0],z[1],z[0],z[1]);

                 suan(z[0],z[1],z[1],z[0]);

                 suan(z[1],z[1],z[0],z[0]);

                 suan(z[1],z[0],z[1],z[0]);

                 suan(z[1],z[0],z[0],z[1]);

                }

               

                if(z[0]==z[3]&&z[1]==z[2]&&z[0]!=z[1]) {

                 suan(z[0],z[0],z[2],z[2]);

                 suan(z[0],z[2],z[0],z[2]);

                 suan(z[0],z[2],z[2],z[0]);

                 suan(z[2],z[2],z[0],z[0]);

                 suan(z[2],z[0],z[2],z[0]);

                 suan(z[2],z[0],z[0],z[2]);

                }

               

                if(z[0]==z[1]&&z[3]==z[2]&&z[0]!=z[3]) {

                 suan(z[0],z[0],z[0],z[3]);

                 suan(z[0],z[0],z[3],z[0]);

                 suan(z[0],z[3],z[0],z[0]);

                 suan(z[3],z[0],z[0],z[0]);

                }

               

                if(z[0]==z[1]&&z[1]==z[3]&&z[0]!=z[2]) {

                 suan(z[0],z[0],z[0],z[2]);

                 suan(z[0],z[0],z[2],z[0]);

                 suan(z[0],z[2],z[0],z[0]);

                 suan(z[2],z[0],z[0],z[0]);

                }

              

                if(z[0]==z[2]&&z[2]==z[3]&&z[0]!=z[1]) {

                 suan(z[0],z[0],z[0],z[1]);

                 suan(z[0],z[0],z[1],z[0]);

                 suan(z[0],z[1],z[0],z[0]);

                 suan(z[1],z[0],z[0],z[0]);

                } 

             

                if(z[1]==z[2]&&z[2]==z[3]&&z[0]!=z[1]) {

                 suan(z[0],z[1],z[1],z[1]);

                 suan(z[1],z[0],z[1],z[1]);

                 suan(z[1],z[1],z[0],z[1]);

                 suan(z[1],z[1],z[1],z[0]);

                }

               

                if(z[0]!=z[1]&&z[0]!=z[2]&&z[0]!=z[3]&&z[1]!=z[2]&&z[2]!=z[3]) {

                 suan(z[0],z[1],z[2],z[3]);

                 suan(z[0],z[1],z[3],z[2]);

                 suan(z[0],z[2],z[1],z[3]);

                 suan(z[0],z[2],z[3],z[1]);

                 suan(z[0],z[3],z[1],z[2]);

                 suan(z[0],z[3],z[2],z[1]);

                 suan(z[1],z[0],z[2],z[3]);

                 suan(z[1],z[0],z[3],z[2]);

                 suan(z[1],z[2],z[0],z[3]);

                 suan(z[1],z[2],z[3],z[0]);

                 suan(z[1],z[3],z[0],z[2]);

                 suan(z[1],z[3],z[2],z[0]);

                 suan(z[2],z[0],z[1],z[3]);

                 suan(z[2],z[0],z[3],z[1]);

                 suan(z[2],z[1],z[0],z[3]);

                 suan(z[2],z[1],z[3],z[0]);

                 suan(z[2],z[3],z[0],z[1]);

                 suan(z[2],z[3],z[1],z[0]);

                 suan(z[3],z[0],z[1],z[2]);

                 suan(z[3],z[0],z[2],z[1]);

                 suan(z[3],z[1],z[0],z[2]);

                 suan(z[3],z[1],z[2],z[0]);

                 suan(z[3],z[2],z[1],z[0]);

                 suan(z[3],z[2],z[0],z[1]);

                

                }

                if(se==0) {

                 System.out.println("这四张纸牌不能通过运算得到24！");

               }

}

}

程序结果截屏：

结果一：四个数字运算可以得出24

结果二：通过四则运算不能得出24

程序调试：

程序在进入在开始的随机函数时的调试：

 

程序进入运算第一步时调试：

 

 

 

 

 

各个步骤运算的总调试：

 

程序测试：

随机函数测试代码：

package zhipaiceshi;

import java.util.Random;

public class ce {

public static void main(String[] args) {

int z[]=new int[4];

Random r=new Random();

int a1=r.nextInt(13)+1;

int a2=r.nextInt(13)+1;

int a3=r.nextInt(13)+1;

int a4=r.nextInt(13)+1;

z[0]=a1;

z[1]=a2;

z[2]=a3;

z[3]=a4;//四个随机数的产生

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

if(z[i]==1) {

System.out.println("A");

}

else if(z[i]==11) {

System.out.println("J");

}

else if(z[i]==12) {

System.out.println("Q");

}

else if(z[i]==13) {

System.out.println("K");

}//根据扑克牌的规定将数字改为扑克牌的数值

else

System.out.println(z[i]);

 

}

}

}

代码结果截屏：

运算函数测试代码：

package zhipaiceshi;

import java.util.Scanner;

public class ceshi1 {

static char[] operator= {'+','-','*','/'};

public static void main(String[] args) {

Scanner x=new Scanner(System.in);

System.out.print("请输入a的值");

int a=x.nextInt();

System.out.print("请输入b的值");

int b=x.nextInt();

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

char operator1=operator[i];

System.out.println(fu(a,b,operator1));

}

}

 

public static int fu(int a , int b,char operator)

{

if(operator=='+') 

{

return  a+b;

}

 

else if((operator=='-')&&(a>b)) {

return a-b;

}

else if(operator=='*') {

return a*b;

}

else if((operator=='/')&&(b!=0)&&(a%b==0)&&(a>b)) {

return a/b;

}//各个符号所代表的意义

else

return -1;

}

}

测试结果截屏：

式子测试代码：

package zhipaiceshi;

import java.util.Scanner;

public class ceshi2 {

static char[] operator= {'+','-','*','/'};

static int se=0;

public static void main(String[] args) {

Scanner x=new Scanner(System.in);

System.out.print("请输入a的值");

int a=x.nextInt();

System.out.print("请输入b的值");

int b=x.nextInt();

System.out.print("请输入c的值");

int c=x.nextInt();

System.out.print("请输入d的值");

int d=x.nextInt();

 

 for(int i=0;i<4;i++)

 {

char  operator1=operator[i];

int v1=fu(a,b,operator1);

int v2=fu(b,c,operator1);

int v3=fu(c,d,operator1);//第一步的运算

 

 for(int j=0;j<4;j++) {

 char operator2=operator[j];

 int v12=fu(v1,c,operator2);

 int v13=fu(c,d,operator2);

 int v21=fu(a,v2,operator2);

 int v23=fu(v2,d,operator2);

 int v32=fu(b,v3,operator2);//第二步运算

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

 char operator3=operator[k];//第三步运算

 if(fu(v12,d,operator3)==24) {

 System.out.println("(("+a+operator1+b+")"+operator2+c+")"+operator3+d);

se=1;

 

 }

 if(fu(v1,v13,operator3)==24) {

 System.out.println("("+a+operator1+b+")"+operator3+"("+c+operator2+d+")");

         se=1;

 }

 if(fu(v21,d,operator3)==24) {

 System.out.println(""+a+operator3+"(("+b+operator1+c+")"+operator2+d+")");

 se=1;

 }

 if(fu(a,v32,operator3)==24) {

 System.out.println(""+a+operator3+"("+b+operator2+"("+c+operator1+d+"))");

se=1;

 }//输出所有可以得到24的式子

 }

 }

 }

 

 if(se==0) {

 System.out.println("这四个数不能通过四则运算得到24！");

 }

}

public static int fu(int a , int b,char operator)

{

if(operator=='+') 

{

return  a+b;

}

 

else if((operator=='-')&&(a>b)) {

return a-b;

}

else if(operator=='*') {

return a*b;

}

else if((operator=='/')&&(b!=0)&&(a%b==0)&&(a>b)) {

return a/b;

}//各个符号所代表的意义

else

return -1;

}

}

测试结果截屏：

 

 

总结：

     本次是第一次使用java来做，可以发现有一些用法、java的程序包等等都有一些不太知道的，在使用的过程中可能一个非常小的问题都要改半天，但我也知道了一些比较基本的非逻辑上的错误应该怎么来改；还有一个收获比较大的地方就是在有一些自己之前没有注意到的小错误，java中在自己打程序的时候都会提示出来；基本上都会不自觉的看看写出来的程序会不会有什么其他的问题。

我学会了使用全局的变量等，让整个程序变得更加的流畅，不再是之前的分裂状态，只要不在一个函数内都会存在考虑数据关系问题。

程序中存在的不足：

由于四则运算中的乘、除优先原则无法正常的在程序中体现出来，所以我采用了将每一步运算都要用括号括起来的方式，这样它不会有优先问题，但也使得整个程序变得麻烦，需要使用数字的排列组合使存在的所有情况都出现，这样程序就会大大拉长，并不简洁。

还有一个未解决的问题：

如何将一个外部调用函数直接使用着写入文件？

错误代码：      bw.write(paixu());

写入文件程序代码：

package zhipaiceshi;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class xieru {
    OutputStreamWriter bw=null;
    try {
        bw=new OutputStreamWriter(new FileOutputStream("C:\\Users\\张敏\\Desktop\\软工一班-17408070802-张敏\\源程序.TopList.txt"),"UTF-8");
        for(int k=0;k<4;k++)
        bw.write(z[k]);
    }
    
        catch(Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(bw!=null) {
                    bw.close();
                }
            }catch(IOException e) {
                e.printStackTrace();
            }
        }
    
    }
}

 

zhang12369
关注
专栏目录
24点纸牌
wangZihan_1812772486的博客
09-30 750
24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 源代码： #include&amp;amp;lt;iostream&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; using namespace std; class Dian { public:
纸牌游戏之24点
yanshushuang的博客
01-07 797
python练习之二十四点 游戏规则 二十四点是一种益智游戏，它能在游戏中锻炼人们的心算，它往往要求人们将三个数字进行加减乘除四则混合运算（允许使用括号）求得二十四。 #纸牌游戏 24点 import itertools #函数1 参数：一个数字列表，从中顺序取出数字，将四则混合运算符按照顺序来添加到三个数字中间并进行运算 def fun1(li,target=24):
24点经典纸牌游戏
qq_42504734的博客
04-12 2997
题目：24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求：随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 分析：穷举法思想 随...
24点游戏是经典的纸牌益智游戏
foxANDbee的博客
09-29 648
24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 1.程序风格良好(使用自定义注释模板) 2.列出...
24点纸牌游戏
mumulianzi的博客
10-05 940
*程序设计方法学 *作业三 *2018.10.5 *24点纸牌游戏 题目：从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 1.程序风格良好(使用自...
java实现24点纸牌游戏
08-19
在本文中，我们将深入探讨如何使用Java编程语言实现24点纸牌游戏。24点游戏是一种基于数学逻辑的益智游戏，玩家需要通过四张扑克牌上的数字，结合加、减、乘、除运算符，尝试找到能够得到24的运算组合。以下是实现这...
C语言实现经典24点纸牌益智游戏
08-25
C语言实现经典24点纸牌益智游戏 本文将详细介绍C语言实现经典24点纸牌益智游戏的相关知识点。 游戏规则 游戏规则是游戏的核心部分，了解游戏规则是编写游戏程序的基础。游戏规则主要包括以下几个方面： 1.从扑克...
C++实现经典24点纸牌益智游戏
08-24
C++实现经典24点纸牌益智游戏 本文主要介绍了使用C++语言实现经典的24点纸牌益智游戏的具体实现方法。该游戏的规则是从扑克中每次取出4张牌，使用加减乘除四则运算，第一个能得出24者为赢。其中，J代表11，Q代表12...
自制24点游戏是经典的纸牌益智游戏
11-14
《自制24点游戏——Android源码解析与纸牌游戏设计》 24点游戏，一个深受人们喜爱的智力挑战游戏，它源自于中国的传统数学游戏，旨在通过四张扑克牌上的数字，利用加减乘除运算得到结果为24。这种游戏锻炼了玩家的...
C#扑克牌24点计算游戏
04-21
C#开发的扑克牌24点计算游戏，图形化显示，可随机出牌进行计算，也可指定数据进行计算。
Qt纸牌游戏 24点
05-19
这个一个用Qt写的纸牌小游戏24点,主要是用于帮助Qt初学者熟悉Qt的基本控件和各种Qt容器类.其中的算法也算得上是一个亮点.
linux下用Qt完成的21点扑克牌游戏
09-27
完整的小游戏，楼主独立完成，如有雷同纯属巧合，界面花了不少功夫，供大家交流参考
Card Game—纸牌游戏（梭哈）
11-10
面向对象大型程序设计——纸牌游戏，有图形界面，含可运行代码和文档详解&PPT;
扑克牌24点小游戏
MR_GXF的博客
04-14 1615
题目要求 基本要求 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 1.程序风格良好(使用自定义注释模板) 2.列出表达式无重复。 提高要求 用户初始生命值为一给定值（比如3），初始分数为0。随机生成4个代表扑克牌牌面的数字或字母，由用户输入包含这4个数字或字母的运...
24点扑克牌游戏
qq_54079095的博客
05-10 884
这里写自定义目录标题 算法分析 题目： 24点游戏是经典的纸牌益智游戏。 24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 提高要求：用户初始生命值为一给定值（比如3），初始分数为0。随机生成4个代表扑克牌牌
24点纸牌游戏（java）
hi_你好
04-13 772
题目 24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 分析 用穷举法列出四个数加上三个运算符号所...
经典纸牌益智游戏--24点游戏
qq_43722072的博客
04-10 678
作者：无* 时间：2019-4-10 说明：此代码中的穷举法参考了资料，结合之后采用了一种较为易懂的穷举法 一．题目分析： 24点游戏（经典的纸牌益智游戏） *基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式。 1.利用随机函数产生四个随机数，可利用数组进行存储。 2.利用穷举法列出所有括号的情况共五种 (1). ((A□B)□C)□D (2...
C语言详解：实现24点纸牌游戏并优化算法
C语言实现纸牌24点小游戏是一种经典的编程练习，它结合了C语言的基础知识和逻辑思维能力，旨在通过模拟实际的扑克牌游戏规则来设计一个程序。该程序的主要目标是让用户从一副虚拟的扑克牌（包含J、Q、K、A分别代表11...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值