数组作业（java）及答案

最新推荐文章于 2024-04-29 10:26:57 发布
最新推荐文章于 2024-04-29 10:26:57 发布
阅读量4.3k 收藏 9
点赞数 1
分类专栏： 计算机知识 作业练习 java 文章标签： 散列表 数据结构 java 开发语言 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45986314/article/details/122420179
版权
java 同时被 3 个专栏收录
55 篇文章 18 订阅
订阅专栏
计算机知识
16 篇文章 0 订阅
订阅专栏
作业练习
10 篇文章 1 订阅
订阅专栏

数组作业

  • 填空题
  1. 数组会在内存中开辟一块____连续____的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。
  2. 要获取一个数组的长度，可以通过___length____属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。
  3. ___声明数组____仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。
  4. 创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是__ __null_____。
  5. 在Java中有二维数组int [ ] [ ] array={{1,2,3},{4,5}} ，可以使_____  array[0].length______得到二维数组中第二维中第一个数组的长度。

  • 选择题

1.

在Java中，以下程序段能正确为数组赋值的是（  AD  ）。（选择二项）

A

int a[]={1,2,3,4};

B.

int b[4]={1,2,3,4};

C.

int c[];c={1,2,3,4};

D.

int d[];d=new int[]{1,2,3,4};

2.

数组元素的索引可以是（  D  ）。（选择一项）

A

整型常量

B.

整型变量

C.

整型表达式

D.

以上都可以

3.

已知表达式int [] m={0,1,2,3,4,5,6};下面（  B  ）表达式的值与数组最大下标数相等。（选择一项）

A

m.length()

B.

m.length-1

C.

m.length()+1

D.

m.length+1

4.

在Java中，以下定义数组的语句正确的是（   CD   ）。（选择二项）

A

int  t[10]=new int[ ];

B.

char [ ]a=”hello”;

C.

String [ ] s=new String [10];

D.

double[ ] d [ ]=new double [4][ ];

5.

在Java中,下面代码的输出结果为（   A  ）。（选择一项）

public static void main(String[] args) {

                 int[] arrA = { 12, 22, 8, 49, 3 }; 

                 int k = 0;                

int len = arrA.length; //5

                 for (int i = 0; i < len; i++) { //3,8,12,22,49

                         for (int j = i + 1; j < len; j++) {

                                  if (arrA[i] > arrA[j]) {

                                          k = arrA[i];

                                          arrA[i] = arrA[j];

                                          arrA[j] = k;

                                  }

                         }

                 }

                 for (int i = 0; i < arrA.length; i++) {

                         System.out.print(arrA[i]);

                         if (i < arrA.length - 1) {

                                  System.out.print("，");

                         }

                 }

}

A

3，8，12，22，49

B.

12，22，8，49，3

C.

49，22，12，8，3

D.

编译错误

9.

以下选项中能够正确创建一个数组的是（  AD  ）。（选择二项）

A.

float []f[] = new float[6][6];

B.

float f[][] = new float[][];

C.

float [6][]f = new float[6][6];

D.

float [][]f = new float[6][];

  • 判断题
  1. 数组可以声明为任何数据类型，包括任何基本数据类型和引用数据类型。（   T   ）
  2. 数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。但是其元素类型可以是不同类型，允许出现混合类型。（  F  ）
  3. 声明数组并分配空间后，数组的每个元素将会赋予初始值。（   T   ）
  4. 创建数组后，系统会给每个数组元素一个默认值，如double型元素的默认值是0.0。（  T  ）
  5. 数组的主要优点是按照索引查找某个元素效率高，同时按照元素值查询某个元素效率也很高，但是添加和删除元素需要大量移动元素，效率低下。（T）

数组的特点：查询快、增删慢   集合

      可以利用偏移地址来访问元素，效率高；可以利用折半方法查找元素，效率较高

查询快，增删慢

  1. 数组的某个元素被传递给一个方法并被该方法修改，当被调用方法执行完毕时，这个元素中含有修改过的数值。（  T   ）
  2. Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。（  T  ）
  3. 对于数组int[][] t={{1,2,3},{4,5,6}}来说，t.length等于3，t[0].length等于2（   F   ）

  • 简答题

1、数组的特点

数组是可以保存一组数据的一种数据结构，它本身也会占用一个内存地址，因此数组是引用类型

