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

初级

Week1

Day1

one time had already accepted

#include 
//#include 

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

Day 2

one time had already accepted

//#define _CRT_SECURE_NO_WARNINGS
#include 
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占四个字节

因为输入在计算机内存中都是以二进制存储的（无论是整形，浮点型还是字符型），输出的时候选择合适的输出类型即可。

#include
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语言中并没有字符串变量。
不能将字符串型常量赋值给字符型变量。

#include 
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

#include
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

#include
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

#include 
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

一次

#include 
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

一次

#include 
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

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

#include
#include
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

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

#include 

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

Day 11

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

#include
#include//在DEV c++里面，malloc函数要调用stdlib库#include
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

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

#include 
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
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

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

#include 
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

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

#include 
#include
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

#include
#include
#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

#define _CRT_SECURE_NO_WARNINGS
#include
#include

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

#include
#include

#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中有相同的变量名，注意替换。