挑战408——组成原理（1）——看看我们要学什么

计算机的发展历程

我一直觉得，要想深入理解，学习一门课程，就必须了解一下它的发展史，尤其是计算机发展对比其他的专业来说可以说是相当的晚了。才100多年历史。所以有机会我一定要好好看看这100年计算机都发生了什么。 言归正传。世界上第一台计算机是1946年在美国诞生的ENIAC。1945年，冯诺依曼提出了存储程序的思想：必须将事先编好的原始程序和数据一同送入主存后，才能执行程序，一旦程序被执行，计算机能在无须人工操作的干预下，自动完成逐条取出指令，并执行的任务。 1965年，Intle公司的缔造者Gordon提出，“微芯片上的集成的晶体管数目，每三年番2倍”的规律，这就是著名的摩尔定律。

硬件发展带来的问题

微处理器的发展，几乎每3年，处理器的性能就提高4—5倍，但计算机上的一些其他部位性能提高的速度达不到该水平 。影响不同部件性能不匹配的主要处理因素为CPU与主存间接口和CPU与外设的接口问题，具体体现在： - CPU与主存之间：是整个计算机最重要的通路，负责在主存和处理器之间传送指令和数据。试想如果与CPU之间的数据传送跟不上CPU的要求，那么CPU就会处于等待状态。一般的我们采取如下方式进行处理： - 加宽数据总线的宽度（道路太挤，扩宽一下） - 在两者之间设置高速缓存（Cache，先给CPU提前准备好原料），并发展为片内缓存和分级缓存。 - 利用高速连接总线和分层总线，来缓冲和分流数据。以提高处理器与存储器之间的连接宽带。 - CPU与外设之间的接口：常见的处理方式： - 加入缓冲机制 - 用高速互连总线以及更快的总线结构来解决。
这些问题都是硬件发展中带来的问题，也是这门课程重点讨论的问题。下面介绍一下软件的发展历程。个人认为仅做了解即可。

软件的发展

软件技术的发展主要体现在编程语言之间的进步。编程语言大致经历了如下的阶段： 机器语言(0 1 代码)——>汇编语言（与机器语言对应）——>高级语言（C++,JAVA）而高级语言不能直接运行，而是需要由程序翻译成机器语言，所以将高级语言程序翻译为机器语言程序的软件，称为翻译程序。而翻译程序又根据翻译形式的不同，分为两种形式： - 编译程序：先把所有的程序都全部翻译完，再执行 - 解释程序：翻译一次，执行一次，边翻译边执行

计算机系统的层次结构

先上图：

说白了，这个体系就分为两个部分，软件范围(M4 - M 2)和硬件范围（M1-M0）.而软件与硬件之间需要有一个桥梁，以便软件和硬件能相互合作，交互。这个桥梁位于 M2和M1之间，这个桥梁称为指令集体结构（ISA）。也就是说，软件与硬件的交互是通过指令来进行的。
典型的冯诺依曼体系结构及其特点

机器以运算器为中心。I/O设备与存储器之间的数据传送通过运算器完成 2. 计算机由运算器，控制器，存储器，I/O设备 五大部件组成。 3. 指令和数据地位相同，按地址访问，按顺序存放
PS：这门课程就是以2为主线，讲解计算机的组成原理的。

计算机软件的分类

一般的我们将计算机软件分为：系统软件和应用软件。其中系统软件包括操作系统，数据库管理系统，语言处理系统等等。

计算机的性能指标

机器字长：指CPU一次能处理的数据的位数。字长越长，数的表示范围越大，精度越高
存储容量：包括主存和辅存容量。具体的到讲了存储器再说。
运算速度：
MIPS：单位时间内执行指令的平均条数
CPI：执行一条指令所需要的时钟周期
FLOPS：每秒的浮点数运算的次数
最常见的问题：指令和数据如何区分？

挑战408——组成原理（2）——二进制数和十六进制数

这算是数据的表示运算这一部分的第一篇文章了，这部分多且繁杂，因为我们通常都是以10进制的数进行计算和表示的，用了10几年，突然接受一种新的表示方式难免会导致理解困难。初学这章我也是半懵逼状态的，好在复习了一轮后，又去多次问了老师相应的问题，才算有个大致的了解。所以这系列的文章如果有不对的地方，欢迎批评指正。
这篇是基础篇，是学习后面的各种运算的基础，所以得好好看，好好理解。

从10进制->2进制->16进制

我们的日常习惯，是用10进制表示的，如果满10了就向前进一位。比如 9 + 2 = 11. 9 + 2 = 10 + 1,所以向前进一位，剩下的位数填在后面。
那么好端端的为什么我们在机器中不用10进制表示而非要改变常规的思路使用二进制呢？我们当然不是吃饱了撑的，是没办法的事，因为这是由计算机的硬件决定的（可以多去百度，不细说）。在接下来的学习中，10进制到2进制的转换就是家常便饭了。具体的转换规则我想打算考408的不可能不会，所以不说。
类似的，计算机也常有16进制来表示一些数，如果说二进制是为了让计算机更容易理解我们的10进制表达方式，那么16进制就是为了让我们更容易读懂计算机的表达方式，而且利用16进制数可以快速的在2进制和16进制之间相互转化。（因为4位2进制数恰好可以表示16个数字（即0-15））。16进制数最常用的是在表示物理内存空间的时候，比如我们看到的0xAFFFH等等就是典型的16进制数。

BCD编码

为了方便的表示各二进制与其他进制的转换关系，于是有了BCD编码，编码的种类很多，我们就讲最简单，最常用的8421编码。特点是用4位二进制数表示一位16进制的数。
下面的表列出了8421编码的对应项（完全可以自己手动算，要记住下面的这个内容）：

为什么强调这张表的重要性呢？我们看看怎么转换吧：
比如，给出一个16进制的数036A，我们化为二进制数就可以这样化：

从末尾开始，将每个16进制的位数都按照形式相应的写出二进制数。
拼接即可。
所以，直接写出二进制数为：
0000,0011,0110,1010（是不是特别方便？这里的逗号是为了方便观察而加的，实际不存在）。

挑战408——组成原理（3）——原码，补码，反码

计算机中的数据分为数值数据和非数值型数据（如声音，图像等等）。我们接下来主要谈的是数值型数据。
在现实的生活中，数值数据主要分为实数和整数两大类，在计算机中，整数用定点数表示，实数用浮点数表示，而所有带符号的整形都用补码表示。目前通用计算机中浮点数大多数采用IEEE754标准，其中尾数采用定点原码表示，所以浮点数的算术运算涉及原码的加减乘除运算。

无符号数与有符号数

无符号数，即没有正负号的数，是数的绝对值，在其面前添上正负号，便成了有符号的数。计算机的数均存放在寄存器中，通常我们称寄存器的位数为机器字长，当存放有符号数的时候，需要占用以为存放符合位，所有，如若机器字长为16位，那么：