一个数组中只能保存一种类型的数据，可以保存基本类型，也可以保存Object。一个int,一个String是不能同时保存在一个数组内的(如果是对象型数组，注意存放的每一个对象都必须被实例化)。数组的长度规定好即固定，无论其保存的数据是否填满数组，数组一旦定义好就不可以修改长度，如果要修改就必须重新定义一个新数组或者引用其他的数组，因此数组的灵活性较差，数组拥有边界检查，尝试获取不在数组范围内的值时，会抛出ArrayIndexOutOfBoundsException异常

2、数组的优缺点

优点：使用方便，查询效率比链表高，内存唯一连续的区域缺点：大小固定，不适合动态存储，不方便动态添加

3、冒泡排序的算法。

按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束

  • 编码题

1、数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

import java.util.Scanner;
public class Test1 {
    // 思路：遍历数组时当有值与输入字符串相同时使用一个boolean记录状态
    public static void main(String[] args) {
        String[] strArr = new String[10];
        strArr[0] = "wade";
        strArr[1] = "james";
        strArr[2] = "kobe";
        strArr[3] = "harden";
        strArr[4] = "durante";
        strArr[5] = "curry";
        strArr[6] = "paul";
        strArr[7] = "george";
        strArr[8] = "work";
        strArr[9] = "lowry";
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入需要查找的NBA球星:");
        String inputStr = sc.next();
        boolean flag = false;
        for (int i = 0; i <= 9; i++) {
            if (strArr[i].equals(inputStr)) {
                flag = true;
            }
        }
        if (flag) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

2、数组逆序操作：定义长度为10的数组，将数组元素对调，并输出对调前后的结果。

      思路：把0索引和arr.length-1的元素交换，把1索引和arr.length-2的元素交换…..

      只要交换到arr.length/2的时候即可。

public class Test2{
    public static void main(String[] args) {
        //定义一个数组，并进行静态初始化。
        int[] arr = {12,15,85,36,42,59,33,62,29,76};
        //逆序前
        System.out.println("逆序前：");
        printArr(arr);
        //逆序后
        System.out.println("逆序后：");
        reverseArr(arr);
        printArr(arr);
    }
    public static void reverseArr(int[] arr) {
        for(int x=0; x<arr.length/2; x++) {
            int temp = arr[x];
            arr[x] = arr[arr.length-1-x];
            arr[arr.length-1-x] = temp;
        }
    }
    //遍历数组
    public static void printArr(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) { //这是最后一个元素
                System.out.println(arr[x]+"]");
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}

3、合并数组操作：现有如下一个数组：   int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}   要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为： int newArr [] ={1,3,4,5,6,6,5,4,7,6,7,5}  

思路： 确定出不为0的个数，这样可以开辟新数组；从旧的数组之中，取出内容，并将其赋给新开辟的数组。如果判断到0,就使用continue关键字。

public class Test3{
    public static void main(String[] args) {
        int oldArr[] = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
        int newArr[] = selectArr(oldArr);
        for (int i =0;i<newArr.length;i++) {
            System.out.print(newArr[i]+" ");
        }
    }

    public static int[] selectArr(int[] arr) {
        // 1.计算数组中元素不为0的个数
        int count = 0;
        for (int i = 0;i<arr.length;i++) {
            if (arr[i] != 0) {
                count++;
            }
        }

        int newArr[] = new int[count];
        int size = 0;
        for (int i = 0;i<arr.length;i++) {
            if (arr[i] != 0) {
                newArr[size] = arr[i];
                size++;
            }
        }
        return newArr;
    }
}

4、二分法查找操作：使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。

      分析：二分法查找的前提是数组有序。

      假如有一组数为3，12，24，36，55，68，75，88要查给定的值24.可设三个变量front，                mid   ，end分别指向数据的上界，中间和下界，mid=（front+end）/2.　　

      1)开始令front=0（指向3），end=7（指向88），则mid=3（指向36）。因为mid>x，故应在前           半段中查找。

      2)令新的end=mid-1=2，而front=0不变，则新的mid=1。此时x>mid，故确定应在后半段中查             找。

     3)令新的front=mid+1=2，而end=2不变，则新mid=2，此时a[mid]=x，查找成功。

     4）如要查找的数不是数列中的数，例如x=25，当第三次判断时，x>a[mid]，按以上规律，令              front=mid+1，即front=3，出现front>end的情况，表示查找不成功。

