C on OrdinaryRobot 的个人博客

质数筛（好题 1）

Thu, 29 Oct 2026 19:50:00 +0800

题目

质数筛

输入 n 个不大于 10⁵ 的正整数。要求全部储存在数组中，去除掉不是质数的数字，依次输出剩余的质数。

输入格式

第一行输入一个正整数 n，表示整数个数。

第二行输入 n 个正整数 aᵢ，以空格隔开。

输出格式

输出一行，依次输出 aᵢ 中剩余的质数，以空格隔开。

代码

#include <iostream>
using namespace std;

int main() {
 int n;
 cin >> n;
 int a[100];
 int m;
 int o = 0; // 记录质数的个数

 for (int i = 0; i < n; i++) {
 cin >> m; // 依次读入这 n 个数字

 int s = 0;
 // 【优化】判断质数只需要从 2 遍历到 sqrt(m) 即可，效率提升极大
 for (int t = 2; t * t <= m; t++) {
 if (m % t == 0) {
 s++;
 }
 }

 // 【修复】加上 m > 1，排除数字 1 的干扰
 if (s == 0 && m > 1) {
 a[o] = m;
 o++;
 }
 }

 for (int i = 0; i < o; i++) {
 cout << a[i] << " ";
 }
 return 0;
}

两个关键点

只试到 √m：若 m 有因数 t，那么 m/t 也是因数，且两者必有一个 ≤ √m。所以 t * t <= m 就够，不用 t < m。写成 t * t 而不是 t <= sqrt(m)，还能避免浮点误差和额外的 <cmath> 依赖。
1 不是质数：m > 1 这个条件不能省，否则输入 1 会被当成质数输出。

另外 a[100] 是按「最多 100 个数」开的，如果 n 可能更大，数组要跟着放大（或用 std::vector）。

数组（一维与二维）

Thu, 29 Oct 2026 19:49:00 +0800

一维数组的创建和初始化

创建一维数组，需要规定数据类型、数组名、数组大小：

type arr_name[常量];

int a[1001];

初始化：

int a1[5] = {1, 2, 3, 4, 5}; // 完全初始化
int a2[5] = {1, 2, 3}; // 不完全初始化，剩余位置由 0 填充
int a3[5] = {0}; // 首个元素初始化为 0，剩下的默认为 0

由字符构建数组：

char ch[] = {'a', 'b', 'c'};
char ch2[] = "CNWU";

printf("%c", ch[1]); // 输出数组里面想要的某一位字符
printf("%s", ch2); // 输出字符串

注意：

字符串尾部隐藏了结束符 \0，所以数组里每个字符串会有（看到的字符数 + 1）个位置。也就是说，如果给每个字符串设置了 20 个字符位置，那么最多只能输入 19 个字符。

%s 打印字符串时，直到 \0 才结束。

求字符串长度：strlen 与 sizeof

strlen 求字符串长度时会一直数，直到遇到 \0 结束。所以形如 char ch2[] = "CNWU" 的字符串可以得出正确的值，而 char ch[] = {'a', 'b', 'c'} 会越界访问，出现乱码。

sizeof 得出的值单位为字节，它是操作符而非函数，算的是操作数所占内存大小，什么类型都适用； strlen 是库函数，需要包含头文件 string.h，只针对字符串，统计的是 \0 之前字符的个数。

int arr[10] = {0};

printf("%zu\n", sizeof(arr)); // 10*4=40，数组的总大小，单位字节
printf("%zu\n", sizeof(arr[0])); // 4，第一个元素的大小，单位字节
printf("%zu\n", sizeof(arr) / sizeof(arr[0])); // 10，元素个数

输出：40 / 4 / 10。

二维数组

二维数组的创建与一维相同：

int a[][5];

左边为行，右边为列，列不可省略。

初始化：

int arr1[3][5] = {1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7};
int arr2[3][5] = {{1, 2}, {3, 4}, {5, 6}};

下一篇：函数的设计