无符号数可表示的范围为 0 — 2^（16） -1
有符号数可表示的范围为 -2^15 — 2^（15） - 1
15次方是因为符号位占用了一位。
那么计算机如何表示有符号数呢？我们规定，用0表示正号，用1表示负号，这样符号也就被数字化了，并规定放在有效数据之前，例如：
+0.1011 在机器中表示为0（小数点位置）1011
-1100 在机器中表示为1，1100（小数点位置）
为了方便区分手写的数和将符号数字化的数，我们把前者称为真值，后者称为机器数。即
-1100（真值） -> 11100（机器数）
将符号数字化以后带来了新的问题，运算时，符号位是否参与运算，如果是，那么如何处理？为了处理好这些问题，于是就引入了原码，补码，反码和移码等编码方式。

原码

原码，又称带符号的绝对值表示，符号位为0表示正，为1表示负。用大白话来讲，就是直接将数值部分写成二进制数然后前面添上0或者1，用来表示正负号。

其实上面的公式我们只需要了解即可，实际的转换很简单
比如X = +1110时 [X]原 = 0,1110
X = -1110时 [X]原 = 1,1110 （逗号只是为了区分符号位实际不存在）
X = 0.1101时 [X]原 = 0.1101
X = -0.1101时 [X]原 = 1,1110（注意不是10.1101，因为0并不是有效数据位）。

注意：

若字长为n+1，那么原码整数的表示范围为：

原码中0的表示方式有两种：

补码

如果说是这几种码制中最重要的编码方式，一点也不为过。计算机中存放的数值方式大多数是用补码存放，计算（尤其是减法做加法运算时）时也通常采用补码运算方式，因此要对补码非常敏感。

对于纯整数：
对于纯小数：

而对于0而言，

具体的实例不举先，先看看我们的反码，我们没有必要按上面的数学公式往上套。

反码

反码，通常用来由原码求补码或者由补码求原码的过渡环节。
我们先看看数学定义：

对于纯小数：

对于纯整数：

所以，记住上面的就够了，我们具体看看运算过程，取反操作就是将原码中的0换成1,1换成0.就完事了。
当X = +1101时，X反 = 0，1101
当X = -1101时，X反 = 1，0010（当为负数的时候，符号位不变，数值位执行取反操作）
当X = +0.0110时，X反 = 0.0110
当X = -0.0110时，X反 = 1.1001

对于0来说，反码的表示方式也有两种（0，000或者1,111），这就自己去写了。

三种码制之间的关系（最重要）

前面的数学公式是应付表示范围类的题目，那么这些内容就是应付计算题的题目：

三种机器码的最高位均为符号位，符号位与数值位用逗号隔开
当真值为正时，原码补码反码表示方式相同。
当真值为负时，三者表现都不同，但是符号位都用1表示，补码可以用“原码求反（不含符号位）后加1”求得。而反码是原码除了符号位以外的部分都进行取反操作。
下面举个简单的计算例子：

移码

当真值用补码表示的时候，由于符号位与数值位一起编码，这与习惯上表示不同，我们很难从补码形式上直接判断真值的大小。但是如果对每个真值位（注意不包含符号位），都加上一个2^n（n为整数位），那么在数轴上，移码表示的范围恰好对应真值在数轴上移动2的n次方个单元。所以叫做移码。

它常常用来表示浮点数的阶数，因为它只能表示整数。
对于移码来说，0的表示是唯一的，假设字长为6位（含一个符号位）那么0的表示为：
+0移 = (2^5) + 0 =1,00000
-0移 = (2^5) - 0 =1,00000
特点：

0 的表示方式唯一
对于同一个真值，移码和补码相差一个符号位，且相反，例如：-11110 补码为1,00010，移码为：000010
引入移码是为了直观的判断真值大小，所以移码大，真值就大

基础算法学习

穷举法

递推法

顺推法

斐波那契数列

逆推法

猴子吃桃

迭代算法

递归算法

数制转换算法

1.十进制转二、八、十六进制

（二进制-除2倒取余法）

十进制整数转换为二进制整数采用”除2取余，逆序排列“法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为零时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>
int main()
{
	int m,n,t;
	printf("请输入要转换的十进制数；");
	scanf("%d",&m);
	t=1;
	n=m;          //存m,如n=53
	while(m)
	{
		t=t*2;
		m=m/2;
	}                             //求t,转换
	t=t/2;
	while(t)
	{
		printf("%d",n/t);
		n=n%t;
		t=t/2;
	}                               //利用t,n求值
	return 0;
}

2.二转十

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stdio.h>
int main()
{
	char b;
	int d;
	printf("请输入要转换的二进制数：");
	d=0;
	scanf("%c",&b);
	while(b!='\n')
	{
		d=d*2+(b-48);
		scanf("%c",&b);
	}
	printf("%d\n",d);
	return 0;
}

数学问题

1.最值问题

2.数列求和（积）

3.整数数字问题

4.整数因子问题

5.最大公约数最小公倍数问题

6.素数问题

7.解非线性方程

（1）牛顿迭代法

（2）二分法

数据结构

1.1数据结构研究内容

PAT乙级学习笔记

