【刷题宝典NO.0】

已于 2024-07-29 22:27:36 修改
阅读量810 收藏 14
点赞数 13
分类专栏： 算法训练(不定期更) 文章标签： 算法 java 基础
于 2023-11-02 07:40:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheMyth142857/article/details/134170568
版权

计算购物款

设某商店售货，按购买货物的钱数多少分别给予不同的优惠折扣:

(1)购货不足250元的，没有折扣;

(2)购货满250元，不足500元，折扣5%;

(3)购货满500元，不足1000元，折扣7. 5%;

(4)购货满1000元，不足2000元， 折扣10%;

(5)购货满2000元，折扣15%。

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入购物款金额：");
        double amount = scanner.nextDouble();
        double discountRate = 0;
        double discountAmount = 0;
        if (amount < 250) {
            discountRate = 0;
        } else if (amount < 500) {
            discountRate = 0.05;
        } else if (amount < 1000) {
            discountRate = 0.075;
        } else if (amount < 2000) {
            discountRate = 0.1;
        } else {
            discountRate = 0.15;
        }
        discountAmount = amount * discountRate;
        double finalAmount = amount - discountAmount;
        System.out.println("购物款为：" + amount);
        System.out.println("折扣率为：" + discountRate);
        System.out.println("折扣金额为：" + discountAmount);
        System.out.println("实际支付金额为：" + finalAmount);
    }
}
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入购物款金额：");
        double amount = scanner.nextDouble();
        double discountRate = 0;
        double discountAmount = 0;
        int level = (int) (amount / 250);
        switch (level) {
            case 0:
                discountRate = 0;
                break;
            case 1:
                discountRate = 0.05;
                break;
            case 2:
            case 3:
                discountRate = 0.075;
                break;
            case 4:
            case 5:
            case 6:
            case 7:
                discountRate = 0.1;
                break;
            default:
                discountRate = 0.15;
        }
        discountAmount = amount * discountRate;
        double finalAmount = amount - discountAmount;
        System.out.println("购物款为：" + amount);
        System.out.println("折扣率为：" + discountRate);
        System.out.println("折扣金额为：" + discountAmount);
        System.out.println("实际支付金额为：" + finalAmount);
    }
}

显示系统当前时间

解题思路：

public class CurrentTime {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //自1970年1月1日零点到现在的毫秒时间（GMT）
        long currentTimeMillis = System.currentTimeMillis();
        //总秒数：
        long totalSeconds = currentTimeMillis/1000;
        //当前秒数：
        long seconds = totalSeconds%60;
        //总分钟数：
        long totalMinutes = totalSeconds/60;
        //当前分钟数：
        long minutes = totalMinutes%60;
        //总小时数：：
        long totalHours = totalMinutes/60;
        //当前小时数：
        long hours = totalHours%24;
        //东八区（UTC/GMT+08:00）是比世界协调时间（UTC）/格林尼治时间（GMT）快8小时的时区
        System.out.println("系统当前时间是："+(hours+8)+":"+minutes+":"+seconds);
    }
}

猜猜生日 

从1~31这个区间猜出你的生日：

根据五次询问生日是否在这个集合里面，输入0或者1，判断你的生日

import java.util.Scanner;
public class GuestBirthday{
        public static void main(String[] args){
                //第1位上为1的1~31间数字的集合
                String set1 = 
                " 1 3 5 7\n"+
                " 9 11 13 15\n"+
                "17 19 21 23\n"+
                "25 27 29 31";
                //第2位上为1的1~31间数字的集合
                String set2 = 
                " 2 3 6 7\n"+
                "10 11 14 15\n"+
                "18 19 22 23\n"+
                "26 27 20 31";
                //第3位上为1的1~31间数字的集合
                String set3 = 
                " 4 5 6 7\n"+
                "12 13 14 15\n"+
                "20 21 22 23\n"+
                "28 28 30 31";
                //第4位上为1的1~31间数字的集合
                String set4 = 
                " 8 9 10 11\n"+
                "12 13 14 15\n"+
                "24 25 26 27\n"+
                "28 29 30 31";
                //第5位上为1的1~31间数字的集合
                String set5 = 
                " 16 17 18 19\n"+
                "20 21 22 23\n"+
                "24 25 26 27\n"+
                "28 29 30 31";
                //定义一个变量用来存放天数
                int day = 0;
                Scanner sc = new Scanner(System.in);
                //第1次询问	
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set1);
                System.out.println("\n是，请输入1；否请输入0：");
                int answer = sc.nextInt();
                day += answer * 1;
                //第2次询问
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set2);
                System.out.println("\n是，请输入1；否请输入0：");
                answer = sc.nextInt();
                day += answer * (1<<1);
                //第3次询问
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set3);
                System.out.println("\n是，请输入1；否请输入0：");
                answer = sc.nextInt();
                day += answer * (1<<2);
                //第4次询问
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set4);
                System.out.println("\n是，请输入1；否请输入0：");
                answer = sc.nextInt();
                day += answer * (1<<3);
                //第5次询问
                System.out.println("你的生日(号数)在这个集合里面嘛？\n");
                System.out.println(set5);
                System.out.println("\n是，请输入1；否请输入0：");
                answer = sc.nextInt();
                day += answer * (1<<4);
                System.out.println("\n你的生日所在天是："+day+"号！");		
        }
}

