复习C语言：王道C语言督学营OJ记录

已于 2022-08-23 20:47:19 修改
阅读量670 收藏 4
点赞数 1
分类专栏： 成长之路 文章标签： c语言 开发语言
于 2022-06-06 12:39:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s1hjf/article/details/125144451
版权

初级

Week1

Day1

Day1
one time had already accepted

#include <stdio.h>
//#include <stdlib.h>

int main() {
	printf("hello wangdao");
	//system("pause");
	return 0;
}

Day 2

Day2
one time had already accepted

//#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
	int a,b;
	scanf("%d%d",&a,&b);//一定要在变量前加入&符号
	//printf("a=%d,b=%d\n",a,b);
	//printf("a+b=%d", a + b);
	printf("%d", a + b);//%d以十进制方式输出某一个整型数
	return 0;
 }

但第二天也讲了进制转换的一部分简单内容。
十进制数转化为二进制数，再将二进制数转化为十六进制数。

Day 3

00 00 00 7b
x86架构是小端存储（英特尔还是AMD），低位在前，高位在后。

为什么内存数据要用十六进制去看？
高效简洁，两个字符表示一个字节，如7b就是一个字节。

1位 即1 bit 存储0或者1
1字节 即 1Byte = 8 bit
1Kb = 1024字节
1Mb = 1024 Kb
1Gb = 1024 Mb
int i就是四个字节
float f占四个字节
DaY3
因为输入在计算机内存中都是以二进制存储的（无论是整形，浮点型还是字符型），输出的时候选择合适的输出类型即可。

#include<stdio.h>
int main(){
	int a;
	scanf("%d",&a);
	printf("%c",a);
}

one time had already accepted

Week 2

Day 4

‘a’为字符型常量。
“a”、“How are you?”双引号包围的是字符串常量，C语言中并没有字符串变量。
不能将字符串型常量赋值给字符型变量。
Day4

#include<stdio.h> 
int main(){
	int year;
	scanf("%d",&year);
	if(year%4==0&&year%100!=0)
		printf("yes");
	else if(year%400==0)
		printf("yes");
	else
		printf("no");
}

one time had already accepted

Day 5

Day5

#include<stdio.h>
int main() {
	int i;
	char j;
	float k,sum;
	scanf("%d %c%f",&i,&j,&k);
	//j=int(j);
	sum=i+j+k;
	printf("%.2f",sum);
	return 0;
}

j=int（j）不能编译通过吗？在DEV上是可以编译的呀，再找找资料。
two accepted

Day 6

Day6

#include<stdio.h>
int main(){
	int a,duichen[10]={0},c[10]={0},i=0,j=0,time=0;
	int weishu=0;
	int ws;
	scanf("%d",&a);
	while(a!=0){
		duichen[i]=a%10;
		a=a/10;
		weishu++,i++;
	}
	ws=weishu-1;
	while(ws>=0){
		c[ws]=duichen[j];
		ws=ws-1;
		j=j+1;
	}
	for(time=0;time<i-1;time++){
		if(c[time]==duichen[time]){
			continue;
		}
		else{
			printf("no");
			break;
		}
	}
	if(time==weishu-1){
		printf("yes");
	}
	return 0;
}

一次提交AC
最开始的做法是取每一位数，然后倒序加起来，跟输入作比较，但在DEV里面math的幂函数计算不是很懂，就没过第二个Sample。
这一种方法是用数组存每一位，然后跟输入输入每一位作比较，每一位都相等就输出yes，若有一位不相等，直接输出no。

Week 3

Day 7.1

Day7.1

#include<stdio.h> 
int main(){
	int i=1,n,sum=1;
	scanf("%d",&n);
	while(i<=n){
		sum=sum*i;
		i++;
	}
	printf("%d",sum);
	return 0;
}

一次

Day 7.2

Day7.2
一次

#include<stdio.h> 
int main(){
	int a,b,c,d;
	int count=0;
	for(a=1;a<=37;a++){
		for(b=1;b<=37;b++){
			for(c=1;c<=18;c++){
				for(d=1;d<=9;d++){
					if((a*1+b*2+c*5+d*10==100)&&(a+b+c+d==40)){
						count=count+1;
					}
				}
			}
		}
	}
	printf("%d",count);
	return 0;
}

每种至少一张，暴力循环最多37次，总面值100，5元最多18次，因为至少有一张10元；10元最多9次。

