oj汇总

最新推荐文章于 2023-01-06 12:44:35 发布
最新推荐文章于 2023-01-06 12:44:35 发布
阅读量423 收藏
点赞数
文章标签： oj汇总
1.

#include "OJ.h"


/*
功能: 输入一个升序单向链表和一个链表节点，向单向链表中按升序插入这个节点。
输入为空指针的情况视为异常，另外不考虑节点值相等的情况。


输入: ListNode* pListHead  单向链表
ListNode* pInsertNode 新插入节点


输出: ListNode* pListHead  单向链表


返回: 正常插入节点返回链表头指针，其它异常返回空指针
*/
ListNode* InsertNodeToList(ListNode* pListHead, ListNode* pInsertNode)
{
/*在这里实现功能*/


/* if(!pListHead||!pInsertNode)
return (ListNode*)NULL;




ListNode *p=pListHead,*q;


for(;(p->m_pNext)&&(p->m_nKey<=pInsertNode->m_nKey);)
{
q=p;
p=p->m_pNext;
}


if(p==pListHead)
{
pInsertNode->m_pNext=pListHead;
pListHead=pInsertNode;
}
else
if(p->m_nKey<pInsertNode->m_nKey)
{
p->m_pNext=pInsertNode;
}
else
{
pInsertNode->m_pNext=q->m_pNext;
q->m_pNext=pInsertNode;
}


return pListHead;
*/


/*在这里实现功能*/
if (pListHead == NULL || pInsertNode == NULL)
{
return (ListNode*)NULL;
}


ListNode *tmp = pListHead, *t;
if (pListHead->m_pNext == NULL)
{
if (pListHead->m_nKey < pInsertNode->m_nKey)
{
pListHead->m_pNext = pInsertNode;
pInsertNode->m_pNext = (ListNode*)NULL;
}
else
{
t = pListHead;
pListHead = pInsertNode;
pInsertNode->m_pNext = t;
}
return pListHead;
}
while (tmp)
{
if (tmp->m_nKey < pInsertNode->m_nKey)
{
t = tmp->m_pNext;
tmp->m_pNext = pInsertNode;
pInsertNode->m_pNext = t;
}
tmp = tmp->m_pNext;
}

return pListHead;

}


2.

#include <iostream>
using namespace std;


// 功能：排列一个m行n列 大小的数组
//给出一个二维数组，请将这个二维数组按第i列(i从1开始)排序，如果第i列相同，则对相同的行按第i+1列的元素排序，如果第i+1列
//的元素也相同，则继续比较第i+2列，以此类推，直到最后一列。如果第i列到最后一列都相同，则按原序排列。
// 输入： int * pArray 指向数组第一个元素的指针,m为行数， n为列数 ，请按第i列排列
// 输出：按第i列排序完成后的数组放到入参指定的地址中 (i的取值范围 1 - n) 
// 返回：
void RangeArray(int * pArray, unsigned int m, unsigned int n, unsigned int i)
{
bool flag = 0;//flag为1表示上行大于下行，需要交换
int temp = 0;
//冒泡排序法
for (unsigned int t = 0; t < m - 1 ; t++){
for (unsigned int row = 0; row < m - 1 - t; row++){
//各行元素都要进行交换,每次是row行和row+1行进行比较
for (int c = i-1; c < n; c++){
if (pArray[row*n + c]>pArray[(row + 1)*n + c]){
flag = 1;
break;
}
else if (pArray[row*n + c] < pArray[(row + 1)*n + c]){
flag = 0;
break;
}
}
if (flag == 1){
for (unsigned int col = 0; col < n; col++){
temp = pArray[row*n+col];
pArray[row*n + col] = pArray[(row + 1)*n + col];
pArray[(row + 1)*n + col] = temp;
}
}
flag = 0;
}
}
}


3.

