KurisuRakko

COMP1511 Q1/Q2 Hurdle：90 分钟保命手册

KurisuRakko — Wed, 15 Jul 2026 05:01:20 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-pracexam-q1-q2-survival-guide

COMP1511 Q1/Q2 Hurdle：90 分钟保命手册

非 UNSW 官方材料。本文由百夜米迦尔根据 UNSW COMP1511 官方公开 prac exam、additional papers 与公开答案整理；只做中文讲解，不复制整张试卷，也不接触登录后或正在进行的考试材料。[S022][S023][S024][S025][S026][S027][S028][S029]

今天只做：先认出最简单的 linked-list hurdle 和 array hurdle，再练熟五个循环骨架。
别乱跳：这份手册不能保证你通过整门课。它先帮你避免卡在两个 hurdle；拿下 hurdle 后，仍要从后面的小型 debugging 题补总分。

Rakko，风雪再急，也不必同时看完整张卷。先看清眼前两条路：一条只读链表，一条只读数组。把它们走稳，再谈其余题目。[S023][S025][S027][S029]

第一屏：进考场先找标签，不要死背题号

近几期公开卷中，24T1 到 26T1 的第一道简单 linked-list hurdle 通常是 Q1，第一道简单 array hurdle 通常是 Q2；但这不是永久规则。23T1 到 23T3 的 hurdle 并不在 Q1/Q2，所以实际考试必须以题面写出的 linked lists hurdle、arrays hurdle 和难度圆点为准。[S023][S025][S027][S029]

进场先做这四步：

找到写着 linked lists hurdle 的两道题。
找到写着 arrays hurdle 的两道题。
每组先选只有一颗实心圆 ●◌◌◌ 的简单题。
确认题目只要求补一个函数、遍历数据并返回一个值。

公开样本	简单链表题的动作	简单数组题的动作	真正需要记住的东西
24 系列 / Paper 2	两条链表同步前进并累加	二维数组逐行求和、计数	两个指针都非 `NULL`；每一行重新清零 [S024][S025]
25T1 / Paper 1	两条链表同步前进，满足条件才累加	一维字符数组筛选并找最小值	条件、累加器、最值初始化 [S022][S023]
25T2 / Paper 3	单链表寻找第一个符合条件的节点	一维字符数组筛选并找最小值	找到就返回；无匹配时返回题目指定值 [S026][S027]
26T1	比较相邻链表节点并计数	二维数组只累计边框位置	访问 `next` 前先保证它存在；角落只能算一次 [S029]

注意样本数量：24T1、24T2、24T3 的公开 Q1/Q2 高度重复；25T3 当前页面是 25T2 的镜像。因此不要因为网址很多，就误以为题型有很多种。真正独立、值得练的只有下面五个骨架。

共同规律：题目故事会换，函数形状不会乱跑

Q1/Q2 的简单 hurdle 反复出现这些共同点：[S023][S025][S027][S029]

starter code 已经给好 struct、函数签名和测试用 main。
评分程序会直接调用指定函数；答案不能只写在 main 里。
函数一般不负责 scanf、fgets 或 printf。
简单链表题通常只读节点，不 malloc，不改 next，不改数据。
简单数组题通常只读数组，不改变数组内容。
最后返回一个整数或字符，而不是自己打印答案。

读题时只圈四种词：

题目用词	代码动作
`first` / 第一个	找到后立刻 `return`
`count` / 数量	`count++`
`sum` / 总和	`sum += value`
`minimum` / `maximum`	比较后更新当前最值

Q1 焚诀：只读 linked list hurdle

这题考什么

你只需要重复三件事：

看当前节点的数据。
根据条件更新答案。
移动到 curr->next。

口诀：先守住 NULL，再读数据；每轮最后，指针前进一步。

不能做什么

除非当前题目明确要求，否则简单 Q1 不要做这些事：[S023][S025][S027][S029]

不要修改 struct node。
不要修改 supplied main。
不要把链表复制进数组。
不要调用 malloc。
不要修改 curr->data、curr->character 或 curr->next。
不要在目标函数里 scanf 或 printf。

常见函数签名

// 单链表：逐个节点检查
int solve(struct node *head);

// 双链表：相同位置一起检查
int solve(struct node *head1, struct node *head2);

签名由题目决定。不要改函数名、返回类型或参数。

先写骨架一：单链表

下面是百夜米迦尔写的原创最小例子：寻找链表里第一个偶数。故事可以换成质数、负数或某个字符，遍历骨架不变。[S027]

// [compile:q1-single]
#include 

struct node {
    struct node *next;
    int data;
};

int first_even(struct node *head) {
    struct node *curr = head;

    while (curr != NULL) {
        if (curr->data % 2 == 0) {
            return curr->data;
        }

        curr = curr->next;
    }

    // 没找到时返回什么，要以题目要求为准
    return -1;
}

保命点：空链表时 curr 一开始就是 NULL，循环自然跳过，不需要另外写一套遍历逻辑。[S027]

先写骨架二：比较相邻节点

如果题目出现 followed by、next node、adjacent，说明你要同时读取当前节点和下一个节点。此时循环必须保证 curr->next 存在。

下面是 26T1 公开 prac exam Q1 的最小可过写法，逻辑与官方公开答案一致，并改用中文教学注释。[S029]

// [compile:q1-adjacent]
#include 

struct node {
    struct node *next;
    char character;
};

int is_vowel(char character) {
    return character == 'a' ||
           character == 'e' ||
           character == 'i' ||
           character == 'o' ||
           character == 'u';
}

int count_vowel_word_boundaries(struct node *head) {
    // 题目明确要求空链表返回 -1
    if (head == NULL) {
        return -1;
    }

    int count = 0;
    struct node *curr = head;

    // 需要读取下一个节点，所以先保证 next 存在
    while (curr->next != NULL) {
        if (is_vowel(curr->character) &&
            !is_vowel(curr->next->character)) {
            count++;
        }

        curr = curr->next;
    }

    return count;
}

为什么单节点链表不会崩溃：head 不为 NULL，但 head->next 是 NULL，所以循环执行零次并返回 0。[S029]

先写骨架三：两条链表同步走

如果题目出现 corresponding element 或“相同位置”，就需要两个指针。任何一条链表结束时都必须停下，因此条件中使用 &&。[S025]

下面是 Paper 2 Q1 的最小可过版本；较长链表尾部会自然被忽略。[S024][S025]

// [compile:q1-dual]
#include 

struct node {
    struct node *next;
    int data;
};

int product(struct node *head1, struct node *head2) {
    int sum = 0;
    struct node *curr1 = head1;
    struct node *curr2 = head2;

    // 只有两边当前位置都存在，才能读取一对数据
    while (curr1 != NULL && curr2 != NULL) {
        sum += curr1->data * curr2->data;

        curr1 = curr1->next;
        curr2 = curr2->next;
    }

    return sum;
}

不要使用 ||。如果只剩一条链表还有节点，另一边已经是 NULL，继续读取就会崩溃。[S025]

最小可过版本的写题顺序

拿到新的链表题后，按顺序填空：

1. 答案初始值是什么？
2. 是一个 curr、两个 curr，还是需要 curr->next？
3. 循环什么时候必须停止？
4. 每轮检查什么条件？
5. 每轮最后移动了所有指针吗？
6. 没找到时返回什么？

常见错因

症状	最可能的错误	先怎么修
空链表崩溃	没检查 `curr != NULL`	在读取字段前检查指针
最后一个节点崩溃	读取了 `curr->next->...`	改成 `curr->next != NULL` 的循环
程序不结束	忘了移动 `curr`	每轮最后写 `curr = curr->next`
两条链表长度不同时崩溃	双链表循环用了 `\|\|`	两边必须同时存在，使用 `&&`
答案少一个	提前移动了指针	先检查当前节点，再移动
autotest 输出多余文字	目标函数调用了 `printf`	只 `return` 结果