素数的判定

题目内容：

给定一个数字，判定一个数字是否是素数

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        //方法1：让n去试除2--->n-1
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int i = 2;
//        for (; i <= n - 1; i++) {    //让n去试除2--->n-1 比如：拿7试除2，3，4，5，6，因为7不能被2--->6内的数整除，说明7是素数
//            if (n % i == 0) {
//                break;
//            }
//        }
//        if (i == n) {   //如果i增长到n了，i == n > n - 1，也可以写成i > n-1 , 说明n只能被它自己整除，即素数
//            System.out.println(n + "是素数");
//        }
        //方法2：让n去试除2--->n/2
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int i = 2;
//        for (; i <= n / 2; i++) {   //让n去试除2--->n/2，比如：16 ：1*16 2*8 4*4 总存在一个数<=2/n
//            if (n % i == 0) {
//                break;
//            }
//        }
//        if (i > n / 2) {   //如果i == (2+n)/2 > n/2 了，也可以写成i > n / 2，说明n只能被它自己整除，即素数
//            System.out.println(n + "是素数");
//        }
        //方法3：让n去试除2--->根号n
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int i = 2;
//        for (; i <= Math.sqrt(n); i++) {   //让n去试除2--->根号n，比如： 根号n * 根号n = n 总存在一个数<=根号n
//            if (n % i == 0) {
//                break;
//            }
//        }
//        if (i > Math.sqrt(n)) {   //如果i > 根号n，说明n只能被它自己整除，即素数
//            System.out.println(n + "是素数");
//        }
//    }
        //方法4：同方法3一样，多引入一个开关 在这有点多此一举
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int flag = 1;   //引入一个开关，1是素数 0不是素数
        int i = 2;
        for (; i <= Math.sqrt(n); i++) {   //让n去试除2--->根号n，比如： 根号n * 根号n = n 总存在一个数<=根号n
            if (n % i == 0) {
                flag = 0;   //如果能被整除，说明不是素数，结束本次循环
                break;
            }
        }
        if (1 == flag) {    //说明是素数
            System.out.println(n + "是素数");
        }
    }
}

 52b65791589241b8ae1752571ba85823.png

打印素数

题目内容：
打印 1 - 100 之间所有的素数，并统计素数的个数

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        //方法1：引入开关
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int count = 0;
//        int j = 2;
//        for (; j <= n; j++) {
//            int flag = 1;//引入一个开关，1是素数 0不是素数
//            int i = 2;
//            for (; i <= Math.sqrt(j); i++) {//让j去试除2--->根号j，比如： 根号n * 根号n = n 总存在一个数<=根号n
//                if (j % i == 0) {//如果能被整除，说明不是素数，结束本次循环
//                    flag = 0;
//                    break;
//                }
//            }
//            if (1 == flag) {//是素数就记录个数并打印
//                count++;
//                System.out.print(j + " ");
//            }
//        }
//        System.out.print("count = " + count);
        //方法2：改进版，将判断素数的方法封装成函数提出去
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        int i = 1;
        for (; i <= n; i++) {
            if (isPrimer(i) == 1) {
                count++;
                System.out.print(i + " ");
            }
        }
        System.out.print("count = " + count);
    }

    //判断是否为素数
    public static int isPrimer(int n) {
        int i = 2;
        for (; i <= Math.sqrt(n); i++) {   //让n去试除2--->根号n，比如： 根号n * 根号n = n 总存在一个数<=根号n
            if (n % i == 0) {
                return 0;
            }
        }
        return 1;
    }
}

756478f236494571b2916994cd1558db.png

打印水仙花数 

题目内容：

求出0～100000之间的所有“水仙花数”并输出。

“水仙花数”是指一个n位数，其各位数字的n次方之和确好等于该数本身，如:153＝1^3＋5^3＋3^3，则153是一个“水仙花数”。

public class OnlineTest {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        int i = 0;
        for (i = 0; i <= 100000; i++) {
            // 判断i是否为自幂数
            // 1. 计算i的位数
            int n = 1; // 一个数至少是一位数
            int tmp = i;
            while ((tmp /= 10) != 0) {
                n++;
            }
            // 2. 得到的i的每一位，求每一位的n次方和
            tmp = i;//刚刚是把tmp做了处理的，现在要重新赋值一次
            int sum = 0;
            while (tmp > 0) {
                sum += (int) Math.pow(tmp % 10, n);
                tmp /= 10;
            }
            if (sum == i) {
                System.out.print(i + " ");
            }
        }
    }
}

28cc0c5544a44ea1ac31713702e29344.png