#include <iostream>
using namespace std;
// 功能：排列一个m行n列 大小的数组
// 输入： int * pArray 指向数组第一个元素的指针,m为行数， n为列数 ，请按第i列排列
// 输出：按第i列排序完成后的数组放到入参指定的地址中 (i的取值范围 1 - n)  
// 返回：
void RangeArray1(int * pArray, unsigned int  m, unsigned int  n, unsigned int  i)
{
if (pArray == NULL || m<0 || n<0 || i>n)
return;
int * tempArray = new  int[n];
//从最后一列开始排序，排序到指定列
for (unsigned int column = n - 1; column >= i - 1; column--){
//对每一列进行排序,冒泡排序的变形
for (unsigned int i = 0; i<m - 1; i++){


for (unsigned int j = 0; j<m - i - 1; j++){


//交换数组元素
if (*(pArray + j*n + column) > *(pArray + (j + 1)*n + column)){
memcpy(tempArray, pArray + j*n, n*sizeof(int));
memcpy(pArray + j*n, pArray + (j + 1)*n, n*sizeof(int));
memcpy(pArray + (j + 1)*n, tempArray, n*sizeof(int));
}
}


}
if (column == 0)
break;
}


}


int main()
{
int pArray[4][3] = { 1, 2, 3, 2, 3, 4, 2, 3, 1, 1, 1, 1 };
RangeArray1(&pArray[0][0], 4, 3, 2);
for (int i = 0; i < 4; ++i)
{
for (int j = 0; j < 3; ++j)
{
cout << pArray[i][j] << " ";
}
cout << endl;
}
return 0;
}


4.

#include <stdio.h>
void main(){
int a,count=0;
scanf_s("%d",&a);
while (a != 0){
count++;
a = a / 10;
}
printf("%d",count);
return;
}


6.

#include<stdio.h>
int main()
{
int i, a, b, c;
for (i = 100; i<1000; i++)
{
a = i / 100;
b = (i / 10) % 10;
c = i % 10;
if ((a*a*a + b*b*b + c*c*c) == i)
printf("%d\n", i);
}
return(0);
}


7.

#include <iostream>
using namespace std;


int main(){
unsigned int num;
cin >> num;
int count = 0;
while (num != 0){
if (num & 1 == 1){
count++;
}
num = num >> 1;
}
cout << count << endl;
return 0;
}


8.



#include "OJ.h"
#include <iostream>
using namespace std;
/*
Description
给定一个字符串，将字符串中所有和前面重复多余的字符删除，其余字符保留，输出处理后的字符串。需要保证字符出现的先后顺序。
Prototype
int GetResult(const char *input, char *output)
Input Param
input     输入的字符串
Output Param
output    输出的字符串
Return Value
0         成功
-1        失败及异常
*/
int GetResult(const char *input, char *output)
{
if (!input || !output || input[0] == '\0')
return -1;
int a[256] = { 0 };
int i = 0, j = 0;
int len = strlen(input);
for (int i = 0; i < len; i++)
{
if (a[input[i]] == 0)
{
a[input[i]] = 1;
output[j++] = input[i];
}
}
output[j] = '\0';
return 0;
}


int GetResult1(const char *input, char *output)
{
if (!input || !output || input[0] == '\0')
return -1;
int a[256] = { 0 }, i = 0, j = 0;


while (input[i])
{


if (a[input[i]] == 0)
{
a[input[i]] = 1;
output[j++] = input[i++];
}
else
i++;


}
output[j] = '\0';




return 0;


}


int main()
{
char outStr[10];
GetResult1("abbbsdfcvvvx",outStr);


cout<< outStr;
return 0;
}


9.

#include <iostream>
using namespace std;
/*
功能: 输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。如果有多对数字的和等于输入的数字，输出任意一对即可。


输入: int aData[]           // 升序数组
unsigned int uiLength // 数组元素个数
int sum,              // 给定两个数组的和


输出: int *pNum1            // 第一个数字，对应数组索引小的
int *pNum2            // 第二个数字，对应数组索引大的


返回: 找到返回true，异常返回false
*/
bool FindTwoNumbersWithSum(int aData[], unsigned int uiLength, int sum, int *pNum1, int *pNum2)
{
/*在这里实现功能*/
if (!aData || uiLength == 0 || uiLength == 1){
return false;
}
for (int i = 0; i < uiLength-1; i++){
int val1 = aData[i];
int val2 = sum - val1;
for (int j = i + 1; j < uiLength; j++){
if (aData[j] == val2){
*pNum1 = i;
*pNum2 = j;
return true;
}
}
}
return false;
}