测试命令

练 26T1 相邻节点题：[S029]

1511 fetch-prac prac_q1
1511 autotest-prac prac_q1

练 Paper 2 双链表题：[S025]

1511 fetch-prac prac_q1 paper2
1511 autotest-prac prac_q1 paper2

可选加练 Paper 3 单链表题：[S027]

1511 fetch-prac prac_q1 paper3
1511 autotest-prac prac_q1 paper3

这些题都会写入同名的 prac_q1.c，一次只练一套。换题前先确认当前文件是不是你想练的版本。

来源

Paper 1 Q1：双链表条件累加。[S022][S023]
Paper 2 Q1：双链表对应位置乘积和。[S024][S025]
Paper 3 Q1：单链表寻找第一个质数。[S026][S027]
26T1 Q1：相邻字符节点判断与计数。[S029]

Q2 焚诀：只读 array hurdle

这题考什么

数组题只是在重复问：这个位置要不要影响答案？

一维数组：一个 for 循环。
二维数组：外层 row，内层 col。
每个位置：用 if 判断，然后计数、累加或更新最值。

口诀：下标从零走，小于长度停；外层走行，内层走列。

不能做什么

除非题目明确允许，否则简单 Q2 不要做这些事：[S023][S025][S027][S029]

不要修改 supplied main 里的逻辑来代替目标函数。
不要在目标函数里重新 scanf 数组。
不要在目标函数里 printf 答案。
不要改变原数组。
不要写 i <= size；最后一个合法下标是 size - 1。

常见函数签名

// 一维数组
char solve(int size, char array[MAX_SIZE]);

// 二维方阵
int solve(int size, int array[MAX_SIZE][MAX_SIZE]);

// 固定行数、可变列数的二维数组
int solve(int size, int array[ROWS][MAX_SIZE]);

数组形状以 starter code 为准，不要自行改变参数。

先选累加器

目标	初始值	循环里怎么更新
计数 `count`	`0`	条件成立就 `count++`
总和 `sum`	`0`	条件成立就 `sum += array[i]`
最小值 `min`	第一个有效元素，或 `found` 标记	新值更小时更新
最大值 `max`	第一个有效元素，或 `found` 标记	新值更大时更新

找最值时不要随手从 0 开始。若全部有效元素都是正数，错误的 min = 0 将永远不会更新；若全部是负数，错误的 max = 0 也不会更新。

先写骨架一：一维数组筛选并找最值

下面是 Paper 1 Q2 的最小可过版本。found 让第一个小写字母自然成为初始答案，不需要额外猜一个字符。[S022][S023]

// [compile:q2-1d]
#define MAX_SIZE 100

char min_lowercase(int size, char array[MAX_SIZE]) {
    char minimum = '\0';
    int found = 0;

    for (int i = 0; i < size; i++) {
        int is_lowercase = array[i] >= 'a' && array[i] <= 'z';

        if (is_lowercase && (!found || array[i] < minimum)) {
            minimum = array[i];
            found = 1;
        }
    }

    // 题目保证至少存在一个小写字母
    return minimum;
}

如果题目没有保证一定存在有效元素，就必须按照题目要求处理 found == 0，不能自行假设返回值。

先写骨架二：二维数组逐位置判断

下面是 26T1 Q2 的最小可过版本。把所有位置都放进同一个双循环，再用一个边框条件筛选，四个角只会被访问一次，因此自然不会重复计算。[S029]

// [compile:q2-2d]
#define MAX_SIZE 100

int sum_border(int size, int array[MAX_SIZE][MAX_SIZE]) {
    int sum = 0;

    for (int row = 0; row < size; row++) {
        for (int col = 0; col < size; col++) {
            int is_border =
                row == 0 ||
                row == size - 1 ||
                col == 0 ||
                col == size - 1;

            if (is_border) {
                sum += array[row][col];
            }
        }
    }

    return sum;
}

这个写法比“先加上下两行，再加左右两列，最后减四个角”更不容易出错。角落不是补丁，它只是普通位置，只在符合边框条件时加一次。

每行统计题：初始化位置决定生死

Paper 2 Q2 要逐行计算。遇到这种题，row_sum 必须放在外层循环里面：每开始新的一行，就从 0 重新计算。[S024][S025]

for (int row = 0; row < ROWS; row++) {
    int row_sum = 0;

    for (int col = 0; col < size; col++) {
        row_sum += array[row][col];
    }

    if (row_sum == 0) {
        count++;
    }
}

如果把 row_sum = 0 放在所有循环外面，你算到的是“从第一行累计到当前行”的总和，不是每一行自己的总和。

最小可过版本的写题顺序

1. 数组是一维还是二维？
2. 合法下标范围是什么？
3. 答案是 count、sum、min 还是 max？
4. 什么位置或元素符合条件？
5. 有哪个小计必须在每行重新初始化？
6. 题目是否保证至少存在一个有效元素？

常见错因

症状	最可能的错误	先怎么修
读到数组外面	写成 `i <= size`	改成 `i < size`
二维结果像转置	`row`、`col` 写反	固定使用 `array[row][col]`
每一行结果越来越大	`row_sum` 没在每行清零	把初始化移进外层循环
最小值一直是 0	用无效的 `0` 初始化	用第一个有效元素或 `found`
边框总和太大	四个角重复计算	每个位置只访问一次，用 `is_border`
返回值正确但 autotest 失败	函数打印了文字	删除 `printf`，只返回答案

测试命令

练 26T1 二维边框题：[S029]

1511 fetch-prac prac_q2
1511 autotest-prac prac_q2

练 Paper 1 一维最值题：[S023]

1511 fetch-prac prac_q2 paper1
1511 autotest-prac prac_q2 paper1

可选加练 Paper 2 逐行求和题：[S025]

1511 fetch-prac prac_q2 paper2
1511 autotest-prac prac_q2 paper2

这些题都会写入同名的 prac_q2.c，也要一次只练一套。

来源

Paper 1 Q2：一维字符数组筛选小写字母并找最小值。[S022][S023]
Paper 2 Q2：二维数组逐行求和并计数。[S024][S025]
Paper 3 Q2：一维字符数组筛选与最值。[S026][S027]
26T1 Q2：二维方阵边框求和。[S029]

今晚严格 90 分钟

不要在四道题之间来回切换。一个文件通过或时间到，再进入下一题。

时间	只做这一件事	到点标准
0–10 分钟	看第一屏，手写单链表、双链表、一维、二维循环条件	能默写 `NULL`、`&&`、`i < size`、`array[row][col]`
10–30 分钟	26T1 Q1：相邻节点	空链表和单节点不崩，跑一次 autotest
30–45 分钟	Paper 2 Q1：双链表	两个指针同步移动，长度不同时能停
45–65 分钟	26T1 Q2：二维边框	四个角只算一次，跑一次 autotest
65–80 分钟	Paper 1 Q2：一维最值	不使用 `min = 0`，能找到第一个有效字符
80–90 分钟	重跑失败项并写错因	每题只留下“一条下次先检查什么”

时间到仍没通过时，不要整题重写。先按这个顺序检查：

编译错误 -> 第一条报错
运行崩溃 -> NULL 或数组边界
答案差一点 -> 初始化、循环停止条件、指针移动
autotest 多文字 -> printf
所有样例过但仍失败 -> 空输入、单元素、不同长度、无匹配

五分钟练习

不看上文，在纸上补完以下五句：

