环境搭建

安装vmware虚拟机

安装ubuntu

在Ubuntu终端里编写C语言程序

打开终端：ctrl+alt+t

新建文件：vim hello.c

输入

1
2
3
4
5
6
7
8

#include <stdio.h>
#define DISPLAY "hello c!"
int main(void)
{
  printf("%s\n", DISPLAY);
  return 0;
}
ZZ（*说明：ZZ当前文件进行快速保存操作*）

退出编译模式：shift+：

输入：w保存q退出

预编译(Preprocessing)

对各种预处理指令（#include #define #ifdef 等#开始的代码行）进行处理，删除注释和多余的空白字符，生成一份新的代码

输入：gcc -E hello.c -o hello.i

1. 命令分解

• gcc ：GNU Compiler Collection（GCC）的编译器命令。
• -E ：选项表示 仅执行预处理阶段 ，不进行编译、汇编和链接。
• hello.c ：输入的C语言源文件。
• -o hello.i ：指定预处理后的输出文件名为 hello.i（.i 是预处理文件的默认后缀）。

2. 预处理阶段的作用

预处理是编译过程的第一个阶段，主要处理以下内容：

1. 头文件展开
   • 将 #include <stdio.h> 等指令替换为对应头文件的实际内容。
2. 宏展开
   • 替换 #define PI 3.14 等宏定义。
3. 条件编译
   • 处理 #ifdef, #ifndef, #endif 等条件编译指令。
4. 删除注释
   • 移除代码中的注释（// 或 /* */）。

编译(Compilation)

对代码进行语法、语义分析和错误判断，生成汇编代码文件

gcc -S hello.i -o hello.s

编译阶段的作用

在编译流程中，-S 选项对应 编译阶段 ，主要完成以下任务：

1. 语法分析 ：检查代码是否符合C语言语法规则。
2. 中间代码生成 ：将预处理后的代码转换为中间表示（如抽象语法树）。
3. 优化 ：根据优化选项（如 -O2）对代码进行优化。
4. 生成汇编代码 ：将优化后的中间代码转换为目标平台的汇编指令（如x86-64汇编）。

汇编(Assembly)

gcc -c hello.s -o hello.o

汇编阶段的作用

该命令执行 汇编阶段 ，将人类可读的汇编代码（如 mov, call 等指令）转换为 二进制机器码 ，生成目标文件（.o）。 目标文件包含：

• 机器指令（二进制代码）。
• 符号表（函数名、变量名等）。
• 未解析的引用（如外部函数 printf 的地址）。

链接(Linking/Build)

gcc hello.o -o hello

链接阶段的作用

链接器（ld）完成以下任务：

1. 合并代码和数据
   • 将 hello.o 中的机器码与标准库（如 stdio.h 中的 printf）的二进制代码合并。
2. 解析符号引用
   • 解决外部符号（如 printf）的地址，确保所有函数和全局变量正确关联。
3. 生成可执行文件格式
   • 创建符合操作系统要求的可执行文件（如Linux的ELF格式）。

程序运行

./hello

手动安装VMware tools

手动安装VMware Tools（提示VMware Tools 不再随旧版客户机操作系统的 VMware Workstation 一起提供的解决办法）_哔哩哔哩_bilibili

在线安装

如果方法一不行，可以试试方法二，我是通过方法二进行安装的。

首先更新系统已安装的软件源，以确保是最新的，在终端输入命令：

1

sudo apt update

然后再输入命令：

1

sudo apt install open-vm-tools-desktop

完成后运行upgrade命令，来升级系统中已安装的软件包(命令后面的 -y可以跳过确认询问)：

1

sudo apt upgrade -y

完成后进行重启，重启过后，点击菜单栏查看，变成重新安装就是成功了。

以下是针对表1和表2中所有函数的实现和验证分析，严格按照约束条件和操作符数量限制设计：

表1 位操作函数实现

1. lsbZero (将x的最低有效位清零)

1
2
3

int lsbZero(int x) {
    return x & (~1);  // 操作符: & ~ 1 (共3个)
}

验证：
x = 0x05 (0b101) → 0x04 (0b100)

2. byteNot (将x的第n个字节取反)

1
2
3
4

int byteNot(int x, int n) {
    int mask = 0xFF << (n << 3);  // 构造字节掩码
    return x ^ mask;               // 操作符: << << 3 << 8 (共6个)
}

验证：
x = 0x12345678, n=1 → 0x1234A978（第1字节 0x56 取反为 0xA9）

3. byteXor (比较x和y的第n个字节)

1
2
3
4
5
6

int byteXor(int x, int y, int n) {
    int shift = n << 3;
    int x_byte = (x >> shift) & 0xFF;
    int y_byte = (y >> shift) & 0xFF;
    return !!(x_byte ^ y_byte);  // 操作符: << >> & ^ !! (共20个)
}

验证：
x=0x12345678, y=0x12745678, n=2 → 1（第2字节 0x34 vs 0x74）

4. logicalAnd (模拟x && y)

1
2
3

int logicalAnd(int x, int y) {
    return (!!x) & (!!y);  // 操作符: !! & (共2个)
}

验证：
x=0, y=5 → 0；x=1, y=2 → 1

5. logicalOr (模拟x || y)

1
2
3

int logicalOr(int x, int y) {
    return (!!x) | (!!y);  // 操作符: !! | (共2个)
}

验证：
x=0, y=0 → 0；x=0, y=1 → 1

6. rotateLeft (循环左移n位)

1
2
3
4

int rotateLeft(int x, int n) {
    int mask = (0xFF << 24) >> (32 - n);  // 构造高位掩码
    return (x << n) | ((x >> (32 - n)) & mask);  // 操作符: << >> | & (共25个)
}

验证：
x=0x12345678, n=4 → 0x23456781（左移4位，高位循环到低位）

7. parityCheck (奇偶校验)

1
2
3
4
5
6
7
8

int parityCheck(int x) {
    x ^= x >> 16;
    x ^= x >> 8;
    x ^= x >> 4;
    x ^= x >> 2;
    x ^= x >> 1;
    return x & 1;  // 操作符: ^ >> & (共20个)
}

验证：
x=0b1010 → 0（2个1，偶数）；x=0b101 → 1（奇数）

表2 补码运算函数实现

**8. mul2OK (判断2*x是否溢出)**

1
2
3
4
5

int mul2OK(int x) {
    int sign = x >> 31;
    int result = x << 1;
    return !(((result >> 31) ^ sign) & (!!(x ^ (x << 1))));  // 操作符: >> << ^ & !! (共20个)
}

验证：
x=0x40000000 → 0（溢出）；x=0x3FFFFFFF → 1

**9. mult3div2 (计算(x*3)/2)**

1
2
3
4
5

int mult3div2(int x) {
    int temp = x + x + x;
    int sign = temp >> 31;
    return (temp + (temp >> 31 & 1)) >> 1;  // 操作符: + >> & (共12个)
}

验证：
x=-3 → (-9)/2 = -4（向零取整）

10. subOK (判断x - y是否溢出)

1
2
3
4
5
6
7

int subOK(int x, int y) {
    int sub = x + (~y + 1);
    int x_sign = x >> 31;
    int y_sign = (~y + 1) >> 31;
    int sub_sign = sub >> 31;
    return !((~(x_sign ^ y_sign)) & (x_sign ^ sub_sign));  // 操作符: ~ ^ + >> & (共20个)
}

验证：
x=0x80000000, y=1 → 0（溢出）

11. absVal (求绝对值)

1
2
3
4

int absVal(int x) {
    int mask = x >> 31;
    return (x + mask) ^ mask;  // 操作符: >> + ^ (共10个)
}

验证：
x=-5 → 5；x=3 → 3

验证方法

1. 编写测试代码：为每个函数设计边界值（如0、最大值、最小值）。
2. 反汇编分析：使用 objdump -d 检查生成的机器码是否符合操作符限制。
3. 覆盖率测试：确保所有分支条件被触发（如正负数、溢出情况）。

关键技巧

