Java 控制台版的跑得快

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量130 收藏
点赞数
文章标签： java windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38101240/article/details/133793826
版权

Java 控制台版的跑得快

package com.iot.common.core;


import org.springframework.beans.BeanUtils;

import java.util.*;
import java.util.stream.Collectors;

public class myTest {

    /**
     * 用户集合
     */
    final static String[] userStr = new String[]{"发哥", "小刀仔", "小趴菜"};

    public static void main(String[] args) {

        System.out.println("******跑得快******");
        System.out.println("开始游戏，请输入【\033[31;4mstart\033[0m】");
        System.out.println("退出游戏，请输入【\033[31;4mexit\033[0m】");

        // 游戏开关
        boolean startBol = true;
        // 游戏次数
        int playerCount = 0;


        while (startBol) {
            System.out.println("请输入......");
            // 用户输入流
            Scanner scanner = new Scanner(System.in);

            String str = scanner.next();

            if ("start".equals(str)) {

                // 次数增加
                playerCount++;

                // 开始游戏
                startBol = startGame(playerCount);
            } else if ("exit".equals(str)){
                System.out.println("结束游戏,拜拜~");
                startBol = false;
            } else {
                System.out.println("请输入【start/exit】");
            }
        }

    }

    /**
     * 开始游戏
     * @param playerCount
     * @return
     */
    public static boolean startGame(int playerCount) {

        System.out.println("第【" + playerCount + "回合开始】......" );

        // 开关
        boolean startBol = true;

        // 出牌顺序队列
        Queue<UserPokerClass> pokerQueue = new LinkedList<>();

        List<UserPokerClass> userPokerClasses = new LinkedList<>();

        for (int i = 0; i <= 2; i++) {
            UserPokerClass userPokerClass = new UserPokerClass();

            userPokerClass.setUserName(userStr[i]);

            userPokerClass.setPokers(
                    pokers
                            .stream()
                            .skip(16 * i)
                            .limit(16
                            )
                            .sorted(Comparator.comparing(PokerClass::getPoker))
                            .collect(Collectors.toList()));
            userPokerClasses.add(userPokerClass);
        }

        // 找到黑桃三放到队列，剩下的数组统一添加到集合
        userPokerClasses = userPokerClasses.stream().filter(eq -> {
            boolean bol = true;
            for (int i = 0; i < eq.getPokers().size(); i++) {
                if (
                        3 == eq.getPokers().get(i).getPoker() &&
                                "♠".equals(eq.getPokers().get(i).getDesignColor())
                ) {
                    pokerQueue.offer(eq);
                    bol = false;
                    break;
                }
            }
            return bol;
        }).collect(Collectors.toList());

        // 剩下两个数组直接放进去(完善过机器人出牌逻辑才放通)
//        pokerQueue.offer(userPokerClasses.get(0));
//        pokerQueue.offer(userPokerClasses.get(1));

        // 打印用户的扑克牌
        putPoker(pokerQueue.peek().getPokers());

        System.out.println("请出牌......");

        boolean bol = true;

        while (bol) {
            Scanner scanner = new Scanner(System.in);

            String str = scanner.next();

            // 把10单独拿出来先装到集合里面
            // 检查用户出的牌，是不是在集合范围内
            List<Integer> scannerList = getUserScannerData(str);

            CheckMsg checkMsg = checkData(scannerList, pokerQueue.peek().getPokers());

            if (checkMsg.getBol()) {
                // 出牌
                putPoker(checkMsg.getPutClasses());
                System.out.println(checkMsg.getMsg() + "......");
                // 消耗队列
                UserPokerClass userPokerClass = pokerQueue.poll();
                userPokerClass.setPokers(checkMsg.getPokerClasses());

                // 新增队列
                pokerQueue.offer(userPokerClass);
                System.out.println("      ");
                System.out.println("      ");
                System.out.println("------------------------------------------");
                System.out.println("      ");
                System.out.println("      ");
                putPoker(checkMsg.getPokerClasses());
                bol = true;
            } else {
                System.out.println(checkMsg.getMsg());
                bol = true;
            }
        }

        return startBol;
    }