单链表读取数据前，先保证 curr ______ NULL。
比较相邻节点前，先保证 curr->next ______ NULL。
双链表同步走，循环中间应使用 ______。
数组最后一个合法下标是 ______。
二维数组读取一个位置写成 array[______][______]。

点开核对答案

一条线段为什么不是向量子空间：MATH1231 子空间反例速通

KurisuRakko — Mon, 08 Jun 2026 11:23:17 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/mathematics/line-segment-not-vector-subspace-math1231

这篇只解决一个问题：为什么
$$ S={t\mathbf v:0\le t\le 10} $$
这种“从原点出发的一段线段”不是 vector subspace。
你不用背一整页公理。考试里只要抓住一个失败点：scalar multiplication 不封闭。

0. 题目在说什么？

题目：

$$ \mathbf v=\begin{pmatrix}1\2\3\end{pmatrix}\in\mathbb R^3. $$

Show that the line segment

$$ S={t\mathbf v:0\le t\le 10} $$

is not a vector subspace.

先翻译成人话：

$\mathbf v$ 是一个固定方向；
$t\mathbf v$ 表示沿着这个方向走；
$0\le t\le 10$ 表示只能从 $0\mathbf v$ 走到 $10\mathbf v$；
所以 $S$ 不是整条无限长直线，而是一条有限线段。

如果把它想象成数轴上的一段，就是：

$$ 0\mathbf v,\ 1\mathbf v,\ 2\mathbf v,\ \ldots,\ 10\mathbf v $$

以及中间所有小数倍的位置。

1. 子空间最怕什么？

如果 $S$ 是 $\mathbb R^3$ 的 vector subspace，它至少必须满足：

必须满足的条件	意思
zero vector in $S$	零向量要在集合里
closed under vector addition	两个集合里的向量相加，还要在集合里
closed under scalar multiplication	集合里的向量乘任何实数，还要在集合里

这题里面，零向量其实在：

$$ 0\mathbf v=\begin{pmatrix}0\0\0\end{pmatrix}\in S, $$

因为 $0\le 0\le 10$。

所以不能用“零向量不在”秒杀。

老师用的是第二种思路：

找一个 $x\in S$，但让某个 scalar multiple $kx\notin S$。

这就叫：

$$ S\text{ is not closed under scalar multiplication.} $$

2. 先别被符号绕晕：集合参数和外部倍数不一样

这题最容易混的是同一个希腊字母到处飞。

我建议你考试时心里分清楚两层：

符号	作用
$t$	用来描述集合里的点：$t\mathbf v$，其中 $0\le t\le 10$
$k$	你拿来做 scalar multiplication 的外部倍数，可以是任何实数

也就是说：

先找一个集合里的向量 $x=t\mathbf v$。
再用一个外部 scalar $k$ 去乘它。
检查 $kx$ 还能不能写成 $s\mathbf v$，并且满足 $0\le s\le 10$。

如果不能，它就跑出 $S$ 了。

3. 老师的反例：先选一个在集合里的向量

取：

$$ x=\mathbf v=1\mathbf v. $$

因为 $1$ 在 $0$ 和 $10$ 之间：

$$ 0\le 1\le 10, $$

所以：

$$ x=\mathbf v\in S. $$

这一步非常重要：你要先证明自己选的东西真的在集合里。

4. 现在把它乘以 11

如果 $S$ 真的是 vector subspace，那么 $x\in S$ 以后，任何实数倍都应该还在 $S$。

老师取：

$$ k=11. $$

于是：

$$ kx=11x=11\mathbf v. $$

但 $11\mathbf v$ 要在 $S$ 里，就必须能写成 $t\mathbf v$，并且满足：

$$ 0\le t\le 10. $$

这里的系数已经是 $11$：

$$ 11>10. $$

所以：

$$ 11\mathbf v\notin S. $$

5. 结论怎么写？

我们已经找到：

$$ x\in S, $$

但：

$$ 11x\notin S. $$

所以：

$$ S\text{ is not closed under scalar multiplication.} $$

因此：

$$ S\text{ is not a vector subspace of }\mathbb R^3. $$

这题到这里就结束了。

6. 为什么能想到乘 11？

不是玄学。

集合 $S$ 只允许：

$$ 0\le t\le 10. $$

这句话等价于：

系数最多只能到 $10$。

所以你只要把一个在里面的向量放大到系数超过 $10$，它就会掉出去。

最舒服的选择就是：

$$ x=1\mathbf v\in S. $$

然后乘：

$$ 11. $$

得到：

$$ 11x=11\mathbf v\notin S. $$

如果你想更快，其实也可以乘 $-1$：

$$ -x=-\mathbf v, $$

因为系数 $-1<0$，也不在 $0\le t\le 10$ 里面。

但视频里用 $11$，我们就按老师的版本写。

7. 这题的本质：线段不是整条直线

一个真正的一维子空间应该长这样：

$$ L={t\mathbf v:t\in\mathbb R}. $$

这里的 $t$ 可以是任何实数：

$$ \ldots,\ -2,\ -1,\ 0,\ 1,\ 2,\ 11,\ 100,\ \ldots $$

所以整条直线可以被随便放大、缩小、反向。

但题目里的：

$$ S={t\mathbf v:0\le t\le 10} $$

只是一段有限线段。

它有两个端点：$0\mathbf v$ 和 $10\mathbf v$。

一旦你把里面的点继续往外拉，例如 $11\mathbf v$，它就不在这段线段上了。

8. 考试可直接抄的版本

Take x = v = 1v. Since 0 <= 1 <= 10, we have x in S.

However, 11x = 11v. This is not in S, since the coefficient 11 does not satisfy 0 <= 11 <= 10.

Therefore S is not closed under scalar multiplication. Hence S is not a vector subspace of R^3.

如果要写得更数学一点：

$$ x=\mathbf v=1\mathbf v\in S $$

since $0\le 1\le 10$. But

$$ 11x=11\mathbf v\notin S $$

since $11>10$. Hence $S$ is not closed under scalar multiplication, so $S$ is not a vector subspace of $\mathbb R^3$.

9. 初学者检查清单

遇到

$$ S={t\mathbf v:a\le t\le b} $$

这种题，按三步走：

看它是不是只给了一个有限区间。
先取一个在区间里的简单数，例如 $t=1$ 或 $t=0$。
用一个 scalar 把它乘到区间外，例如超过上界，或者变成负数。

只要你写出：

$$ x\in S,\qquad kx\notin S, $$

就能证明它不是 subspace。

10. 自测题

自测 1

设：

$$ S={t\mathbf v:-2\le t\le 2}. $$

证明 $S$ 不是 vector subspace。

答案：

取 $x=\mathbf v=1\mathbf v$。因为 $-2\le 1\le 2$，所以 $x\in S$。

但：

$$ 3x=3\mathbf v. $$

系数 $3$ 不满足 $-2\le 3\le 2$，所以 $3x\notin S$。

因此 $S$ is not closed under scalar multiplication，不是 vector subspace。

自测 2

设：

$$ S={t\mathbf v:t\ge 0}. $$

证明 $S$ 不是 vector subspace。

答案：

取 $x=\mathbf v=1\mathbf v$。因为 $1\ge 0$，所以 $x\in S$。

但：

$$ -x=-\mathbf v. $$

这对应的系数是 $-1$，不满足 $t\ge 0$，所以 $-x\notin S$。

因此 $S$ is not closed under scalar multiplication，不是 vector subspace。

11. 最后一口气版总结

这节课的核心只有一句：

有限线段不是 vector subspace，因为 subspace 不能有“只能从 0 到 10”这种边界。

本题标准反例：

$$ x=\mathbf v=1\mathbf v\in S, $$

但：