• 位掩码：使用 0xFF、0x80000000 等构造特定模式。
• 符号位操作：通过 x >> 31 提取符号位。
• 逻辑运算替代：用 !!x 将非零值转换为1，用 x ^ (x >> 31) 处理绝对值。

如果需要具体函数的详细推导或测试用例，可进一步说明！

实验1：变量输出与机器数分析

1.1 运行代码并分析输出

源代码：

1
2
3
4
5
6
7
8

#include <stdio.h>
int main() {
    int x = -1;
    unsigned u = 2147483648;
    printf("x = %u = %d.\n", x, x);
    printf("u = %u = %d.\n", u, u);
    return 0;
}

编译与运行：

1
2

gcc -o test1 test1.c
./test1

输出结果（假设32位系统）：

1
2

x = 4294967295 = -1.
u = 2147483648 = -2147483648.

结果分析： - x = %u：
x 是 int 类型的 -1，二进制补码为 0xFFFFFFFF。用 %u（无符号）解释时，0xFFFFFFFF 对应 4294967295。 - x = %d：
正常输出 -1。 - u = %u：
u 是 unsigned 类型的 2147483648（即 0x80000000），直接输出为 2147483648。 - u = %d：
用 %d（有符号）解释 0x80000000，最高位为1，表示负数，结果为 -2147483648。

1.2 反汇编分析机器数

步骤： 1. 生成目标文件：

1

gcc -c test1.c -o test1.o

1

objdump -d -M intel test1.o

关键汇编代码（简化）：

1
2

mov DWORD PTR [rbp-4], 0xffffffff   ; x = -1 (机器数 0xFFFFFFFF)
mov DWORD PTR [rbp-8], 0x80000000   ; u = 2147483648 (机器数 0x80000000)

变量机器数总结： | 变量 | 机器数（十六进制） | | —- | —————— | | x | 0xFFFFFFFF | | u | 0x80000000 |

实验2：表达式结果与反汇编分析

2.1 验证表达式结果

源代码：

1
2
3
4
5
6
7
8

#include <stdio.h>
int main() {
    printf("-1 < 0\t\t -> %d\n", (-1 < 0));
    printf("-1 < 0U\t -> %d\n", (-1 < 0U));
    printf("2147483647 > -2147483647 - 1\t -> %d\n", (2147483647 > -2147483647 - 1));
    printf("2147483647U > -2147483647 - 1\t -> %d\n", (2147483647U > -2147483647 - 1));
    return 0;
}

编译与运行：

1
2

gcc -o test2 test2.c
./test2

输出结果：

1
2
3
4

-1 < 0           -> 1
-1 < 0U          -> 0
2147483647 > -2147483647 - 1  -> 1
2147483647U > -2147483647 - 1 -> 0

结果分析： 1. -1 < 0：
有符号比较，-1 小于 0，结果为真（1）。 2. -1 < 0U：
0U 是无符号，-1 被转换为无符号数 0xFFFFFFFF（4294967295），远大于 0U，结果为假（0）。 3. 2147483647 > -2147483647 - 1：
右侧表达式 -2147483647 - 1 等于 -2147483648（INT_MIN），有符号比较，2147483647（INT_MAX）大于 INT_MIN，结果为真（1）。 4. 2147483647U > -2147483647 - 1：
左侧是无符号，右侧 INT_MIN 被转换为无符号数 0x80000000（2147483648），比较 2147483647 和 2147483648，结果为假（0）。

2.2 反汇编分析表达式

步骤： 1. 生成目标文件：

1

gcc -c test2.c -o test2.o

1

objdump -d -M intel test2.o

关键汇编代码（以 -1 < 0U 为例）：

1
2
3

mov DWORD PTR [rbp-4], 0xffffffff   ; -1 的机器数
cmp DWORD PTR [rbp-4], 0            ; 比较时，-1 被视为无符号数 4294967295
setb al                             ; 设置结果（0 表示假）

总结： - 类型转换规则决定了比较结果。 - 反汇编显示编译器如何处理有符号与无符号的隐式转换。

实验报告建议

1. 源代码与输出结果：附上代码及运行结果。
2. 反汇编截图：展示变量赋值和表达式比较的汇编代码。
3. 分析：
   • 解释类型转换对输出的影响。
   • 说明反汇编中机器数与表达式比较的底层实现。

如果需要更详细的反汇编代码或具体步骤解释，请随时告知！

广告点击率预测

广告点击率(CTR)预测是广告行业的典型应用，是评估广告效果的一个非常重要的指标。通过历史数据训练预测模型，对于每天的增量数据进行预测，找出广告的CTR符合标准的样本进行投放。 ## 数据集介绍 数据集来自于kaggle，数据包含了10天的Avazu的广告点击数据，训练集10000个，测试集1000个。每一条广告包含：广告id、时间、广告位置等属性。

任务1：导入库和数据集与数据预处理

• 读入训练数据和测试数据，划分data和label
• 将string类型的特征转化为int型：1）进行 one-hot 编码处理，会得到高维稀疏的特征，增大内存开销；2）使用python内置的hash函数将那些类型为object的特征变量映射为一定范围内的整数(原来的string被映射成了integer)，可以大大降低内存的消耗。

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

import gzip
import pandas as pd
import random
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import linear_model

types_train = {
    'id': np.dtype(int),
    'click': np.dtype(int),         #是否点击,1表示被点击,0表示没被点击
    'hour': np.dtype(int),          #广告被展现的日期+时间
    'C1': np.dtype(int),            #匿名分类变量
    'banner_pos': np.dtype(int),    #广告位置
    'site_id': np.dtype(str),       #站点Id
    'site_domain': np.dtype(str),   #站点域名
    'site_category': np.dtype(str), #站点分类
    'app_id': np.dtype(str),        # appId
    'app_domain': np.dtype(str),    # app域名
    'app_category': np.dtype(str),  # app分类
    'device_id': np.dtype(str),     #设备Id
    'device_ip': np.dtype(str),     #设备Ip
    'device_model': np.dtype(str),  #设备型号
    'device_type': np.dtype(int),   #设备型号
    'device_conn_type': np.dtype(int),
    'C14': np.dtype(int),   #匿名分类变量
    'C15': np.dtype(int),   #匿名分类变量
    'C16': np.dtype(int),   #匿名分类变量
    'C17': np.dtype(int),   #匿名分类变量
    'C18': np.dtype(int),   #匿名分类变量
    'C19': np.dtype(int),   #匿名分类变量
    'C20': np.dtype(int),   #匿名分类变量
    'C21':np.dtype(int)     #匿名分类变量
}

# 添加列名
header_row = ['id', 'click', 'hour', 'C1', 'banner_pos', 'site_id', 'site_domain', 'site_category', \
              'app_id', 'app_domain', 'app_category', 'device_id', 'device_ip', 'device_model',\
              'device_type', 'device_conn_type', 'C14', 'C15', 'C16', 'C17', 'C18', 'C19',\
              'C20', 'C21']

# 读入训练数据和测试数据
train = pd.read_csv('train_data.csv', names=header_row, dtype=types_train)
test = pd.read_csv('test_data.csv', names=header_row, dtype=types_train)
# 去除第0行（表示列的编号，不是样本）
train = train.drop(labels=train.index.values[0])
test = test.drop(labels=test.index.values[0])
print(test.shape)

# 划分data和label
train_data = train.drop('click', axis=1) #去除click 这一列
print(train_data.shape)
train_label = train['click'] #提取click 这一列

# 数据预处理
# 使用pd.get_dummies对非数值型特征进行 one-hot 编码处理，得到高维稀疏的特征
train_data1 = pd.get_dummies(train_data)
print(train_data1.shape)

# 编写convert_obj_to_int()函数将string类型的特征转换为int型
def convert_obj_to_int(self):
    object_list_columns = self.columns
    object_list_dtypes = self.dtypes
    new_col_suffix = '_int'
    for index in range(0, len(object_list_columns)):
        if object_list_dtypes[index] == object:
            # 使用hash和map将string特征变量映射为一定范围内的整数
            self[object_list_columns[index] + new_col_suffix] = self[object_list_columns[index]].map(lambda x: hash(x) % (1 << 32))
            self.drop([object_list_columns[index]], inplace=True, axis=1)
    return self