Day 8

Day 8
一次

#include<stdio.h> 
int main(){
	int n,count=0;
	int a[100];
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
		if(a[i]==2){
			count++;
		}
	}
	printf("%d",count);
	return 0;
}

Day 9

day 9
中间可能有空格，用gets，而scanf就把空格忽略了

#include<stdio.h>
#include<string.h>
int main() {
	char c[100];
	char d[100];
	int i=0,j=0; 
	gets(c);
	j=strlen(c);
	for(i=0;i<strlen(c);i++) {	
		d[i] = c[j - 1];
		j--;
	}
	d[strlen(c)] = 0;
	int result = strcmp(c, d);
	if (result < 0){
		printf("%d\n", -1);
	}
	else if (result > 0){
		printf("%d\n", 1);
	}
	else {
		printf("%d\n", 0);
	}
	return 0;
}

Week 4

Day 10

day10
通过指针直接修改实参所对应的值
一次

#include<stdio.h> 

void change(int* j){
	*j=(*j)/2;
} 
int main(){
	int i;
	scanf("%d",&i);
	change(&i);
	printf("%d",i);
	return 0;
}

Day 11

day11
在DEV c++里面，malloc函数要调用stdlib库
//注意在scanf和gets中间使用scanf(“%c”,&c),去除换行
一次

#include<stdio.h>
#include<stdlib.h>//在DEV c++里面，malloc函数要调用stdlib库#include<stdlib>
int main() {
	int n;
	char huanhang;
	char *p;
	scanf("%d",&n);
	p=(char*)malloc(n);
	scanf("%c",&huanhang);//注意在scanf和gets中间使用scanf("%c",&c),去除换行（去除缓冲区内的\n）
	gets(p);
	puts(p);
	return 0;
}

Day12

day12
用函数递归写
注意函数返回值的接收
一次

#include<stdio.h> 
int sum=0;
int cal(int b){
	if(b>0){
		sum=cal(b-1);
	}
	if(b>0){
		sum=cal(b-2);
	}
	if(b==0){
		return sum+1;
	}
	return sum;
}
int main(){
	int a,ans;
	scanf("%d",&a);
	ans=cal(a);
	printf("%d",ans); 
	return 0;
}

这是一个斐波那契数列，没看出来，直接暴力递归了
斐波那契数列代码如下

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int step(int n) {
	if (1 == n || 2 == n) {
		return n; //结束条件
	}
	return step(n - 1) + step(n - 2); //结束公式
}
int main() {
	int n;
	scanf("%d", &n);
	printf("%d\n", step(n));
	return 0;
}

中级

Week 1

Day 1

中级 day1
简单考察结构体的使用，注意空格的输入和输出
一次

#include<stdio.h> 
struct student{
	int num;
	char name[20];
	char sex;
};
int main(){
	struct student xs;
	scanf("%d %s %c",&xs.num,&xs.name,&xs.sex);
	printf("%d %s %c",xs.num,xs.name,xs.sex);
	return 0;
}

Day 2

中级，day2
按要求写即可，注意引用的格式
一次

#include<stdio.h> 
#include<stdlib.h>
void shuru(char* &q){
	q=(char*)malloc(100);
	fgets(q,100,stdin);
}
int main(){
	char* p;
	shuru(p);
	printf("%s",p);
	return 0;
}

Day 3

中级Day3

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50
typedef int ElemType;//顺序表中元素的类型
//静态分配
typedef struct {
	ElemType data[MaxSize];//定义的数组，用来存元素
	int length;//当前顺序表中有多少个元素
}SqList;

bool ListInsert(SqList& L, int i, ElemType e) {
	if (i<1 || i>L.length + 1)//判断要插入的位置是否合法
		return false;
	if (L.length >= MaxSize)//元素存储满了，不能再存了
		return false;
	for (int j = L.length; j >= i; j--)//移动顺序表中的元素，从最后一个元素开始依次往后移动
		L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;//元素的位置从1开始，数组的下标从0开始。元素在数组中的下标即为位置减1
	L.length++;
	return true;//走到这里代表插入成果，返回True
}