    /**
     * 机器人出牌
     * @param userPutData
     * @param pokerQueue
     * @return
     */
    public static CheckMsg AIPutPoker(List<Integer> userPutData, Queue<UserPokerClass> pokerQueue) {

        // 消耗当前出牌队列
        UserPokerClass nowPokerClass = pokerQueue.poll();

        return null;
    }

    /**
     * 出单张牌
     * @param nowPokerClass
     * @return
     */
    public static List<PokerClass> putOne(UserPokerClass nowPokerClass, List<Integer> userPutData) {

        // 上一个用户出的牌
        Integer userPoker = userPutData.get(0);

        /**
         * 几段跑得快出牌逻辑
         * 1、在不拆牌的情况下出牌；
         * 2、是不是有出一张较大的牌就能出跟多张牌或者能够有顺序的出完牌；
         * 3、没有大过用户的牌拆牌输出；
         * 4、如何拆顺子、对子；
         * 5、有炸弹的情况下是否要出炸弹；
         * 6、拆了单排就没办法大3带二或者四带二需要拆对子。
         */
        return null;
    }

    /**
     * 检查数据
     * @param putData
     * @param checkData
     * @return
     */
    public static CheckMsg checkData(List<Integer> putData, List<PokerClass> checkData) {
        CheckMsg checkMsg = new CheckMsg();

        List<PokerClass> putPokerClasses = new ArrayList<>();

        for (Integer putDatum : putData) {
            boolean bol = false;
            for (int i = 0; i < checkData.size(); i++) {
                if (putDatum == checkData.get(i).getPoker()) {
                    PokerClass pokerClass = new PokerClass();
                    BeanUtils.copyProperties(pokerClass, checkData.get(i));
                    putPokerClasses.add(pokerClass);
                    checkData.remove(i);
                    bol = true;
                    break;
                }
            }
            if (!bol) {
                checkMsg.setMsg("不存在扑克牌：【"+pokerFormat(putDatum)+"】");
                checkMsg.setBol(false);
                return checkMsg;
            }
        }

        checkMsg.setBol(true);

        // 验证用户出牌是否合规 单张、对子、连对、顺子、三带二、炸弹、四带二
        // 单张校验
        if (putPokerClasses.size() == 1) {
            checkMsg.setMsg("单张");
        } else if (isPairs(putPokerClasses)) {
            checkMsg.setMsg("对子");
        } else if (isBomb(putPokerClasses)) {
            checkMsg.setMsg("炸弹");
        } else if (isStraight(putPokerClasses)) {
            checkMsg.setMsg("顺子");
        } else if (is3And2(putPokerClasses)){
            checkMsg.setMsg("三带二");
        } else if (is3And2s(putPokerClasses)){
            checkMsg.setMsg("飞机");
        } else if (is4And2(putPokerClasses)) {
            checkMsg.setMsg("四带二");
        } else if (isConsecutivePairs(putPokerClasses)) {
            checkMsg.setMsg("连对");
        } else {
            checkMsg.setBol(false);
            checkMsg.setMsg("出牌不合规【单张、对子、连对、三代二、炸弹、四带二】");
        }

        checkMsg.setPokerClasses(checkData);
        checkMsg.setPutClasses(putPokerClasses);

        return checkMsg;
    }

    /**
     * 是否是对子
     * @param pokerClasses
     * @return
     */
    public static boolean isPairs(List<PokerClass> pokerClasses) {
        if (pokerClasses.size() == 2) {
            return pokerClasses.get(0).getPoker() == pokerClasses.get(1).getPoker();
        }
        return false;
    }