# 调用convert_obj_to_int()函数，将string类型转换为int型    
train_data = convert_obj_to_int(train_data)
print(train_data.shape)

(1000, 24)
(10000, 23)
(10000, 10531)
(10000, 23)


C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:

任务2：特征分析

以广告在网页中的位置(banner_pos)为例，查看banner_pos和最终类标(click)之间的关系。 - 查看banner_pos在数据集中的取值分布； - 查看不同banner_pos对点击率click的贡献。

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

# 查看banner_pos在数据集中的取值分布
print(train.banner_pos.value_counts()/len(train))

# 查看不同banner_pos对点击率click的贡献
banner_pos_val = train.banner_pos.unique()
banner_pos_val.sort()
ctr_avg_list = []
for i in banner_pos_val:
    selected_data = train.loc[train.banner_pos == i]
    ctr_avg = selected_data.click.mean()
    ctr_avg_list.append(ctr_avg)
    print(" banner 位置: {},  点击率: {}".format(i, ctr_avg))

banner_pos
0    0.8041
1    0.1951
2    0.0007
4    0.0001
Name: count, dtype: float64
 banner 位置: 0,  点击率: 0.16975500559631887
 banner 位置: 1,  点击率: 0.19067145053818554
 banner 位置: 2,  点击率: 0.14285714285714285
 banner 位置: 4,  点击率: 0.0

任务3：模型训练与评估

• 调用sklearn的逻辑回归函数LogisticRegression()，进行模型训练
• 对测试集test_data进行预测，计算预测结果的各项指标acc, pre, recall, auc
• 绘制ROC曲线（使用预测的概率值而不是预测的类标）
• 选做：自定义逻辑回归函数MyLogisticRegression()，进行模型训练与预测，与上述结果比较。

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

test_data = test.drop('click', axis=1)
test_data = convert_obj_to_int(test_data)
test_label = test['click']
# 调用sklearn的逻辑回归函数LogisticRegression()
clf = linear_model.LogisticRegression(max_iter=1000)  # 增加最大迭代次数防止不收敛

# 模型训练
clf.fit(train_data, train_label)  
print("Finish Training!")

# 模型预测
pred = clf.predict(test_data)
pred_proba = clf.predict_proba(test_data)[:, 1]

# 计算模型的acc, pre, recall, auc，并输出
# 请在下方作答
acc = accuracy_score(test_label, pred)
pre = precision_score(test_label, pred)
recall = recall_score(test_label, pred)
auc = roc_auc_score(test_label, pred_proba)
print(f"Accuracy: {acc:.4f}, Precision: {pre:.4f}, Recall: {recall:.4f}, AUC: {auc:.4f}")
# 绘制roc曲线
# 请在下方作答
fpr, tpr, _ = roc_curve(test_label, pred_proba)
plt.figure(figsize=(8,6))
plt.plot(fpr, tpr, label=f'AUC = {auc:.4f}')
plt.plot([0,1], [0,1], 'k--')
plt.title('ROC Curve (sklearn)')
plt.legend()
plt.show()
# 自定义实现逻辑回归函数MyLogisticRegression()
# 请在下方作答

Finish Training!
Accuracy: 0.8120, Precision: 0.0000, Recall: 0.0000, AUC: 0.4983


C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
C:\Users\29020\AppData\Local\Temp\ipykernel_71456\1472409378.py:66: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  if object_list_dtypes[index] == object:
f:\Anconda\Anconda\envs\general\Lib\site-packages\sklearn\metrics\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))

​
Custom Model - Accuracy: 0.8240, Precision: 0.6875, Recall: 0.1170, AUC: 0.6580

线性回归

任务1. 一元线性回归

任务介绍：

• 自定义一元回归函数MyLinearRegression()，输入参数为x和y的数组xArr和yArr，输出为参数w1和w0，利用最小二乘法求得参数;
• 使用美国医疗保险费数据insurance.csv中的输入特征age和目标特征charges，输入MyLinearRegression()函数，得到回归参数值w1和w0，并保留到小数点后两位;
• 调用sklearn的LinearRegression()函数，比较其运行结果与上述自定义函数MyLinearRegression()的输出结果是否一致。
• 利用age与charges绘制真实样本点，利用w1与w0计算预测值，再绘制age与预测值的点图，观察真实样本点与预测点之间的拟合程度。

补全代码

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

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

insurance = pd.read_csv('insurance.csv')
age = insurance['age'].values
charges = insurance['charges'].values

# 请在下方作答
# 定义一元线性回归函数
def MyLinearRegression(xArr, yArr):
    
    # x均值, y均值计算
    mean_x = xArr.mean()
    mean_y = yArr.mean()
    
    # w0, w1计算，公式
    numerator = np.sum((xArr - mean_x) * (yArr - mean_y))
    denominator = np.sum((xArr - mean_x)**2)
    w1 = numerator / denominator
    w0 = mean_y - w1 * mean_x
    
    return round(w0,2), round(w1,2)
    
print("模型训练，得到参数值")
w0, w1 = MyLinearRegression(age, charges)
print(w1,'\n', w0)

print("sklearn的训练结果")
lr = LinearRegression()
#线性回归模型训练
lr.fit(age.reshape(-1, 1), charges)
print(round(lr.coef_[0],2))
print(round(lr.intercept_,2))

# 观察真实样本点与预测点之间的拟合程度
plt.scatter(age, charges, marker='.')  # 画样本点，随机散点
# 利用w1与w0计算预测值，绘制预测点
plt.scatter(age, w1 * age + w0, marker='+')  # 画预测点，形成直线
plt.show()

# 请直接运行处结果，然后提交作业，该运行结果会自动一同提交上去

模型训练，得到参数值
257.72 
 3165.89
sklearn的训练结果
257.72
3165.89

最小二乘法求解公式

目标：最小化预测值与真实值的平方误差之和： $$ \min_{w_0, w_1} \sum_{i=1}^n (y_i - \hat{y}_i)^2 $$

闭式解（Normal Equation）：
1. 斜率 ( w_1 )：
$$ w_1 = \frac{\sum_{i=1}^n (x_i - \bar{x})(y_i - \bar{y})}{\sum_{i=1}^n (x_i - \bar{x})^2} $$
其中 ({x}) 和 ({y}) 分别是 (x) 和 (y) 的均值。

2. 截距 ( w_0 )：
   w₀ = ȳ − w₁x̄

round(w0, 2) 和 round(w1, 2) 的作用是对线性回归模型的参数进行四舍五入处理，保留两位小数。

这段代码使用 scikit-learn 的 LinearRegression 类实现线性回归，并输出模型参数。以下是逐行解释： ### 1. 创建线性回归模型实例

1

lr = LinearRegression()

1

lr.fit(age.reshape(-1, 1), charges)

1
2

print(round(lr.coef_[0], 2))
print(round(lr.intercept_, 2))

任务2. 多元线性回归

任务介绍：

• 自定义多元线性回归函数MyLinearRegression2()，输入参数为X和y的数组xArr和yArr，输出为参数ws，利用最小二乘法求得参数;
• 使用美国医疗保险费数据insurance.csv中的输入特征age、bmi和children，目标特征charges，根据MyLinearRegression2()函数，得到回归参数值ws；注意判断（X^T X）^{-1}是否为满秩，如果满秩，则引入正则项，参数为alpha，目标函数变为岭回归问题。
• 为了得到模型的截距，需要在矩阵X最后增加一列，并且该列所有行的值均为1。
• 调用sklearn的LinearRegression()函数，比较其运行结果与上述自定义函数MyLinearRegression2()的输出结果是否一致。

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

from sklearn.linear_model import LinearRegression
import numpy as np
from numpy import linalg, column_stack, ones, array
import pandas as pd
insurance = pd.read_csv('insurance.csv')