//删除使用元素e的引用的目的是拿出对应的值
bool ListDelete(SqList& L, int i, ElemType& e) {
	if (i<1 || i>L.length)//如果删除的位置是不合法
		return false;
	if (L.length == 0) {//顺序表中没有元素，无需删除
		return false;
	}
	e = L.data[i - 1];//获取顺序表中对应的元素，赋值给e
	for (int j = i; j < L.length; j++) {//从i的位置依次把元素往前覆盖
		L.data[j - 1] = L.data[j];
	}
	L.length--;//删除一个元素，顺序表长度减1
	return true;
}

//打印顺序表元素
void PrintList(SqList & L) {
	for (int i = 0; i < L.length; i++) {
		printf("%3d", L.data[i]);//要求所有元素打印到一排
	}
	printf("\n");
}

int main() {
	SqList L;//顺序表的名称
	bool ret;//查看返回值，布尔型是True，或者False
	ElemType del;//用来存要删除的元素
	//首先手动在顺序表中前三个元素赋值
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.length = 3;//总计三个元素
	int shuru;
	scanf("%d",&shuru);
	ret = ListInsert(L, 2, shuru);//往第二个位置插入60这个元素
	if (ret) {
		PrintList(L);//打印成功后的顺序表
	}
	int shanchu; 
	scanf("%d",&shanchu);
	ret = ListDelete(L, shanchu, del);//删除第一个位置的元素，并把元素值输出
	if (ret) {
		PrintList(L);
	}
	else {
		printf("false\n");
	}
	return 0;
}

Day 4

Day4

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;//指向下一个节点
}LNode,*LinkList;//LinkList等价于struct Lnode
//头插法新建链表
LinkList CreatList1(LinkList& L)//list_head_insert
{
	LNode* s;
	int x;
	L = (LinkList)malloc(sizeof(LNode));//带头结点的链表
	L->next = NULL;//L->data里面没放东西
	scanf("%d", &x);//从标准输入读取数据
	//3 4 5 6 7 9999
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));//申请一个新空间给s，强制类型转换
		s->data = x;//把读取到的值，给新空间中的data成员
		s->next = L->next;//让新节点的next指针指向链表的第一个元素（第一个放我们数据的元素）
		L->next = s;//让s作为第一个元素
		scanf("%d", &x);//读取标准输入
	}
	return L;
}

//尾插法新建链表
LinkList CreatList2(LinkList& L)//list_tail_insert
{
	int x;
	L = (LinkList)malloc(sizeof(LNode));//创建带头结点的链表
	LNode* s, * r = L;//LinkList s,r=L;写成这样也可以,r代表链表表尾节点，指向链表尾部
	//3 4 5 6 7 9999
	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;//让尾部节点指向新节点
		r = s;//r指向新的表尾节点
		scanf("%d", &x);
	}
	r->next = NULL;//若不将尾节点的next赋值为NULL，则会出现异常
	return L;
}

//打印链表
void PrintList(LinkList L){
	L=L->next;
	while(L!=NULL){
	printf("%d",L->data);//打印当前结点数据
	L=L->next;//指向下一个结点
	if(L!=NULL){
	printf(" ");
	}
  }
	printf("\n");
}

//main函数
int main() {
	LinkList L;//链表头，是结构体指针类型
	CreatList1(L);//输入数据可以为3 4 5 6 7 9999,头插法添加元素
	PrintList(L);//链表打印
	//printf("\n");
	CreatList2(L);
	PrintList(L);//链表打印
	return 0;
}

连续输入两次，再输出两次即可（输入一行输出一行，然后再输入第二行数据，然后进行第二次输出）

Day 5

Day5

#include<stdio.h>
#include<stdlib.h>

#define MaxSize 50

#define MaxSize_queue 5

typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];//数组
	int top;
}SqStack;

typedef struct {
	ElemType data[MaxSize_queue];//数组，存储MaxSize-1个元素
	int front, rear;//队列头，队列尾
}SqQueue;

void InitStack(SqStack &S) {
	S.top = -1;//代表栈为空
}

bool StackEmpty(SqStack S) {
	if (-1 == S.top) {
		return true;
	}
	else{
	return false;
	}
}

//入栈
bool Push(SqStack& S, ElemType x) {
	if (S.top == MaxSize - 1) {//数组的大小不能改变，避免访问越界
		return false;//栈满了
	}
	S.data[++S.top] = x;
	return true;//返回true就是入栈成功
}

//出栈
bool Pop(SqStack& S, ElemType& x) {
	if (StackEmpty(S)) {//栈为空
		return false;
	}
	x = S.data[S.top--];//等价于x=S.data[S.top];再做S.top--;
	return true;
}