百钱买百坤

public class OnlineTest {
    public static void main(String[] args) {
        //公鸡，母鸡，小鸡三个不是必须都有
        int cock, hen, chick;
        for (cock = 1; cock <= 20; cock++) {
            for (hen = 1; hen <= 33; hen++) {
                for (chick = 3; chick <= 99; chick += 3) {
                    if (cock * 5 + hen * 3 + chick / 3 == 100) {
                        if (cock + hen + chick == 100) {
                            System.out.println("公鸡：" + cock + "母鸡：" + hen + "小鸡：" + chick);
                        }
                    }
                }
            }
        }
    }
}

public class OnlineTest {
    public static void main(String[] args) {
        /*
        百钱买百鸡：
        公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱，
        用100文钱买一百只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱。
        数学：
        设未知数：
        公鸡：x只
        母鸡：y只
        小鸡：z只
        x+y+z=100只
        5x+3y+z/3=100钱
        麻烦方式：//下面那个代码不需要判断z%3==0，是因为每次z+=3，z的增长已经是三的倍数了。
        for(int x=1;x<=100;x++){
                for(int y=1;y<=100;y++){
                        for(int z=1;z<=100;z++){//可以修改为(int z=3;z<=100;z+=3),下面就不需要再z%3==0了。
                                if((x+y+z==100)&&(5*x+3*y+z/3==100)&&(z%3==0)){
                                        System.out.println(x+"\t"+y+"\t"+z);
                                }
                        }
                }
        }
        */
        //优化：
        for (int x = 1; x <= 19; x++) {//100-1-3=96,96/5=19
            for (int y = 1; y <= 31; y++) {//100-5-1=94,94/3=31
                int z = 100 - x - y;
                if ((5 * x + 3 * y + z / 3 == 100) && (z % 3 == 0)) {
                    System.out.println(x + "\t" + y + "\t" + z);
                }
            }
        }
    }
}

 629f258ee2974e21bed5a3597487f2f7.png

找最大值

题目内容：

输入n个整数，输出最大值

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入整数的个数 n: ");
        int n = scanner.nextInt();

        int[] numbers = new int[n];

        // 依次输入 n 个整数
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第 " + (i + 1) + " 个整数: ");
            numbers[i] = scanner.nextInt();
        }

        int max = numbers[0];

        // 寻找最大值
        for (int i = 1; i < n; i++) {
            if (numbers[i] > max) {
                max = numbers[i];
            }
        }

        System.out.println("输入的 " + n + " 个整数中最大的数是: " + max);
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入整数的个数 n: ");
        int n = scanner.nextInt();

        int[] numbers = new int[n];

        // 依次输入 n 个整数
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第 " + (i + 1) + " 个整数: ");
            numbers[i] = scanner.nextInt();
        }

        int max = Integer.MIN_VALUE;
        // 寻找最大值
        for (int i = 0; i < n; i++) {
            max = Math.max(max, numbers[i]);
        }

        System.out.println("输入的 " + n + " 个整数中最大的数是: " + max);
    }
}

输出闰年

题目内容：
输出 1000 - 2000 之间所有的闰年 

public class OnlineTest {
    public static boolean isLeapYear(int year) {
//        if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) {
//            return true;
//        }else{
//            return false;
//        }
        return ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0));
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        for (int year = 1000; year <= 2000; year++) {
            boolean flag = isLeapYear(year);
            if (flag) {
                System.out.println(year + "是闰年！");
            }
        }
    }
}

9301226d54fd49399f8e188713aad134.png

逆序打印一个整数的每一位

题目内容：
逆序打印一个整数的每一位，如：123的每一位是3，2，1

本题主要考虑，如何获取一个数字的每一位：
123 % 10 = 3
123/10=12 12%10=2
12/10=1 1%10= 1

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        while (n != 0) {
            System.out.print(n % 10 + " ");
            n /= 10;
        }
    }
}

d0fe914df6834ca58d26513ab4d3f5ca.png

输出乘法口诀表 

题目内容：
输出n*n的乘法口诀表，n由用户输入。

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + i * j + "\t");
            }
            System.out.println();
        }
        for (int i = n; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + i * j + "\t");
            }
            System.out.println();
        }
    }
}

 846dc06a49ed47b989e66d6cdf8da3b5.png

数字9出现的次数 

题目内容：
编写程序数一下 1到 100 的所有整数中出现多少个数字9

public class OnlineTest {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 10 == 9) {//判断个位的9
                count++;
            }
            if (i / 10 == 9) {
                count++;//判断十位的9
            }
            //多少个数字出现过9，此时99算1个数字，即一共19个
            /*if (i % 10 == 9) {//判断个位的9
                count++;
            }
            else if(i / 10 == 9) {
                count++;//判断十位的9
            }*/
        }
        System.out.println(count);
    }
}

a4263a2f356d42ccb0e63a0b9ae20954.png

二进制1的个数 