ASCII 码表（0–127）

Thu, 29 Oct 2026 19:46:00 +0800

ASCII 码表（0–127）

大写字母在前，码值更小：A–Z = 65–90，之后是 a–z = 97–122，小写整体比大写大 32。两者之间（91–96）夹着 6 个符号：[、\、]、^、_、`（反引号）。

1. 完整码表

行列都是十六进制：码值 = 行 × 16 + 列。

高位 \ 低位	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
0x0	NUL	SOH	STX	ETX	EOT	ENQ	ACK	BEL	BS	HT	LF	VT	FF	CR	SO	SI
0x1	DLE	DC1	DC2	DC3	DC4	NAK	SYN	ETB	CAN	EM	SUB	ESC	FS	GS	RS	US
0x2	空格	!	"	#	$	%	&	'	(	)	*	+	,	-	.	/
0x3	0	1	2	3	4	5	6	7	8	9	:	;	<	=	>	?
0x4	@	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O
0x5	P	Q	R	S	T	U	V	W	X	Y	Z	[	\	]	^	_
0x6	`	a	b	c	d	e	f	g	h	i	j	k	l	m	n	o
0x7	p	q	r	s	t	u	v	w	x	y	z	{	\|	}	~	DEL

举例：A 在 0x4 行第 1 列 → 4×16+1 = 65；a 在 0x6 行第 1 列 → 6×16+1 = 97。

2. 大小写字母对照

大写	码值	小写	码值	大写	码值	小写	码值
A	65	a	97	N	78	n	110
B	66	b	98	O	79	o	111
C	67	c	99	P	80	p	112
D	68	d	100	Q	81	q	113
E	69	e	101	R	82	r	114
F	70	f	102	S	83	s	115
G	71	g	103	T	84	t	116
H	72	h	104	U	85	u	117
I	73	i	105	V	86	v	118
J	74	j	106	W	87	w	119
K	75	k	107	X	88	x	120
L	76	l	108	Y	89	y	121
M	77	m	109	Z	90	z	122

每一对差值恒为 32：a - A = 32，b - B = 32 …… z - Z = 32。

3. 常用速查

字符	码值	字符	码值
`'0'`	48	`'9'`	57
`'A'`	65	`'Z'`	90
`'a'`	97	`'z'`	122
空格	32	`'a' - 'A'`	32

补充：数字 0–9 的码值是连续的 48–57，所以 '7' - '0' 直接得到数值 7。

4. C/C++ 里的用法

char c = 'm';

// 判断小写（下界小、上界大，别写反）
if (c >= 'a' && c <= 'z') { /* ... */ }

// 判断大写
if (c >= 'A' && c <= 'Z') { /* ... */ }

// 小写 -> 大写
if (c >= 'a' && c <= 'z') c -= 32;

// 大写 -> 小写
if (c >= 'A' && c <= 'Z') c += 32;

// 字符数字转真正的数字
int d = '7' - '0'; // d == 7

也可以用 <cctype> 里的现成函数：

#include <cctype>
islower(c); isupper(c); isdigit(c);
toupper(c); tolower(c);

5. 两个常见错误

错误一：区间写反

if (c >= 'z' && c <= 'a') // 恒假

等价于 c >= 122 && c <= 97，要求一个数同时大于 122 又小于 97，永远不成立。正确写法是 c >= 'a' && c <= 'z'，等价于 97 <= c <= 122。

错误二：把 sizeof 当成字符串长度

for (int p = 1; p < sizeof(m); p++) // 错，sizeof(string) 恒为 32
for (int p = 1; p < m.size(); p++) // 对

sizeof 是编译期运算符，算的是类型占多少字节，与内容无关；std::string 的长度要用 m.size()。

相关笔记：数组（一维与二维）

函数的设计

Thu, 29 Oct 2026 19:45:00 +0800

目标

掌握自定义函数的设计（参数、返回值……）
掌握用函数进行代码编写
掌握函数的声明和定义，还有多文件程序的基本形式
掌握 static 和 extern 关键字的使用