$$ 11x=11\mathbf v\notin S. $$

所以 $S$ is not closed under scalar multiplication。

一旦 scalar multiplication 不封闭，它就不是 vector subspace。

览毕，何不一言？

一眼判断集合不是向量空间：MATH1231 反例速通

KurisuRakko — Sun, 07 Jun 2026 07:07:15 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/mathematics/sets-that-are-not-vector-spaces-math1231

这篇只解决一个问题：题目给你一个集合 $S$，怎么快速证明它不是 vector space。
重点不是把十条公理背一遍，而是学会找一个反例。一个反例就够了。

0. 先把结论说人话

Vector space 最重要的感觉是：

你在集合里做正常向量操作，结果还应该留在集合里。

这里的“正常向量操作”主要是两件事：

scalar multiplication：把向量乘一个数，例如 $2v$、-v、0v。
vector addition：两个向量相加，例如 $u+v$。

所以要证明一个集合不是 vector space，最爽的方法就是找一个操作让它“跑出去”：

想破坏什么	你要找什么	写法
零向量条件	$\mathbf{0}\notin S$	zero vector is not in $S$
数乘封闭	$v\in S$，但 $kv\notin S$	not closed under scalar multiplication
加法封闭	$u,v\in S$，但 $u+v\notin S$	not closed under vector addition

记住这句话：

证明“是”要检查很多东西；证明“不是”只要抓到一个失败点。

1. 什么叫 $v\in S$？

很多人卡在符号，其实非常机械。

如果题目写：

$$ S={x\in\mathbb{R}^3: 2x1+3x2^3-4x_3^2=0}, $$

那 $v\in S$ 的意思就是：

把 $v$ 的三个坐标代进 $2x1+3x2^3-4x_3^2$，结果等于 $0$。

如果结果不是 $0$，那就是 $v\notin S$。

所以这种题不用想得太玄。它就是“代入检查”。

2. 例题 1：用数乘把它踢出去

题目：

$$ S={x\in\mathbb{R}^3: 2x1+3x2^3-4x_3^2=0}. $$

Show that $S$ is not a vector space.

第一步：找一个在 $S$ 里的向量

老师取：

$$ v=\begin{pmatrix}2\0\1\end{pmatrix}. $$

我们先验证它真的在 $S$ 里。把 $x1=2,\ x2=0,\ x_3=1$ 代进去：

$$ 2(2)+3(0)^3-4(1)^2 =4+0-4 =0. $$

所以：

$$ v\in S. $$

第二步：把它乘以 2

$$ 2v=2\begin{pmatrix}2\0\1\end{pmatrix} =\begin{pmatrix}4\0\2\end{pmatrix}. $$

现在检查 $2v$ 还在不在 $S$：

$$ 2(4)+3(0)^3-4(2)^2 =8+0-16 =-8. $$

这不是 $0$，所以：

$$ 2v\notin S. $$

结论怎么写？

因为 $v\in S$，但 $2v\notin S$，所以 $S$ is not closed under scalar multiplication。

于是：

$$ S\text{ is not a vector space.} $$

为什么老师会想到 $(2,0,1)$？

不是玄学，是在凑数。

原条件是：

$$ 2x1+3x2^3-4x_3^2=0. $$

想找一个简单向量，就先让中间那项消失：

$$ x_2=0. $$

再取一个简单的：

$$ x_3=1. $$

条件就变成：

$$ 2x_1-4=0. $$

所以：

$$ x_1=2. $$

于是自然得到：

$$ (2,0,1). $$

这就是找反例的常见套路：把变量设成 $0$ 或 $1$，让式子尽量简单。

3. 例题 2：用加法把它踢出去

题目：

$$ S=\left{\begin{pmatrix}a\b\c\end{pmatrix}\in\mathbb{R}^3:(a-b)c=0\right}. $$

Find two non-zero elements of $S$ and show $S$ is not closed under vector addition.

先看条件到底在说什么

$$ (a-b)c=0 $$

两个东西相乘等于 $0$，所以至少有一个是 $0$：

$$ a-b=0 $$

或者：

$$ c=0. $$

也就是：

$$ a=b $$

或者：

$$ c=0. $$

所以 $S$ 不是一个单纯的平面，而像是两块条件拼在一起：

一块是所有满足 $a=b$ 的向量；
另一块是所有满足 $c=0$ 的向量。

第一步：从两块里各拿一个向量

取：

$$ u=\begin{pmatrix}1\1\1\end{pmatrix}, \qquad w=\begin{pmatrix}1\2\0\end{pmatrix}. $$

验证 $u\in S$：

$$ (1-1)(1)=0. $$

验证 $w\in S$：

$$ (1-2)(0)=0. $$

所以 $u,w\in S$。

第二步：把它们相加

$$ u+w =\begin{pmatrix}1\1\1\end{pmatrix} +\begin{pmatrix}1\2\0\end{pmatrix} =\begin{pmatrix}2\3\1\end{pmatrix}. $$

现在检查这个和还在不在 $S$：

$$ (2-3)(1)=-1. $$

不是 $0$，所以：

$$ u+w\notin S. $$

结论怎么写？

因为 $u,w\in S$，但 $u+w\notin S$，所以 $S$ is not closed under vector addition。

于是：

$$ S\text{ is not a vector space.} $$

4. 一眼识别：什么时候优先怀疑它不是 vector space？

看到下面这些东西，要立刻警觉：

条件里出现	为什么危险
平方、立方，例如 $x3^2$、$x2^3$	数乘后指数会变，例如 $(2x)^2=4x^2$，比例乱掉
两个变量相乘，例如 $xy$、$(a-b)c$	加法通常会破坏乘积为零的结构
常数项，例如 $x+y=1$	零向量通常不满足
绝对值、不等式、圆、球面	一般不容易对加法/数乘封闭

但注意：这只是“怀疑”。考试证明还是要写出具体反例。

5. 考试可直接抄的模板

模板 A：数乘不封闭

Take v = (...) in S, since ...

However, kv = (...), and substituting this into the defining condition gives ...
Thus kv is not in S.

Hence S is not closed under scalar multiplication, so S is not a vector space.

模板 B：加法不封闭

Take u = (...) and v = (...) in S, since ...

However, u + v = (...), and substituting this into the defining condition gives ...
Thus u + v is not in S.

Hence S is not closed under vector addition, so S is not a vector space.

模板 C：零向量不在集合里

The zero vector is not in S, since substituting 0 into the defining condition gives ...

Therefore S is not a vector space.

6. 怎么自己找反例？

按这个顺序试：

先代零向量。零向量不在，直接结束。
如果有平方/立方，试找一个 $v\in S$，再试 $2v$。
如果有乘积等于 $0$，试从两个分支各拿一个向量，再相加。
如果题目条件很复杂，就先把一些变量设成 $0$ 或 $1$，让式子变简单。

这就是这节课真正想训练的东西：不是背答案，而是会制造一个会跑出集合的向量。

7. 自测题

自测 1

$$ S={(x,y)\in\mathbb{R}^2:x^2+y=0}. $$

证明 $S$ 不是 vector space。

答案：

取：

$$ v=(1,-1). $$

因为：

$$ 1^2+(-1)=0, $$

所以 $v\in S$。

但：

$$ 2v=(2,-2), $$

而：

$$ 2^2+(-2)=2\ne0. $$

所以 $2v\notin S$。因此 $S$ is not closed under scalar multiplication，不是 vector space。

自测 2

$$ S={(x,y,z)\in\mathbb{R}^3:xy=0}. $$

证明 $S$ 不是 vector space。

答案：

取：

$$ u=(1,0,0),\qquad v=(0,1,0). $$