    /**
     * 是否是连对
     * @param pokerClasses
     * @return
     */
    public static boolean isConsecutivePairs(List<PokerClass> pokerClasses) {
        if (pokerClasses.size()%2 == 0) {

            List<Integer> integerList = pokerClasses.stream().map(PokerClass::getPoker).distinct().sorted().collect(Collectors.toList());

            /**
             * 判断，当前数+1是不是等于下一位数
             */
            for (int i = 0; i < integerList.size() -1; i++) {
                if (integerList.get(i) + 1 != integerList.get(i + 1)) {
                    return false;
                }
            }
        } else {
            return false;
        }
        return true;
    }

    /**
     * 是否是顺子
     * @param pokerClasses
     * @return
     */
    public static boolean isStraight(List<PokerClass> pokerClasses) {
        if (pokerClasses.size() >= 5) {

            List<Integer> integerList = pokerClasses.stream().map(PokerClass::getPoker).sorted().collect(Collectors.toList());

            /**
             * 判断，当前数+1是不是等于下一位数
             */
            for (int i = 0; i < integerList.size() -1; i++) {
                if (integerList.get(i) + 1 != integerList.get(i + 1)) {
                    return false;
                }
            }
        } else {
            return false;
        }
        return true;
    }

    /**
     * 是否是三带二
     * @param pokerClasses
     * @return
     */
    public static boolean is3And2(List<PokerClass> pokerClasses) {
        if (pokerClasses.size() == 5) {
            List<Integer> integerList = pokerClasses.stream().map(PokerClass::getPoker).distinct().sorted().collect(Collectors.toList());

            for (Integer integer : integerList) {
                if (pokerClasses.stream().filter(eq -> eq.getPoker() == integer).collect(Collectors.toList()).size() == 3) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 是否是飞机
     * @param pokerClasses
     * @return
     */
    public static boolean is3And2s(List<PokerClass> pokerClasses) {
        if (pokerClasses.size() >= 10) {
            // 应该具备三张的位数
            int count = pokerClasses.size() / 5;

            List<Integer> integerList = pokerClasses.stream().map(PokerClass::getPoker).distinct().sorted().collect(Collectors.toList());

            // 三张的数量
            int count3 = 0;

            for (Integer integer : integerList) {
                if (pokerClasses.stream().filter(eq -> eq.getPoker() == integer).collect(Collectors.toList()).size() == 3) {
                    count3++;
                }
            }

            if (count == count3) {
                return true;
            }
        }

        return false;

    }


    /**
     * 是否是四带二
     * @param pokerClasses
     * @return
     */
    public static boolean is4And2(List<PokerClass> pokerClasses) {
        if (pokerClasses.size() == 5) {
            List<Integer> integerList = pokerClasses.stream().map(PokerClass::getPoker).distinct().sorted().collect(Collectors.toList());

            for (Integer integer : integerList) {
                if (pokerClasses.stream().filter(eq -> eq.getPoker() == integer).collect(Collectors.toList()).size() == 4) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 是否是炸弹
     * @param pokerClasses
     * @return
     */
    public static boolean isBomb(List<PokerClass> pokerClasses) {
        if (pokerClasses.size() == 4) {
            List<Integer> integerList = pokerClasses.stream().map(PokerClass::getPoker).distinct().sorted().collect(Collectors.toList());

            if (integerList.stream().distinct().collect(Collectors.toList()).size() == 1) {
                return true;
            }
        }

        return false;
    }

    /**
     * 解析用户输入值
     * @param str
     * @return
     */
    public static List<Integer> getUserScannerData(String str) {
        boolean bol = true;

        List<Integer> dataList = new ArrayList<>();

        while (bol) {
            if (str.indexOf("10") >= 0) {
                dataList.add(10);
                str = str.replaceFirst("10" , "");
            } else {
                bol = false;
            }
        }
        for (char c : str.toCharArray()) {
            dataList.add(pokerFormat2(String.valueOf(c)));
        }

        return dataList;

    }

    /**
     * 输出扑克牌
     * @param pokers
     */
    public static void putPoker(List<PokerClass> pokers) {
        StringBuffer sop1 = new StringBuffer();
        StringBuffer sop2 = new StringBuffer();
        StringBuffer sop3 = new StringBuffer();
        StringBuffer sop4 = new StringBuffer();

        // 给用户发牌
        for (PokerClass poker : pokers) {

            if (poker.getPoker() == 10) {
                sop1.append("\033[31;4m"+pokerFormat(poker.getPoker())+"  "+poker.getDesignColor()+"\033[0m  ");
            } else {
                sop1.append("\033[31;4m"+pokerFormat(poker.getPoker())+"   "+poker.getDesignColor()+"\033[0m  ");
            }
            sop2.append("       ");
            sop3.append("       ");

            if (poker.getPoker() == 10) {
                sop4.append("\033[31;4m"+poker.getDesignColor()+"  "+pokerFormat(poker.getPoker())+"\033[0m  ");
            } else {
                sop4.append("\033[31;4m"+poker.getDesignColor()+"   "+pokerFormat(poker.getPoker())+"\033[0m  ");
            }
        }

        System.out.println(sop1);
        System.out.println(sop2);
        System.out.println(sop3);
        System.out.println(sop4);
    }

    /**
     * 扑克牌
     */
    static class UserPokerClass {

        String userName;

        List<PokerClass> pokers;

        public String getUserName() {
            return userName;
        }

        public void setUserName(String userName) {
            this.userName = userName;
        }

        public List<PokerClass> getPokers() {
            return pokers;
        }

        public void setPokers(List<PokerClass> pokers) {
            this.pokers = pokers;
        }
    }

    /**
     * 打乱顺序
     */
    static class MyComparator implements Comparator<PokerClass> {

        @Override
        public int compare(PokerClass o1, PokerClass o2) {
            return Math.random() < 0.5? 1 : -1;
        }
    }

    /**
     * 扑克牌集合
     */
    static List<PokerClass> pokers = makePoker();

    /**
     * 创建扑克牌
     *
     * @return
     */
    public static List<PokerClass> makePoker() {

        List<PokerClass> pokerClasses = new ArrayList<>();

        int[] pokers = new int[]{3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15,};
        String[] designColor = new String[]{"♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦","♠","♣","♥","♦"};

        for (int i = 0; i < pokers.length; i++) {
            PokerClass pokerClass = new PokerClass();
            pokerClass.setPoker(pokers[i]);
            pokerClass.setDesignColor(designColor[i]);

            pokerClasses.add(pokerClass);
        }

        // 打乱顺序
        Comparator cmp = new MyComparator();
        pokerClasses.sort(cmp);

        return pokerClasses;
    }

    /**
     * 扑克格式化
     * @param poker
     * @return
     */
    public static String pokerFormat(int poker) {
        String data;

        switch (poker) {
            case 10:
                data = "10";
                break;
            case 11:
                data = "J";
                break;
            case 12:
                data = "Q";
                break;
            case 13:
                data = "K";
                break;
            case 14:
                data = "A";
                break;
            case 15:
                data = "2";
                break;
            default:
                data = String.valueOf(poker);
                break;
        }
        return data;
    }

    /**
     * 扑克格式化(反向)
     * @param poker
     * @return
     */
    public static int pokerFormat2(String poker) {
        int data;

        switch (poker) {
            case "10":
                data = 10;
                break;
            case "J":
            case "j":
                data = 11;
                break;
            case "Q":
            case "q":
                data = 12;
                break;
            case "K":
            case "k":
                data = 13;
                break;
            case "A":
            case "a":
                data = 14;
                break;
            case "2":
                data = 15;
                break;
            default:
                data = Integer.valueOf(poker);
                break;
        }
        return data;
    }

    static class CheckMsg {

        /**
         * 验证状态
         */
        private boolean bol;

        /**
         * 验证结果
         */
        private String msg;

        /**
         * 用户剩余扑克牌数据
         */
        private List<PokerClass> pokerClasses;

        /**
         * 用户出牌数据
         */
        private List<PokerClass> putClasses;

        public boolean getBol() {
            return bol;
        }

        public void setBol(boolean bol) {
            this.bol = bol;
        }

        public String getMsg() {
            return msg;
        }

        public void setMsg(String msg) {
            this.msg = msg;
        }

        public List<PokerClass> getPokerClasses() {
            return pokerClasses;
        }

        public void setPokerClasses(List<PokerClass> pokerClasses) {
            this.pokerClasses = pokerClasses;
        }

        public List<PokerClass> getPutClasses() {
            return putClasses;
        }

        public void setPutClasses(List<PokerClass> putClasses) {
            this.putClasses = putClasses;
        }
    }

    /**
     * 扑克
     */
    static class PokerClass {
        int poker;

        String designColor;

        public int getPoker() {
            return poker;
        }

        public void setPoker(int poker) {
            this.poker = poker;
        }

        public String getDesignColor() {
            return designColor;
        }

        public void setDesignColor(String designColor) {
            this.designColor = designColor;
        }
    }

}
超基基
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
was控制台java虚拟机默认值_JVM 参数设置
weixin_36325589的博客
02-27 2478
不管是YGC还是Full GC,GC过程中都会对导致程序运行中中断,正确的选择不同的GC策略,调整JVM、GC的参数，可以极大的减少由于GC工作，而导致的程序运行中断方面的问题，进而适当的提高Java程序的工作效率。但是调整GC是以个极为复杂的过程，由于各个程序具备不同的特点，如：web和GUI程序就有很大区别(Web可以适当的停顿，但GUI停顿是客户无法接受的)，而且由于跑在各个机器上的配置不...
java虚拟机第三版学习
星月IWJ
10-09 770
java虚拟机第三版学习
Java游戏\声色棋牌之跑得快.jar
05-04
Java游戏\声色棋牌之跑得快.jarJava游戏\声色棋牌之跑得快.jar
10万字208道Java经典面试题总结(附答案)
热门推荐
学Java，找哪吒
08-02 98万+
1、JDK 和 JRE 有什么区别？ JDK（Java Development Kit），Java开发工具包 JRE（Java Runtime Environment），Java运行环境 JDK中包含JRE，JDK中有一个名为jre的目录，里面包含两个文件夹bin和lib，bin就是JVM，lib就是JVM工作所需要的类库。 2、== 和 equals 的区别是什么？ 对于基本类型，==比较的是值； 对于引用类型，==比较的是地址； equals不能用于基本类型的比较； 如果没有重写equa
掌握P5级Java面试技巧
Java程序员廖志伟
03-25 3万+
HashMap底层原理，扩容机制，jdk8以后会使用红黑树优化？红黑树和二叉平衡树的区别，红黑树和B树，B+树的区别，Mysql二大引擎索引底层实现，HashMap在多线程环境中为何出错？ConcurrentHashMap底层实现，CAS，原子引用，ABA问题，volatile，如何解决HashMap出现的OOM问题？（WeakHashMap） HashMap是Map的一个实现类，它是以键值对存储数据的，Key-Value都是Map.Entry中的属性。当我们向HashMap中存放一个元素(k1,v1)
Java重点原理精炼(免费版)
枫度柚子
02-28 9302
Java相关原理精炼 主要是处理一些难记忆的概念、参数，尽量不丢失原意的基础上进行白话简概
Java学习笔记——小白快速入门
qq_43631268的博客
02-20 1382
Java：从入门到入土——只需要几个小时
Sentinel 控制台学习
记录,交流,共同进步
04-30 1597
Sentinel 系统自适应限流从整体维度对应用入口流量进行控制，结合应用的 Load、CPU 使用率、总体平均 RT、入口 QPS 和并发线程数等几个维度的监控指标，通过自适应的流控策略，让系统的入口流量和系统的负载达到一个平衡，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。从上图可以看到，快速失败方式下，会出现5个接口调用成功，5个接口调用失败，并且会有一个5秒钟的时间间隔（自己设置的时间间隔），排队等待就是利用这个时间间隔，处理处于等待中的请求，从而实现流控。
Java线上问题排查神器Arthas快速上手与原理浅谈
蛮三刀酱
11-17 7437
前言 当你兴冲冲地开始运行自己的Java项目时，你是否遇到过如下问题： 程序在稳定运行了，可是实现的功能点了没反应。 为了修复Bug而上线的新版本，上线后发现Bug依然在，却想不通哪里有问题？ 想到可能出现问题的地方，却发现那里没打日志，没法在运行中看到问题，只能加了日志输出重新打包——部署——上线 程序功能正常了，可是为啥响应时间这么慢，在哪里出现了问题？ 程序不但稳定运行，而且功能完美，但...
Java 控制台 打印表格 改进版
01-17
Java 控制台 打印表格 可前往http://blog.csdn.net/j506825719/article/details/78996659查看效果图后再决定是否需要下载。
基于java实现学生成绩管理系统（java控制台版本）
10-24
2.编写Java程序，实现一个简单的学生成绩管理系统，主要包括注册、登录、成绩录入和成绩查询等功能。具体要求如下: (1)显示。如输出显示学生成绩管理系统欢迎语，提示用户输入不同数字进入注册、登录、成绩录入和...
java控制台版笔记本
03-24
Java控制台版笔记本是一种利用Java编程语言开发的简单文本处理工具，主要在命令行界面运行。这个项目可能是一个为了教学、学习或者轻量级笔记管理而设计的小型应用程序。通过控制台，用户可以进行基本的文字输入、...
Java项目:控制台商城系统(java+打印控制台)
12-21
在本项目中，我们关注的是一个基于Java编程语言构建的控制台商城系统。这个系统的主要目的是在命令行界面（控制台）中模拟一个简单的商城环境，实现基础的商业操作，如管理客户信息、商品信息以及购物信息。让我们...
java控制台输出百分比进度条示例
09-04
在Java编程中，有时我们需要在控制台上显示任务的进度，比如下载、上传或者计算等操作。这可以通过创建一个百分比进度条来实现，使用户能够直观地了解程序执行的进度。本文将详细介绍如何在Java控制台上实现一个简单...
《Web 程序设计》JAVA 版期末试卷
m0_73302939的博客
06-27 1195
A．tomcat/bin/startup.bat 文件D．以上都不选B这个文件是用来启动 Tomcat 的脚本文件。它根本不会包含 Tomcat 端口配置。这个文件是 Tomcat 的全局 Web 应用程序部署描述符。它用于定义全局的 servlet 和过滤器映射等配置，你写Servlet的时候肯定用过。D.排除这是 Tomcat 的主要配置文件，其中包括连接器的配置。要修改 Tomcat 的端口号，需要在server.xml文件中找到元素并修改其port属性。
sentinel 初步学习+控制台使用
Adda_Chen的博客
09-04 2984
资源可以是很多类型，但是经常使用的是将某个接口或者某个方法设置为资源，我们这里设置方法为资源，因为需要使用注解跟原生两种方式，所以定义两个不同的方法：/*** 方法定义于 demoService 中");} /*** 原生流控写法 - 注解方法}/*** 原生流控写法 - 耦合方法** @returnString str = "访问被保护的资源了。。";}查看机器列表以及健康情况当您在机器列表中看到您的机器，就代表着您已经成功接入控制台；如果没有看到您的机器，请检查配置，并通过。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 309
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1090
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Java控制台五子棋实现探索
在《疯狂java实战演义高清版》中，第一章以控制台五子棋为例，深入浅出地介绍了Java编程的基础知识。五子棋是一个简单却富有策略性的游戏，适合用来教学编程的基本概念和逻辑处理。在控制台环境下实现五子棋，虽然...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值