int main(){
int num1=0;
int num2=0;
int *pNum1 = &num1;
int *pNum2 = &num2;
int a[] = { 1, 2, 3, 5, 7, 9 };
FindTwoNumbersWithSum(a, 6, 9, pNum1, pNum2);
cout << *pNum1 << " " << *pNum2<< endl;
return 0;
}


10

#include <iostream>
using namespace std;
/*
void GetResult(int InputNum, double *NumResult);
输入参数：
Int  InputNum：输入一个正整数，进行表达式计算
char *NumResult：输出表达式的值
返回值：
void


编写程序，输入一个正整数n，求下列算式的值。
要求定义和调用函数fact(k)计算k的阶乘，函数返回值的类型是double。
1+1/2!+ .... +1/n!
输出保留5位小数。
下面是一些合理的表达式的例子：
Input         5
Output      1.71667


*/
double fact(int k)
{
double temp = 1.0;
for (int i = 1; i <= k; i++){
temp *= i;
}
return 1.0 / temp;
}


void GetResult(int InputNum, double *NumResult)
{
*NumResult = 0;
if (InputNum <= 0){
*NumResult = 0;
}
else{
for (int i = 1; i <= InputNum; i++){
*NumResult += fact(i);
}
}
return;
}


int main(){
int InputNum = 5;
double res = 0.0;
double *NumResult = &res;
GetResult(InputNum, NumResult);
cout << *NumResult << endl;
return 0;
}


11

#include <iostream>
using namespace std;


int main(){
int input;
int count = 0;
int a[100];
cin >> input;
if (input <= 1 || input > 100){
return -1;
}
for (int i = 3; i <= input; i++){
for (int j = 2; j < i; j++){
if (i%j == 0){
a[count++] = i;
break;
}
}
}
for (int i = 0; i < count; i++){
cout << a[i] << endl;
}
return 0;
}


12



#include <iostream>
#include"stdio.h"
using namespace std;
/*
功能: 找出字符串中第一个出现次数最多的字符


输入: char* pInputString：字符串


输出: char* pChar：出现次数最多的字符


返回: false 异常失败
true  输出成功
*/


bool FindChar(char* pInputString, char* pChar)
{
//在这里实现功能
if (!pInputString || pInputString[0] == '\0'){
return false;
}
int rec[256] = { 0 };
int len = strlen(pInputString);
for (int i=0; i < len; i++){
rec[pInputString[i]]++;
}
int max = rec[pInputString[0]];
int pos = 0;
for (int i=1; i < len; i++){
if (rec[pInputString[i]]>max){
max = rec[pInputString[i]];
pos = i;
}
}
*pChar = '0'+pos;
return true;
}


int main(){
char in[] = "afbcdeffsse";
char* pInputString = in;
char a=' ';
char* p = &a;
    FindChar(pInputString, p);
cout <<*p<<endl;
return 0;
}


13

#include <stdlib.h>
#include"iostream"
using namespace std;


/*
功能:
给出一个不多于5位的整数，
要求:
1、求出它是几位数
2、分别输出每一位数字
3、按逆序输出各位数字，例如原数为321,应输出123
输入:
整型 iInput,位数不大于5的整数


输出:
整数位数 iNum
空格间隔输出结果    strRst
逆序整数 iOutput


返回:
0  成功
-1 输入无效
*/




int ProcessX(int iInput, int& iNum, char * strRst, int& iOutput)
{
if (strRst == NULL){
return -1;
}//if
if (iInput >= 100000 || iInput <= -100000){
return -1;
}
iNum = 0;
char *temp = (char *)malloc(sizeof(char)* 20);
char* p = temp;
iOutput = 0;
if (iInput!=0){
if (iInput < 0){
iInput = -iInput;
*strRst = '-';  //负数
strRst++;
}
while (iInput != 0){
*p++ = '0' + iInput % 10; //存反序字符串
iOutput = iOutput * 10 + iInput % 10; //反序
iNum++;
iInput /= 10;
}
if (iInput < 0){
iOutput = -iOutput;
}
*p = '\0';
}
else{
*strRst = 0;
iOutput = 0;
return 0;
}
p--;
for (int i = 0; i < iNum;i++){
*strRst = *p;
strRst++;
*strRst = ' ';
strRst++;
p--;
}
strRst--;
*strRst = '\0';
free(temp);
return 0;
}