public class Test4 {
    public static void main(String[] args) {
        int[] array = {3,12,24,36,55,68,75,88};
        System.out.println(searchLoop(array, 24));
    }
    /**
     * 循环二分查找，返回第一次出现该值的位置
     * @param array 已排序的数组
     * @param findValue   需要找的值
     * @return 值在数组中的位置，从0开始。找不到返回-1
     */
    public static int searchLoop(int[] array, int findValue) {
        // 如果数组为空，直接返回-1，即查找失败
        if (array == null) {
            return -1;
        }
        // 起始位置
        int front = 0;
        // 结束位置
        int end = array.length - 1;
        while (front <= end) {
            // 中间位置
            int middle = (front + end) / 2;
            // 中值
            int middleValue = array[middle];
            if (findValue == middleValue) {
                // 等于中值直接返回
                return middle;
            } else if (findValue < middleValue) {
                // 小于中值时在中值前面找
                end = middle - 1;
            } else {
                // 大于中值在中值后面找
                front = middle + 1;
            }
        }
        // 返回-1，即查找失败
        return -1;
    }
}

5、二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和：
     int[][] b={{11},{21,22},{31,32,33}}

public class Test5 {
    public static void main(String[] args) {
        int sum=0;
        int[][] b={{11},{21,22},{31,32,33}};
        for(int i=0;i<b.length;i++){
            for(int j=0;j<b[i].length;j++){
                sum += b[i][j];
            }
        }
        System.out.println(sum);
    }
}
  • 可选题

1、题目：输入某年某月某日，判断这一天是这一年的第几天？

分析：以3月5日为例，先把前两个月的加起来，然后再加上5天即本年第几天，特殊情况，闰年且输入月份大于3需考虑多加一天。可定义数组存储1-12月各月天数。

import java.util.Scanner;
public class Test6 {
    public static void main(String[] args) {
        Scanner scanner1 = new Scanner(System.in);
        System.out.print("输出今年是第几年");
        int year = scanner1.nextInt();
        System.out.print("输出今年是第几月");
        int month = scanner1.nextInt();
        System.out.print("输出今年是第几日");
        int day = scanner1.nextInt();
        int daynum = 0; // 天数
        //一年365天
        int[] month1 = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 };
        //闰年366天
        if ((year % 400 == 0) ||( year % 100 != 0 && year % 4 == 0)){
            month1 = new int[] { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 }; // 闰年里的每个月的天数
        }
        //判断这一天是第几天
        for (int index = 1; index <= month; index++) {
            if (index == 1) {
                daynum = day;
            } else {
                daynum += month1[index - 2];
            }
        }
        System.out.println("这一天是这一年的第" + daynum + "天！");
    }
}

2、使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。使用递归实现

import java.util.Scanner;
public class Test7 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        System.out.println(searchRecursive(array, 0, array.length - 1, n));
    }
    public static int searchRecursive(int[] array, int start, int end, int findValue) {
        // 如果数组为空，直接返回-1，即查找失败
        if (array == null) {
            return -1;
        }
        if (start <= end) {
            // 中间位置
            int middle = (start + end) / 1;
            // 中值
            int middleValue = array[middle];
            if (findValue == middleValue) {
                // 等于中值直接返回
                return middle;
            } else if (findValue < middleValue) {
                // 小于中值时在中值前面找
                return searchRecursive(array, start, middle - 1, findValue);
            } else {
                // 大于中值在中值后面找
                return searchRecursive(array, middle + 1, end, findValue);
            }
        } else {
            // 返回-1，即查找失败
            return -1;
        }
    }
}

3、 数组A：1，7，9，11，13，15，17，19；数组b：2，4，6，8，10   

 两个数组合并为数组c，按升序排列。 

public class Test8 {
    public static void main(String[] args) {
        int[] A = new int[]{1, 7, 9, 11, 13, 17, 19};
        int[] B = new int[]{2, 4, 6, 8, 10};
        int[] C = chongzu(A, B);
        BubbleSort(C);
        printArray(C);
    }
    public static int[] chongzu(int src1[], int src2[]) {
        int len = src1.length + src2.length; // 新数组的大小
        int arr[] = new int[len]; // 新数组
        for(int i = 0; i < src1.length; i ++) {
            arr[i]=src1[i];
        }
        for(int i1 = 0; i1 < src2.length; i1 ++) {
            arr[src1.length+i1]=src2[i1];
        }
        return arr;
    }