题目内容：
求一个整数，在内存当中存储时，二进制1的个数。

import java.util.Scanner;
public class OnlineTest {
    //方法1：
    /*public static int numberOf1(int n) {
        int count = 0;
        for (int i = 0; i < 32; i++) { //n可以在2进制中表示32位，每次让n无符号向右移动一位，每一位和1相与
            if (((n >>> i) & 1) == 1) {
                count++;
            }
        }
        return count;
    }*/
    //方法2：
    /*public static int numberOf1(int n) {
        int count = 0;
        *//*for (int i = 0; i < 32; i++) {
            if ((n & 1) == 1) {
                count++;
            }
            n >>>= 1;
        }*//*
        while (n != 0) {
            if ((n & 1) != 0) {
                count++;
            }
            n >>>= 1;
        }
        return count;
    }*/
    //方法3：n & (n - 1) 每次消去一个1，记录消去1的次数，直到1全部被消去变为0为止
    public static int numberOf1(int n) {
        int count = 0;
        while (n != 0) {
            n = n & (n - 1);    //n &= n - 1;
            count++;
        }
        return count;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = numberOf1(n);
        System.out.println(ret);
    }
}

8e2417259b49497ea3a7bfb90c54a33c.png

717701d90235413194b44688c895eb5c.png

输出一个整数的偶数位和奇数位的二进制序列  

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        //偶数位 下标从1开始（第二个数），每次让n右移2位让偶数位 和 1做 & 运算，如果结果是1说明当前偶数位是1，同理结果是0。。。
        for (int i = 31; i >= 1 ; i-=2) {
            System.out.print(((n >> i) & 1)+" ");
        }
        System.out.println();
        //奇数位 下标从0开始（第一个数），每次让n右移2位让奇数位 和 1做 & 运算，如果结果是1说明当前奇数位是1，同理结果是0。。。
        for (int i = 30; i >= 0 ; i-=2) {
            System.out.print(((n >> i) & 1)+" ");
        }
    }
}

bffc70fa3f804d30b27db333c7ec0bd2.png

a6123d50e1ba40e98942e616cb5ff778.png

 0a4b37185d3248e6b4c52eccae4d58f8.png 

求两个整数的最大公约数 

题目内容：
给定两个数，求这两个数的最大公约数

例如：

输入：20 40

输出：20

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        //方法1：找出m和n之间的最小值min，用m和n同时对min整除，如果同时被整除，那么这个min就是最大公约数，如果不能整除，那么就min--
        /*Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int min = m > n ? n : m;
        while (true) {
            if (m % min == 0 && n % min == 0) {
                System.out.println("最大公约数：" + min);
                break;
            }
            min--;
        }*/
        //方法2：辗转相除法 m % n = r ,如果r != 0，m = n，n = r，当r = 0时，n为最大公约数
        // 例如：m:24 n:18 第一次：m % n = 24 % 18 = 6 第二次：18 % 6 = 0，6为最大公约数
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        /*int r = m % n;
        while (r != 0) {
            m = n;
            n = r;
            r = m % n;
        }*/
        int r = 0;
        while ((r = m % n) != 0) {
            m = n;
            n = r;
        }
        System.out.println("最大公约数：" + n);
    }
}

a5d4f89bda664e68975f44837ba12031.png

求两个整数的最小公倍数 

题目内容：
给定两个数，求这两个数的最小公倍数

例如：

输入：12 15

输出：60

import java.util.Scanner;
public class OnlineTest {
    public static void main(String[] args) {
        //找出m和n之间的最大值max，用max对m和n整除，如果同时整除了m和n，那么这个max就是最小公倍数，如果不能整除，那么就max++
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int max = m > n ? m : n;//或者int max = Math.max(m, n);
        while (true) {
            if (max % m == 0 && max % n == 0) {
                System.out.println("最小公倍数：" + max);
                break;
            }
            max++;
        }
    }
}

004f50e0134b429cb02de13e7528904f.png

小乐乐与欧几里得

https://www.nowcoder.com/share/jump/4389976241698855052246

描述

小乐乐最近在课上学习了如何求两个正整数的最大公约数与最小公倍数，但是他竟然不会求两个正整数的最大公约数与最小公倍数之和，请你帮助他解决这个问题。

输入描述：

每组输入包含两个正整数n和m。(1 ≤ n ≤ 109，1 ≤ m ≤ 109)

输出描述：

对于每组输入，输出一个正整数，为n和m的最大公约数与最小公倍数之和。

示例1

输入：

10 20

输出：

30

示例2

输入：

15 20

输出：

65

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long m = scanner.nextLong();
        long n = scanner.nextLong();
        long m2 = m;
        long n2 = n;
        long r = 0;
        //最大公约数
        while ((r = m2 % n2) != 0) {
            m2 = n2;
            n2 = r;
        }
        long max = n2;
        //最小公倍数：m * n / 最大公约数
        long min = m * n / n2;
        System.out.println(max + min);
    }
}