int main(){
int input = -12345;
int num = 0;
char* strRst=(char*)malloc(sizeof(char)*20);
int iOutput;
ProcessX(input, num, strRst, iOutput);
cout << "return" << endl;
cout << num<<endl;
cout << strRst << endl;
cout << iOutput << endl;
free(strRst);
return 0;
}


14



#include <iostream>
using namespace std;
/*
Description
取给定正整数的指定bit位开始的指定长度的数据。bit位从右向左从0开始计算。
Prototype
unsigned int GetBitsValue(unsigned int input, unsigned int startbit, unsigned int bitlen)
Input Param
input      输入的整数
startbit   需要获取的开始bit
bitlen     需要获取的bit长度
Output Param
无
Return Value
对应的bit取值
*/


unsigned int GetBitsValue(unsigned int input, unsigned int startbit, unsigned int bitlen)
{
/*在这里实现功能*/


if (startbit>31 || bitlen>32 || (bitlen>startbit))
return -1;


if (bitlen == 0)
return -1;




input = input >> (startbit - bitlen + 1);




unsigned int temp = 1, sum = 1;
for (unsigned int i = 1; i<bitlen; i++)
{
temp = temp * 2;
sum = sum + temp;


}


input = input&sum;//除去高位的前半部分


return input;


}


int main()
{
int val;
val = GetBitsValue(13, 2, 2);
cout << val <<endl;
return 0;
}


15

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;


/*
功能:


输入:pIntArray:数组,nCout:数组长度


输出:


返回:返回最大值
方法：动态规划，就是要存储前一步的局部量，动态跟新局部量


*/


int GetSubArraySum(int* pIntArray, int nCount){
/*在这里实现功能*/
int sum = pIntArray[0];
int max = pIntArray[0];
for (int i = 1; i < nCount; i++){
//如果前面的累加和是负的，则清空
if (sum < 0){
sum = 0;
}
//并建立新的部分和
sum += pIntArray[i];
//更新max
if (sum > max){
max = sum;
}
}
return max;
}


int main()
{
int a[] = { 1, -2, 3, 10, -4, 7, 2, -5 };
cout<<GetSubArraySum(a, 8)<<endl;
return 0;
}


16

#include <string.h>
#include <iostream>
using namespace std;


/*
功能:计算字符串的最小周期。
原型：
int GetMinPeriod(char *string);


输入参数：
char * string：字符串。


返回值：
int 字符串最小周期。




strlen();
int len=0; char* p=inputstring; while (*p++) len++


*/


int GetMinPeriod(char *inputstring)
{
/*在这里实现功能*/
if (!inputstring || inputstring[0] == '\0')
return 0;


//而对于int数组，没有求长度的函数
int len = (int)strlen(inputstring), count=0;
int ok = 1;
for (int i = 1; i < len; i++){
if (len % i != 0){
ok = 0;
continue;
}
else{
ok = 1;
for (int j = 0; j < len-i; j++){
if (inputstring[j] != inputstring[j + i]){
ok = 0;
break;
}
}
if (ok){
count = i;
break;
}
}
}
return count;
}


int main(){
cout << GetMinPeriod("abcdabcabcabc")<<endl;
return 0;
}


17

#include <stdlib.h>
#include <iostream>
#include"string"
using namespace std;




/* 功能：在字符串中找出连续最长的数字串，并把这个串的长度返回
函数原型：
unsigned int Continumax(char** pOutputstr,  char* intputstr)
输入参数：
char* intputstr  输入字符串
输出参数：
char** pOutputstr: 连续最长的数字串，如果连续最长的数字串的长度为0，应该返回空字符串
pOutputstr 指向的内存应该在函数内用malloc函数申请，由调用处负责释放


返回值：
连续最长的数字串的长度


*/
unsigned int Continumax(char** pOutputstr, char* intputstr)
{
if (!intputstr || !*intputstr){
return 0;
}
int len = strlen(intputstr);
int maxLen = 0;
int count = 0;//当前子数字串的长度计数
int start = 0;
for (int i = 0; i < len; i++){
if (intputstr[i] >= '0'&&intputstr[i] <= '9'){
count++;
}
else{
if (count>maxLen){
maxLen = count;
start = i - maxLen;
}
count = 0;
}
}
char* pstr = (char*)malloc((maxLen + 1)*sizeof(char));
for (int i = 0; i < maxLen; i++){
pstr[i] = intputstr[start + i];
}
pstr[maxLen] = '\0';
*pOutputstr = pstr;
return maxLen;


}