void InitQueue(SqQueue &Q){
	Q.front = Q.rear = 0;
}

//判空
bool isEmpty(SqQueue &Q){
	if (Q.front = Q.rear)//不需要为零
		return true;
	else
		return false;
}

//入队
bool EnQueue(SqQueue &Q,ElemType x){
	if ((Q.rear + 1) % MaxSize_queue == Q.front) {
		return false;//队列满了
	}
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize_queue;//向后移动一格
	return true;
}

//出队
bool DeQueue(SqQueue &Q,ElemType &x){
	if (Q.front == Q.rear) {//队列为空
		return false;
	}
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize_queue;
	return true;
}

int main() {
	SqStack S;
	bool flag;
	ElemType m;//存储拿出来的栈顶元素的
	InitStack(S);//初始化
	flag = StackEmpty(S);
	int a,b,c;
	int q,w,e,r,t;
	scanf("%d%d%d",&a,&b,&c); 
	scanf("%d%d%d%d%d",&q,&w,&e,&r,&t);
	Push(S, a);
	Push(S, b);
	Push(S, c);
	flag = Pop(S, m);//弹出栈顶元素
	if (flag) {
		printf(" %d", m);
	}
	flag = Pop(S, m);//弹出栈顶元素
	if (flag) {
		printf(" %d", m);
	}
	flag = Pop(S, m);//弹出栈顶元素
	if (flag) {
		printf(" %d", m);
	}
	printf("\n");
	SqQueue Q;
	bool ret;//存储返回值
	ElemType element;//存储出队元素
	InitQueue(Q);//初始化循环队列
	EnQueue(Q, q);
	EnQueue(Q, w);
	EnQueue(Q, e);
	EnQueue(Q, r);
	ret = EnQueue(Q, t);
	if (ret) {
		printf("入队成功\n");
	}
	else {
		printf("false\n");
	}
	ret = DeQueue(Q, element);
	if (ret) {
		printf(" %d",element);
	}
	ret = DeQueue(Q, element);
	if (ret) {
		printf(" %d",element);
	}
	ret = DeQueue(Q, element);
	if (ret) {
		printf(" %d",element);
	}
	ret = DeQueue(Q, element);
	if (ret) {
		printf(" %d",element);
	}
	return 0;
}

把栈和循环队列的代码放在一起就行了，注意，在视频写的main.cpp中有相同的变量名，注意替换。