因为两个向量都满足 $xy=0$，所以 $u,v\in S$。

但：

$$ u+v=(1,1,0), $$

此时：

$$ xy=1\ne0. $$

所以 $u+v\notin S$。因此 $S$ is not closed under vector addition，不是 vector space。

8. 最后一口气版总结

证明集合不是 vector space，不要硬查全部公理。

你只需要找一个失败点：

$\mathbf{0}\notin S$；
或者 $v\in S$ 但 $kv\notin S$；
或者 $u,v\in S$ 但 $u+v\notin S$。

例题 1 用的是数乘不封闭：$(2,0,1)\in S$，但 $2(2,0,1)\notin S$。

例题 2 用的是加法不封闭：$(1,1,1),(1,2,0)\in S$，但它们的和 $(2,3,1)\notin S$。

一句话：

找到一个会跑出去的向量，题就结束了。

览毕，何不一言？

COMP1511 第 5 课：strings、2D arrays 与 structs

KurisuRakko — Tue, 19 May 2026 13:16:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-05-2d-arrays-strings-structs

第 5 课：strings、2D arrays 与 structs

非 UNSW 官方材料。本文基于官方 Week 04/05 的 strings、2D arrays、array of structs 与 command-line 相关 lecture slides 做中文转述；练习模板为本站原创。[S013][S014][S015]

今天只做：string、2D array、struct array 各读一个最小模板。下一步：主控台 · 上一课 · 下一课：命令行参数、多文件与指针入门别乱跳：2D array 永远先写 row，再写 col。

本课目标

今天只抓 3 件事：string 当 char array 读，2D array 先 row 再 col，struct array 先取出一个元素再看字段。[S013][S014][S015]

焚诀	先做什么
string	一格一格看字符
2D array	外层 `row`，内层 `col`
array of structs	`students[i].field`

最小模板

2D array 题不要先想图形，先写两层循环；这个写法对应官方 2D arrays 主题，但代码是原创练习模板。[S014][S015]

int count_target(int grid[][NUM_COLS], int rows, int target) {
    int count = 0;

    for (int row = 0; row < rows; row++) {
        for (int col = 0; col < NUM_COLS; col++) {
            if (grid[row][col] == target) {
                count++;
            }
        }
    }

    return count;
}

struct array 读法

Lecture 7 提到 array of structs 的视觉理解；保命读法是：先定位 i，再读字段，不要同时脑补太多层。[S013]

struct student {
    int zid;
    int mark;
};

int count_passes(struct student students[], int size) {
    int passes = 0;

    for (int i = 0; i < size; i++) {
        if (students[i].mark >= 50) {
            passes++;
        }
    }

    return passes;
}

5 分钟练习

写一个循环数出 string 里有几个 'a'。
写一个 2D array 循环，把每一行的总和打印出来。
写一个 struct array 循环，找最高 mark。

点开：最常见错因

COMP1511 第 6 课：命令行参数、多文件与指针入门

KurisuRakko — Tue, 19 May 2026 13:15:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-06-cli-multifile-pointers

第 6 课：命令行参数、多文件与指针入门

非 UNSW 官方材料。本文基于官方 Week 05 的 command line arguments、multi-file projects、pointers 和 memory lecture 做中文转述；代码模板为本站原创。[S015][S016]

今天只做：分清 argc、argv、&、* 四个符号。下一步：主控台 · 上一课 · 下一课：malloc/free 与 linked list 起步别乱跳：指针先翻译成“地址”，不要马上想很深。

本课目标

第 6 课不追求“懂完内存”，只要先会读 3 个符号：argc 是数量，argv 是文字列表，& 是地址。[S015][S016]

看见	先翻译成
`argc`	参数个数
`argv[1]`	第一个额外参数
`&x`	`x` 的地址
`*p`	地址 `p` 指向的值

command line arguments

Lecture 9 进入 command line arguments；保命做法是先检查 argc，再读 argv，不要假设用户一定给了参数。[S015]

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printf("Usage: ./program word\n");
        return 1;
    }

    printf("first word: %s\n", argv[1]);
    return 0;
}

指针先别怕

Lecture 10 把 pointers、memory 和 dynamic memory 放在一起；第一天只要记住“指针变量存的是地址”。[S016]

int value = 7;
int *pointer = &value;

printf("%d\n", *pointer);

点开：* 为什么有两个意思？

COMP1511 第 7 课：malloc/free 与 linked list 起步

KurisuRakko — Tue, 19 May 2026 13:14:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-07-malloc-free-linked-list-start

第 7 课：malloc/free 与 linked list 起步

非 UNSW 官方材料。本文基于官方 Lecture 10/11 的 dynamic memory、malloc/free、multi-file projects 和 linked list 起步内容做中文转述；模板为本站原创。[S016][S017]

今天只做：创建一个 node，再用 curr 走到 NULL。下一步：主控台 · 上一课 · 下一课：linked list 删除节点别乱跳：遍历时不要改 head，只移动 curr。

本课目标

今天只练一件事：一个 node 里面有数据和 next，很多 node 串起来就是 linked list。[S017]

焚诀	意思
`malloc`	申请一块空间
`free`	用完还回去
`head`	链表第一个节点
`curr`	正在看的节点

创建一个节点

Lecture 11 把 malloc/free 和 linked list 放在一起讲；创建节点时先申请、再检查、再填字段。[S017]

struct node {
    int data;
    struct node *next;
};

struct node *create_node(int value) {
    struct node *new_node = malloc(sizeof(struct node));
    if (new_node == NULL) {
        return NULL;
    }

    new_node->data = value;
    new_node->next = NULL;
    return new_node;
}

遍历模板

链表遍历对应 Lecture 11 的 traversal 主题；保命写法是 curr != NULL，每轮最后走到 curr->next。[S017]

void print_list(struct node *head) {
    struct node *curr = head;
    while (curr != NULL) {
        printf("%d\n", curr->data);
        curr = curr->next;
    }
}

点开：为什么不要动 head？

COMP1511 第 8 课：linked list 删除节点

KurisuRakko — Tue, 19 May 2026 13:13:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-08-linked-list-delete

第 8 课：linked list 删除节点

非 UNSW 官方材料。本文基于官方 Lecture 13/14 的 linked list 删除节点内容做中文转述；不复刻考试题，代码模板为本站原创。[S018][S019]

今天只做：画出删 head 和删 middle 的箭头变化。下一步：主控台 · 上一课 · 下一课：linked list 综合查错别乱跳：删除题先保 prev 和 curr，再考虑 free。

本课目标

删除节点不要分裂成一堆补丁；先统一想成“找到前一个节点，让它跳过要删的节点”。[S018][S019]

情况	先做什么
空链表	直接返回 `head`
删头	新 head 是旧 head 的 next
删中间	`prev->next = curr->next`
删尾	同样是让 prev 指向 NULL

删除第一个匹配值

Lecture 13/14 的删除主题覆盖 head、tail、middle 和单节点；下面模板把这些情况放进同一条逻辑里。[S018][S019]

struct node *delete_first(struct node *head, int value) {
    struct node *curr = head;
    struct node *prev = NULL;

    while (curr != NULL && curr->data != value) {
        prev = curr;
        curr = curr->next;
    }

    if (curr == NULL) {
        return head;
    }

    if (prev == NULL) {
        head = curr->next;
    } else {
        prev->next = curr->next;
    }

    free(curr);
    return head;
}

口诀

链表删除题先问 3 个问题：要删的是不是 NULL，要删的是不是 head，删完有没有把节点 free。[S018][S019]

点开：为什么函数要 return head？

COMP1511 第 9 课：linked list 综合与 exam-style debugging