    public static void BubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {//外层循环控制排序趟数
            for (int j = 0; j < arr.length - i - 1; j++) {//内层循环控制每一趟排序多少次
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }


    public static void printArray(int[] arr){
        for(int i=0;i<arr.length;i++){
            if(i==0){
                System.out.print("["+arr[i]+",");
            }else if(i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
    }
}

L缶神
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java数组作业
09-16
请参照String类，对一个封装了字节数组的类提供如下函数 public class MyByteArray { private byte[] data; public MyByteArray(byte[] data) { this.data = data; } //返回字节数据b在字节数组中的位置 public int indexOf(byte b) { } //合并两个字节数组对象 public MyByteArray concat(MyByteArray another) { } //返回部分字节数组 public MyByteArray subByteArray(int beginIndex, int endIndex) { } //返回部分字节数组 public MyByteArray subByteArray(int beginIndex) { } //返回封装的字节数组 public byte[] getByteArray() { } //读取字节数组中某个位置的值 public byte byteAt(int index) { } //修改某个位置的字节数据 public void setByteAt(int index, byte b) { } //返回字节数组中的数据，用字符串形式输出 public String toString() { } }
14 数组
qq_53537301的博客
03-21 739
数组 数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成 其中,每一个数据称作一个数组元素每个数组元素可以通过一个下标来访问它们 数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下: dataType[] array
JAVA程序设计 数组作业
qq_64246637的博客
10-13 486
【代码】JAVA程序设计 数组作业。
Java常见数组练习题及答案
alkaid001的博客
01-10 531
println("请输入第" + (i + 1) + "行" + (j + 1) + "列的数：");.println("请输入第"+(i+1)+"行"+(j+1)+"列的数：");.println("请输入第"+(i+1)+"行"+(j+1)+"列的数：");.println("请输入第"+(i+1)+"行"+(j+1)+"列的数：");.println("请输入第"+(i+1)+"行"+(j+1)+"列的数：");.println("请输入第"+(i+1)+"行"+(j+1)+"列的数：");
Java数组作业题
PPDY93的博客
11-15 807
计算一维数组中最大值和最小值的数据之和; package org.oracle.test; public class Arr01 { public static void main(String[] args) { int[] arr = { 6, 3, 2, 7, 9, 1, 5, 4, 4, 4, 10, 9 }; int max = arr[0]; int min = arr[0]; for (int i = 1; i < arr.length; i++) { if.
Java 方法与数组作业
qq_41268108的博客
10-14 421
1. 使用for循环打印乘法口诀表 public class Example{ public static void main(String [] args){ for(int i=1;i&lt;=9;i++){ for(int j=1;j&lt;=i;j++){ int result=i*j; ...
Java入门第35课——数组作业
Java学习博客
05-19 603
1.int[]是一种数据类型吗？ 2.使用两种方式，初始化数组arr的长度为4 3.查询数组最小值，并将数组扩容形成新数组 创建程序，实现查询数组中最小值的功能，并将最小值放入数组的第一位。需求为：创建一个长度为10的数组，数组内放置10个0到99之间(包含0，包含99)的随机整数作为数组元素，要求查询出数组中的最小值，并打印显示在界面上。然后，将数组的长度扩容为11，将查询到的数组...
5.数组作业答案1
08-08
} } }}现在有如下的一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} 要求将以上数组中值为
Educoder头歌实践平台 Java 数据结构之图 答案.txt
11-10
Educoder头歌实践平台 中 Java 数据结构之图 共4关 金币共2300 的那个实践项目答案 由于图论问题渗透整个计算机科学，图算法对于计算机学科至关重要。成百上千的计算问题最后都可以归约为图论问题。
达内 coreJava 习题答案
02-10
import java.util.Scanner; class Bissextile{ public static void main(String[] arge){ System.out.print("请输入年份"); int year; //定义输入的年份名字为“year” Scanner scanner = new Scanner(System.in...
Java数组练习题(带答案).doc
03-15
Java数组阶段的选择题、填空题、编程题、判断题都有，适合想自己测试下的学生以及准备出题的老师
java一维数组课程作业
05-31
用java实现了一个一维数组类。包括加和、最值、归并排序等
java语言与面向对象程序设计作业题与参考答案汇编.doc
05-29
答案：错误 JAVA语言与面向对象程序设计作业2 单项选择题 第1题 下面的语句的作用是：（）。 Vector MyVector = new Vector(100,50); A、创建一个数组类对象MyVector，有100个元素的空间，每个元素的初值为50 B、...
Java.First.GeekBrains.HomeTaskThirdLesson:Java第三课的作业
04-29
Java.First.GeekBrains.HomeTaskThirdLesson Java第三课的作业家庭作业的第三稿。 任务： 创建单词数组String [] words = {“苹果”，“橙色”，“柠檬”，“香蕉”，“杏”，“鳄梨”，“西兰花”，“胡萝卜”，...
（39）4.29数据结构（栈，队列和数组）栈
最新发布
2302_81921490的博客
04-29 365
/****做题的时候一定要注意top指针指向的位置，看看是指向栈顶元素还是指向栈顶元素后面一个位置****///////声明一个顺序栈(分配空间）//先出栈，指针再减一。//静态数组存放栈中元素。
《数据结构》C语言版 (清华严蔚敏考研版） 第二章 线性表知识梳理与总结
路漫漫其修远兮，吾将上下而求索。小手点一波关注进阶的李仙桎，我们一起携手进步，
04-28 1340
线性表是数据结构的一种，它是一组具有相同数据类型的数据元素的有限序列。在线性表中，除了第一个和最后一个数据元素之外，每个数据元素均只有一个直接前驱和一个直接后继。线性表的元素个数n（n≥0）定义为线性表的长度，当n=0时，称为空表。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链表的形式存储线性表的抽象数据类型定义ADT List{数据对象:D={ai|aiEElemSet.i=1,2,…,n,n≥0} //任意数据元素的集合。
深入探索 Python 中的动态数组：实现、操作、优化及其与传统数组和其他数据结构的性能比较
lph159的博客
04-29 1350
本文详细探讨了 Python 中动态数组的实现及其核心特性，特别是 Python 列表如何在运行时动态调整大小以适应不断变化的数据需求。我们首先介绍了动态数组的概念及其与传统静态数组的差异，着重于 Python 列表的动态性和灵活性。文章进一步深入讨论了列表的内部结构，如何在内存中表示，以及在需要时如何自动扩展其容量。此外，对列表进行元素添加、删除、访问和调整大小等操作的时间复杂度进行了分析，展示了这些操作的效率和实际应用中的表现。
数据结构：初识集合框架
li_wj6的博客
04-26 789
初入数据结构
数据结构篇其二---单链表（C语言+超万字解析）
2303_79972050的博客
04-26 692
单链表，这里不带头节点，只有头指针。单链表篇-------我认为单链表帮我深入理解指针和结构体；指针部分：1.传值和传址调用2.涉及到二级指针结构体部分：结构体自引用；结构体指针；由一的引入，可以说链表是由一个个结点组成的有序集合。首先，链表是一种线性表。线性表有逻辑结构和物理结构的特点，那么链表呢？链表：逻辑结构：连续（线性），满足线性表的定义。物理结构：不连续（非线性）。那么我们就可以借此画图分析了，即逻辑图和物理图。
java数组方法习题及答案
08-01
Java数组方法习题及答案 1. 编写一个方法，接受一个整数数组作为参数，并返回数组中的最大值。 ``` public static int findMax(int[] arr) { int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } return max; } ``` 2. 编写一个方法，接受一个整数数组作为参数，并返回数组中的最小值。 ``` public static int findMin(int[] arr) { int min = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] < min) { min = arr[i]; } } return min; } ``` 3. 编写一个方法，接受一个整数数组作为参数，并返回数组的平均值。 ``` public static double findAverage(int[] arr) { double sum = 0; for (int num : arr) { sum += num; } return sum / arr.length; } ``` 4. 编写一个方法，接受一个整数数组作为参数，并返回数组的元素个数。 ``` public static int countElements(int[] arr) { return arr.length; } ``` 5. 编写一个方法，接受一个整数数组作为参数，并返回数组中奇数元素的个数。 ``` public static int countOddElements(int[] arr) { int count = 0; for (int num : arr) { if (num % 2 != 0) { count++; } } return count; } ``` 希望以上习题及答案能对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值