# 请在下方作答 #
# 定义多元线性回归函数
def MyLinearRegression2(xArr, yArr):
    
    # 调用mat将Array转换为矩阵
    xMat = np.asmatrix(xArr)
    yMat = np.asmatrix(yArr).T  # 转换为列向量
    xTx = xMat.T*xMat
    # 通过调用linalg计算行列式来判定协方差矩阵是否可逆
    if linalg.det(xTx) < 1e-8:
        print( "singular matrix, can't do inverse")
        # 引入正则项，即 岭回归
        alpha = 0.1
        # 添加岭回归正则项（单位矩阵大小为特征数+1）
        xTx  += alpha * np.eye(xMat.shape[1])

    # 计算参数向量
    # 计算参数并转为一维数组
    ws = xTx.I * (xMat.T * yMat)
    
    return ws

# 模型训练，得到参数值
X = insurance[['age', 'bmi', 'children']].values
# 调用column_stack函数在矩阵X后增加一列，并且该列所有行的值均为1
# 添加截距列（全1）
X = column_stack((X, ones(X.shape[0])))
y = insurance['charges']
ws = MyLinearRegression2(X, y)
print("自定义的训练结果")
print(ws)
# sklearn的训练结果
lr = LinearRegression(fit_intercept=False)  # 关键：禁用自动截距
#线性回归模型训练
lr.fit(X, y)
print("sklearn的训练结果")
print(lr.coef_)
print(lr.intercept_)

# 请直接运行处结果，然后提交作业，该运行结果会自动一同提交上去

自定义的训练结果
[[  239.99447429]
 [  332.0833645 ]
 [  542.86465225]
 [-6916.24334779]]
sklearn的训练结果
[  239.99447429   332.0833645    542.86465225 -6916.24334779]
0.0

任务3. 线性回归应用：预测医疗费用

任务介绍

• 对insurance.csv中的名义型特征进行One-Hot编码，得到了数据变量insurance
• 请使用自定义的多元回归函数MyLinearRegression2()得到回归模型参数ws和预测值y_pred，并计算R2分数
• 比较使用sklearn进行模型训练和模型评价R2分数的结果

复用上一节实验中实现的代码，可以复制粘贴代替下面的代码

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

import pandas as pd
import numpy as np
from sklearn import linear_model, metrics
from numpy import array, mean, ones
import matplotlib.pyplot as plt

# 调用get_dummies函数对非数值型特征进行 one-hot 编码处理，以便于运算
insurance = pd.read_csv('insurance.csv')
insurance = pd.get_dummies(insurance, drop_first=True)  # One-Hot编码
print(insurance.shape)

# 从insurance中获取X与y
X = insurance.drop(['charges'], axis=1).values.astype(np.float64)
y = insurance['charges'].values.astype(np.float64)

# 对每个特征与y的关系进行可视化，观察与y的相关性
plt.figure(figsize=(20,10))
for i in range(X.shape[1]):
    plt.subplot(2,6,i+1)
    plt.scatter(array(X)[:,i],y,s=20)
plt.show()

def MyLinearRegression2(xArr, yArr):
    
    # 调用mat将Array转换为矩阵
    xMat = np.asmatrix(xArr)
    yMat = np.asmatrix(yArr).T  # 转换为列向量
    xTx = xMat.T*xMat
    # 通过调用linalg计算行列式来判定协方差矩阵是否可逆
    if np.linalg.det(xTx) < 1e-8:
        print( "singular matrix, can't do inverse")
        # 引入正则项，即 岭回归
        alpha = 0.1
        # 添加岭回归正则项（单位矩阵大小为特征数+1）
        xTx  += alpha * np.eye(xMat.shape[1])

    # 计算参数向量
    # 计算参数并转为一维数组
    ws = xTx.I * (xMat.T * yMat)
    
    return ws

# 根据X、y和自定义函数MyLinearRegression2()训练模型参数ws，并计算X的预测值y_pred
ws = MyLinearRegression2(X, y)
y_pred = X.dot(ws)
y_pred = array(y_pred).reshape(y_pred.shape[0],) # 将矩阵转换为一行多列的array格式

# 调用metrics中的r2_score函数根据y和y_pred计算决定系数score
score = metrics.r2_score(y, y_pred)

# sklearn模型训练与预测
lr = linear_model.LinearRegression(fit_intercept=False)
# 模型训练
lr.fit(X, y)
# 计算X的预测值y_pred_sk与R2分数score_sk
y_pred_sk = lr.predict(X)              # 使用训练好的sklearn模型进行预测
score_sk = metrics.r2_score(y, y_pred_sk)  # 计算决定系数R²
print(score_sk)

# 请直接运行处结果，然后提交作业，该运行结果会自动一同提交上去

(1338, 9)

0.7235368166092777

1

正文

作业

什么是信息增益？根据下图分别计算按照属性A和B划分时的信息增益。ID3决策树学习算法将会选择哪个属性？

什么是交叉验证法？有什么用途？

什么是过拟合（overfitting）？什么情况下可能发生过拟合？采取什么措施有助于消除过拟合？

正文

极大似然估计

作业

1、何为正则化？其功能是什么？如何理解L1和L2正则化？

2、什么是偏差与方差？简要说明偏差、方差与过拟合、欠拟合的关系。

3、公式推导：最小二乘法、多元线性回归与岭回归、逻辑回归（极大似然法）

参考文献

“L1和L2正则化”直观理解(之一)，从拉格朗日乘数法角度进行理解_哔哩哔哩_bilibili

超级棒的公式证明，对我帮助很大

https://www.bilibili.com/video/BV1Mh411e7VU?vd_source=bacf29bd4bb51f2ecf08a1ac7c7d8f11&p=3&spm_id_from=333.788.videopod.episodes

前言

好久不编算法了，为了不让300r打水漂，废话不多说，决战蓝桥杯！！！

我是算法彩笔，而且python也不是很会用，所有刷题刷的很慢，后续会把文件整理上传GitHub

思考了一下，因为时间紧迫，没有时间复盘每一道题了，这一篇文章简单记录一下进度

进度记录

3.13

贪心：1.力扣406. 根据身高重建队列2.P10387 [蓝桥杯 2024 省 A] 训练士兵3.蓝桥杯真题 谈判

3.14

贪心：1.蓝桥杯真题 翻硬币

bfs：1.蓝桥杯真题 扫雷2.蓝桥杯真题 长草3.力扣695.岛屿的最大面积

3.16

哈希：1.力扣 两数之和

前缀和：1.洛谷 求区间和

二分问题：1.洛谷 查找

dfs：1.蓝桥杯真题 小朋友崇拜圈2.蓝桥杯真题 最大数字

3.17

二分问题：1.力扣 统计公平数对的数目2.力扣 2226.每个小孩最多能分到多少糖果

3.18

二分答案：1.蓝桥杯真题 冶炼金属

并查集：1.洛谷P1551 亲戚2.洛谷P1536 村村通

3.19

哈希：1.力扣 3080.执行操作标记数组中的元素

堆：1.力扣 2530.执行k次操作后的最大分数

动态规划：1.力扣 70.爬楼梯2.力扣 198.打家劫舍3.P1048 [NOIP 2005 普及组] 采药4.力扣 494. 目标和5.力扣 322.零钱兑换

3.21

动态规划：1.力扣 2915.和为目标值的最长子序列的长度2.蓝桥杯真题 蓝桥课程抢购3.力扣518. 零钱兑换 II

图论：1.力扣1971.寻找图中是否存在路径

3.25

图论：1.力扣743.网络延迟时间

数论：1.蓝桥杯真题 数字诗意

3.26

贪心：1.蓝桥杯真题 回文数组

图论：1.力扣 1584.连接所有点的最小费用2.蓝桥杯真题 城市规划大师

3.27

动态规划：1.力扣1143.最长公共子序列2.蓝桥杯真题 查找最长公共子序列3.力扣583.两个字符串的删除操作

3.28

动态规划：1.蓝桥杯真题 砍柴