1. 函数概念

函数实际上是一个小程序，里面包装了预先写好的代码，用于减少重复代码的书写，比如 main、scanf、printf。

2. 函数的形式

数据类型 + 函数名 +（参数），(void) 表示没有参数。

int name(int x, int y) // 函数头
{
 return x + y; // 函数体
}

3. 库函数

预先写好、包装好的函数，被集中放在库文件中，配有说明书「头文件」。
一般由编译器厂商放在自家编译器中。

4. 自定义函数

一串自己写的代码：

#include <stdio.h>

// 定义函数
int average(int x, int y)
{
 int z = (x + y) / 2;

 return z;
}

int main()
{
 int a, b;

 scanf("%d %d", &a, &b);

 int r = average(a, b);

 printf("%d", r);

 return 0;
}

下一篇：三目运算符，可以用来简化判断最大值的函数。

参数：形参和实参

形参，即定义函数时的参数（int x, y），它们在未被调用、没有存储实参时，不会申请占用内存，并不是真实存在的。
实参，即传递给函数的参数（如 a、b），它们是实际存在的。

三目运算符

Wed, 28 Oct 2026 19:38:00 +0800

三目运算符（条件运算符）

C++ 唯一的三目运算符，用来在一个表达式里完成 if-else 的选择。

原型

条件 ? 条件成立时的值 : 条件不成立时的值
 ↑ ↑ ↑
判断 true 分支 false 分支

先判断，再二选一：条件为真取 ? 后面那个，为假取 : 后面那个。

典型用法：求最大值

int myMax(int x, int y) {
 return x > y ? x : y;
}

等价于：

int myMax(int x, int y) {
 if (x > y) return x;
 else return y;
}

比 if-else 强在哪

表达式能直接嵌进别的地方，if-else 不行：

int big = x > y ? x : y; // 直接赋值
cout << (x > y ? x : y); // 直接输出
a[x > y ? 1 : 0]++; // 直接当下标

三个坑

坑	错误写法	正确写法
优先级低，嵌算式要加括号	`x > y ? x : y + 1`（实际是 `x > y ? x : (y + 1)`）	`(x > y ? x : y) + 1`
嵌套太深看不懂	`x > y ? (x > z ? x : z) : (y > z ? y : z)`	三个数以上用 if 或数组
两边类型不一致	`flag ? 1 : 2.5`（结果变 double）	两边保持同类型

标准库替代

#include <algorithm>
max(x, y); // 求较大值
min(x, y); // 求较小值

刷题用 max() 完全没问题，但要知道它等价于 x > y ? x : y。

上一篇：函数的设计

随机数

Wed, 21 Oct 2026 12:16:00 +0800

while (n) 其实等同于 while (n != 0)

goto 随机数生成(头文件 stdlib.h) ： rand 函数需要头文件 stdlib.h返回伪随机数

#include <stdio.h>
#include <stdlib.h>
int main()
{
 printf("%d", rand());
 return 0;
}

原理：rand是依靠对“种子”基准值运算生成的伪随机数 srand函数 初始化“种子“（随机数生成器）

原型：void srand (unsigned int seed) 程序在使用rand生成随机数之前会调用srand初始化生成的种子，种子变，伪随机数就变

int main{
srand(1);
printf("%d",rand());

return 0;
}

time 函数（头文件time.h) 因为时间在不断变化，所以可以用时间作为种子，改变随机数

time_t time(time_t *timer);

time_t * timer为指针参数，不用时用NULL

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main(){
 srand((unsigned int)time(NULL));
 printf("%d",rand());

 return 0;
}

在现代 C++ 标准（C++11 及以后）和安全规范（如 CERT C++ 规则 MSC30-C 和 MSC50-CPP）中，rand() 已经被明确标记为不推荐甚至禁止使用（会报警）

素数与回文数

Wed, 21 Oct 2026 12:14:00 +0800