努力向前的JF（s1hjf）
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
王道C语言督学营oj练习附个人学习感受（持续更新ing）
qq_43498726的博客
02-23 7109
初级阶段 个人感受分享： 初级阶段比较基础，但像龙哥说的那样，即使是科班出身，也需要听课。龙哥讲课把C语言以及之后考研用到的数据结构、计算机组成原理都有融合，也带着一步一步进行进行调试，在代码运行和问题解决方面有很大的收获。 这里建议大家上完课立马去写作业进行巩固，否则会对知识有所遗忘，有条件的朋友可以多刷几次课程加深记忆与理解。 关于oj，有时候确实很烦人。但现在BAT企业以及考研复试都是使用oj系统，所以也是刚好的帮助大家适应。我也曾多次被oj折磨的痛不欲生，但在这个过程中也是有提升自己的耐心，当你听到
C语言督学营初级思维导图
01-25
自己写的，如果有大佬看到我这个有错误，希望可以指正一下 零基础跨考的
王道c语言 OJ
weixin_46091602的博客
04-12 544
Description 输入3 4 5 6 7 9999一串整数，9999代表结束，通过尾插法新建链表，查找第二个位置的值并输出，在2个位置插入99，输出为 3 99 4 5 6 7，删除第4个位置的值，打印输出为 3 99 4 5 6 7。 输出函数如下： void PrintList(LinkList L) { L = L->next; while (L != NULL) { printf(“%3d”, L->data);//打印当前结点数据 L = L->next
王道C语言 OJ
weixin_46091602的博客
04-12 564
题目:输入一个整型数，然后申请对应大小空间内存，然后读取一个字符串，字符串的输入长度小于最初输入的整型数大小，最后输出输入的字符串即可（无需考虑输入的字符串过长，超过了内存大小）； 注意下面问题： char *p; scanf(“%d”,&n); p=malloc(n); scanf(“%c”,&c);//注意在scanf和gets中间使用scanf(“%c”,&c),去除换行 gets§; #define _CRT_SECURE_NO_WARNINGS #include<st
王道：c语言OJ
2201_75903640的博客
03-14 408
新建一个栈，读取标准输入3个整数3 4 5，入栈3 4 5，依次出栈，打印 5 4 3，新建循环队列（Maxsize为5），读取标准输入3 4 5 6 7，入队7时，队满，打印false，然后依次出队，输出 3 4 5 6。读取标准输入，内容依次是3 4 5，换行后，接着是3 4 5 6 7。如果输入是3 4 5，换行，接着是3 4 5 6 7，那么输出是。
王道C语言督学营oj练习（全部更新完成）
热门推荐
weixin_51330523的博客
04-10 3万+
王道C语言督学营oj练习及答案
王道C语言督学营OJ练习全解【24考研最新版】
一个非常Cool的人
03-03 4007
本篇博客是在博主参加王道408专业课前置课程-----C语言督学营的学习笔记，包含了从第一节课到最后一节课的所有OJ习题题解，文章中每一题都给出了详尽的代码，并在每一题的关键部位加上了注释，记录下来的目的是方便自己以后进行复习，也希望能够帮助到大家，经过测试所有代码都可以通过王道OJ网站给出的样例，如果还有什么疑问的话评论区留言吧！（tips:网站上的样例比较简单，可能刷刷小聪明也可以通过，但是我建议大家还是按照要求来最好，毕竟是要锻炼自己的能力，投机取巧也不好！如果是感觉非常没有必要的能省则省。）
C语言督学营.md
09-23
C语言督学营.md
上课的C语言课件
03-21
C语言课件
c语言考研指导
07-31
这是关于c语言考研方面的资料书，读者可以从中掌握考研规律及技巧
王道【计算机408学习笔记】C语言(初级)学习笔记 01课程导学、编程环境搭建+02数据的类型、数据的输入输出（部分）
01-03
内容摘要：根据王道计算机408C语言督学营-初级课程进行的笔记整理 适用人群：考研的人，计算机或软件工程等 适用场景及目标：考研、C语言入门
王道考研408 | 数据结构 | 栈的实验代码 | 王道C语言督学营
lijiamingccc的博客
03-22 379
目录实验环境栈的存储结构栈的初始化 InitStack(Sqstack& S)栈判空 StackEmpty(Sqstack S)元素进栈 Push(Sqstack& S, ElemType x)获取栈顶元素 GetTop(Sqstack S, ElemType& m)弹出栈顶元素 Pop(Sqstack& S, ElemType& x)测试代码测试结果 实验环境 vscode 2022 社区版 vscode 2022 社区版的搭建： https:/
王道考研408 | 数据结构 | 循环队列的实验代码 | 王道C语言督学营
lijiamingccc的博客
03-23 1613
目录循环队列的存储结构循环队列的初始化 InitQueue(SqQueue& Q)循环队列判空 isEmpty(SqQueue Q)循环队列 入队 EnQueue(SqQueue& Q, ElemType x)循环队列出队 DeQueue(SqQueue& Q, ElemType& x)循环队列 待出队元素 Getfront(SqQueue& Q, ElemType& x)遍历队列元素 printQueue(SqQueue Q)测试代码测试截图 循环队列的存
C语言笔记第9篇：字符函数和字符串函数
2302_78977491的博客
05-28 936
在编程的过程中，我们经常要处理字符和字符串，为了方便操作字符和字符串，C语言标准库中提供了一系列库函数，接下来我们就学习一下这些函数。一、
聊一聊开发语言的基础控制结构
m0_46552684的博客
05-28 1194
一、描述下for循环、while循环和do-while循环的区别和用法。在编程中，for循环、while循环和do-while循环是用于重复执行一段代码直到满足特定条件的控制结构。每种循环都有其特定的用途和语法。
pd16.py11111111111
最新发布
06-02
pd16.py11111111111
u-boot-2024.07-rc3.tar.bz2
06-02
【U-Boot 2024.07源码深度解析】002 - 下载及编译 U-Boot 源码 https://blog.csdn.net/Ciellee/article/details/139381921 配套的资源
287_基于移动端选课系统的设计与实现-源码.zip
06-02
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
4_New Project_2024-05-28_touch_test.eprj
06-02
4_New Project_2024-05-28_touch_test.eprj

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值