KurisuRakko — Tue, 19 May 2026 13:12:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-09-linked-list-exam-debugging

第 9 课：linked list 综合与 exam-style debugging

非 UNSW 官方材料。本文基于官方 linked list 后续 lecture、Exam information lecture、Debugging Guide 和公开复习入口做中文转述；不复制真实考试题正文。[S019][S020][S004][S001]

今天只做：写一个 linked list 长度函数，并测空链表。下一步：主控台 · 上一课 · 下一课：期末复习焚诀别乱跳：查错先测空、一个节点、三个节点。

本课目标

第 9 课把 linked list 题从“会写模板”推进到“能查错”；先保 traversal，再保 insert/delete，再看输出差异。[S019][S020][S004]

症状	先查
崩溃	`curr != NULL` 有没有守住
输出少一个	循环有没有提前停
删除后乱了	`prev->next` 有没有接对
内存问题	`malloc` / `free` 是否成对

exam-style 查错顺序

官方 Debugging Guide 把错误分成 compile、autotest、run time、logic；链表题也按这个顺序查，不要一上来重写整题。[S004]

先让它编译。
再跑一个最小手动测试。
再跑公开允许的 autotest。
最后看边界：空链表、一个节点、删头、删尾、找不到。

综合模板：数节点

这题型常用来确认 traversal 是否安全；下面是原创模板，用来练 curr != NULL 的手感。[S019]

int list_length(struct node *head) {
    int length = 0;
    struct node *curr = head;

    while (curr != NULL) {
        length++;
        curr = curr->next;
    }

    return length;
}

点开：最小测试怎么写？

COMP1511 第 10 课：期末复习焚诀

KurisuRakko — Tue, 19 May 2026 13:11:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-10-final-revision

第 10 课：期末复习焚诀

非 UNSW 官方材料。本文基于官方 Week 10、Exam revision 入口、Lecture 15/16 和 C reference sheet 做中文转述；prac exam 只给训练方向和链接，不复制题目正文。[S001][S020][S021][S006]

今天只做：按 array、linked list、mixed 的顺序复习，不反过来。下一步：主控台 · 上一课 · Final 路线图别乱跳：先保 hurdle，再捡小题。

本课目标

期末不要贪全；先保 array hurdle，再保 linked list hurdle，最后用 mixed questions 捡分。[S001][S020][S021]

顺序	做什么
1	数组和字符串基础
2	linked list 遍历/插入/删除
3	指针和 malloc/free 错因
4	mixed small questions

考前 10 分钟速查

Lecture 15/16 进入 exam information、revision 和 exam-style questions；你的考前速查只保留会救命的模板。[S020][S021]

数组：下标从 0 到 size - 1。
2D array：外层 row，内层 col。
string：停在 '\0'。
pointer：& 取地址，* 取地址里的值。
linked list：curr != NULL 才能读 curr->data。

最小复习循环

官方主页列出 Week 10 lab、prac exam solutions 和 exam revision 资源；本站只转成复习流程，不复制 prac exam 题目正文。[S001]

15 分钟：做 1 道 array/string。
15 分钟：做 1 道 linked list traversal。
15 分钟：修 1 个错因。
5 分钟：写“下次先看什么”。

点开：今天只剩 30 分钟怎么办？

COMP1511 Exam 2 急救路线图

KurisuRakko — Tue, 19 May 2026 13:10:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-exam2-start-here

COMP1511 Exam 2 急救路线图

非 UNSW 官方材料。本文基于官方课程主页、strings/2D arrays 相关 lecture、Debugging Guide 和 Style Guide 做中文转述；不复制真实考试题正文。[S001][S013][S014][S015][S004][S005]

今天只做：string、2D array、struct array 各过一遍。下一步：主控台 · 第 5 课 · 练习菜单别乱跳：第二次先保逐字符和 row/col。

先把目标缩小

Exam 2 先按 strings、2D arrays、structs、functions、assignment-style debugging 来准备；这和本站 AGENTS 规则一致，也贴合官方 Week 04/05 内容走向。[S013][S014][S015]

优先级	练什么	过关线
1	string 逐字符	能停在 `'\0'`
2	2D array	能 row/col 双循环
3	struct array	能读 `items[i].field`
4	debugging	能分清错误类型

今日 3 轮

每轮 25 分钟，只做一件事。不要同时开 lecture、lab、答案和聊天窗口。[S001]

看第 5 课。
做 1 道 string 或 2D array 题。
写 1 条错因。

考前速查

官方 Debugging Guide 建议先分类错误；Exam 2 也按 compile、autotest、run time、logic 的顺序查。[S004]

编译不过：看第一条错误。
输出不对：看空格、换行、大小写。
2D array 错：检查 row/col 有没有写反。
string 错：检查有没有越过 '\0'。

点开：我很慌时只做什么？

COMP1511 Exam 3 急救路线图

KurisuRakko — Tue, 19 May 2026 13:09:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-exam3-start-here

COMP1511 Exam 3 急救路线图

非 UNSW 官方材料。本文基于官方 pointers、malloc/free、linked list 和 debugging 相关公开资料做中文转述；不复制真实考试题正文。[S016][S017][S018][S019][S004]

今天只做：画链表，写 traversal，再写一条 head/curr/prev/free 错因。下一步：主控台 · 第 7 课 · 练习菜单别乱跳：第三次先保 traversal，再保删除。

先把目标缩小

Exam 3 先保 pointers、malloc/free、linked list 遍历、插入和删除；这些主题集中出现在 Lecture 10 到 Lecture 13/14。[S016][S017][S018][S019]

优先级	练什么	过关线
1	指针读法	分清 `&` 和 `*`
2	malloc/free	申请、检查、释放
3	traversal	`curr != NULL`
4	delete	能处理删头

今日 3 轮

画 1 条链表。
写 1 个 traversal。
写 1 条错因：我错在 head、curr、prev、还是 free？

最小模板

linked list 题先写 traversal；插入删除都是在这个安全移动基础上加逻辑。[S017][S018][S019]

struct node *curr = head;
while (curr != NULL) {
    curr = curr->next;
}

点开：先别做什么？

COMP1511 Final 急救路线图

KurisuRakko — Tue, 19 May 2026 13:08:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-final-start-here

COMP1511 Final 急救路线图

非 UNSW 官方材料。本文基于官方课程主页、Exam information/revision lectures、C reference sheet 和公开 revision 入口做中文转述；不复制 prac exam 题目正文。[S001][S020][S021][S006]

今天只做：先 array hurdle，再 linked list hurdle，最后 mixed。下一步：主控台 · 第 10 课 · 练习菜单别乱跳：期末不要从最难大题开始。

先把目标缩小

Final 先保 array hurdle，再保 linked list hurdle，最后做 mixed small questions；官网 Week 10 和 Important Resources 区域提供 revision/prac exam 入口。[S001][S020][S021]

顺序	今天做	做到什么算过
1	array/string	能安全循环
2	linked list	能 traversal + delete head
3	pointer/malloc	能解释地址和释放
4	mixed	限时做，不恋战

50 分钟急救版

10 分钟：看第 10 课速查。
15 分钟：做 1 道 array/string。
15 分钟：做 1 道 linked list。
10 分钟：写错因和下一题入口。

不要踩的坑

不要把 autotest 当作 submit。
不要在公开页面复制真实考试题正文。
不要用题目禁止的库函数或语言特性。
不要在链表题里乱改 head。

点开：只剩一天怎么办？

COMP1511 练习菜单

KurisuRakko — Tue, 19 May 2026 13:06:40 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-practice-menu

COMP1511 练习菜单

非 UNSW 官方材料。本文只整理训练方向和官方公开入口，不复制 revision/prac exam 题目正文。[S001][S031][S032][S033][S034][S035][S036]