经典：判断素数


#include<stdio.h>

int main(){

    int n=0;
    int t=1;

    scanf("%d",&n);
    if(n<=1){

        return 0;
    }else{

        for(int i=2;i<n;i++){

            if(n%i==0 && n!=2){

                t=0;
                break;
            }
        }
    }

    if(t==1){
        printf("Yes");

    }else{
        printf("No");
    }

    return 0;
}

定义变量（比如 int t = 1;）：这相当于给变量办“出生证明”。如果在循环里定义，那出了循环它就“死”了（作用域结束），外面确实访问不到。
修改变量（比如 t = 0;）：这相当于给变量“换个衣服”。==🟡只要这个变量在之前已经“出生”了==（在循环外面定义过了），==🟠你在哪里修改它都可以==。

判断回文数

回文数：即一个数字，形如111，121，1001，反转之后依然等于这个数的数叫做回文数

判断回文数的程序：

int n;
scanf("%d",&n);

读取数字

int original=n;//先记下这个数字
int reserve;//记录反转的数字

初始化

while(n>0){
 reserve=reserve*10+n%10;
 n/=10;
}

反转数字

if(reserve==original){
 printf("0K");
}else{
 printf("N0");
}

判断回文数

空瓶与瓶盖换酒（好题 2）

Sun, 18 Oct 2026 17:26:00 +0800

一、题干背景与规则

题目背景：江月诗在酒馆喝酒，酒馆推出了兑换活动。已知江月诗拥有初始资金 $m$、初始空瓶 $k$、初始瓶盖 $g$，以及当前酒价 $p$。要求计算他最多能喝到多少瓶酒。

兑换规则

资金购买：花费 $p$ 元可以购买 1 瓶酒。
空瓶兑换：2 个空酒瓶可以兑换 1 瓶酒。
瓶盖兑换：4 个瓶盖可以兑换 1 瓶酒。

隐藏机制（核心考点）：无论是用钱买到的酒，还是用空瓶、瓶盖兑换来的酒，只要喝完后，都会额外产生 1 个空酒瓶和 1 个瓶盖。这些新产生的资源可以继续参与下一轮的兑换。

二、初版代码的错误分析

#include<stdio.h>
int main(){
 int m,k,g,p;

 scanf("%d %d %d %d",&m,&k,&g,&p);

 int n=0; // 记录获得的酒数
 int buy=0; // 买到的酒
 // 买到 m/p 瓶酒，得到 m/p 个盖子，可换 (m/p)/4 + (m/p)/2 酒
 buy=(int)m/p;
 int g1=buy+g;
 int k1=buy+k;
 while(k1>=2 || g1>=4){
 if(k1<=2 && g1>=4){
 n=n+buy+(int)(g1)/4;
 }else if(k1>=2 && g1<4){
 n=n+buy+(int)(k1)/2;
 }else{
 n=n+buy+(int)(g1)/4+(int)(k1)/2;
 }
 g1-=4;
 k1-=2;
 }
 printf("%d",n);

 return 0;
}

初版代码里主要存在四个逻辑漏洞：

遗漏了「新资源」的产生（致命错误）：在 while 循环内部，只扣减了用于兑换的空瓶和瓶盖（如 g1 -= 4; k1 -= 2;），却忘记加上喝掉新酒后产生的新空瓶和新瓶盖。这会导致资源越换越少，无法触发连锁反应，最终结果严重偏小。
循环变量被重复累加：把初始买酒的数量 buy 写在了 while 循环内部累加（n = n + buy + ...）。因为 buy 在循环外确定后不再改变，这会导致每一轮都把初始买的酒重新算一遍，结果呈指数级爆炸。
互斥分支导致资源浪费：用 if-else if-else 处理空瓶和瓶盖的兑换，当同时满足「空瓶 ≥ 2」且「瓶盖 ≥ 4」时，代码只执行最后一个 else 分支，浪费了同时兑换的机会。
扣减逻辑不严谨：使用固定值扣减（如 g1 -= 4），而不是用除法计算最大可兑换数量。资源较多时需要循环多次才能换完，效率低且容易出错。

