C++上机

最新推荐文章于 2022-04-15 11:12:26 发布
最新推荐文章于 2022-04-15 11:12:26 发布
阅读量624 收藏
点赞数
分类专栏： C++

1、选秀节目打分，分为专家评委和大众评委，score[]数组里面存储每个评委打的分数，judge_type[]里存储与 score[]数组对应的评委类别，judge_type[i] == 1，表示专家评委，judge_type[i] == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分  * 0.6 +大众评委 * 0.4，总分取整。如果没有大众评委，则总分 =专家评委平均分，总分取整。函数最终返回选手得分。

            函数接口   intcal_score(int score[], int judge_type[], int n) 

[cpp]  view plain  copy
 print ?
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. int cal_score(int score[],int judge_type[],int n)  
  5. {  
  6.     int expert = 0;  
  7.     int publicJudge = 0;  
  8.   
  9.     int number_of_expert = 0;  
  10.     int averageScore = 0;  
  11.       
  12.     int index;  
  13.       
  14.     for(index = 0; index < n;index++)  
  15.     {  
  16.         if(judge_type[index] = 1)  
  17.         {  
  18.             expert += score[index];  
  19.             number_of_expert ++;  
  20.         }  
  21.         else  
  22.         {  
  23.             publicJudge += score[index];  
  24.         }  
  25.     }  
  26.   
  27.     if(number_of_expert == n)  
  28.         averageScore = expert/n;  
  29.     else  
  30.         averageScore = expert/number_of_expert*0.6 + publicJudge/(n-number_of_expert)*0.4;  
  31.   
  32.     return averageScore;  
  33. }  
  34.   
  35. int main()  
  36. {  
  37.     int n = 10;  
  38.     int score[10] = {80,85,90,80,75,95,80,90,95};  
  39.     int judge_type[10] = {1,2,1,1,2,2,1,1,2,1};  
  40.     int average_score = cal_score(score,judge_type,n);  
  41.     cout << average_score << endl;  
  42.     return 0;  
  43. }  


      2、给定一个数组input[]，如果数组长度n为奇数，则将数组中最大的元素放到 output[]数组最中间的位置，如果数组长度n为偶数，则将数组中最大的元素放到 output[]数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。

      例如：input[] = {3, 6,1, 9, 7}   output[] = {3, 7, 9, 6,1};            input[] = {3, 6, 1, 9, 7, 8}    output[] = {1, 6, 8, 9, 7,3}

             函数接口   voidsort(int input[[, int n, int output[])

[cpp]  view plain  copy
 print ?
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. #define N 1000  
  5.   
  6. void bubbleSort(int a[],int len)  
  7. {  
  8.     int i,j,temp;  
  9.     for(i = 0;i < len-1;i++)  
  10.         for(j = i+1;j < len;j++)  
  11.         {  
  12.             if(a[i] > a[j])  
  13.             {  
  14.                 temp = a[i];  
  15.                 a[i] = a[j];  
  16.                 a[j] = temp;  
  17.             }  
  18.         }  
  19. }  
  20.   
  21. void sort(int input[], int len, int output[])  
  22. {  
  23.   
  24.     int mid = len/2;  
  25.     int left =  mid - 1;  
  26.     int right = mid + 1;  
  27.       
  28.   
  29.     bubbleSort(input,len);  
  30.   
  31.     int index = len - 1;  
  32.     output[mid] = input[index--];  
  33.     while(index >= 0)  
  34.     {  
  35.         output[left--] = input[index--];  
  36.         output[right++] = input[index--];  
  37.     }  
  38.   
  39.     for(left = 0;left < len;left++)  
  40.         cout << output[left] << " ";  
  41. }  
  42.   
  43. int main()  
  44. {  
  45.     int arr[] = {3,6,1,9,7,8};  
  46.     int destArr[N];  
  47.     sort(arr,6,destArr);  
  48.   
  49.     cout << endl;  
  50.   
  51.     int arr1[] = {31,6,15,9,72,8,99,5,6};  
  52.     int destArr1[N];  
  53.     sort(arr1,9,destArr1);  
  54.       
  55.     return 0;  
  56. }  

      3、操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 50，用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务，应予以剔除。现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。函数scheduler实现如下功能，将task[]中的任务按照系统任务、用户任务依次存放到 system_task[]数组和 user_task[]数组中（数组中元素的值是任务在task[]数组中的下标），并且优先级高的任务排在前面，优先级相同的任务按照入队顺序排列（即先入队的任务排在前面），数组元素为-1表示结束。

      例如：task[] = {0, 30,155, 1, 80, 300, 170, 40, 99}    system_task[] = {0, 3, 1, 7,-1}    user_task[] = {4, 8, 2, 6, -1}

            函数接口   void scheduler(int task[], int n, int system_task[], int user_task[])

[cpp]  view plain  copy
 print ?
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. typedef struct stask{  
  5.     int priority;  
  6.     int index;  
  7. }task_node;  
  8.   
  9. void scheduler(int task[], int n, int system_task[], int user_task[])  
  10. {  
  11.     int i;  
  12.     task_node *task_list;  
  13.     task_list = new task_node[n*sizeof(task_node)];  
  14.     //将task序列中的任务优先级和下标存入任务结构中.  
  15.     for(i = 0;i < n; i++)  
  16.     {  
  17.         task_list[i].priority = task[i];  
  18.         task_list[i].index = i;  
  19.     }  
  20.       
  21.     //根据优先级对任务排序.  
  22.     task_node temp;  
  23.     for(i = 0;i < n - 1;i++)  
  24.     {  
  25.         for(int j = i+1;j < n;j++)  
  26.             if(task_list[i].priority > task_list[j].priority)  
  27.             {  
  28.                 temp = task_list[i];  
  29.                 task_list[i] = task_list[j];  
  30.                 task_list[j] = temp;  
  31.             }  
  32.     }  
  33.     int k1= 0,k2 = 0;  
  34.     //将任务归类存入不同数组.  
  35.     for(i = 0;i < n - 1;i++)  
  36.     {  
  37.         if(task_list[i].priority<50)  
  38.             system_task[k1++] = task_list[i].index;  
  39.         else  
  40.             if(task_list[i].priority >= 50 && task_list[i].priority <= 255)  
  41.                 user_task[k2++] = task_list[i].index;  
  42.     }  
  43.     system_task[k1] = -1;  
  44.     user_task[k2] = -1;  
  45.       
  46.     //输出归类结果.  
  47.     for(i = 0;i <= k1;i++)  
  48.         cout << system_task[i] << " ";  
  49.     cout << endl;  
  50.     for(i = 0;i <= k2;i++)  
  51.         cout << user_task[i] << " ";  
  52.       
  53.     delete [] task_list;  
  54. }  
  55.   
  56. int main()  
  57. {  
  58.     int task[] = {0, 30,155, 1, 80, 300, 170, 40, 99};  
  59.     int system_task[10];  
  60.     int user_task[10];  
  61.     scheduler(task, 9, system_task, user_task);  
  62.           
  63.         return 0;  
  64. }  

4．身份证号码合法性判断 问题描述 

我国公民的身份证号码特点如下： 

1.长度为18位 

2.1-17位只能为数字 

3.第十八位可以是数字或者小写英文字母 

4.身份证号码的第7-14位表示持有人生日的年月日信息 

 
请实现身份证号码合法性判断的函数，除满足以上要求外，需要对持有人生日的年月日信息进行校验，年份大于等于1900，小于等于2100年。需要考虑闰年、大小月的情况。所谓闰年，能被4整除且不能被100整除或能被400整除的年份。闰年2月份为29天，非闰年的2月份为28天。其他情况的合法性校验，不用考虑  
函数返回值： 
1.如果身份证号合法，返回0 
2.如果身份证号长度不合法，返回1 
3.如果身份证号第1-17位含有非数字的字符，返回2 
4.如果第十八位既不是数字也不是英文小写字母x，返回3 5.如果身份证号的年信息非法，返回4 
6.如果身份证号的月信息非法，返回5 
7.如果身份证号的日信息非法，返回6（请注意闰年的情况） 
 
注：除成功的情况外，以上其他情况合法性判断的优先级依次降低，也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断  
要求实现函数 
int verifyIDCard(char *input)  
示例： 
1.输入："511002 111222"返回1 

2.输入:"511002 abc123456789" 返回2

 3.输入:"511002 19880808123a"返回3

 4.输入:"511002 188808081234" 返回4

 5.输入:"511002 198813081234" 返回5 

6.输入:"511002 198808321234"返回6

 7.输入:"511002 198902291234"返回7 

8.输入:"511002 198808081234"返回0

5. 链表逆序

[cpp]  view plain  copy
 print ?
  1. #include <iostream>  
  2. #include <assert.h>  
  3. using namespace std;  
  4.   
  5. typedef struct NODE{  
  6.     int value;  
  7.     NODE *pNext;  
  8. }Node,*pNode;  
  9.   
  10. //创建链表.     
  11. Node* creat()      
  12. {  
  13.     int nuberOfNode = 5;  
  14.     int data;  
  15.     pNode head = new Node;    
  16.       
  17.     if(NULL == head)  
  18.         cout << "分配内存失败\r\n";  
  19.       
  20.     head->pNext = NULL;      
  21.       
  22.     pNode p = head;  
  23.     pNode s = NULL;  
  24.     cout << "请输入数据:\r\n";  
  25.     while(nuberOfNode--)      
  26.     {      
  27.         cin >> data;            
  28.         s = new Node;         
  29.         assert(NULL != s);        
  30.         s->value = data;      
  31.         p->pNext = s;      
  32.         p = s;   
  33.     }      
  34.     p->pNext = NULL;      
  35.     return(head);      
  36. }      
  37.   
  38. //实现链表逆序.  
  39. pNode reverseList(pNode Header)  
  40. {  
  41.     //空链表或只有一个节点.  
  42.     if(Header == NULL || Header->pNext == NULL)  
  43.         return 0;  
  44.       
  45.     //pre,cur分别指向首节点，第二个节点.  
  46.     pNode pre = Header->pNext;  
  47.     pNode cur = pre->pNext;  
  48.     pre->pNext = NULL;  
  49.     pNode next = NULL;  
  50.       
  51.     while(NULL != cur)  
  52.     {  
  53.         next = cur->pNext;  
  54.         cur->pNext = pre;  
  55.         pre = cur;  
  56.         cur = next;  
  57.     }  
  58.     Header->pNext = pre;//有头结点的链表.  
  59.       
  60.     return Header;  
  61. }  
  62.   
  63. //打印链表.  
  64. void printList(pNode head)  
  65. {  
  66.     pNode start = head->pNext;  
  67.     while(start)  
  68.     {  
  69.         cout << start->value << " ";  
  70.         start = start->pNext;  
  71.     }  
  72. }  
  73.   
  74. int main()  
  75. {  
  76.     pNode pl = creat();  
  77.     printList(pl);  
  78.     cout << endl;  
  79.     printList(reverseList(pl));  
  80.       
  81.     return 0;  
  82. }  

6. 查找子字符串出现次数，并从原字符串中删除。

[cpp]  view plain  copy
 print ?
  1. /* 
  2. 编写函数，string deletestring（string str,string sub_str）从str中查找 
  3. 匹配的字符串sub_str,采用最左匹配，且输出形式为str+"_"+匹配的次数。 
  4. */  
  5. #include <iostream>  
  6. using namespace std;  
  7.   
  8. //删除指定位置字符串.  
  9. void delSpecifiedSubString(char *str,int start,int end)  
  10. {  
  11.     char *p1 = &str[start];  
  12.     char *p2 = &str[end + 1];  
  13.     while((*p1++ = *p2++) != '\0');  
  14. }  
  15.   
  16. int delSubString(char *str,char *subStr)  
  17. {  
  18.     int count = 0;  
  19.     int index = 0;  
  20.   
  21.     char *pstr = str;  
  22.     char *psubStr = subStr;  
  23.   
  24.     if(str == NULL ||subStr == NULL)  
  25.         return 0;  
  26.   
  27.     while(*pstr != '\0')  
  28.     {  
  29.         if(*pstr == *psubStr)  
  30.         {  
  31.             pstr++;  
  32.             psubStr++;  
  33.             index++;  
  34.         }  
  35.         else  
  36.         {  
  37.             psubStr = subStr;  
  38.             pstr = pstr - index + 1;  
  39.             index = 0;  
  40.         }  
  41.         if(*psubStr == '\0')  
  42.         {  
  43.             count++;  
  44.             psubStr = subStr;  
  45.             delSpecifiedSubString(str,  
  46.                 pstr - index - str,  
  47.                 pstr - 1 - str);  
  48.         }  
  49.     }  
  50.     cout << str << " " << count << endl;  
  51.     return count;  
  52. }  
  53.   
  54. int main()  
  55. {  
  56.     char str[50];  
  57.     char subStr[30];  
  58.     cout << "输入str和subStr：" << endl;  
  59.     gets(str);  
  60.     gets(subStr);  
  61.     delSubString(str,subStr);  
  62.   
  63.     return 0;  
  64. }  


[cpp]  view plain  copy
 print ?
  1. <span style="color:#ff0000;">//错误有做法！！！</span>  
  2. #include <iostream>  
  3. #include <string>  
  4. using namespace std;  
  5.   
  6. char *fun(char *str,char *subStr)  
  7. {  
  8.     string s(str);  
  9.     while(s.find(subStr) != string::npos)  
  10.     {  
  11.         cout << s.find(subStr) << endl;  
  12.         //从s中删除找到的子字符串subStr.  
  13.         s.erase(s.find(subStr),strlen(subStr));  
  14.     }  
  15.     char *m = new char[50];  
  16.     strcpy(m,s.c_str());  
  17.     //注意这边的string转成char*返回值是const char*，不能直接将其return，  
  18.     //而且不能直接赋给char*，需要用strcpy来做。  
  19.   
  20.     return m;  
  21. }  
  22.   
  23. int main()  
  24. {  
  25.     char str[50];  
  26.     char subStr[30];  
  27.     gets(str);  
  28.     gets(subStr);  
  29.     cout << str << endl;  
  30.     cout << subStr << endl;  
  31.     cout << fun(str,subStr) << endl;  
  32.   
  33.     return 0;  
  34. }  


[cpp]  view plain  copy
 print ?
  1. <span style="color:#ff0000;">//功能：删除str中的subStr.  
  2. //正确的方法！！！</span>  
  3. #include <iostream>  
  4. #include <string>  
  5. using namespace std;  
  6.   
  7. char *fun(char *str,char *subStr)  
  8. {  
  9.     string s(str);  
  10.     int index = 0;  
  11.     while(s.find(subStr,index) != string::npos)  
  12.     {  
  13.          index = s.find(subStr,index);  
  14.         //从s中删除找到的子字符串subStr.  
  15.         s.erase(s.find(subStr),strlen(subStr));  
  16.         index++;  
  17.     }  
  18.     char *m = new char[50];  
  19.     strcpy(m,s.c_str());  
  20.     //注意这边的string转成char*返回值是const char*，不能直接将其return，  
  21.     //而且不能直接赋给char*，需要用strcpy来做。  
  22.   
  23.     return m;  
  24. }  
  25.   
  26. int main()  
  27. {  
  28.     char str[50];  
  29.     char subStr[30];  
  30.     gets(str);  
  31.     gets(subStr);  
  32.     cout << "str:" << str << endl;  
  33.     cout <<  "subStr:" << subStr << endl;  
  34.     cout <<  "result:" << fun(str,subStr) << endl;  
  35.   
  36.     return 0;  
  37. }  


[cpp]  view plain  copy
 print ?
  1. /*将一个字符串的元音字母复制到另一个字符串，并排序（30分） 
  2. 问题描述： 
  3. 有一字符串，里面可能包含英文字母（大写、小写）、数字、特殊字符，现在需要实现一函数，将此字符串中的元音字母挑选出来，存入另一个字符串中，并对字符串中的字母进行从小到大的排序（小写的元音字母在前，大写的元音字母在后，依次有序）。 
  4.   
  5. 说明： 
  6. 1、  元音字母是a,e,i,o,u,A,E,I,O,U。 
  7. 2、  筛选出来的元音字母，不需要剔重； 
  8.   
  9. 最终输出的字符串，小写元音字母排在前面，大写元音字母排在后面，依次有序。 
  10.   
  11. 要求实现函数： 
  12. void sortVowel (char* input, char* output); 
  13. 【输入】  char* input，表示输入的字符串 
  14. 【输出】  char* output，排好序之后的元音字符串。 
  15. 【返回】  无 
  16.   
  17. 示例 
  18. 输入：char *input = “Abort!May Be Some Errors In Out System. “ 
  19. 输出：char *output =“aeeeooAEIO */  
  20. #include <iostream>  
  21. using namespace std;  
  22.   
  23. void sortVowel(char *input,char *output)  
  24. {  
  25.     char arr[10] = {'a','e','i','o','u','A','E','I','O','U'};  
  26.     int number[10] = {0};  
  27.     int i = 0;  
  28.     int sum = 0;  
  29.       
  30.     while('\0'!= *input)  
  31.     {  
  32.         for(i = 0;i < 10;i++)  
  33.         {  
  34.             if(arr[i] == *input)  
  35.             {  
  36.                 number[i]++;  
  37.                 break;  
  38.             }  
  39.         }  
  40.         input++;  
  41.     }  
  42.       
  43.     //计算总的出现元音字母的次数.  
  44.     for(i = 0;i < 10;i++)  
  45.         sum += number[i];  
  46.   
  47.     output = new char[sum+1];  
  48.     char *start = output;  
  49.       
  50.     for(i = 0;i < 10;i++)  
  51.     {  
  52.         while(number[i]--)  
  53.             *start++ = arr[i];  
  54.     }  
  55.     *start = '\0';  
  56.     while(*output!= '\0')  
  57.         cout << *output++;  
  58.       
  59.     cout << endl;       
  60. }  
  61.   
  62. int main()  
  63. {  
  64.     char input[] = "Abort!May Be Some Errors In Out System.";  
  65.     char *output = NULL;  
  66.     sortVowel(input,output);  
  67.       
  68.     return 0;  
  69. }  
2017最全华为机试题C/C++（含答案源码）
09-22
2017最全华为机试题C/C++（含答案源码)，包含111道上机考试题，欢迎下载，觉得资源好请好评。
c++上机实例
06-29
在这个"c++上机实例"中，我们主要关注两个核心主题：日期时间的操作以及二叉树的存储和打印。这两个主题都是C++编程中基础且关键的知识点。 首先，日期和时间的操作在许多应用程序中都有广泛的应用，例如日志记录、...
2012华为机试题目（C/C++）
天涯明月的专栏
08-02 6511
1、选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type[i] == 1，表示专家评委，judge_type[i] == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分  *
c++上机（第一次）
zyw0929的博客
04-19 861
1. Read the codes carefully on page 230 and page 248 of the book, or on page 247 and page 266 of the e-book, then answer the questions as below:  1.1 Describe the main data structure of Stack；  1.2 De...
2014 华为校招机试题（c/c++开发类）
01-19 2180
第一题： 1、2、3.。。。n盏灯，同时有n个人， 第1个人将1的倍数的灯拉一下， 第2个人将2的倍数的灯拉一下， ...... 问最后有几盏灯是亮的， 初始状态下灯是灭的， 输入整数n(n 输出亮的灯数 方法解析：设置一个map，关键字为灯的编号，值为0或1，分别表示灯灭和灯亮状态，遍历map，第i个灯，将所有i倍数的灯进行一次取反操作，也可以通过数组实现。代码如下： #in
C++上机实验
zhangyuheng1的博客
03-10 1041
/*  * 文件名称：exe1  * 作    者：张宇恒   * 完成日期：2016  年  3   月  10  日  * 版 本 号：v1.0  * 对任务及求解方法的描述部分: * 输入描述：两个整数a,b   * 问题描述：求a,b两数的和及差  * 程序输出：a+b= ,a-b= ,   * 问题分析：略  * 算法设计：略   */   #include
吉林大学C++上机实验报告
07-15
在C++课程中，通过编写一个多项式类的实验报告，学生不仅能够加深对C++语言基础知识的理解，还能够学习面向对象编程的思想和技术细节。以下是一篇基于上述信息撰写的详细文章。 --- **C++编程实验：多项式类的实现...
C++上机实验报告.pdf
09-05
C++上机实验报告
C++上机试题
03-25
### C++上机试题知识点解析 #### 题目背景 本套试题为计算机等级考试二级中的C++部分，共包含两道编程题。通过这两道题目，旨在考察考生对于C++基本语法、面向对象编程的理解及应用能力。 #### 第一题：模拟书籍...
c++上机实验报告模板
10-31
### C++上机实验报告知识点概述 #### 一、实验目的和要求 1. **熟悉上机环境**：包括理解并使用Visual Studio集成开发环境，掌握如何进行源程序的编辑、程序调试、变量查看以及程序运行操作。 - **Visual Studio...
华为C++机试题总结和答案，大量习题数百道
04-29
从其他网上找到的，大量华为近几年的机试编程题，都有答案，很详细。
C++上机考试系统（包括100道题）
10-09
这是C++上机考试系统（包括100道题），和c++正式上机考试题类型、难度都相似。
C++第一次上机
Eliuyin的博客
03-10 728
一.问题及代码 /* * 文件名称：ly作业1 * 作 者：刘寅 * 完成日期： 2016 年 3 月 10 日 * 版 本 号：v1.0 * 对任务及求解方法的描述部分:输入两个整数，求其和商积差 * 输入描述：输入整数a和b和商积差 * 问题描述：第一次c++作业，熟悉程序编辑，运行过程 * 程序输出：输出a和b的和商积差的值 * 问题分析：略 * 算
Visual C++上机指南
macrohui29的专栏
02-29 1409
一、启动Visual C++ 二、建立项目文件 三、建立C++源程序文件 四、编写程序、编译程序 四、链接和执行程序
C++经典机试题目
choutiaolin8504的博客
01-18 689
1. 表达式求值 - 中缀转后缀 #include <iostream> #include <stack> using namespace std; int Priority(char oper) { switch(oper) { case '(':...
C++机试题
08-07 1033
1．第一题的题目大概是输入整型数组求数组的最小数和最大数之和，例如输入1,2,3,4则输出为5，当输入只有一个数的时候，则最小数和最大数都是该数，例如只输入1，则输出为2；另外数组的长度不超过50 void main() { int num[50] = { 0 }; int i, n; printf("请输入整型数组的长度(1~50)："); scanf("%d", &n);
C++:上机练习(C++实现)
weixin_57425841的博客
04-15 1136
现有nx个x，ny个y，nz个z，nw个w，将这若干个非负整数分别置于A数组中或B数组中。规则是：所有x必须放入A数组，所有y必须放入B数组，z和w可以放入A数组也可以放入B数组。SA为A数组的和，SB为B数组的和，S为SA和SB的较大者。当x,y,z,w和nx,ny,nz,nw确定后，如何放置，可以使得S最小，并求出这个S值。其中 0<=x,y,z,w<=10000000，nx,ny,nz,nw<=10000000。 如：x,y,z,w,nx,ny,nz,nw分别为：10 1 10 1
c++上机
shiliuyetongge的博客
12-12 618
声明一个SortArray继承类MyArray,在该类中定义一个函数，具有将输入的整数进行排序的功能。 派生类构造函数的一般格式为： 派生类名（参数总表）：基类名（参数表）， { 派生类新增数据成员的初始化语句； } 基类和派生类的构造函数与析构函数的顺序为： 创建派生类对象时 1.执行基类的构造函数 2.执行派生类的构造函数 撤销派生类对象时 1.执行派生类的析构函数 2.执行基类的析构函数 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值