int main(){
unsigned int len = 0;
char* intputstr = "abc12345abc456789abc98765";
char* pstr = NULL;
len = Continumax(&pstr, intputstr);
cout << len << endl;
cout << "pOutputstr=" << pstr << endl;
free(pstr);
}


18

#include <iostream>
using namespace std;


/******************************************************************************


Copyright (C), 2001-2011, Huawei Tech. Co., Ltd.


******************************************************************************
File Name     :
Version       :
Author        :
Created       :
Last Modified :
Description   :
Function List :


History       :
1.Date        :
Author      :
Modification: Created file


******************************************************************************/






//给出一个非负整数，找到这个非负整数中包含的最大递减数。一个数字的递减数是指相邻的数位从大到小排列的数字。
//如： 95345323，递减数有：953,95,53,53,532,32, 那么最大的递减数为953。
//如果输入的数字为负数，返回-1。


#include"stdio.h"
#include"string.h"


int getMaxDegressiveNum(int num)
{
// your code here...
char str[100];
int max;
sprintf_s(str, "%d", num);
max = str[0] - '0';
int val = max;
for (int i = 0; i < strlen(str); i++){
if (str[i] < str[i - 1]){
val = val * 10 + str[i] - '0';
}
else{
//可以在递减序列的末尾更新局部max,不需要每次都更新
if (val>max){
max = val;
}
val = str[i] - '0';
}
}
return max;
}


int main(){
cout << getMaxDegressiveNum(953453213)<<endl;
return 0;
}


19

#include <stdio.h>
#include <iostream>
using namespace std;


int main(){
int a, b, c;
scanf_s("%d%d",&a,&b);
while (b != 0){
c = a%b;
a = b;
b = c;
}
printf("%d",a);
return 0;
}