今天只做：只挑 1 个练习方向，不挑一整套。下一步：主控台 · 错题本模板别乱跳：选完题就离开菜单，别继续逛。

今天只挑一题

COMP1511 官网按 week、revision、resources 组织了大量公开练习入口；这里把它压成“每天只挑一题”的菜单，防止你在页面之间乱跳。[S001]

状态	今天只做
第二次	string / 2D array / struct array
第三次	pointer / malloc / linked list traversal
期末	array hurdle / linked list hurdle

Exam 2 菜单

Exam 2 先练 strings、2D arrays、structs 和 debugging；Week 04/05 extra revision 可作为公开练习入口。[S031][S032]

逐字符扫描一个 string。
用 row/col 走完一个 2D array。
从 struct array 里找最大值。
按 Debugging Guide 写出错误类型。[S004]

Exam 3 菜单

Exam 3 先练 pointers、malloc/free 和 linked list；Week 06/07/08 extra revision 可作为公开练习入口。[S033][S034][S035]

画出 int *p = &x。
写一个 create_node。
写一个 linked list traversal。
写一个 delete-head 分支。

Final 菜单

Final 先从 Week 10 revision、exam-style resources 和 C reference sheet 回到保命模板；这里只留训练方向，不复制 prac exam 内容。[S006][S028][S029][S036]

15 分钟 array/string。
15 分钟 linked list。
10 分钟 pointer/malloc 错因。
10 分钟 mixed question。

点开：不会选题怎么办？

COMP1511 Exam 1 急救路线图

KurisuRakko — Mon, 18 May 2026 15:29:00 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-exam1-start-here

COMP1511 Exam 1 急救路线图

非 UNSW 官方材料。这是百夜米迦尔基于 COMP1511 26T1 官方公开页面、Lab Exam 信息页和 lecture slides 写的中文转述学习笔记，不复制题目正文、不托管 PDF/PPT、不替代官方说明。[S001][S002][S003]

今天只做：基础虚就按第 1-4 课顺序补，不开其他路线。下一步：主控台 · 第 1 课 · 练习菜单别乱跳：Exam 1 只保编译、循环、数组、debugging。

先把目标缩小

课程首页把内容按 week、lecture、tutorial、lab、revision 和 resources 组织；Lab Exam 信息页公开说明了示例考试的时间、题量、分值结构和保密要求，所以今晚的目标不是“把整门课完整补完”，而是按 Exam 1 最高收益主题补齐输入输出、条件、循环、函数、数组、字符串和 debugging。[S001][S003]

优先级	今晚主题	你要做到
1	1D / 2D array	能用下标循环、计数、找位置、返回结果
2	输入输出	能写 `printf` / `scanf`，并让格式完全匹配
3	条件和循环	能把题目条件翻译成 `if/else`、`while`、`for`
4	debugging / string	能定位编译错误、autotest 差异和字符串结束条件

官方来源告诉我们的复习顺序

Lecture 1/2 覆盖 C 程序、终端、变量和基础输入输出；Lecture 3/4 进入条件与循环；Lecture 5/6 开始强调函数、style 和数组；Lecture 7/8/9 继续展开字符串与二维数组。这个顺序很适合做“从第一节课开始，但只抓 Exam 1 相关动作”的急救路径。[S007][S008][S009][S010][S011][S012][S013][S014][S015]

Debugging Guide 把错误分成编译错误、autotest 错误、运行时错误和逻辑错误；这正好对应考前最后一轮检查：先让代码能编译，再看输出差异，最后处理边界和逻辑。[S004]

点开：如果只剩 90 分钟，怎么救？

COMP1511 第 2 课：变量、scanf 与 if/else

KurisuRakko — Mon, 18 May 2026 15:27:00 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-02-variables-input-branching

第 2 课：变量、scanf 与 if/else

非 UNSW 官方材料。本文按官方 Lecture 2/3/4 和 C reference sheet 转述变量、输入输出和条件控制；练习题为原创。[S008][S009][S010][S006]

今天只做：把 int、double、char 和 scanf 占位符配对。下一步：主控台 · 上一课 · 下一课：循环、函数与数组别乱跳：输入题先把格式读对，再写漂亮分支。

变量：先说类型，再放值

Lecture 2 明确把 variables、constants 和 C 里的 maths 放在早期主题；你现在要先能识别 int、double、char，再配对 printf / scanf 的格式占位符。[S008][S006]

int age = 18;
double mark = 72.5;
char grade = 'C';

类型	常见用途	输出占位符
`int`	整数	`%d`
`double`	小数	`%lf`
`char`	单个字符	`%c`

scanf：先练对普通变量

Lecture 3 回顾了 printf() / scanf()，Lecture 4 继续把 scanf 错误和控制流放在一起；考前先记住普通变量读入时要把地址传给 scanf。[S009][S010]

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

char ch;
scanf(" %c", &ch);

%c 前面的空格是为了跳过前面残留的空白字符；这条是考前很实用的经验解释，来源背景是官方 debugging 和 lecture 对输入错误的反复强调。[S004][S010]

点开：为什么 int 要写 &x？

COMP1511 第 3 课：循环、函数与数组

KurisuRakko — Mon, 18 May 2026 15:26:00 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-03-loops-functions-arrays

第 3 课：循环、函数与数组

非 UNSW 官方材料。本文基于官方 functions、style、1D array、2D array 和 strings 相关 lecture PDF 做中文转述；所有练习模板为原创。[S011][S012][S013][S014][S015]

今天只做：写一个 for 循环，能安全访问 array[i]。下一步：主控台 · 上一课 · 下一课：debugging、字符串与模拟考试别乱跳：数组题先找下标，不先背一整章。

循环：重复做同一件事

Lecture 3/4 把 loop 放进 control flow，Lecture 6 进入 arrays；数组题其实就是“用循环访问很多格子”，所以你先把 for 读顺。[S009][S010][S012]

for (int i = 0; i < size; i++) {
    printf("%d\n", i);
}

这段的读法是：i 从 0 开始；只要 i < size 就继续；每轮后 i++。这个解释是本站原创，但结构来自 C 的基础控制流和数组访问。[S006][S012]

函数题：先看题目让不让输出

Lecture 5 把 functions 和 style 放在同一课，Style Guide 也强调代码布局、函数和限制；Exam 练习里常见坑是题目要 return，你却写了 printf。[S011][S005]

题目说法	你该怎么做
should return	用 `return 值;`
should not print	不要写 `printf`
should not scan	不要写 `scanf`

1D array 模板：找位置，再处理附近

Lecture 6 开始看 arrays，并把函数和数组放在一起复习；下面的模板不是官方题目，是用于练“找目标下标”的原创模式。[S012]

int index_of_first(int values[], int size, int target) {
    for (int i = 0; i < size; i++) {
        if (values[i] == target) {
            return i;
        }
    }

    return -1;
}

点开：为什么找不到时返回 -1？

COMP1511 第 4 课：debugging、字符串与模拟考试

KurisuRakko — Mon, 18 May 2026 15:25:00 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/comp1511/comp1511-04-debugging-strings-exam-drill

第 4 课：debugging、字符串与模拟考试

非 UNSW 官方材料。本文基于 Debugging Guide、Lab Exam 信息页、strings/2D array lecture 和 C reference sheet 做中文转述；不复制官方 exam 题目或样例。[S004][S003][S014][S006]

今天只做：把错误分成 compile、autotest、runtime、logic 其中一类。下一步：主控台 · 上一课 · 下一课：strings、2D arrays 与 structs 别乱跳：先看第一条错误，不整题重写。

debugging：先分类，不要乱猜

