📚 OpenKernel EDU3D3D

← 全部教师资源

打印学生学习单查看参考答案

教师参考答案

构建小程序

收集四类证据：相关状态的预测；多种案例（包括边界）的行为；依据轨迹和状态的解释；对一次不一致作出有理由的修正。使用纸面或学校现有批准流程，将各项记录为初步、需支持或独立完成。挑战通过证明的是机器行为，不证明作者身份或完全掌握。接受等效正确程序；公开答案是示范，并非唯一答案。

公开教学材料。答案是示例；等效的正确程序也可能通过实际检查。

28. 迷你目标游戏

用保存的状态与计分规则制作三轮游戏。

打开本课 →

1. 预测与跟踪

运行试做程序前，预测输出，并跟踪最先执行的三条指令。按需要记录相关寄存器、标志或内存，再逐步执行进行比较。

STORE 5 200
LOAD [200] R1
LOAD 0 R2
LOOP 3
INPUT
CMP R1
JUMP_IF_ZERO hit
JUMP next
hit: LOAD R2
ADD 1
COPY R0 R2
next: NOP
RETURN
LOAD R2
STORE 201
PRINT
HALT

加入输入队列: 5, 2, 5

初始化内存: 200: 5

试做预测答案

输出: 2

指令执行前 PC执行后 PC执行前 R0执行后 R0相关状态输出
STORE0100{"registers":[0,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[200]}无
LOAD1200{"registers":[0,5,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[200],"memoryWrites":[]}无
LOAD2300{"registers":[0,5,0,0,0,0,0,0],"flags":{"zero":true,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}无

2. 构建与检查

内存 200 包含目标字节。恰好读取三次猜测，计算匹配次数，保存到内存 201，并输出该分数一次。

必需的指令类型: INPUT, CMP, LOOP, STORE, JUMP_IF_ZERO

挑战示例答案

LOAD [200] R1
LOAD 0 R2
LOOP 3
INPUT
CMP R1
JUMP_IF_ZERO hit
JUMP next
hit: LOAD R2
ADD 1
COPY R0 R2
next: NOP
RETURN
LOAD R2
STORE 201
PRINT
HALT

实际检查器测试数据

案例 1
输入
5, 2, 5
初始内存
200: 5
预期输出
2
预期最终内存
200: 5, 201: 2
必需的内存读取
200
案例 2
输入
1, 2, 3
初始内存
200: 9
预期输出
0
预期最终内存
200: 9, 201: 0
必需的内存读取
200
案例 3
输入
0, 0, 0
初始内存
200: 0
预期输出
3
预期最终内存
200: 0, 201: 3
必需的内存读取
200
案例 4
输入
17, 1, 2
初始内存
200: 17
预期输出
1
预期最终内存
200: 17, 201: 1
必需的内存读取
200

3. 解释机器

猜对和猜错时，哪些状态改变？

推理与教学说明

仅相等时分数递增；目标仍为保存的输入或规则数据。三次猜测产生数字分数。

29. 用栈实现缓冲区工具

结合输入、循环、栈和索引存储。

打开本课 →

1. 预测与跟踪

运行试做程序前，预测输出，并跟踪最先执行的三条指令。按需要记录相关寄存器、标志或内存，再逐步执行进行比较。

LOAD 3 R3
LOAD 10
PUSH
LOAD 20
PUSH
LOAD 30
PUSH
LOAD 0 R1
LOOP R3
POP
STORE R1
PRINT
LOAD R1
ADD 1
COPY R0 R1
RETURN
HALT

加入输入队列: 无

初始化内存: 所有字节初始为零

试做预测答案

输出: 30, 20, 10

指令执行前 PC执行后 PC执行前 R0执行后 R0相关状态输出
LOAD0100{"registers":[0,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}无
LOAD12010{"registers":[10,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}无
PUSH231010{"registers":[10,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[10],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}无

2. 构建与检查

读取 N（0–5），再恰好读取 N 个字节值。使用数据栈倒序排列它们。输出倒序结果，并从内存地址 0 开始保存。

必需的指令类型: INPUT, LOOP, PUSH, POP, STORE

挑战示例答案

INPUT
COPY R0 R3
LOOP R3
INPUT
PUSH
RETURN
LOAD 0 R1
LOOP R3
POP
STORE R1
PRINT
LOAD R1
ADD 1
COPY R0 R1
RETURN
HALT

实际检查器测试数据

案例 1
输入
0
初始内存
所有字节初始为零
预期输出
无
预期最终内存
0: 0
案例 2
输入
1, 7
初始内存
所有字节初始为零
预期输出
7
预期最终内存
0: 7
案例 3
输入
4, 1, 2, 3, 4
初始内存
所有字节初始为零
预期输出
4, 3, 2, 1
预期最终内存
0: 4, 1: 3, 2: 2, 3: 1
案例 4
输入
3, 0, 255, 8
初始内存
所有字节初始为零
预期输出
8, 255, 0
预期最终内存
0: 8, 1: 255, 2: 0

3. 解释机器

为什么使用两个阶段？N=0 应怎样？

推理与教学说明

先收集和压栈，再倒序出栈、写入和输出；零次重复不产生输出或意外写入。

30. 你自己的迷你操作系统

将队列作业分派到可复用服务，并记录结果。

打开本课 →

1. 预测与跟踪

运行试做程序前，预测输出，并跟踪最先执行的三条指令。按需要记录相关寄存器、标志或内存，再逐步执行进行比较。

LOAD 4
CALL double
STORE 64
PRINT
LOAD 3
CALL square
STORE 65
PRINT
HALT
double: MUL 2
RETURN
square: MUL R0
RETURN

加入输入队列: 无

初始化内存: 所有字节初始为零

试做预测答案

输出: 8, 9

指令执行前 PC执行后 PC执行前 R0执行后 R0相关状态输出
LOAD0104{"registers":[4,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}无
CALL1944{"registers":[4,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[2],"loopStack":[],"memoryReads":[],"memoryWrites":[]}无
MUL91048{"registers":[8,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[2],"loopStack":[],"memoryReads":[],"memoryWrites":[]}无

2. 构建与检查

读取 N（0–3），再读取 N 对（操作、数值）。操作 0 加倍，1 求平方，2 加一。通过 CALL 子程序分派。输出每个完整结果，并按作业顺序把结果字节存入地址 64、65、……。

必需的指令类型: INPUT, LOOP, CALL, CMP, STORE, RETURN

挑战示例答案

INPUT
COPY R0 R3
LOAD 64 R2
LOOP R3
INPUT
COPY R0 R4
INPUT
COPY R0 R1
LOAD R4
CMP 0
JUMP_IF_ZERO doubleJob
CMP 1
JUMP_IF_ZERO squareJob
LOAD R1
CALL increment
JUMP finish
doubleJob: LOAD R1
CALL double
JUMP finish
squareJob: LOAD R1
CALL square
finish: STORE R2
PRINT
LOAD R2
ADD 1
COPY R0 R2
RETURN
HALT
double: MUL 2
RETURN
square: MUL R0
RETURN
increment: ADD 1
RETURN

实际检查器测试数据

案例 1
输入
3, 0, 4, 1, 3, 2, 9
初始内存
所有字节初始为零
预期输出
8, 9, 10
预期最终内存
64: 8, 65: 9, 66: 10
案例 2
输入
2, 1, -2, 0, 0
初始内存
所有字节初始为零
预期输出
4, 0
预期最终内存
64: 4, 65: 0
案例 3
输入
0
初始内存
所有字节初始为零
预期输出
无
预期最终内存
64: 0
案例 4
输入
3, 2, 255, 0, 130, 1, 16
初始内存
所有字节初始为零
预期输出
256, 260, 256
预期最终内存
64: 0, 65: 4, 66: 0

3. 解释机器

为什么输出 260 时，内存日志可以为 4？

推理与教学说明

R0 保留完整安全整数；STORE 保留低字节。服务 CALL 隐藏计算细节，不隐藏分派规则。