3.30

贪心：1.蓝桥杯真题 三国游戏2.蓝桥杯真题 平均

暴力：1.蓝桥杯真题 翻转

单调队列，单调栈：1.力扣239.滑动窗口最大值2.力扣739.每日温度3.力扣42.接雨水

双指针：1.力扣209.长度最小的子数组2.力扣3.无重复字符的最长字串3.力扣713.乘积小于k的子数组

3.31

二维单调队列：1.蓝桥杯真题 子矩阵（拼劲全力无法战胜，放弃）

4.1

数论：1.蓝桥杯真题 阶乘的和2.蓝桥杯真题 质因数个数

树：1.蓝桥杯真题 子树的大小

4.4

模拟：1.蓝桥杯真题 消除游戏

4.5

差分：1.蓝桥杯真题 重新排序2.力扣1094.拼车

动态规划：1.蓝桥杯真题 全排列的价值2.力扣300.最长递增子序列

贪心：1.蓝桥杯真题 优清零方案

4.9-11

刷填空题

4.12后记：也是考完蓝桥杯了，后面应该很长时间不碰算法了嘿嘿

正文

算法基础

快读模板

1
2
3
4
5
6

# 导入系统模块
import sys
# 重定义input函数，用于快速读取输入
# sys.stdin.readline() 比 python 自带的 input() 快
# strip() 用于去除行末的换行符
input = lambda:sys.stdin.readline().strip()

输入

列表推导器

参考文献

竟然在b站刷到学长做的视频，太惊喜了，真是雪中送炭

【蓝桥杯】Python速成 刷题指南_哔哩哔哩_bilibili

代码模板 (Python) - Open Wiki Community

TsingPig/LanQiao_Python: 视频合集 https://space.bilibili.com/398421867/lists?sid=4898042&spm_id_from=333.788.0.0

讲的很好的视频

分享｜如何科学刷题？- 讨论 - 力扣（LeetCode）

目录

说明

说明

版本信息

书名：《计算机系统基础（第二版）》 袁春风

整理日期：2019-10-27

整理人：李加其（幽弥狂）

内容：课后习题参考答案

联系方式：13812991101

邮箱：1768478912@qq.com

QQ:1768478912

版本：v1.0

声明

1、如果有侵权或者其他问题欢迎联系我。

2、参考书目为https://github.com/JackeyLea/NJUCS中README.md文件中列出的参考书目。

3、红色字体为重要内容，比如曾作为课后习题、考试考过等等。

4、括号里的P**表示在书本的第几页。

第一部分 系统概述和可执行目标文件的生成

第一章计算机系统概述

1、见《计算机系统基础习题解答与教学指导》

2、简单回答下列问题。

（1）冯·诺依曼计算机由哪几部分组成？各部分的功能是什么？

控制器：用于控制主动执行指令；

运算器：用于执行指令；

存储器：存放数据和指令；

输入输出设备：通过输入输出设备使用计算机；

（2）什么是“存储程序”工作方式？

必须将事先编好的程序和原始数据送人主存后才开能执行程序，一旦程序被启动执行，计算机能在必须操作人员干预的情况下自动完成逐条指令取出和执行任务。（P3）

（3）一条指令的执行过程包含哪几个阶段？

程序的执行就是指令的执行过程。

阶段：
取指令、取数、传数、ALU运算阶段。（P6）

（4）计算机系统的层次结构如何划分？

电路设计、数字设计、ISA、汇编程序、编译程序、应用程序、操作系统（P18 图1.11）

（5）计算机系统的用户可分哪几类？每类用户工作在哪个层次？

用户有四种：

最终用户：应用程序级

系统管理员：操作系统

应用程序员：编译程序

系统程序员：汇编程序和ISA之间

（6）程序的 CPI 与哪些因素有关？

总时钟周期数、指令条数（P20）

（7）为什么说性能指标 MIPS 不能很好地反映计算机的性能？

MIPS反映了机器执行定点指令的速度。首先，不同机器的指令集是不同的，而且指令的功能也是不同的，也许在机器1上一条指令完成的功能机器2需要多条指令。其次，不同机器的CPI和时钟周期也是不同的，因此同一条指令在不同的机器上所用的时间也不同。（P20 最后一段）

3、略

4、略

5、题目略

仿照图1.3

仿照图1.5

6、若有两个基准测试程序P1和P2在机器M1和M2上运行，假定M1和M2的价格分别是5000元和8000元，下表给出了P1和P2在M1和M2上所花的时间和指令条数。

请回答下列问题：

（1）对于P1，哪台机器的速度快？快多少？对于P2呢？

对于P1，M2比M1快一倍；对于P2，M1比M2快一倍。

（2）在M1上执行P1和P2的速度分别是多少MIPS？在M2上的执行速度又各是多少？从执行速度来看，对于P2，哪台机器的速度快？快多少？

对于M1，P1的速度为：200M/10=20MIPS；P2为300k/0.003=100MIPS。

对于M2，P1的速度为：150M/5=30MIPS；P2为420k/0.006=70MIPS。

从执行速度来看，对于P2，因为100/70=1.43倍，所以M1比M2快0.43倍。

（3）假定M1和M2的时钟频率各是800MHz和1.2GHz，则在M1和M2上执行P1时的平均时钟周期数CPI各是多少？

在M1上执行P1时的平均时钟周期数CPI为：10×800M/(200×106)=40。

在M2上执行P1时的平均时钟周期数CPI为：5×1.2G/(150×106)=40。

（4）如果某个用户需要大量使用程序P1，并且该用户主要关心系统的响应时间而不是吞吐率，那么，该用户需要大批购进机器时，应该选择M1还是M2？为什么？（提示：从性价比上考虑）

考虑运行P1时M1和M2的性价比，因为该用户主要关心系统的响应时间，所以性价比中的性能应考虑执行时间，其性能为执行时间的倒数。故性价比R为：

R=1/(执行时间×价格)

R越大说明性价比越高，也即，“执行时间×价格”的值越小，则性价比越高。

因为10×5000 > 5×8000，所以，M2的性价比高。应选择M2。

（5）如果另一个用户也需要购进大批机器，但该用户使用P1和P2一样多，主要关心的也是响应时间，那么，应该选择M1还是M2？为什么？

P1和P2需要同等考虑，性能有多种方式：执行时间总和、算术平均、几何平均。

若用算术平均方式，则：因为 (10+0.003)/2×5000 > (5+0.006)/2×8000，所以M2的性价比高，应选择M2。

若用几何平均方式，则：因为sqrt(10×0.003) ×5000 < sqrt(5×0.006) ×8000，所以M1的性价比高，应选择M1。

7．若机器M1和M2具有相同的指令集，其时钟频率分别为1GHz和1.5GHz。在指令集中有五种不同类型的指令A~E。下表给出了在M1和M2上每类指令的平均时钟周期数CPI。

请回答下列问题： （1）M1和M2的峰值MIPS各是多少？

M1上可以选择一段都是A类指令组成的程序，其峰值MIPS为1000MIPS。
M2上可以选择一段A和B类指令组成的程序，其峰值MIPS为1500/2=750MIPS。

（2）假定某程序P的指令序列中，五类指令具有完全相同的指令条数，则程序P在M1和M2上运行时，哪台机器更快？快多少？在M1和M2上执行程序P时的平均时钟周期数CPI各是多少？

5类指令具有完全相同的指令条数，所以各占20%。
在M1和M2上执行程序P时的平均时钟周期数CPI分别为：
    M1：20%×(1+2+2+3+4)= 0.2×12 = 2.4
    M2：20%×(2+2+4+5+6)= 0.2×19 = 3.8
假设程序P的指令条数为N，则在M1和M2上的执行时间分别为：
    M1：2.4× N×1/1G = 2.4N (ns)
    M2：3.8×N×1/1.5G = 2.53 N (ns)
M1执行P的速度更快，每条指令平均快0.13ns，也即M1比M2快0.13/2.53×100%≈5%。