编号 标题 题解 分类
1001 害死人不偿命的(3n+1)猜想 C++ 简单模拟
1002 写出这个数 C++ 字符串处理
1003 我要通过！ C++ 数学
1004 成绩排名 C++ 查找元素
1005 继续(3n+1)猜想 C++ 散列
1006 换个格式输出整数 C++ 字符串处理
1007 素数对猜想 C++ 素数
1008 数组元素循环右移问题 C++ 简单模拟
1009 说反话 C++、Java、python 字符串处理
1010 一元多项式求导 C++ 简单模拟
1011 A+B和C C++ 简单模拟
1012 数字分类 C++ 简单模拟
1013 数素数 C++ 素数
1014 福尔摩斯的约会 C++ 字符串处理
1015 德才论 C++ 排序
1016 部分A+B C++ 简单模拟
1017 A除以B C++ 大整数运算
1018 锤子剪刀布 C++ 简单模拟
1019 数字黑洞 C++ 数学
1020 月饼 C++ 贪心
1021 个位数统计 C++ 字符串处理
1022 D进制的A+B C++ 进制转换
1023 组个最小数 C++ 贪心
1024 科学计数法 C++ 字符串处理
1025 反转链表 C++ 链表
1026 程序运行时间 C++ 简单模拟
1027 打印沙漏 C++ 字符串处理
1028 人口普查 C++ 查找元素
1029 旧键盘 C++ 散列
1030 完美数列 C++ 二分查找、two pointers
1031 查验身份证 C++ 字符串处理
1032 挖掘机技术哪家强 C++ 查找元素
1033 旧键盘打字 C++ 散列
1034 有理数四则运算 C++ 分数
1035 插入与归并 C++ 暂无
1036 跟奥巴马一起编程 C++ 图形输出
1037 在霍格沃茨找零钱 C++ 进制转换
1038 统计同成绩学生 C++ 散列
1039 到底买不买 C++ 散列
1040 有几个PAT C++ 动态规划
1041 考试座位号 C++ 查找元素
1042 字符统计 C++ 散列
1043 输出PATest C++ 散列
1044 火星数字 C++ 进制转换+字符串处理
1045 快速排序 C++ 动态规划
1046 划拳 C++ 简单模拟
1047 编程团体赛 C++ 散列
1048 数字加密 C++ 字符串处理
1049 数列的片段和 C++ 数学
1050 螺旋矩阵 C++ 中级模拟
1051 复数乘法 C++ 数学
1052 卖个萌 C++ 字符串处理
1053 住房空置率 C++ 简单模拟
1054 求平均值 C++ 字符串处理
1055 集体照 C++ 排序+中级模拟
1056 组合数的和 C++ 简单模拟
1057 数零壹 C++ 进制转换
1058 选择题 C++ 中级模拟+常用stl
1059 C语言竞赛 C++ 散列
1060 爱丁顿数 C++ 中级模拟
1061 判断题 C++ 简单模拟
1062 最简分数 C++ 分数
1063 计算谱半径 C++ 简单模拟
1064 朋友数 C++ 常用stl
1065 单身狗 C++ 散列+常用stl
1066 图像过滤 C++ 简单模拟
1067 试密码 C++ 字符串处理
1068 万绿丛中一点红 C++ 简单模拟
1069 微博转发抽奖 C++ 中级模拟
1070 结绳 C++ 贪心
1071 小赌怡情 C++ 简单模拟
1072 开学寄语 C++ 中级模拟+二分查找
1073 多选题常见计分法 C++ 中级模拟+常用stl
1074 宇宙无敌加法器 C++ 进制转换+字符串处理
1075 链表元素分类 C++ 链表
1076 Wifi密码 C++ 简单模拟
1077 互评成绩计算 C++ 简单模拟
1078 字符串压缩与解压 C++ 字符串处理
1079 延迟的回文数 C++ 大整数运算
1080 MOOC期终成绩 C++ 排序
1081 检查密码 C++ 字符串处理
1082 射击比赛 C++ 查找元素
1083 是否存在相等的差 C++ 常用stl
1084 外观数列 C++ 字符串处理
1085 PAT单位排行 C++ 排序
1086 就不告诉你 C++ 水题
1087 有多少不同的值 C++ 水题
1088 三人行 C++ 简单模拟
1089 狼人杀-简单版 C++ 简单模拟
1090 危险品装箱 C++ 常用stl
1091 N-自守数 C++ 水题
1092 最好吃的月饼 C++ 查找
1093 字符串A+B C++ 散列
1094 谷歌的招聘 C++ 素数
1095 解码PAT准考证 C++ 排序
————————————————
版权声明：本文为CSDN博主「日沉云起」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/richenyunqi/article/details/84981369

https://blog.csdn.net/qq_40946921/article/details/81320389

Italink

https://blog.csdn.net/weixin_42582136/article/details/100155268

[ME->CS]

字符串处理

1002 写出这个数 (20 分)

读入一个正整数 n，计算其各位数字之和，用汉语拼音写出和的每一位数字。

输入格式：

每个测试输入包含 1 个测试用例，即给出自然数 n 的值。这里保证 n 小于 10100。

输出格式：

在一行内输出 n 的各位数字之和的每一位，拼音数字间有 1 空格，但一行中最后一个拼音数字后没有空格。

输入样例：

1

1234567890987654321123456789

输出样例：

1

yi san wu

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <cstdio>
#include <cmath>
int process(char a[])
{
	int result=0;
	for(int i=0;a[i]!='\0';++i)
	{
		result+=a[i]-'0';
	}
	return result;
}
int main()
{
	char num[110];
	char arti[10][6]={"ling","yi","er","san","si","wu","liu","qi","ba","jiu"};
	scanf("%s",num);
	int res=process(num);
	int count=0;
	int temp=res;
	while(temp!=0)
	{
		temp/=10;
		++count;
	}
	int pro;
	do
	{
		pro=pow(10.0,count-1);
		printf("%s",arti[res/pro]);
		if(count>1)
			printf(" ");
		else
			printf("\n");
		res%=pro;
		--count;
	}while(count>0);
	return 0;
}

emmmmm  就是先用字符数组存储，然后将每一位数加起来得到结果，最后处理的时候，可以利用整除法计算出数字的位数，然后再从高位到低位依次去整输出，（能用这种方法的原因是100位就算全是9加起来也就900，10的3次方而已，不会超限）注意末尾没有空格哦，其他的就没啥啦~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <iostream>  (柳神代码)
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int sum = 0;
string str[10] = {"ling", "yi", "er", "san", "si", "wu", "liu", "qi",
"ba", "jiu"};
for (int i = 0; i < s.length(); i++)
sum += (s[i] - '0');
string num = to_string(sum);
for (int i = 0; i < num.length(); i++) {
if (i != 0) cout << " ";
cout << str[num[i] - '0'];
}
return 0;
}

分析：⽤用string接收输⼊入，string的每⼀一位数字累加到sum⾥里里⾯面，再将sum转化为string类型的num，对
num的每⼀一位输出对应中⽂文拼⾳音～

C++入门

备注：cstdio是将stdio.h的内容用C++头文件的形式表示出来。stdio.h是C标准函数库中的头文件，即：standard buffered input&output。提供基本的文字的输入输出流操作（包括屏幕和文件等）。由于C语言并没有提供专用于文字输入输出的关键字，所以该库是最普遍的C语言程序加载库。

cstdio 和 stdio.h是有差别的，并不是同样的文件。

stdio.h是以往的C和C++的头文件，cstdio是标准C++（STL），且cstdio中的函数都是定义在一个名称空间std里面的，如果要调用这个名字空间的函数，必须得加std::或者在文件中声明using namespace std。 [2]

1

`#include<cstdio>` `using``　``namespace``　std;``/*你也可以同时加上这个语句*/`

明解C语言-中级篇

第1章 猜数游戏

1-1 猜数判定

1.通过 if语句实现条件分支

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/* 猜数游戏（其一：测试版）*/

#include <stdio.h>
int main(void)
{
	int no;			/* 读取的值 */
	int ans = 7;	/* 目标数字 */
printf("请猜一个0~9的整数。\n\n");
printf("是多少呢：");
scanf("%d", &no);
if (no > ans)
	printf("\a再小一点。\n");
else if (no < ans)
	printf("\a再大一点。\n");
else
	printf("回答正确。\n");
return 0;
}