小乐乐与进制转换

https://www.nowcoder.com/share/jump/4389976241698856221648

描述

小乐乐在课上学习了二进制八进制与十六进制后，对进制转换产生了浓厚的兴趣。因为他的幸运数字是6，所以他想知道一个数表示为六进制后的结果。请你帮助他解决这个问题。

输入描述：

输入一个正整数n  (1 ≤ n ≤ 109)

输出描述：

输出一行，为正整数n表示为六进制的结果

示例1

输入：

6

输出：

10

示例2

输入：

120

输出：

320

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int arr[] = new int[20];
        int i = 0;
        while (n > 0) {
            arr[i] = n % 6;
            n /= 6;
            i++;
        }
        for (--i; i >= 0; i--) {
            System.out.print(arr[i]);
        }
    }
}

计算分数的值

题目内容：
计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值 。

思路：
1. 从上述表达式可以分析出
   该表达式主要由100项，奇数项为正，偶数项为负
2. 设置一个循环从1~100，给出表达式中的每一项：1.0/i, 注意此处不能使用1，否则结果全部为0
  然后使用flag标记控制奇偶项，奇数项为正，偶数项为负
  然后将所有的项相加即可

public class OnlineTest {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        double sum = 0.0;
        int flag = 1;
        for (int i = 1; i <= 100; i++) {
            sum += 1.0 * flag / i;
            flag = -flag;
        }
        System.out.println(sum);
    }
}

 06cd35f6bc244e1f85bef961041c995b.png

计算求和

题目内容：

求Sn=a+aa+aaa+aaaa+aaaaa的前5项之和，其中a是一个数字，

例如：2+22+222+2222+22222

import java.util.Scanner;

public class OnlineTest {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int n = scanner.nextInt();
        int i = 0;
        int Sn = 0;
        int k = 0;
        for (i = 0; i < n; i++) {
            k = k * 10 + a;
            Sn += k;
        }
        System.out.println(Sn);
    }
}

0f16cfe1e97e447b8c0f2b6ace57fc6a.png

数列求和 

数列求和

09508f6b56e1485499d686ae7f4f3456.png

前n（n<=20）项之和。（不使用if…else等选择分支语句）
思路：
1.推导公式：

0b8b2efd1a534dbdbca5ef43d215e2cc.png

2.每次循环累加的时候符号要变换，引入一个开关，控制正负号
3.在循环里面的时候a的值每次还要减a，不然a会一直累加，a的值是相对于上个式子的b基础上+1的

import java.util.Scanner;
public class Main {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        //b/a == b=a+b/a=b+1
        double b = 2; //起始分子
        double a = 1; //起始分母
        double sum = 0.0;
        int flag = 1;
        for (int i = 0; i < n; i++) {
            sum += 1.0 * flag * b / a; //累加
            b += a;  //分子
            a = b + 1 - a;  //分母 注意这儿每次循环要-a，因为每次循环分母a的值会累加，a的值是相对于上个式子的b基础上+1
            flag = -flag;
        }
        System.out.println(sum);
    }
}

 0310e6243f554d9b951a8699f073a588.png

打印各种图案

打印长方形

7eea04fb926e4dc7bc9f4438f270de5c.png

public class OnlineTest {
    public static void main(String[] args) {
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //*********
            for (int i = 1; i <= 9; i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

9d9f97b6e7a34b92bd33403d2d31ae4a.png

打印距离前面有一定空隙的长方形

0979c3f91034447daa5566b06571d037.png

public class OnlineTest {
    public static void main(String[] args) {
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= 5; i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= 9; i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

f272f659fb394adf86e7903432717ecd.png

打印空心正方形

https://www.nowcoder.com/share/jump/1698854024034

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的“空心”正方形图案。

输入描述：

多组输入，一个整数（3~20），表示输出的行数，也表示组成正方形边的“*”的数量。

输出描述：

针对每行输入，输出用“*”组成的“空心”正方形，每个“*”后面有一个空格。

示例1

输入：

4

输出：

* * * * 
*     * 
*     * 
* * * *

示例2

输入：

5

输出：

* * * * * 
*       * 
*       * 
*       * 
* * * * * 
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if ((i == 0) || (i == n - 1) || (j == 0) || (j == n - 1))
                        System.out.print("* ");
                    else
                        System.out.print("  ");
                }
                System.out.println();
            }
        }
        scanner.close();
    }
}

打印 X 图形 

https://www.nowcoder.com/practice/83d6afe3018e44539c51265165806ee4

描述

KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的X形图案。

输入描述：

多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。

输出描述：

针对每行输入，输出用“*”组成的X形图案。

示例1

输入：

5

复制输出：

*     *
  * *
   * 
  * *
*    *

复制

示例2

输入：

6

复制输出：

*        *
  *    *
   * * 
   * * 
  *   *
*       *

import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n  = in.nextInt();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if ((i == j) || (i + j == n - 1)) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
                System.out.println();
            }
        }
    }
}