8．假设同一套指令集用不同的方法设计了两种机器M1和M2。机器M1的时钟周期为0.8ns，机器M2的时钟周期为1.2ns。某个程序P在机器M1上运行时的CPI为4，在M2上的CPI为2。对于程序P来说，哪台机器的执行速度更快？快多少？

假设程序P的指令条数为N，则在M1和M2上的执行时间分别为：
    M1：4 N×0.8 = 3.2N (ns)
    M2：2 N×1.2 = 2.4 N (ns)  
所以，M2执行P的速度更快，每条指令平均快0.8ns，比M1快0.8/3.2×100%=25%。

9．假设某机器M的时钟频率为4GHz，用户程序P在M上的指令条数为8×109，其CPI为1.25，则P在M上的执行时间是多少？若在机器M上从程序P开始启动到执行结束所需的时间是4秒，则P占用的CPU时间的百分比是多少？

程序P在M上的执行时间为：1.25×8××1/4G = 2.5 s，
从启动P执行开始到执行结束的总时间为4秒，
其中2.5秒是P在CPU上真正的执行时间，
其他时间可能执行操作系统程序或其他用户程序。
程序P占用的CPU时间的百分比为：2.5/4 = 62.5%。

10．假定某编译器对某段高级语言程序编译生成两种不同的指令序列S1和S2，在时钟频率为500MHz的机器M上运行，目标指令序列中用到的指令类型有A、B、C和D四类。四类指令在M上的CPI和两个指令序列所用的各类指令条数如下表所示。 | | A | B | C | D | |–| —|—|—|—| 各指令的CPI 1 2 3 4 S1的指令条数 5 2 2 1 S2的指令条数 1 1 1 5

请问：S1和S2各有多少条指令？CPI各为多少？所含的时钟周期数各为多少？执行时间各为多少？

S1有10条指令，CPI为 (5×1+2×2+2×3+1×4)/10=1.9, 所含的时钟周期数为10×1.9=19，执行时间为19/500M = 38ns。
S2有8条指令，CPI为 (1×1+1×2+1×3+5×4)/8 =3.25, 所含的时钟周期数为8×3.25=26，执行时间为26/500M = 52ns。 

10．假定机器M的时钟频率为1.2GHz，某程序P在机器M上的执行时间为12秒钟。对P优化时，将其所有的乘4指令都换成了一条左移2位的指令，得到优化后的程序P’。已知在M上乘法指令的CPI为5，左移指令的CPI为2，P的执行时间是P’执行时间的1.2倍，则P中有多少条乘法指令被替换成了左移指令被执行？ 参考答案： 显然，P’的执行时间为10秒，因此，P比P’多花了2秒钟，因此，执行时被换成左移指令的乘法指令的条数为1.2G×2/(5–2) = 800M。

第二章计算机系统基本功能和基本组成

1、见习题解答。

2、简单回答下列问题。

（1）为什么计算机内部采用二进制表示信息？既然计算机内部所有信息都用二进制表示，为什么还要用到十六进制或八进制数？

制造两个稳定状态的元器件比多个稳定状态的元器件要容易，两个稳定状态对应高低电平，正好可以用0/1表示；二进制编码规则简单，可用开关电路实现；方便通过逻辑电路实现算术运算。 二进制硬件容易理解，但是不方便书写和阅读。

（2）常用的定点数编码方式有哪几种？ 通常它们各自用来表示什么？

原码：用定点原码表示浮点数的尾数部分；

补码：带符号整数；

反码：

移码：

（3）为什么计算机中大多用补码表示带符号整数？

（4）在浮点数的基和位数一定的情况下，浮点数的表数范围和表数精度分别由什么决定？两者如何相互制约？

（5）为什么要对浮点数进行规格化？有哪两种规格化操作？

（6）为什么有些计算机中除了用二进制外还用 BCD 码来表示数值数据？

（7）为什么计算机处理汉字时会涉及到不同的编码（如，输入码、内码、字模码）？说明这些编码中哪些是用二进制编码，哪些不是用二进制编码，为什么？

3．实现下列各数的转换。 （1）(25.8125)10= (?)2= (?) 8= (?) 16

（2）(101101.011)2 = (?)10= (?) 8= (?) 16= (?) 8421

（3）(0101 1001 0110.0011)8421 = (?)10= (?) 2= (?) 16

（4）(4E.C)16 = (?)10= (?) 2

参考答案：

（1） (25.8125)10 = (1 1001.1101)2 = (31.64) 8 = (19.D) 16

（2）(101101.011)2 = (45.375)10 = (55.3) 8 = (2D.6) 16 = (0100 0101.0011 0111 0101) 8421

（3）(0101 1001 0110.0011)8421 = (596.3)10 = (1001010100.01001100110011…) 2 = (254.4CCC…) 16

（4）(4E.C)16 = (78.75)10 = (0100 1110.11) 2

4． 假定机器数为8位（1位符号，7位数值），写出下列各二进制数的原码和补码表示。 +0.1001，–0.1001，+1.0，–1.0，+0.010100，–0.010100，+0，–0

参考答案： | 原码 | 补码 | |—– |—–| |+0.1001： 0.1001000 0.1001000 –0.1001： 1.1001000 1.0111000 +1.0： 溢出 溢出 –1.0： 溢出 1.0000000 +0.010100： 0.0101000 0.0101000 –0.010100： 1.0101000 1.1011000 +0： 0.0000000 0.0000000 –0： 1.0000000 0.0000000

5． 假定机器数为8位（1位符号，7位数值），写出下列各二进制数的补码和移码表示。 +1001，–1001，+1，–1，+10100，–10100，+0，–0 参考答案：
移码 补码 +1001： 10001001 00001001 –1001： 01110111 11110111 +1： 10000001 00000001 –1： 011111111 11111111 +10100： 10010100 00010100 –10100： 01101100 11101100 +0： 10000000 00000000 –0： 10000000 00000000

6． 已知 [x]补，求x （1）[x]补=1.1100111 （2）[x]补=10000000 （3）[x]补=0.1010010 （4）[x]补=11010011 参考答案： （1）[x]补=1.1100111 x = –0.0011001B （2）[x]补=10000000 x = –10000000B = –128 （3）[x]补=0.1010010 x = +0.101001B （4）[x]补=11010011 x = – 101101B = – 45

7．假定一台32位字长的机器中带符号整数用补码表示，浮点数用IEEE 754标准表示，寄存器R1和R2的内容分别为R1：0000108BH，R2：8080108BH。不同指令对寄存器进行不同的操作，因而，不同指令执行时寄存器内容对应的真值不同。假定执行下列运算指令时，操作数为寄存器R1和R2的内容，则R1和R2中操作数的真值分别为多少？ （1）无符号数加法指令 （2）带符号整数乘法指令 （3）单精度浮点数减法指令 参考答案： R1 = 0000108BH = 0000 0000 0000 0000 0001 0000 1000 1011b R2 = 8080108BH = 1000 0000 1000 0000 0001 0000 1000 1011b （1）对于无符号数加法指令，R1和R2中是操作数的无符号数表示，因此，其真值分别为R1：108BH, R2：8080108BH。 （2）对于带符号整数乘法指令，R1和R2中是操作数的带符号整数补码表示，由最高位可知， R1为正数， R2为负数。R1的真值为+108BH, R2的真值为–(0111 1111 0111 1111 1110 1111 0111 0100b + 1b) = –7F7FEF75H。 （3）对于单精度浮点数减法指令，R1和R2中是操作数的IEEE754单精度浮点数表示。在IEEE 754 标准中，单精度浮点数的位数为32位，其中包含1位符号位，8位阶码，23位尾数。 由R1中的内容可知，其符号位为0，表示其为正数，阶码为0000 0000，尾数部分为000 0000 0001 0000 1000 1011，故其为非规格化浮点数，指数为–126，尾数中没有隐藏的1，用十六进制表示尾数为+0.002116H，故R1表示的真值为+0.002116H × 10-126。 由R2中的内容可知，其符号位为1，表示其为负数，阶码为0000 0001， 尾数部分为000 0000 0001 0000 1000 1011，故其为规格化浮点数，指数为1–127 = –126，尾数中有隐藏的1，用十六进制表示尾数为–1.002116H，故R2表示的真值为–1.002116H × 10-126