转义字符 \n 换行 \a 警报

2.if 语句的嵌套

一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。

if语法

C 语言中 if 语句的语法：

1
2
3
4

if(boolean_expression)
{
   /* 如果布尔表达式为真将执行的语句 */
}

C 语言中 if…else 语句的语法：

1
2
3
4
5
6
7
8

if(boolean_expression)
{
   /* 如果布尔表达式为真将执行的语句 */
}
else
{
   /* 如果布尔表达式为假将执行的语句 */
}

if…else if…else 语句

一个 if 语句后可跟一个可选的 else if…else 语句，这可用于测试多种条件。

当使用 if…else if…else 语句时，以下几点需要注意：

• 一个 if 后可跟零个或一个 else，else 必须在所有 else if 之后。
• 一个 if 后可跟零个或多个 else if，else if 必须在 else 之前。
• 一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。

C 语言中的 if…else if…else 语句的语法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

if(boolean_expression 1)
{
   /* 当布尔表达式 1 为真时执行 */
}
else if( boolean_expression 2)
{
   /* 当布尔表达式 2 为真时执行 */
}
else if( boolean_expression 3)
{
   /* 当布尔表达式 3 为真时执行 */
}
else 
{
   /* 当上面条件都不为真时执行 */
}

在 C 语言中，嵌套 if-else 语句是合法的，这意味着您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。

C 语言中 嵌套 if 语句的语法：

1
2
3
4
5
6
7
8

if( boolean_expression 1)
{
   /* 当布尔表达式 1 为真时执行 */
   if(boolean_expression 2)
   {
      /* 当布尔表达式 2 为真时执行 */
   }
}

1-1 重复猜到对为止

重复输入 循环判断

do while 语句 先循环 后判断 注意 while 末尾带有;

1.通过do语句循环

C do…while 循环

不像 for 和 while 循环，它们是在循环头部测试循环条件。在 C 语言中，do…while 循环是在循环的尾部检查它的条件。

do…while 循环与 while 循环类似，但是 do…while 循环会确保至少执行一次循环。

语法

C 语言中 do…while 循环的语法：

1
2
3
4
5

do
{
   statement(s);

}while( condition );

请注意，条件表达式出现在循环的尾部，所以循环中的 statement(s) 会在条件被测试之前至少执行一次。

如果条件为真，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。这个过程会不断重复，直到给定条件变为假为止。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stdio.h>
 