whisper_ma
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OJ 网址汇总
06-23
OJ 网址汇总 本资源汇总了国内外知名的OJ平台网址、学习论坛BBS链接、学习网址和信息学竞赛网址，为信息学爱好者和竞赛选手提供了一个便捷的资源平台。 OJ 平台网址 OJ 平台网址是信息学爱好者和竞赛选手的必备...
OJ网站汇总
WUTAO2213的博客
08-28 1136
http://poj.openjudge.cn/POJ http://openjudge.cn/百炼 https://www.luogu.org/落谷 http://codevs.cn/天梯系统 https://nanti.jisuanke.com/acm计蒜客 https://www.nowcoder.com/activity/oj牛客 https://ww...
【数据结构之链表系列】链表常见OJ题汇总（持续更新）
最新发布
胡坚涛的博客
01-06 1434
本文主要总结博主平时做过的链表的常见OJ题，持续更新~
各大常见OJ与推荐OJ汇总（OJ题量统计）
良月澪二的博客
03-13 1万+
这么长时间了 收集了不少做题的网站 在这里列一列 **并没有什么顺序**
OJ推荐
dxyinme-Zz
08-15 2355
给大家推荐几个个人感觉挺不错的OnlineJudge codevs ，以前的wikioi    网址：codevs.cn 洛谷OJ是厦门一中的OJ    网址：luogu.org 电子科技大学的OJ，画面感全球顶级，不吹不黑    网址：acm.uestc.edu.cn codeforces，彻头彻尾的神题发源地，有很多比赛，不过大部分都是凌晨的   网址：codeforces.com
OJ题解汇总
nameofcsdn的博客
01-08 1万+
。。。
OJ系统汇总-2021-12-24(d).pdf
12-25
OJ 系统汇总 本文档对 OJ 系统进行了汇总，涵盖了多种 OJ 平台，包括 Openjudge、Poj 北大 OJ、洛谷、Atcoder、Codeforces、牛客竞赛网、计蒜客、力扣中文版、Comet OJ、HDU、Universal Online Judge、Vjudge、...
2020CVPR VSR Space-Time-Aware Multi-Resolution Video Enhancement
eight_Jessen的博客
11-09 378
Space-Time-Aware Multi-Resolution Video Enhancement 1、总结 同时做时间和空间的超分。高分辨率可以提高运动细节，高帧率有利于做运动对齐。文中的方法是在ST-SR期间生成潜在的低分辨率和高分辨率表示的模型组件可用于微调仅针对空间SR或时间SR的专用机制。 作者提出了 Space-Time-Aware multi-Resolution Network STARnet。STARnet通过为ST-SR提供从LR到HR的直接连接，明确合并了在LR和HR空间中相互增强
练编程：在线OJ汇总
丁磊_ml的博客
03-25 3426
算法设计学习 http://blog.csdn.net/rodestillfaraway/article/details/50533742 南阳理工acm类别分的很好的，有时候会卡 杭电 国内前几 华科有一个Virtual Judge，可以使用其他高校的oj 北大 浙大 bestcoder 是比赛，oj用的是杭电的 Leetcode 其他汇总 知乎回答 牛客网 技蒜客 acm俱乐部 acm俱乐
C语言头文件 #include＜ctype.h＞
MMMMMMNONG的博客
10-17 4294
这个头文件是对字符类型进行处理，拥有一些对字符处理的功能函数 比如ZZULIOJ上面1066: 字符分类统计，可以用这个头文件进行处理。 代码 #include<stdio.h> #include<ctype.h> int main() { int u=0,p=0,y=0; char ch; while(ch=getchar(),ch!='\n') { if(isalpha(ch))//判断输入的字符是不是字母小写a~z和大写A~Z { u++; }
各大OJ网址汇总（致力于爱刷OJ的小伙伴们）
热门推荐
努力当学神的博客
03-05 2万+
POJ（1）：http://poj.org/ POJ（2）：http://poj.openjudge.cn/ HDU：http://acm.hdu.edu.cn/ 哈理工OJ：http://acm.hrbust.edu.cn/index.php# BNUOJ：http://www.bnuoj.com/ BUAAOJ：https://buaacoding.cn/index FuZhouOJ：htt...
OJ网站程序员必备
weixin_34209851的博客
03-22 754
一. Online Judge简介： Online Judge系统（简称OJ）是一个在线的判题系统。用户可以在线提交程序多种程序（如C、C++、Pascal）源代码，系统对源代码进行编译和执行，并通过预先设计的测试数据来检验程序源代码的正确性。 一个用户提交的程序在Online Judge系统下执行时将受到比较严格的限制，包括运行时间限制，内存使用限制和安全限制等。用户程序执行的结果将被Onl...
组长我来开个头~~
oj_group3的博客
05-13 371
先从初级题入手： Prob 1.求int型整数中1的个数 #include #include #include "oj.h" #include /* 功能: 输入:整型 输出: 返回:返回1的个数 */ int GetCount(int iValue) { char bits[33]; memset(bits, 0, sizeof(char) * 33); i
华为OJ 在字符串中找出连续最长的数字串
yulubupt的专栏
05-08 994
第一种算法 O（n*n），时间超时了。不过答案是对的。 #include #include #include //#include "oj.h" using namespace std; /* 功能：在字符串中找出连续最长的数字串，并把这个串的长度返回 函数原型： unsigned int Continumax(char** pOutputstr, char* intputst
各种OJ网站，刷题必备
SSL_LJH的博客
09-07 1945
各种OJ网站 落谷 vijos JoyOI CodeVS Comet OJ 北京大学 浙江大学 杭州电子科技大学 信息学奥赛一本通 以上就是本蒟蒻所知的OJ网站 收集和打字应该值一个赞吧 ...
2021年OJ系统及编程平台汇总：从入门到进阶
OJ系统汇总是一份详细介绍各类在线编程竞赛平台的文档，发布日期为2021年10月5日，共计32页。这份文档涵盖了多个知名的编程竞赛平台，对不同水平的选手都有适用性。 1. **CCF中学生程序设计在线评测系统**：这是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值