8．假定机器M的字长为32位，用补码表示带符号整数。下表第一列给出了在机器M上执行的C语言程序中的关系表达式，请参照已有的表栏内容完成表中后三栏内容的填写。 关系表达式 运算类型 结果 说明 0 == 0U –1 < 0 –1 < 0U 2147483647 > –2147483647 – 1 2147483647U > –2147483647 – 1 2147483647 > (int) 2147483648U –1 > –2 (unsigned) –1 > –2 无符号整数 有符号整数 无符号整数 有符号整数 无符号整数 有符号整数 有符号整数 无符号整数 1 1 0 1 0 1 1 1 00…0B = 00…0B 11…1B (–1) < 00…0B (0) 11…1B (232–1) > 00…0B(0) 011…1B (231–1) > 100…0B (–231) 011…1B (231–1) < 100…0B(231) 011…1B (231–1) > 100…0B (–231) 11…1B (–1) > 11…10B (–2) 11…1B (232–1) > 11…10B (232–2)

9．以下是一个C语言程序，用来计算一个数组a中每个元素的和。当参数len为0时，返回值应该是0，但是在机器上执行时，却发生了存储器访问异常。请问这是什么原因造成的，并说明程序应该如何修改。 1 float sum_elements(float a[], unsigned len) 2 { 3 int i; 4 float result = 0; 5 6 for (i = 0; i <= len–1; i++) 7 result += a[i]; 8 return result; 9 }

参考答案： 参数len的类型是unsigned，所以，当len=0时，执行len-1的结果为11…1，是最大可表示的无符号数，因而，任何无符号数都比它小，使得循环体被不断执行，引起数组元素的访问越界，发生存储器访问异常。 只要将len声明为int型，或循环的测试条件改为i<len。

1. 设某浮点数格式为：

其中，移码的偏置常数为16，补码采用一位符号位，基数为4。 （1）用这种格式表示下列十进制数：+1.7，–0.12，+19，–1/8。 （2）写出该格式浮点数的表示范围，并与12位定点补码整数表示范围比较。 参考答案：（假定采用0舍1入法进行舍入） （1） +1.7 = +1.1011001B = 0.011011B× 41, 故阶码为1 +16 = 17 = 10001B, 尾数为+0.011011的补码， 即0.011011，所以+1.7表示为0 10001 011011。

–0.12 = – 0.000111101B = – 0.011111B × 4–1, 故阶码为 –1 + 16 =15 = 01111B, 尾数为– 0.011111的补码，即1.100001, 所以–0.12表示为1 01111 100001。

+19 = +10011B = 0.010011B× 43，故阶码为3 + 16 = 19 = 10011B, 尾数为0.010011，所以+19表示为0 10011 010011。

–1/8 = – 0.125 = – 0.001B = – 0.100000 × 4–1，阶码为 –1 + 16 = 15 = 01111B，尾数为– 0.100000的补码，即1.100000，所以–1/8表示为1 01111 100000。

（2）该格式浮点数表示的范围如下。 正数最大值：0.111111B × 411111，即：0.333× 415 （≈230 ≈109） 正数最小值：0.000001B × 400000，即：0.001× 4–16 （≈2–34≈10–10） 负数最大值：–0.000001B × 400000，即：–0.001× 4–16 负数最小值：–1.000000B × 411111，即：–1.000× 415 因此，该格式浮点数的数量级在10–10～109之间。 12位定点补码整数的表示范围为：–211～+(211–1)，即：–2048～2047 由此可见，定点数和浮点数的表示范围相差非常大。

11. 下列几种情况所能表示的数的范围是什么？ （1）16位无符号整数 （2）16位原码定点小数 （3）16位补码定点小数 （4）16位补码定点整数 （5）下述格式的浮点数（基数为2，移码的偏置常数为128）

    参考答案： （1）无符号整数：0～216–1。 （2）原码定点小数：–(1–2–15) ～ + (1–2–15)。 （3）补码定点小数：–1 ～ + (1–2–15)。 （4）补码定点整数：–32768 ～ +32767。 （5）浮点数：负数：– (1–2–7)×2+127 ～ –2–7×2–128。 正数：+2–135 ～ (1–2–7) ×2+127。

12. 以IEEE 754单精度浮点数格式表示下列十进制数。 +1.75，+19，–1/8，258 参考答案： +1.75 = +1.11B = 1.11B × 20, 故阶码为0+127=01111111B, 数符为0，尾数为1.110…0，小数点前为隐藏位，所以+1.7表示为0 01111111 110 0000 0000 0000 0000 0000，用十六进制表示为3FE00000H。

    +19 = +10011B = +1.0011B × 24，故阶码为4+127 = 10000011B, 数符为0，尾数为1.00110…0，所以+19表示为0 10000011 001 1000 0000 0000 0000 0000，用十六进制表示为41980000H。

    –1/8 = – 0.125 = – 0.001B = – 1.0 × 2–3，阶码为–3+127 = 01111100B，数符为1，尾数为1.0…0，所以–1/8表示为1 01111100 000 0000 0000 0000 0000 0000，用十六进制表示为BE000000H。

258=100000010B=1.0000001B × 28, 故阶码为8+127=10000111B, 数符为0，尾数为1.0000001，所以258表示为0 10000111 000 0001 0000 0000 0000 0000，用十六进制表示为43810000H。

13．设一个变量的值为4098，要求分别用32位补码整数和IEEE 754单精度浮点格式表示该变量（结果用十六进制表示），并说明哪段二进制序列在两种表示中完全相同，为什么会相同？ 参考答案： 4098 = +1 0000 0000 0010B = +1. 0000 0000 001 × 212 32位2-补码形式为：0000 0000 0000 0000 0001 0000 0000 0010 （00001002H） IEEE754单精度格式为：0 10001011 0000 0000 0010 0000 0000 000 （45801000H） 粗体部分为除隐藏位外的有效数字，因此，在两种表示中是相同的序列。

14．设一个变量的值为–2147483647，要求分别用32位补码整数和IEEE754单精度浮点格式表示该变量（结果用十六进制表示），并说明哪种表示其值完全精确，哪种表示的是近似值。 参考答案： –2147483647 = –111 1111 1111 1111 1111 1111 1111 1111B = –1.11 1111 1111 1111 1111 1111 1111 1111 × 230 32位2-补码形式为：1000 0000 0000 0000 0000 0000 0000 0001 （80000001H） IEEE 754单精度格式为：1 10011101 1111 1111 1111 1111 1111 111 （CEFFFFFFH） 32位2-补码形式能表示精确的值，而浮点数表示的是近似值，低位被截断

15．下表给出了有关IEEE 754浮点格式表示中一些重要数据的取值，表中已经有最大规格化数的相应内容，要求填入其他浮点数的相应内容。（注：表中a代表一个在1到10之间的正纯小数） 项目 阶码 尾数 单精度 双精度 以2的幂次表示的值 以10的幂次表示的值 以2的幂次表示的值 以10的幂次表示的值 0 1 最大规格化数 最小规格化数 最大非规格化数 最小非规格化数 +∞ NaN 00000000 01111111 11111110 00000001 00000000 00000000 11111111 11111111 0….00 0….00 1…11 0….00 1…11 0…01 0….00 非全0 0 1 (2–2–23)×2127 1.0×2–126 (1–2–23)×2–126 2–23×2–126=2–149 – – 0 1 a×1038 a×10–38 a×10–38 a×10–44 – – 0 1 (2–2–52)×21023 1.0×2–1022 (1–2–52)×2–1022 2–52×2–1022 – – 0 1 a×10308 a×10–308 a×10–308 a×10–? – –