int main ()
{
   /* 局部变量定义 */
   int a = 10;

   /* do 循环执行 */
   do
   {
       printf("a 的值： %d\n", a);
       a = a + 1;
   }while( a < 20 );
 
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

1
2
3
4
5
6
7
8
9
10

a 的值： 10
a 的值： 11
a 的值： 12
a 的值： 13
a 的值： 14
a 的值： 15
a 的值： 16
a 的值： 17
a 的值： 18
a 的值： 19

2.通过while语句循环

while 循环

只要给定的条件为真，C 语言中的 while 循环语句会重复执行一个目标语句。

语法

C 语言中 while 循环的语法：

1
2
3
4

while(condition)
{
   statement(s);
}

在这里，statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。

condition 可以是任意的表达式，当为任意非零值时都为 true。当条件为 true 时执行循环。 当条件为 false 时，退出循环，程序流将继续执行紧接着循环的下一条语句。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stdio.h>
 
int main ()
{
   /* 局部变量定义 */
   int a = 10;

   /* while 循环执行 */
   while( a < 20 )
   {
      printf("a 的值： %d\n", a);
      a++;
   }
 
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

1
2
3
4
5
6
7
8
9
10

a 的值： 10
a 的值： 11
a 的值： 12
a 的值： 13
a 的值： 14
a 的值： 15
a 的值： 16
a 的值： 17
a 的值： 18
a 的值： 19

C break 语句

C 语言中 break 语句有以下两种用法：

1. 当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。
2. 它可用于终止 switch 语句中的一个 case。

如果您使用的是嵌套循环（即一个循环内嵌套另一个循环），break 语句会停止执行最内层的循环，然后开始执行该块之后的下一行代码。

语法

C 语言中 break 语句的语法：

1

break;

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>
 
int main ()
{
   /* 局部变量定义 */
   int a = 10;

   /* while 循环执行 */
   while( a < 20 )
   {
      printf("a 的值： %d\n", a);
      a++;
      if( a > 15)
      {
         /* 使用 break 语句终止循环 */
          break;
      }
   }
 
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

1
2
3
4
5
6

a 的值： 10
a 的值： 11
a 的值： 12
a 的值： 13
a 的值： 14
a 的值： 15

1-3 随机设定目标数字

C语言实验题――相加和最大值

时间限制: 1000MS 内存限制: 65536KByte 64位IO格式:%I64d & %I64u

描述输入三个整数a,b,c。并进行两两相加，最后比较相加和的最大值。输入输入数据包含三个整数，用空格分开。输出输出两两相加后的最大值。样例输入**样例输出**[提交

1001 害死人不偿命的(3n+1)猜想 (15 分)

卡拉兹(Callatz)猜想：

对任何一个正整数 n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把 (3n+1) 砍掉一半。这样一直反复砍下去，最后一定在某一步得到 n=1。卡拉兹在 1950 年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证 (3n+1)，以至于有人说这是一个阴谋，卡拉兹是在蓄意延缓美国数学界教学与科研的进展……

我们今天的题目不是证明卡拉兹猜想，而是对给定的任一不超过 1000 的正整数 n，简单地数一下，需要多少步（砍几下）才能得到 n=1？

输入格式：

每个测试输入包含 1 个测试用例，即给出正整数 n 的值。

输出格式：

输出从 n 计算到 1 需要的步数。

输入样例：

1

3

输出样例：

1

5

问题 A: 例题5-1-1 连续自然数求和时间限制: 1 Sec 内存限制: 12 MB
提交: 2221 解决: 1832
[提交][状态][讨论版][命题人:外部导入]

题目描述

求1+2+3+…+100，即求

要求用while语句实现

输入

无

输出

要求的和，末尾输出换行。

样例输入

1

无

样例输出

1

5050

[提交][状态]

描述

输入三个整数a,b,c。并进行两两相加，最后比较相加和的最大值。

输入

输入数据包含三个整数，用空格分开。

输出

输出两两相加后的最大值。

样例输入

样例输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

## **C语言实验题――相加和最大值**



**描述**

输入三个整数a,b,c。并进行两两相加，最后比较相加和的最大值。

**输入**

输入数据包含三个整数，用空格分开。

**输出**

输出两两相加后的最大值。

**样例输入**



**样例输出**

5

title: 计算机组成原理

categories:

• CS基础
  tags:
• 计组
• 专业课
• 笔记
• 基础
  typora-root-url: ..

计算机组成原理

预备知识

进制知识

数电逻辑

计算机中阶符、阶码、数符、尾数的意思

一个浮点数a由两个数m和e来表示：a = m × b^e。在任意一个这样的系统中，我们选择一个基数b（记数系统的基）和精度p（即使用多少位来存储）。m（即尾数）是形如±d.ddd…ddd的p位数（每一位是一个介于0到b-1之间的整数，包括0和b-1)。如果m的第一位是非0整数,m称作规格化的。有一些描述使用一个单独的符号位(s 代表+或者-）来表示正负，这样m必须是正的。e是指数。

结构
由此可以看出，在计算机中表示一个浮点数，其结构如下：
尾数部分（定点小数） 阶码部分（定点整数）

一个十进制数可写成一个纯小数乘上10的若干次方，相似的，一个二进制可写成一个纯小数乘上2的若干次方。例如，11.01=22×0.1101；
一般地,任一个二进制N，可表示为N=2j×S；
　　
其中J为二进制数，叫阶码；
J如果有正负号的话，正负号就叫阶符；
S为纯小数，叫做尾数；
数符，指的是N整个数的符号。

浮点数能表示的范围由阶码的位数决定，精确度有尾数的位数决定
————————————————
版权声明：本文为CSDN博主「猴儿2333」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/littlecase233/article/details/82959410

在尾数用补码表示时，规格化浮点数应满足尾数最高数位与符号位不同，如相同就是不满足规格化。
尾数用双符号位补码表示，经过加/减运算之后，可能出现以下六种情况，即
① 00.1 x x … x
② 11.0 x x … x
③ 00.0 x x … x
④ 11.1 x x … x
⑤ 01.x x x … x
⑥ 10.x x x … x 第①、②种情况，符合规格化数的定义，已是规格化数。 第③、④种情况不是规格化数，需要使尾数左移以实现规格化，这个过程称为左规。尾
浮点数运算的的规格化
浮点数运算的的规格化
浮点数运算的的规格化
数每左移一位，阶码相应减 1，直至成为规格化数为止。
左规可以进行多次。

第⑤、⑥种情况在定点加减运算中称为溢出，但在浮点加减运算中，只表明此时尾数的 绝对值大于 1，而并非真正的溢出。这种情况应将尾数右移以实现规格化。这个过程称为右 规。尾数每右移一位，阶码相应加 1。
右规最多只有一次。

总结：左规处理，及时数往小数点左边走，阶码-1，右规反之。

https://blog.csdn.net/qq546770908/article/details/45486397

小数的二进制表示，阶码

知识点 加 题目 加 排版 加 图片 加 个人思想

第1章 计算机系统概率

1.1 计算机的分类

1.2 计算机的发展简史

已知补码如何求原码（真值）~
1.当补码最高位为0时
因为最高位为0，即该数是正数，正数的原码、反码、补码都是一样的。

所以该补码即是原码。

例如：【X】补=01111111求真值。

解：因为最高位为0，所以【X】原=【X】补=01111111=127.

2.当补码最高位为1时
因为最高位是1，所以该数为负数。负数的补码=反码+1

补码 的补码 即为该补码的原码（真值）。

逻辑右移就是不考虑符号位，右移一位，左边补零即可。
算术右移需要考虑符号位，右移一位，若符号位为1，就在左边补1,；否则，就补0。
所以算术右移也可以进行有符号位的除法，右移,n位就等于除2的n次方。

例如，8位二进制数11001101分别右移一位。
逻辑右移就是[0]1100110
算术右移就是[1]1100110

C语言入门及进阶

\t 制表符 与 空格的关系

https://www.cnblogs.com/guokai/p/3641953.html

tab

如何 在 C 输出 \ %

%% \ \

如何在 C使用 百分数 %

double n,x;

n=0.01*x;

2.各种类型输入输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

特别注意 A-Z区间的表示 以及 字符的 ''

#include <stdio.h>
int main()
{
	char n;
	scanf("%c",&n);
	if(n>='A'&&n<='Z')
{
	 printf("%c",n+32);

}
	else printf("%c",n);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <stdio.h>
int main()
{
	char a,b,c,d,e;
	scanf("%c",&a);
	scanf("%c",&b);
	scanf("%c",&c);
	scanf("%c",&d);
	scanf("%c",&e);
	printf("password is %c%c%c%c%c",a+4,b+4,c+4,d+4,e+4);
	return 0;
}
方法	
#include <stdio.h>
int main()
{
	char a,b,c,d,e;
	scanf("%c%c%c%c%c",&a,&b,&c,&d,&e);
	printf("password is %c%c%c%c%c",a+4,b+4,c+4,d+4,e+4);
	return 0;
}
方法三
#include <stdio.h>
int main()
{
	char a,b,c,d,e;
	a=getchar();
	b=getchar();
	c=getchar();
	d=getchar();
	e=getchar();
	printf("password is ");
	putchar(a+4);
	putchar(b+4);
	putchar(c+4);
	putchar(d+4);
	putchar(e+4);
	return 0;
}

这种 不行 会报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include<stdio.h>
//实现摄氏温度和华氏温度的转化函数
float f_c(float F)
{
	return 5*(F-32)/9;
}
int main()
{
	float f,c;
	scanf("%f",&f);
	c=f_c(f);
	printf("%.2f",c);
	return 0;
}

3.简单运算

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main()
{
	int a,b,c;
	scanf("%d%d",&a,&b);
	c=(a/10)*1000+(a%10)*10+(b/10)*100+(b%10);
	printf("The result is: %d",c);
	return 0;
}

4.加点难度的运算

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main()
{
	int n,x;
	scanf("%d",&n);
	x=(n%10)*100+((n%100)/10)*10+(n/100);
	printf("%d",x);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <stdio.h>
int main()
{
     int a;
	 int b;
 scanf("%d %d", &a, &b);
 printf("%d", b/a+1);
 return 0;
}
化繁为简 考虑简单的

超时的程序？  ＞的话 反过来就要考虑 小于等于
#include <stdio.h>
int main()
{
	int a,b,m=1,z;
	scanf("%d%d",&a,&b);
	while(z<=b)
	{
		m++;
		z=a*m;
	}
	printf("%d",m);	
	return 0;
}
这里涉及了 C语言运行程序的计算 调试 

https://www.cnblogs.com/Emcikem/p/11518388.html
#include<stdio.h>
#include<time.h>   //用到clock()函数
int main() {
    int begintime,endtime;
    int i = 0;
    int a[1002];
    begintime=clock();  //计时开始
    

        /*
        代码块
        */

    endtime = clock();  //计时结束
    printf("\n\nRunning Time：%dms\n", endtime-begintime);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main()
{
	int x,y,n,m;
	scanf("%d%d",&n,&m);
	y=(m-2*n)/2;
	x=n-y;
	printf("%d %d",x,y);
	return 0;
}
数学果然是个好东西

5.简单选择结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <stdio.h>
int main()
{
	int a;
	scanf("%d",&a);
	if(a%3==0&&a%5==0)
	{
		printf("Yes");
	}
	else
	{
		printf("No");	
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdio.h>
int main()
{
	int a,b,c,t;
	scanf("%d %d %d",&a,&b,&c);
	if(a>b)
	{
		t=a;
		a=b;
		b=t;
	}
	if(a>c)
	{
		t=a;
		a=c;
		c=t;		
	}
	if(b>c)
	{
		t=b;
		b=c;
		c=t;		
	}
	printf("%d",b);
	return 0;
}

三目运算符

三数比较

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main()
{
	int a,b,c,max;
	scanf("%d%d%d",&a,&b,&c);
	max=(a>b)?((a>c)?a:c):((b>c)?b:c);
	printf("max=%d",max);
	return 0;
}

二数比较

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main()
{
	int a,b,max;
	scanf("%d%d",&a,&b);
	max=a>b?a:b;
	printf("max=%d",max);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include<stdio.h>
int main()
{
	int a,b,c,x,y,z,max;
 	scanf("%d %d %d",&a,&b,&c);
 	x=a+b;
 	y=a+c;
 	z=b+c;
 	max=(x>y)?((x>z)?x:z):((y>z)?y:z);
 	printf("%d",max);
	return 0;
}



#include<stdio.h>
int main()
{
int a,b,c;
int x,y,z;
 scanf("%d%d%d",&a,&b,&c);
 x=a+b;
 y=a+c;
 z=b+c;
 if(x>=y&&x>=z)
 {
	 printf("%d",x);
 }else{
	 if(y>z&&y>x)
	 {
		 printf("%d",y);
	 }else{
		 printf("%d",z);
	 }
 }
}

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main()
{
	int a,b,c,max,min,n;
	scanf("%d%d%d",&a,&b,&c);
	max=(a>b)?((a>c)?a:c):((b>c)?b:c);
	min=(a<b)?((a<c)?a:c):((b<c)?b:c);
	n=max-min;
	printf("%d",n);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include<stdio.h>

int main()
{C
	int a,b,c,d;
	scanf("%d.%d.%d.%d",&a,&b,&c,&d); 
	if(0<=a&&a<=255&&
	   0<=b&&b<=255&&
	   0<=c&&c<=255&&
	   0<=d&&d<=255)
		printf("YES");
	else
		printf("NO");
	return 0;	
}

6.加强选择结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include<stdio.h>
int main()
{
	int month,year;
	scanf("%d\\%d",&year,&month);
	if(month==1||month==3||month==5||month==7||month==8||month==10||month==12)
	printf("31");
	else if(month==4||month==6||month==9||month==11)
	printf("30");
	if(month==2)
	{
	if(year%4==0&&year%100!=0||year%400==0)
	printf("29");
	else 
	printf("28");
	}
	return 0;
}


#include<stdio.h>
int main()
{
 int year,month,day;
 scanf("%d\\%d",&year,&month);
 switch(month)
 {
 case 1:
 case 3:
 case 5:
 case 7:
 case 8:
 case 10:
 case 12:day=31;break;
 case 4:
 case 6:
 case 9:
 case 11:day=30;break;
 }
 if(month==2)
 {
 	if((year%4==0&&year%100!=0)||year%400==0)
 	day=29;
 	else  day=28;
 }
	printf("%d",day);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include<stdio.h>
#include<math.h>
int main()
{
	float a,b,c;
	float x1,x2,d;
	scanf("%f %f %f",&a,&b,&c);
	if(a!=0)
{
	d=sqrt((b*b)-(4.0*a*c));
	x1=((-b+d)/(2.0*a));
	x2=((-b-d)/(2.0*a));
	if(x1>=x2)
	{
		printf("%.2f %.2f",x1,x2);
	}
	else 	printf("%.2f %.2f",x2,x1);
}
	else printf("not root!");
 return 0;
}

强调 实数的定义 数学知识的补充 课外知识的背景 还有 学好英语！！！！！

上面挖个坑 你把函数 指针 学熟 再来补

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<stdio.h>  
#include<math.h>  
int main()  
{     
   double a,b,c,x1,x2,m,n;  
   scanf("%lf%lf%lf",&a,&b,&c); 
   if(a==0)printf("%.2f %.2f\n",-c/b,-c/b); 
   else if(b*b-4*a*c<0)
   {
   	 m=-b/(2*a);  n=sqrt(4*a*c-b*b);
     if(a>0)printf("%.2f+%.2fi %.2f-%.2fi\n", m,n/(2*a),m,n/(2*a) );
     else printf("%.2f+%.2fi %.2f%.2fi\n", m,-n/(2*a),m,n/(2*a));
   }
   else
    {
   	 x1=(-b+sqrt(b*b-4*a*c))/(2*a);  
     x2=(-b-sqrt(b*b-4*a*c))/(2*a);  
     if(x1>x2)printf("%.2f %.2f",x1,x2);  
     else printf("%.2f %.2f",x2,x1);  
    } 
    return 0;  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include<stdio.h>  
int main()  
{
	int x,y,z;
	scanf("%d,%d,%d",&x,&y,&z);
	if(x>y&&x>z)
	{
		if(y>z)
		printf("%d %d %d",z,y,x);
		else 
		printf("%d %d %d",y,z,x);
	}
	else if(y>x&&y>z)
	{
		if(x>z)
		printf("%d %d %d",z,x,y);
		else 
		printf("%d %d %d",x,z,y);
}
	else if(z>y&&z>x)
{
	if(x>y)
	printf("%d %d %d",y,x,z);
	else 
	printf("%d %d %d",x,y,z);
}
return 0;  
}  


#include<stdio.h>
int main()
{
	int a,b,c,max,min,mid;
	scanf("%d,%d,%d",&a,&b,&c);
	max=(a>b)?((a>c)?a:c):((b>c)?b:c);
	min=(a<b)?((a<c)?a:c):((b<c)?b:c);
	mid=a+b+c-max-min;
	printf("%d %d %d",min,mid,max);
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

#include<stdio.h>
typedef struct Time{
	int h,m,s;
}Time;
/*
	描述时间的结构体 
*/
/*
	输入时间函数 
*/
void ReadTime(Time *time)
{
	scanf("%d:%d:%d",&time->h,&time->m,&time->s);
}
/*
	输出时间函数 
*/
void PrintTime(Time *time)
{
	printf("%d:",time->h);
	if(time->m<10)
		printf("0");
	printf("%d:",time->m);
	if(time->s<10)
		printf("0");
	printf("%d",time->s);	
}
//计算两个时间只差 
void TimeSub(Time *time1,Time *time2,Time *time)
{
	long t1,t2,t;
	t1=time1->h * 3600 + time1->m *60 + time1->s;
	t2=time2->h * 3600 + time2->m *60 + time2->s;
	t=t1-t2;//将时间转化为秒 
	if(t<0)
		t=t*(-1);
	//将秒转化为时间 
	time->h= t/3600;
	time->m= (t-time->h*3600)/60;
	time->s= t%60; 
}
int main()
{
	Time time1,time2,time;
	ReadTime(&time1);//读时间 
	ReadTime(&time2);//读第一个时间 
	TimeSub(&time1,&time2,&time);//计算减法 
	PrintTime(&time);//返回一个时间 
	return 0;
 }




#include<stdio.h>
int main()
{
	int h1, m1, s1;
	int h2, m2, s2;
	int a, b, c;
	scanf("%d:%d:%d", &h1, &m1, &s1);
	scanf("%d:%d:%d", &h2, &m2, &s2);
	if (h1 * 3600 + m1 * 60 + s1 < h2 * 3600 + m2 * 60 + s2)
	{
		a = h2 - h1, b = m2 - m1, c = s2 - s1;
		if (c < 0)
		{
			c = 60 + c;
			b--;
		}
		if (b < 0)
		{
			b = b + 60;
			a--;
		}
	}
	else
	{
		a = h1 - h2, b = m1 - m2, c = s1 - s2;
		if (c < 0)
		{
			c = 60 + c;
			b--;
		}
		if (b < 0)
		{
			b = b + 60;
			a--;
		}
	}
	printf("%d:%02d:%02d", a, b, c);
}



#include<stdio.h>
int main()
{
    int h1, h2, m1, m2, s1, s2, t1, t2, del;
    t1 = t2 = 0;
    scanf("%d:%d:%d",&h1, &m1, &s1);
    scanf("%d:%d:%d",&h2, &m2, &s2);
    t1 = h1 * 3600 + m1 * 60 + s1;
    t2 = h2 * 3600 + m2 * 60 + s2;
    if(t1 > t2)
    {
        del = t1 - t2;
    }
    else
    {
        del = t2 - t1;
    }
    int a, b, c;
    a = del / 3600;
    b = del / 60 % 60;
    c = del % 60;
    printf("%02d:%02d:%02d\n",a, b, c);
    return 0;
}

7.简单一重循环

1
2
3
4
5
6
7
8
9

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include<stdio.h>
int main()
{
	float sum=0.0;
	int a=1,i;
	for (i=1;i<=100;i++){
		sum+=(1.0*a)/i;
		a=-a;
	}
	printf("%f",sum);
	return 0;
}



#include <stdio.h>

int main(void)
{
    int i = 1;
    float sum = 0;

    while(i <= 100)
    {
        if(i % 2 == 0)
        {
            sum -=1/(i++*1.0);
        }else
        {
            sum +=1/(i++*1.0);
        }
    }
    printf("%f\n",sum);
}

​

1.0 的重要性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include<stdio.h>
int main(void)
{
    int num=0,i=0,a=0;
    int str[1000];
    scanf("%d",&num);
    for(i=0;i<num;i++)
    {
        scanf("%d",&a);
        str[i]=a;
    }
    for(i=0;i<num;i++)
    {
        printf("%c",str[i]);
    }
    return 0;
}

#include <stdio.h>
int main()
{
	int n;
	scanf("%d",&n);
	int i,a;
	for( i=0;i<n;i++)
{
		scanf("%d",&a);
		printf("%c",a);
}
}

 

#include<stdio.h>
#include<string.h>
using namespace std;
int main(){
	int n,i;
	char s[100];
	int len=0;
	scanf("%d",&n);
	for(i=0;i<n;i++){
		int a;
		scanf("%d",&a);
		if(a>=0&&a<=256) s[len++]=a; //ASCll范围[0,256] 
	}
	 s[len]='\0';
	 printf("%s",s);  
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    char c[1001];
    int x[1001];
    cin>>n;
 
    for(int i=0;i<n;i++)
    {
        scanf("%d",&x[i]);
        c[i]=x[i];
 
    }
    for(int i=0;i<n;i++)
        printf("%c",c[i]);
}

https://www.cnblogs.com/kimsimple/p/6874988.html

#include<bits/stdc++.h>包含了目前c++所包含的所有头文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stdio.h>
int main()
{
float a;
int n,i;
float sum=0,average;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%f",&a);
sum=sum+a;
}
average=sum/n;
printf("%.2f",average);
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

#include<stdio.h>
int main()
{
	int t,a,b,sum;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&a,&b);
		sum=(a%100+b%100)%100;//实验证明若用sun=(a+b)%100，在hdoj上提交会WA 
		printf("%d\n",sum);
	}
	return 0;
}

关于while(n–)知识点的补充

下面这段代码我们都很熟悉

#include <stdio.h>
int main()
{
int n=5;
while(n)
{
n=n-1;
}
printf(“%d\n”,n);
return 0;
}
它的输出结果为0.
再看下面这一段代码：

#include <stdio.h>
int main()
{
int n=5;
while(n–)
{
;
}
printf(“%d\n”,n);
return 0;
}
它的输出结果却是-1.
很多人都认为这两段代码是等价的，我之前也误认为它们等价，但是实验证明这不是等价的。

第二段代码中，while(n–)，当n=0时，并没有马上跳过循环条件和循环体，而是将循环条件执行完再跳过循环体。

原因：n–是一个整体，从编译器gcc角度看，先将n赋值给一个临时变量，然后自身减去1，返回的不是n而是临时变量。此时临时变量0，n为-1。故n–操作是一个整体，必须完整的执行完，不是割裂看的。之前，我误认为while中判断n为0时就直接结束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include<stdio.h>
int main()
{
   int n,a,b,i;
   float sum =0;
   scanf("%d",&n);
   a = 1;
   b = 2;
   for(i =0; i<n;i++)
   {
      sum = sum + 1.0/a - 1.0/b;
      a = a+2;
      b = b+2;
   }
   printf("%0.2f\n",sum);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include<stdio.h>
int main()
{ 
	int i,n,fm=0;
	double sum=0;
	scanf("%d",&n);
	for ( i=0;i<n;i++ ) //总共n次循环，加n项
{ 	fm+=(i+1); //分母每次累加当前项号：0+1,1+2,3+3,...
	sum+=(double)1/fm; //累加当前项
}
	printf("%.2f\n",sum);
}



#include<stdio.h>
int main()
{	
	int i,n;
	double s=0,m=0;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
{
	m+=i;
	s+=1.0/m;
}
	printf("%.2lf",s);
}






#include<stdio.h>
int main()
{
	int n,i;
	float sum=0,s=0;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		sum=sum+i;
		s=s+(1.0/sum);
	}
	printf("%.2f",s);
	return 0;
}

论 sum=0的重要性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include<stdio.h>
#include<math.h>
int main()
{
	double x1,x0,d;
	x1=0.0;
	x1=cos(x0);
	scanf("%lf",&d);
	while(fabs(x0-x1)>d)
{
	x0=x1;
	x1=cos(x0);
}
	printf("%.2f\n",x1);
	return 0;
}

迭代

迭代法是数值计算中一类典型方法，应用于方程求根，方程组求解，矩阵求特征值等方面。其基本思想是逐次逼近，先取一个粗糙的近似值，然后用同一个递推公式，反复校正此初值，直至达到预定精度要求为止。

从概念上讲，递归就是指程序调用自身的编程思想，即一个函数调用本身；迭代是利用已知的变量值，根据递推公式不断演进得到变量新值得编程思想。

从直观上讲，递归是将大问题化为相同结构的小问题，从待求解的问题出发，一直分解到已经已知答案的最小问题为止，然后再逐级返回，从而得到大问题的解（一个非常形象的例子就是分类回归树 classification and regression tree，从root出发，先将root分解为另一个(root,sub-tree)，就这样一直分解，直到遇到leafs后逐层返回）；而迭代则是从已知值出发，通过递推式，不断更新变量新值，一直到能够解决要求的问题为止。

递归实际上不断地深层调用函数，直到函数有返回才会逐层的返回，因此，递归涉及到运行时的堆栈开销（参数必须压入堆栈保存，直到该层函数调用返回为止），所以有可能导致堆栈溢出的错误；但是递归编程所体现的思想正是人们追求简洁、将问题交给计算机，以及将大问题分解为相同小问题从而解决大问题的动机。

迭代大部分时候需要人为的对问题进行剖析，将问题转变为一次次的迭代来逼近答案。迭代不像递归一样对堆栈有一定的要求，另外一旦问题剖析完毕，就可以很容易的通过循环加以实现。迭代的效率高，但却不太容易理解，当遇到数据结构的设计时，比如图‘表、二叉树、网格等问题时，使用就比较困难，而是用递归就能省掉人工思考解法的过程，只需要不断的将问题分解直到返回就可以了。

总之，递归算法从思想上更加贴近人们处理问题的思路，而且所处的思想层级算是高层（神），而迭代则更加偏向于底层（人），所以从执行效率上来讲，底层(迭代)往往比高层(递归)来的高，但高层(递归)却能提供更加抽象的服务，更加的简洁。

从个人来讲，我非常认同“迭代是人，递归是神”！

编程中，循环、迭代、遍历和递归之间的区别

循环(loop) - 最基础的概念, 所有重复的行为
递归(recursion) - 在函数内调用自身, 将复杂情况逐步转化成基本情况
(数学)迭代(iterate) - 在多次循环中逐步接近结果
(编程)迭代(iterate) - 按顺序访问线性结构中的每一项
遍历(traversal) - 按规则访问非线性结构中的每一项
————————————————
版权声明：本文为CSDN博主「Never-say-Never」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/mad1989/article/details/8933078

当型循环和直到型循环

当型循环：
开始循环
判断循环条件，成立
执行循环体
判断循环条件，成立
执行循环体
…
判断循环条件，这一次条件不成立
不执行循环体，直接继续往下

直到型循环：
开始循环
执行循环体
判断循环条件，成立
执行循环体
…
判断循环条件，这一次条件不成立
不执行循环体，直接继续往下

“当型”
while(i<n)
{
…..
}则说明当满足条件i<n时执行{ }中代码；

“直到型”
do
{
} while(i<n)
则说明先执行{ }中代码，再判断是否是i<n;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include<stdio.h>
int main()
{
	int n,max,i,j;
	scanf("%d",&n);
	if(n>=1&&n<=10)
	{
		for(i=0;i<n;i++)
		{
			scanf("%d",&j);
			if(i==0)
			{
				max=j;
			}
			else
			{
				max =(max>j)?max:j;
			}
		}
	}
	printf("%d",max);
	return 0;
}


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

比较 输出 最大最小值

8.加强一重循环

https://blog.csdn.net/S1259364843/article/details/92420371

C语言求最小公倍数和最大公约数三种算法(经典)

1
2
3
4
5
6
7
8
9
10

#include<stdio.h> 
int main()   /*  辗转相除法求最大公约数 */ 
{ 
   int m, n, a, b, t, c;
   scanf("%d %d", &a,&b);
   m=a;   n=b;
   while(b!=0)  /* 余数不为0，继续相除，直到余数为0 */ 
   { c=a%b; a=b;  b=c;}
   printf("%d %d\n",m*n/a,a);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include <stdio.h>

int check(int num);

int main()
{
   int i;
   int count;
   int num;

   count=0;
   scanf("%d", &num);

   for(i=1; i<=num; i++)
   {
	   if(i%3==0)
	   {
		   count++;
	   }
	   else if(check(i))
	   {
           count++;
	   }
   }

   printf("%d", count);
}

int check(int num)
{
   int flag=0;

   while(num)
   {
       if(num%10==3)
	   {
	      flag=1;
	   }
	   num/=10;
   }

   return flag;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include<stdio.h>
int main()
{
   double n=2,m=1,N,t,sum=0.00;
   scanf("%Lf",&N);
while(N)
{
  sum=sum+n/m; 
  t=m;
  m=n;
  n=n+t;
  N--;
}	
printf("%.6f\n",sum);
return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include<stdio.h>  
#include<math.h>  
int main()  
{     
    int n;
    double sum=0,i,t=1;
	scanf("%d",&n);
	for(i=1;i<=4*n-1;i=i+2)
	{  sum=sum+t/i;
	    t=-t;
    }
	printf("%.5f",4*sum);
    return 0;  
}

素数：除了1和它自己之外，不能被其他数整除的数。

以下用三种方法解答：

https://blog.csdn.net/yuemeicheng/article/details/81185154

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>
int main()
{
    int i,j;
    int count=0;
    int a[100];
    //求素数
    for(i=100;i<=200;i++)    
    {
        for(j=2;j<i;j++)
        {
            if(i%j==0)   //如果i/j没有余数就跳出循环
            {
                break;
            }
        }
        if(i==j)   //判断是不是跳出循环的数，
        {
            a[count++]=i;   //把素数存入数组
        }
    }
    printf("%d\n",count);
    for (i=0;i<count;i++)
    {
        printf("%d",a[i] );  //输出
        if(i!=count-1)
        {
            printf(" ");
        }
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.h>
int main()
{
    double x, sum, t, item;
    int n, i;
    while (scanf("%lf %d", &x, &n)==2)
    {
        t = x*x;
        item = 1.0;
        sum = 1.0;
        for (i=1; i<=n; i++)
        {
            item *= -t;
            item /= (i*2-1)*(i*2);
            sum += item;
        }
        printf("%.4lf\n", sum);
    }
    return 0;
}