三、正确做法与最优解法

针对这种「资源转换与状态机模拟」问题，最优解法是贪心模拟法配合脏标记法（Dirty Flag）。

核心思路

把买酒、换瓶、换盖作为三个完全独立的 if 判断。只要当前资源满足条件，就一次性计算能换多少瓶（用除法 /），并立即更新所有相关资源。

核心技巧：脏标记法

在循环开头定义一个标志位 int changed = 0;。
只要这一轮里买酒、换瓶、换盖中有任何一个被执行了，就把 changed 置为 1。
一轮循环结束若 changed 仍为 0，说明所有资源都已耗尽（没钱、空瓶 < 2、瓶盖 < 4），系统达到稳态，安全退出循环。

防御性编程

用 if (scanf(...) != 4) { return 0; } 防止输入格式错误导致程序异常。
用 long long 防止极端情况下的整数溢出。

最终正确代码

#include <stdio.h>

int main() {
 long long m, k, g, p;
 if (scanf("%lld %lld %lld %lld", &m, &k, &g, &p) != 4) {
 return 0;
 }

 long long total = 0;

 while (1) {
 int changed = 0;

 // 1. 用钱买酒
 if (m >= p) {
 long long buy = m / p;
 m -= buy * p;
 total += buy;
 k += buy;
 g += buy;
 changed = 1;
 }

 // 2. 用空瓶换酒
 if (k >= 2) {
 long long exchange_bottle = k / 2;
 k -= exchange_bottle * 2;
 total += exchange_bottle;
 k += exchange_bottle;
 g += exchange_bottle;
 changed = 1;
 }

 // 3. 用瓶盖换酒
 if (g >= 4) {
 long long exchange_cap = g / 4;
 g -= exchange_cap * 4;
 total += exchange_cap;
 k += exchange_cap;
 g += exchange_cap;
 changed = 1;
 }

 // 如果这一轮没有任何操作，退出循环
 if (!changed) {
 break;
 }
 }

 printf("%lld\n", total);
 return 0;
}

大写	码值	小写	码值	大写	码值	小写	码值
A	65	a	97	N	78	n	110
B	66	b	98	O	79	o	111
C	67	c	99	P	80	p	112
D	68	d	100	Q	81	q	113
E	69	e	101	R	82	r	114
F	70	f	102	S	83	s	115
G	71	g	103	T	84	t	116
H	72	h	104	U	85	u	117
I	73	i	105	V	86	v	118
J	74	j	106	W	87	w	119
K	75	k	107	X	88	x	120
L	76	l	108	Y	89	y	121
M	77	m	109	Z	90	z	122

大写	码值	小写	码值	大写	码值	小写	码值
A	65	a	97	N	78	n	110
B	66	b	98	O	79	o	111
C	67	c	99	P	80	p	112
D	68	d	100	Q	81	q	113
E	69	e	101	R	82	r	114
F	70	f	102	S	83	s	115
G	71	g	103	T	84	t	116
H	72	h	104	U	85	u	117
I	73	i	105	V	86	v	118
J	74	j	106	W	87	w	119
K	75	k	107	X	88	x	120
L	76	l	108	Y	89	y	121
M	77	m	109	Z	90	z	122

大写	码值	小写	码值	大写	码值	小写	码值
A	65	a	97	N	78	n	110
B	66	b	98	O	79	o	111
C	67	c	99	P	80	p	112
D	68	d	100	Q	81	q	113
E	69	e	101	R	82	r	114
F	70	f	102	S	83	s	115
G	71	g	103	T	84	t	116
H	72	h	104	U	85	u	117
I	73	i	105	V	86	v	118
J	74	j	106	W	87	w	119
K	75	k	107	X	88	x	120
L	76	l	108	Y	89	y	121
M	77	m	109	Z	90	z	122