16．已知下列字符编码：A=100 0001，a=110 0001，0=011 0000，求E、e、f、7、G、Z、5的7位ACSII码和第一位前加入奇校验位后的8位编码。 参考答案： E的ASCII码为 ‘A’ + (‘E’ – ‘A’) = 100 0001 + 100 = 100 0101, 奇校验位P = 0，第一位前加入奇校验位后的8位编码是0 100 0101。 e的ASCII码为‘a’+ (‘e’ – ‘a’) = 110 0001 + 100 = 110 0101， 奇校验位P = 1, 第一位前加入奇校验位后的8位编码是1 110 0101。 f的ASCII码为‘a’+ (‘f’ – ‘a’) = 110 0001 + 101 = 110 0110, 奇校验位P = 1, 第一位前 加入奇校验位后的8位编码是 1 110 0110。 7的ASCII码为‘0’+ (7 - 0) = 011 0000 + 111 = 011 0111,奇校验位P = 0, 第一位前加入奇校验位后的8位编码是0 011 0111。 G的ASCII码为‘A’+ (‘G’ – ‘A’) = 100 0001 + 0110 = 100 0111, 奇校验位P = 1, 第一位前加入奇校验位后的8位编码是1 100 0111。 Z的ASCII码为‘A’+(‘Z’ – ‘A’) = 100 0001 + 11001 = 101 1010, 奇校验位P = 1, 第一位前加入奇校验位后的8位编码是 1 101 1010。 5的ASCII码为‘0’+(5 – 0) = 011 0000 + 101 = 011 0101， 奇校验位P = 1, 第一位前加入奇校验位后的8位编码是 1 011 0101。

17．假定在一个程序中定义了变量x、y和i，其中，x和y是float型变量（用IEEE754单精度浮点数表示），i是16位short型变量（用补码表示）。程序执行到某一时刻，x = –0.125、y=7.5、i=100，它们都被写到了主存（按字节编址），其地址分别是100，108和112。请分别画出在大端机器和小端机器上变量x、y和i在内存的存放位置。 参考答案： –0.125 = –0.001B = –1.0 × 2-3 x在机器内部的机器数为：1 01111100 00…0 (BE00 0000H) 7.5= +111.1B= +1.111 × 22 y在机器内部的机器数为：0 10000001 11100…0 (40F0 0000H) 100=64+32+4=1100100B i在机器内部表示的机器数为：0000 0000 0110 0100（0064H） 大端机 小端机 地址 内容 内容
100 BEH 00H 101 00H 00H 102 00H 00H 103 00H BEH 108 40H 00H 109 F0H 00H 110 00H F0H 111 00H 40H 112 00H 64H 113 64H 00H

18．假定某计算机的总线采用奇校验，每8位数据有一位校验位，若在32位数据线上传输的信息是8F 3C AB 96H，则对应的4个校验位应为什么？若接受方收到的数据信息和校验位分别为87 3C AB 96H和0101B，则说明发生了什么情况，并给出验证过程。 参考答案： 传输信息8F 3C AB 96H展开为1000 1111 0011 1100 1010 1011 1001 0110，每8位有一个奇校验位，因此，总线上发送方送出的4个校验位应该分别为0、1、0、1。 接受方的数据信息为87 3C AB 96H，展开后为1000 0111 0011 1100 1010 1011 1001 0110；接收到的校验位分别为0、1、0、1。在接受方进行校验判断如下： 根据接收到的数据信息计算出4个奇校验位分别为1、1、0、1，将该4位校验位分别和接收到的4位校验位进行异或，得到1、0、0、0，说明数据信息的第一个字节发生传输错误。对照传输前、后的数据信息，第一字节8FH变成了87H，说明确实发生了传输错误，验证正确。

19．写出16位数据的SEC码。假定数据为0101 0001 0100 0110，说明SEC码如何正确检测数据位5的错误。 参考答案： 对于16位数据， 可以如下插入校验位： M16 M15 M14 M13 M12 P5 M11 M10 M9 M8 M7 M6 M5 P4 M4 M3 M2 P3 M1 P2 P1 其中Mi是原信息数据， Pi是加入的校验位， 对于各个校验位的值可以如下计算 P1 = M1⊕M2⊕M3⊕M4⊕M5⊕M7⊕M9⊕M11⊕M12⊕M14⊕M16 = 1 P2 = M1⊕M3⊕M4⊕M6⊕M7⊕M10⊕M11⊕M13⊕M14 = 1 P3 = M2⊕M3⊕M4⊕M8⊕M9⊕M10⊕M11⊕M15⊕M16 = 0 P4 = M5⊕M6⊕M7⊕M8⊕M9⊕M10⊕M11 = 0 P5 = M12⊕M13⊕M14⊕M15⊕M16 = 0 所以此时P5 P4 P3 P2 P1 = 00011，第五位数据出错时，数据字变为：0101 0001 0101 0110，P5’P4’P3’P2’P1’= 01010，故障字 = 00011⊕01010 = 01001，说明码字第9位出错，即M5出错。

20．假设要传送的数据信息为：100011，若约定的生成多项式为：G(x)= x3+1，则校验码为多少？假定在接收端接收到的数据信息为100010，说明如何正确检测其错误，写出检测过程。

参考答案： 原数据信息为100011，对应的报文多项式为M(x) = x5 + x + 1, 生成多项式的位数为4位， 所以在原数据信息后面添加3个0，变为M’(x) = x3M(x) = x8 + x4 + x3, 用M(x)去模2除G(x)，得到的余数为111， 所以得到CRC码为100011 111。

检测时， 用接收到的CRC码去模2除生成多项式1001，若得到的余数为0，则表明正确，否则说明传输时发生了错误。此题中接收到的CRC码为100010 111（即数据100010加检验位111），显然，用100010 111 模2除 1001，得到余数为001，不为0，说明传输时发生错误。

安装git

Git是目前世界上最先进的分布式版本控制系统，没有之一！说到Git,另一个需要知道的便是GitHub，GitHub是目前使用最多的社交代码托管平台。

输入git –version 查看Git版本信息

配置本地信息 为了在后面上传项目到github时方便知道是谁上传的，需要给本机git配置用户名和邮箱：

git config –global user.name “zxj” git config –global user.email “zxj2902065320@163.com” 查看配置命令：git config –list

配置SSH

ssh key生成命令ssh-keygen -t rsa -C “注册邮箱”

获取ssh key公钥内容（id_rsa.pub）cd ~/.ssh cat id_rsa.pub

Github账号上添加公钥

验证是否配置成功 ssh -T git@github.com

问题

在检验ssh配置时，始终报错，问ai说是配置的原因，尝试删除后，报错Could not resolve hostname github.com: Name or service not known，琢磨无法解决，拼尽全力无法战胜，于是保留下来交给未来的自己

git常用指令

克隆仓库git clone https://github.com/logan-zou/Chat_with_Datawhale_langchain.git

1
2
3
4
5
6
7
8
9
10
11

git init：初始化一个git仓库
git clone：clone一个git仓库
git add 命令可将文件添加到缓存
git status 命令来查看相关文件的状态
git commit 将缓存区内容添加到仓库中，可以在后面加-m选项，以在命令行中提供提交注释

git remote add：添加远程仓库
git remote：查看当前的远程仓库
git fetch、git pull：提取远程仓仓库
git push：推送到远程仓库
git remote rm：删除远程仓库

先做记录，我没用过，我目前选择vscode+GitHub的可视化界面

vscode+GitHub

输入仓库名称 点击commit提交

每次更改代码都可以命名后再次提交

代理配置

1
2

git config --global http.proxy "http://127.0.0.1:8080" 
git config --global https.proxy "http://127.0.0.1:8080"

分别代码本地和远程仓库的位置

天呐这图形化太方便了

参考文献

git安装配置教程(小白保姆教程2024最新版)_git安装及配置教程-CSDN博客

给傻子的Git教程_哔哩哔哩_bilibili

Git教程 Git Bash详细教程-CSDN博客

GIT Proxy 一键设置代理 让你的 git clone Github 再也不像百度云一样内行-CSDN博客

简介 - Git教程 - 廖雪峰的官方网站