Debugging Guide 把问题分成 compile error、autotest error、run time error 和 logic error；你明天考试时先判断是哪一类，再决定看报错、看输出差异、还是补边界测试。[S004]

症状	先查什么
编译后马上报错	看第一条错误、行号和 dcc 解释
autotest 不过	先挑一个失败测试，看你的输出和期望输出差异
运行中崩掉	检查数组下标、除以 0、输入是否读到
结果不对	检查条件边界、循环次数和初始化位置

字符串：先当 char array 看

Lecture 7/8 把 strings 和 arrays 放在一起讲，C reference sheet 也列出 string.h 中常见函数；Exam 1 急救时先掌握 char 数组和 '\0' 结束标记，再考虑库函数。[S013][S014][S006]

char word[51];
fgets(word, 51, stdin);

int i = 0;
while (word[i] != '\0') {
    i++;
}

如果题目要求逐字符处理，就用下标循环读 word[i]。下面是原创练习模板，用来训练“遇到某个字符就改掉”。[S014]

int i = 0;
while (word[i] != '\0') {
    if (word[i] == 'x') {
        word[i] = 'y';
    }
    i++;
}

点开：什么时候不用 scanf("%s", word)？

微积分定理秒杀关键词速记

KurisuRakko — Mon, 04 May 2026 23:00:00 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/mathematics/calculus-theorem-speedrun

这是最新文档

Intermediate Value Theorem (介值定理 - IVT)

秒杀关键词： continuous (连续), opposite signs (一正一负), root (根), exists c such that f(c) = 0 (存在c使得函数值等于某数)。

大白话：从A点走到B点，如果一个在水面上，一个在水面下，那你肯定得穿过水面。你刚才做对的那道平面题就是这个。

Mean Value Theorem (中值定理 - MVT)

秒杀关键词： derivative (导数), $f'(c)$, rate of change (变化率), tangent parallel to secant (切线平行于割线)。

大白话：你开车从悉尼去堪培拉，平均时速是 $100$。那路上肯定有那么一瞬间，你的仪表盘速度刚好指在 $100$ 上。只要题目扯到导数和平均变化的关系，闭眼选它。

Maximum-Minimum Theorem (极值定理 / 最值定理)

秒杀关键词： closed interval (闭区间 $[a,b]$), maximum / minimum (最大值/最小值), bounded (有界的)。

大白话：一段连绵不断的山脉，只要圈定一个明确的起点和终点，里面绝对能找出一个最高峰和一个最低谷。

Second Fundamental Theorem of Calculus (微积分基本定理第二部分)

秒杀关键词：题目里同时出现了积分号 $\int$ 和求导符号 $\frac{d}{dx}$。

大白话：积分的上限是个变量 $x$，然后让你对整个积分式子求导。这就是微积分的核心——求导和积分是逆运算。

Inverse Function Theorem (反函数定理)

秒杀关键词： $f^{-1}$, one-to-one (一一映射), inverse (反函数)。

大白话：专门用来算反函数的导数的。原函数某点的斜率如果是 $2$，反函数对应点的斜率就是 $\frac{1}{2}$。

Fundamental Theorem of Algebra (代数基本定理)

秒杀关键词： polynomial (多项式), complex roots (复数根)。

大白话： $n$ 次多项式必定有 $n$ 个复数根。这在你们这门微积分课里多半是个凑数的干扰项。

Split Function Theorem (分段函数定理)

秒杀关键词： piecewise function (分段函数)，检查连接点 (break point)。

大白话：就是左极限等于右极限，左导数等于右导数那套东西。

览毕，何不一言？

逻辑题真值表速通：Part a / Part b 一分钟搞定

KurisuRakko — Sat, 18 Apr 2026 14:01:00 GMT

此渲染由 Yohaku API 生成，或存排版之虞，最佳体验请往：https://rakko.cn/posts/productivity/truth-table-speedrun

第一步：死记四个符号的“作弊规则”

不要管它们叫什么“合取”、“析取”，你只需要记住它们像什么人：

∼ （波浪号）= 杠精。 专门唱反调。看到 T 就写 F，看到 F 就写 T。
∧ （尖尖朝上）= 挑剔狂。 必须左右两个都是 T，结果才是 T。只要看到哪怕一个 F，结果直接写 F。
∨ （圆圆朝下）= 老好人。 只要左右看到哪怕一个 T，结果就是 T。只有两个都是 F 时，他才勉强写 F。
→ （箭头）= 渣男背叛。 这是唯一需要注意顺序的！只有前面是 T，后面是 F （即 T→F）时，结果才是 F（承诺了却做不到，渣男）。其他所有情况（哪怕是 F→F），结果全写 T。

第二步：光速填表 (Part a)

用上面这四个规则，你可以直接无脑填表了。我拿图一给你举个例子，考场上你就按这个步骤在草稿纸上比划：

看第一列 ∼p∨q
- 先看 p，在心里把它“杠”一下（T, T, F, F 变成 F, F, T, T）。
- 然后把这串新结果和 q 放在一起，用“老好人” ∨ 规则。
- 第一行：F∨T=T
- 第二行：F∨F=F
- 第三行：T∨T=T
- 第四行：T∨F=T
- 填表答案就是：T, F, T, T
看第二列 p→∼q
- 把 q 在心里“杠”一下（变成 F, T, F, T）。
- 把 p 放在前面，新 q 放在后面，找“渣男”情况（前 T 后 F）。
- 第一行：T→F （抓到渣男了！） =F
- 第二行：T→T=T
- 第三行：F→F=T
- 第四行：F→T=T
- 填表答案就是：F, T, T, T

(图二和图三完全是一模一样的机械动作，按规则套就完事了。)

第三步：秒杀 Part b（终极作弊技巧）

这里有个天大的捷径，你发现了吗？Part b 下面的那串又长又恶心的公式，括号里的内容，其实就是你在 Part a 刚刚填完的那两列！

你根本不需要从头算，直接把你表里的答案代进去！

你要选的三个英文单词的意思：

Tautology (永真式)：最后算出来四个全是 T。
Contradiction (矛盾式)：最后算出来四个全是 F。
Contingency (偶然式)：有 T 有 F。

实战演示：

图一的 (b)： ∼(p→∼q)→∼(∼p∨q)

前半部分 (p→∼q) 就是你的第二列答案（F, T, T, T）。
后半部分 (∼p∨q) 就是你的第一列答案（T, F, T, T）。
公式翻译过来就是：∼(第二列)→∼(第一列)。
我们只测第一行：第二列是 F，第一列是 T。代进去：∼F→∼T，也就是 T→F。触发渣男规则，结果是 F。
我们再测第二行：第二列是 T，第一列是 F。代进去：∼T→∼F，也就是 F→T。不是渣男，结果是 T。
出结果了！ 有 F 有 T，不用再往下算了，直接选 Contingency。

图二的 (b)： ∼(∼p→q)∧(p∧∼q)

翻译：∼(第二列)∧(第一列)。
你自己算一下第一列的结果是：F, T, F, F。第二列的结果是：T, T, T, F。
用挑剔狂 ∧ 规则代入测试。你会发现每一行算出来都是 F。
四个全 F，直接选 Contradiction。

图三的 (b)： (∼p∨∼q)∨∼(p∧q)

翻译：(第二列)∨∼(第一列)。
第一列结果：T, F, F, F。第二列结果：F, T, T, T。
第一行代入：F∨∼T，即 F∨F=F。
第二行代入：T∨∼F，即 T∨T=T。
有 F 有 T，选 Contingency。

就这么简单。把那四个小符号的性格记住，拿笔在纸上标一下，这几道题一分钟就能填完。

览毕，何不一言？