打印平行四边形

23ebc3d0e56548daa62babc6e7fc4cf4.png

public class OnlineTest {
    public static void main(String[] args) {
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (9 - j); i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= 9; i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

94cb15a7ca944d99a3808aebad69fa47.png

打印三角形

592a97074f994b3bba39ecebab98d605.png

public class OnlineTest {
    public static void main(String[] args) {
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (9 - j); i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= (2 * j - 1); i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

8ada18b9f782475c9e2dba361b1e6de1.png

打印菱形

52a15e17d15b4048b0fc7e57935fb465.png

public class OnlineTest {
    public static void main(String[] args) {
        //上面三角形：
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (9 - j); i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= (2 * j - 1); i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }

        //下面三角形：
        for (int j = 1; j <= 3; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (j + 5); i++) {//i:控制空格的个数
                System.out.print(" ");
            }
            //*********
            for (int i = 1; i <= (7 - 2 * j); i++) {//i:控制*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();
        }
    }
}

d7ca106188364222a18c9ee4cb419aa5.png

public class OnlineTest {
    public static void main(String[] args) {
        //先打印出一个正方形，然后某些位置上打印* 某些位置上打印空格：
        int size = 17;
        int startNum = size / 2 + 1;//起始列号
        int endNum = size / 2 + 1;//结束列号
        //引入一个布尔类型的变量---》理解为“开关”
        boolean flag = true;
        for (int j = 1; j <= size; j++) {
            //*****
            for (int i = 1; i <= size; i++) {
                if (i >= startNum && i <= endNum) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            //换行
            System.out.println();
            if (endNum == size) {
                flag = false;
            }

            if (flag) {//flag是true相当于在菱形的上半侧   flag是false相当于在菱形的下半侧
                startNum--;
                endNum++;
            } else {
                startNum++;
                endNum--;
            }
        }
    }
}

 2a0701a23c70490fb05c3d158cd7e511.png

打印空心菱形 

4f18d12a936d4142a512d85051cb1990.png

public class OnlineTest {
    public static void main(String[] args) {
        //先打印出一个正方形，然后某些位置上打印* 某些位置上打印空格：
        int size = 17;
        int startNum = size / 2 + 1;//起始列号
        int endNum = size / 2 + 1;//结束列号
        //引入一个布尔类型的变量---》理解为“开关”
        boolean flag = true;
        for (int j = 1; j <= size; j++) {
            //*****
            for (int i = 1; i <= size; i++) {
                if (i == startNum || i == endNum) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            //换行
            System.out.println();
            if (endNum == size) {
                flag = false;
            }

            if (flag) {//flag是true相当于在菱形的上半侧   flag是false相当于在菱形的下半侧
                startNum--;
                endNum++;
            } else {
                startNum++;
                endNum--;
            }
        }
    }
}

 6ad94c2db9b24410ac4fd49ce4335b9a.png

小乐乐走台阶

https://www.nowcoder.com/share/jump/4389976241698854945904

描述

小乐乐上课需要走n阶台阶，因为他腿比较长，所以每次可以选择走一阶或者走两阶，那么他一共有多少种走法？

输入描述：

输入包含一个整数n (1 ≤ n ≤ 30)

输出描述：

输出一个整数，即小乐乐可以走的方法数。

示例1

输入：

2

输出：

2

示例2

输入：

10

输出：

89

import java.util.Scanner;

public class Main {
    public static int walk(int n) {
        if (n <= 2) {
            return n;
        } else {
            return walk(n - 1) + walk(n - 2);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = walk(n);
        System.out.println(ret);
        scanner.close();
    }
}

斐波那契数列 

题目内容：
求斐波那契数列的第n项。(迭代实现)


斐波那契数列定义为：1 1 2 3 5 8 13 21 我们可以看到，从第3项开始，都等于前一项+前一项的前一项的和。
3=1+2
5+2+3
13 = 5+8
我们可以先定义f1保存第一项的值，f2保存第2项的值，f3保存第3项的值。
每次算法一个f3，就同步更新f1和f2的值。

import java.util.Scanner;
public class OnlineTest {//1.递归实现斐波那契数列
    public static int fib1(int n) {
        if (n <= 2) {
            return 1;
        } else {
            return fib1(n - 1) + fib1(n - 2);
        }
    }
    //2.       fib: 1   1   2   3   5
    //              a + b = c
    //                  a + b = c
    //          n: 1   2   3   4   5
    //                     n = 3，即n > 2时，有 c = a + b ; a = b ; b = c
    public static int fib2(int n) {
        int a = 1;
        int b = 1;
        int c = 0;
        while (n > 2) {//从第三项开始
            c = a + b;
            a = b;
            b = c;
            n--;
        }
        return c;
    }
    public static int fib3(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        int f1 = 1;
        int f2 = 1;
        int f3 = 0;
        for (int i = 3; i <= n; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int ret1 = fib1(n);
        int ret2 = fib2(n);
        int ret3 = fib3(n);
        System.out.println("递归实现：" + ret1);
        System.out.println("--------------");
        System.out.println("非递归实现：" + ret2);
        System.out.println("非递归实现：" + ret3);
    }
}

 1e0ae15494934b65870a02b1fb9615f0.png

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(fib(n));
    }

    public static int fib(int n) {
        if (n <= 2) {
            return n;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

递归实现n的k次方 

public class OnlineTest {
    public static void main(String[] args) {
        int n = 2;
        int k = -1;
        System.out.println(power(n, k));
    }
    public static double power(int n, int k) {
        if (k == 0) {
            return 1;
        } else if (k > 0 ){
            return n * power(n, k - 1);
        } else {//k < 0
            return 1.0 / power(n, -k);
        }
    }
}

3ecf4a90f5854a188d84bc4d7310263f.png

递归求 N 的阶乘

题目内容：
递归求 N 的阶乘
递归代码重要的是推导递推公式：假设N的阶乘用F(n)表示，那么F(n) = n * F(n-1);

import java.util.Scanner;
public class OnlineTest {
    public static int fac(int n) {
        if(n < 2) {
            return 1;
        }
        return n * fac(n-1);
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(fac(n));
    }
}

fd01ab29ab3a4b8aaf78602d6ef67006.png

递归求和 

题目内容：
递归求 1 + 2 + 3 + ... + 10

假设用F(n) 代表1-n的和，那么F(n) = n + F(n-1)的和
F(n-1)就是1到n-1的和

import java.util.Scanner;
public class OnlineTest {
    public static int sum(int n) {
        if(n == 1) {
            return 1;
        }
        return n + sum(n-1);
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(sum(n));
    }
}

8406fa4b598c496eb5b440dd364b08d3.png

递归打印数字的每一位 

题目内容：
按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4) （递归）
假设用F(n) 代表 要顺序打印n的每一位，如果n是一个1位数，直接输出，如果n是2位数以上。
如：
123 相当于先打印12的每一位，再打印3
12 相当于先打印1的每一位，再打印2
1 只有一位数，直接打印。
依次回退打印完，每一位即可。

public class OnlineTest {
    //写法1：
    public static void print(int num) {
        if (num > 9) {
            print(num / 10);
        }
        System.out.println(num % 10);
    }
    //写法2：
    public static void fun(int n) {
        if (n <= 9) {
            System.out.println(n);
            return; //出口，不然会栈溢出错误（必须由程序员解决）
        }
        fun(n / 10);
        System.out.println(n % 10);
    }
    public static void main(String[] args) {
        fun(1234);
        System.out.println("-----");
        print(1234);
    }
}

 f71e157c2da24de09cf42e67d757479f.png

递归返回的数字之和 

题目内容：
写一个递归方法，输入一个非负整数，返回组成它的数字之和

要计算123的每一位，主要在于如何得到每一位。在前面的习题中我们知道，除10 ， 模10.可以做到。
如下图，在执行n=123的时候，先执行add(123/10)也就是add(12)这个函数，等最后回来之后，才会把n=123时候的n%10算完。

public class OnlineTest {
    public static int digitSum(int n) {
        if (n <= 9) {
            return n;
        }
        // >9 只能是两位数
        return n % 10 + digitSum(n / 10);
    }
    //只是判断条件做了下调整
    public static int digitSum2(int n) {
        if (n >= 10) {
            return n % 10 + digitSum2(n / 10);
        }
        // <10 只能是一位数
        return n;//或者也可以return n % 10，因为任何一个数n % m，结果一定是在[0,m-1]之间，但是没必要
    }
    public static void main(String[] args) {
        System.out.println(digitSum(123));
        System.out.println(digitSum2(123));
    }
}

TheMythWS
关注
专栏目录
【刷题宝典NO.2】
TheMyth142857的博客
10-30 683
如果 Bob 拿走前 3 颗，那么剩下的是 [4,5]，Alice 拿走后 5 颗赢得 10 分。如果 Bob 拿走后 5 颗，那么剩下的是 [3,4]，Alice 拿走后 4 颗赢得 9 分。这表明，取前 5 颗石子对 Alice 来说是一个胜利的举动，所以返回 true。注意，要求返回第三大的数，是指在所有不同数字中排第三大的数。Alice 先开始，只能拿前 5 颗或后 5 颗石子。假设他取了前 5 颗，这一行就变成了 [3,4,5]。如果喝掉了水瓶中的水，那么水瓶就会变成空的。
【刷题宝典NO.1】
TheMyth142857的博客
10-29 784
你和你的朋友，两个人一起玩桌子上有一堆石头。你们轮流进行自己的回合，。每一回合，轮到的人拿掉 1 - 3 块石头。拿掉最后一块石头的人就是获胜者。假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为n的情况下赢得游戏。如果可以赢，返回true；否则，返回false。
【刷题宝典NO.3】
TheMyth142857的博客
10-20 742
输入：nums = [0,0,1,1,1,2,2,3,3,4] 输出：5, nums = [0,1,2,3,4] 解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。**输入：**nums = [3,2,2,3], val = 3 **输出：**2, nums = [2,2] **解释：**函数应该返回新的长度。
刷题必备宝典
Closure
03-16 438
基本操作 #include <bits/stdc++.h> 宏定义 #define FF(a,b) for(int a=0;a<b;a++) #define F(a,b) for(int a=1;a<=b;a++) #define LEN 200 #define INF ((1<<30)-1) #define bug(x) cout<<#x&lt...
【PAT刷题甲级】1057.Stack
C_greenbird的博客
09-19 264
1057 Stack (30 分) Stack is one of the most fundamental data structures, which is based on the principle of Last In First Out (LIFO). The basic operations include Push (inserting an element onto the top position) and Pop (deleting the top element). Now you
我是怎么学习的No.27
u010459192的博客
07-13 118
我是小蕉。今天分享分享我自己的学习经历，如果能帮到大家就更好了。目前我接触的领域只有两个，JAVA和大数据，所以也只能从这两个领域来跟大家分享学习的路径。当初没什么人指导...
Android开发：使用Viewpager模仿驾考宝典试卷答题界面
小五博客园
10-14 4686
目录 引言 效果图 一、activity页实现 二、activity对应的layout页面布局 三、ExamPaperNoAnswerDetailFragment页代码实现 四、ExamPaperNoAnswerDetailFragment页对应的layout页面 五、ExamPaperNoAnswerViewPagerAdapter代码实现 六、总结 引言 最近，公司...
C语言牛客网（NowCoder)刷题篇
m0_68931081的博客
08-25 449
牛客网刷题篇
源码解析 Handler 面试宝典
2401_85377184的博客
07-17 892
意思就是Message 会持有当前的handler，handler 已经成为了massage的一部分，假如我设置一个消息需要等待20分钟后执行，那么就意味，我的message会一直等待20分钟之后才会执行，message 持有 handler，handler 持有 (this)activity，这样就导致GC无法回收，JVM 通过可达性算法，告诉我们，没法到达，就无法回收。，this 就是上下文，唯一的ThreadLocal key，key 唯一了，那么value 也就是唯一的，
【Codeforces高效刷题宝典】：系统规划算法训练，提升解题能力
[【Codeforces高效刷题宝典】：系统规划算法训练，提升解题能力](https://cdn.hackr.io/uploads/posts/attachments/1669727683bjc9jz5iaI.png) # 1. 算法竞赛与Codeforces平台介绍 ## 算法竞赛的内涵与魅力 算法...
中高级前端面试宝典之浏览器篇
学骑扫把的小女巫
03-03 1822
总结了各个大厂的中高级前端面试题，然后进行分门别类整理，将知识点划成一整块一整块的，便于理解记忆和查询
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 2984
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
redis5-0-7-版本集群liunx部署简易流程(1)
didi558的博客
04-20 192
cluster-enabled yes #启用集群模式 cluster-node-timeout 5000 #超时时间 appendonly yes # 是否启用aof daemoni Java开源项目【ali1024.coding.net/public/P7/Java/git】 ze yes #后台运行 protected-mode no #非保护模式 cluster-config-file nodes.conf # redis启动自己创建 pidfile /var/run/redis_6379.pid
PCA（主成分分析）算法的应用场景
huanfeng_AI的博客
11-09 604
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
STL set
hls0611的博客
11-09 263
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
0-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
最新发布
太极生两鱼
11-12 111
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1475
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
洛谷 P2239 [NOIP2014 普及组] 螺旋矩阵
jzwalliser的博客
11-09 1189
本文由Jzwalliser原创，发布在CSDN平台上，遵循CC 4.0 BY-SA协议。因此，若需转载/引用本文，请注明作者并附原文链接，且禁止删除/修改本段文字。
算法每日双题精讲——双指针（有效三角形的个数，和为s的俩个数）
A Charmer 的博客
11-09 1270
本文围绕算法中的双指针技巧，详细讲解了 “有效三角形的个数” 和 “和为 s 的俩个数” 两道题目。对于 “有效三角形的个数”，通过排序数组后利用双指针遍历统计满足条件的三元组；“和为 s 的俩个数” 则是先排序，再用双指针找到和为目标值的两个数的下标。文中给出了 C++ 代码实现，并分析了每道题的时间复杂度和空间复杂度，最后强调双指针算法在解决数组问题中的优势，鼓励读者在算法学习中掌握该技巧。
LintCode题解大全：Java版求职刷题宝典
LintCode题解是一份针对Java程序员的编程题目集锦，旨在帮助求职者提升技能，熟悉面试过程中的常见算法问题。该题解涵盖了多个主题，包括数据结构（如链表、数组）、排序算法（如归并排序、快速排序）、递归与动态...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TheMythWS

你的鼓励，我的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值