从零开始的汇编语言笔记（2）

这里应该是一些主要的代码模板记录。

一. 基础读写#

1. 单个非负整数输入#

控制台输入一个十进制整数字符串，转成数存储。

1
dataseg segment
2

3
    input_buffer        db 20
4
    input_buffer_len    db ?
5
    input_buffer_data   db 20 dup(?)
6

7
    input_num           dw ?
8

9
dataseg ends
10

11
codeseg segment
12
    assume cs:codeseg, ds:dataseg
13
main proc far
14
    push ds
15
    xor ax, ax
16
    push ax
17
    mov ax, dataseg
18
    mov ds, ax
19

20
    call read_num
21
    mov ax, input_num
22

23
    pop ax
24
    pop ds
25
    mov ax, 4C00h
26
    int 21h
27

28
main endp
29

30
; 输入一个整数，存入input_num
31
read_num proc near
32
    push ax
33
    push bx
34
    push cx
35
    push dx
36
    push si
37

38
    mov ah, 0Ah
39
    lea dx, input_buffer
40
    int 21h
41

42
    call newline
43

44
    xor ch, ch
45
    mov cl, input_buffer_len
46
    mov ax, 0
47
    lea si, input_buffer_data
48
    mov bx, 10
49
    xor dx, dx
50

51
    read_loop:
52
        mul bx
53
        mov dl, [si]
54
        and dl, 0Fh
55
        add ax, dx
56
        inc si
57
        loop read_loop
58

59
    mov input_num, ax
60

61
    pop si
62
    pop dx
63
    pop cx
64
    pop bx
65
    pop ax
66
    ret
67
read_num endp
68

69
; 换行
70
newline proc near
71
    push ax
72
    push dx
73
    mov ah, 02h
74

75
    mov dl, 0Dh
76
    int 21h
77
    mov dl, 0Ah
78
    int 21h
79

80
    pop dx
81
    pop ax
82
    ret
83
newline endp
84

85
codeseg ends
86

87
end main

2. 单个非负整数输出#

1
; 输出一个整数，存在output_num
2
write_num proc near
3
    push ax
4
    push bx
5
    push cx
6
    push dx
7
    push si
8

9
    lea si, output_buffer
10
    mov ax, output_num
11

12
    xor dx, dx
13
    mov cx, 10
14
    write_loop:
15
        div cx              ; AX = AX / 10, 商在 AX, 余数在 DX
16
        mov bx, dx          ; BL = 余数
17
        or bl, 030h         ; 转换为 ASCII 字符
18
        mov [si], bl        ; 存储字符
19
        inc si              ; 指向下一个位置
20
        xor dx, dx
21

22
        cmp ax, 0
23
        jne write_loop
24

25
    mov byte ptr [si], '$'
26

27
    lea di, output_buffer
28
    mov cx, si
29
    sub cx, di
30
    dec si
31
    shr cx, 1
32
    jz write_num_print
33

34
    reverse_loop:
35
        mov al, [si]
36
        xchg al, [di]
37
        xchg al, [si]
38
        inc di
39
        dec si
40
        loop reverse_loop
41

42
    write_num_print:
43
        mov ah, 09h
44
        lea dx, output_buffer
45
        int 21h
46

47
        call newline
48

49
    pop si
50
    pop dx
51
    pop cx
52
    pop bx
53
    pop ax
54
    ret
55
write_num endp

合并后的输入输出：

1
dataseg segment
2

3
    input_buffer        db 20
4
    input_buffer_len    db ?
5
    input_buffer_data   db 20 dup(?)
6

7
    input_num           dw ?
8

9
    output_num      dw  ?
10
    output_buffer   db  10 dup (?)
11

12
dataseg ends
13

14
codeseg segment
15
    assume cs:codeseg, ds:dataseg, es:dataseg
16
main proc far
17
    push ds
18
    xor ax, ax
19
    push ax
20
    mov ax, dataseg
21
    mov ds, ax
22
    mov es, ax
23

24
    call read_num
25
    mov ax, input_num
26

27
    mov output_num, ax
28
    call write_num
29

30
    pop ax
31
    pop ds
32
    mov ax, 4C00h
33
    int 21h
34

35
main endp
36

37
; 输入一个整数，存入input_num
38
read_num proc near
39
    push ax
40
    push bx
41
    push cx
42
    push dx
43
    push si
44

45
    mov ah, 0Ah
46
    lea dx, input_buffer
47
    int 21h
48

49
    call newline
50

51
    xor ch, ch
52
    mov cl, input_buffer_len
53
    mov ax, 0
54
    lea si, input_buffer_data
55
    mov bx, 10
56
    xor dx, dx
57

58
    read_loop:
59
        mul bx
60
        mov dl, [si]
61
        and dl, 0Fh
62
        add ax, dx
63
        inc si
64
        loop read_loop
65

66
    mov input_num, ax
67

68
    pop si
69
    pop dx
70
    pop cx
71
    pop bx
72
    pop ax
73
    ret
74
read_num endp
75

76
; 输出一个整数，存在output_num
77
write_num proc near
78
    push ax
79
    push bx
80
    push cx
81
    push dx
82
    push si
83

84
    lea si, output_buffer
85
    mov ax, output_num
86

87
    xor dx, dx
88
    mov cx, 10
89
    write_loop:
90
        div cx              ; AX = AX / 10, 商在 AX, 余数在 DX
91
        mov bx, dx          ; BL = 余数
92
        or bl, 030h         ; 转换为 ASCII 字符
93
        mov [si], bl        ; 存储字符
94
        inc si              ; 指向下一个位置
95
        xor dx, dx
96

97
        cmp ax, 0
98
        jne write_loop
99

100
    mov byte ptr [si], '$'
101

102
    lea di, output_buffer
103
    mov cx, si
104
    sub cx, di
105
    dec si
106
    shr cx, 1
107
    jz write_num_print
108

109
    reverse_loop:
110
        mov al, [si]
111
        xchg al, [di]
112
        xchg al, [si]
113
        inc di
114
        dec si
115
        loop reverse_loop
116

117
    write_num_print:
118
        mov ah, 09h
119
        lea dx, output_buffer
120
        int 21h
121

122
        call newline
123

124
    pop si
125
    pop dx
126
    pop cx
127
    pop bx
128
    pop ax
129
    ret
130
write_num endp
131

132
; 换行
133
newline proc near
134
    push ax
135
    push dx
136
    mov ah, 02h
137

138
    mov dl, 0Dh
139
    int 21h
140
    mov dl, 0Ah
141
    int 21h
142

143
    pop dx
144
    pop ax
145
    ret
146
newline endp
147

148
codeseg ends
149

150
end main

3. 多个非负数输入输出#

（1）每行一个#

每行输入1个数。

输入结束后输出。

1
dataseg segment
2
    input_buffer        db 20
3
    input_buffer_len    db ?
4
    input_buffer_data   db 20 dup(?)
5
    input_num           dw ?
6

7
    output_num      dw  ?
8
    output_buffer   db  10 dup (?)
9

10
    nums_len    dw  3
11
    nums        dw  3 dup (?)
12

13
dataseg ends
14

15
codeseg segment
16
    assume cs:codeseg, ds:dataseg, es:dataseg
17
main proc near
18
    push ds
19
    xor ax, ax
20
    push ax
21
    mov ax, dataseg
22
    mov ds, ax
23
    mov es, ax
24

25
    mov cx, [nums_len]
26
    lea si, nums
27
    get_nums_loop:
28
        call read_num
29
        mov ax, [input_num]
30
        mov word ptr [si], ax
31
        add si, 2
32
        loop get_nums_loop
33

34
;    call sort_num
35

36
    mov cx, [nums_len]
37
    lea si, nums
38
    put_nums_loop:
39
        mov ax, [si]
40
        mov [output_num], ax
41
        call write_num
42
        add si, 2
43
        loop put_nums_loop
44

45
    pop ax
46
    pop ds
47
    mov ax, 4C00h
48
    int 21h
49
main endp
50

51

52
; 输入一个整数，存入input_num
53
read_num proc near
54
    push ax
55
    push bx
56
    push cx
57
    push dx
58
    push si
59

60
    mov ah, 0Ah
61
    lea dx, input_buffer
62
    int 21h
63

64
    call newline
65

66
    xor ch, ch
67
    mov cl, [input_buffer_len]
68
    mov ax, 0
69
    lea si, input_buffer_data
70
    mov bx, 10
71
    xor dx, dx
72

73
    read_loop:
74
        mul bx
75
        mov dl, [si]
76
        and dl, 0Fh
77
        add ax, dx
78
        inc si
79
        loop read_loop
80

81
    mov [input_num], ax
82

83
    pop si
84
    pop dx
85
    pop cx
86
    pop bx
87
    pop ax
88
    ret
89
read_num endp
90

91
; 输出一个整数，存在output_num
92
write_num proc near
93
    push ax
94
    push bx
95
    push cx
96
    push dx
97
    push si
98
    push di
99

100
    lea si, output_buffer
101
    mov ax, [output_num]
102

103
    xor cx, cx              ; 位数计数器
104
    mov bx, 10
105
    write_loop:
106
        xor dx, dx
107
        div bx              ; AX = AX / 10, 商在 AX, 余数在 DX
108
        or dl, 030h         ; 转换为ASCII码
109
        mov [si], dl        ; 存储字符
110
        inc si              ; 指向下一个位置
111
        inc cx
112

113
        cmp ax, 0
114
        jne write_loop
115

116
    mov byte ptr [si], '$'
117
    dec si                  ; 指向最后一个
118
    lea di, output_buffer   ; 指向第一个
119
    shr cx, 1
120
    jz write_num_print      ; （防止cx=0时的循环）
121

122
    reverse_loop:
123
        mov al, [si]
124
        xchg al, [di]
125
        xchg al, [si]
126
        inc di
127
        dec si
128
        loop reverse_loop
129

130
    write_num_print:
131
        mov ah, 09h
132
        lea dx, output_buffer
133
        int 21h
134

135
        call newline
136

137
    pop di
138
    pop si
139
    pop dx
140
    pop cx
141
    pop bx
142
    pop ax
143
    ret
144
write_num endp
145

146
; 换行
147
newline proc near
148
    push ax
149
    push dx
150
    mov ah, 02h
151

152
    mov dl, 0Dh
153
    int 21h
154
    mov dl, 0Ah
155
    int 21h
156

157
    pop dx
158
    pop ax
159
    ret
160
newline endp
161

162
codeseg ends
163

164
end main

（2）每行多个#

读入一行数，存入input_nums中，并且数的个数存入input_cnt中。

1
dataseg segment
2
    input_nums          dw 20 dup(?)
3
    input_cnt           dw ?
4

5
    input_invalid       db 0
6

7
    input_buffer        db 100
8
    input_buffer_len    db ?
9
    input_buffer_data   db 100 dup(?)
10

11

12
    output_num      dw  ?
13
    output_buffer   db  10 dup (?)
14

15
    nums_len    dw  ?
16
    nums        dw  20 dup (?)
17

18
dataseg ends
19

20
stackseg segment
21
    db 100 dup (?)
22
stackseg ends
23

24
codeseg segment
25
    assume cs:codeseg, ds:dataseg, es:dataseg, ss:stackseg
26
main proc near
27
    push ds
28
    xor ax, ax
29
    push ax
30
    mov ax, dataseg
31
    mov ds, ax
32
    mov es, ax
33
    mov ax, stackseg
34
    mov ss, ax
35

36
    call readline_num
37

38
    call writeline_num
39

40
    pop ax
41
    pop ds
42
    mov ax, 4C00h
43
    int 21h
44
main endp
45

46
; 输入一行多个整数，存入
47
readline_num proc near
48
    push ax
49
    push bx
50
    push cx
51
    push dx
52
    push si
53
    push di
54

55
    mov ah, 0Ah
56
    lea dx, input_buffer
57
    int 21h
58

59
    call newline
60

61
    xor ch, ch
62
    mov cl, input_buffer_len
63
    lea si, input_buffer_data   ; 扫描到的原始字符串位置
64

65
    mov ax, 0                   ; 存储当前结果
66
    lea di, input_nums          ; 当前正在写入的位置
67
    mov dl, 0                   ; 标志位，最低位表示是否有数尚未存入结果
68
                                ;        第二位表示是否有负数标志
69

70
    xor bh, bh
71

72
    readline_loop:
73
        mov bl, byte ptr [si]
74

75
        cmp bl, ' '
76
        je readline_isspace     ; 是空格
77
        cmp bl, 0Dh             ; 回车
78
        je readline_isspace
79
        cmp bl, 0Ah             ; 换行
80
        je readline_isspace
81
        cmp bl, '-'
82
        je readline_isneg
83

84
        cmp bl, '0'             ; 检查是否是数字
85
        jb readline_invalid
86
        cmp bl, '9'
87
        ja readline_invalid
88
        jmp readline_isnumber
89

90
        readline_isneg:
91
            test dl, 02h            ; 多个符号
92
            jnz readline_invalid
93
            xor dl, 02h             ; 标志位
94
            jmp readline_charover
95

96
        readline_isspace:
97
            test dl, 03h            ; 完全没开始
98
            jz readline_charover
99
            and dl, 03h
100
            cmp dl, 02h             ; 检查禁止的情况，仅有一个符号
101
            je readline_invalid
102
            test dl, 02h            ; 是负数
103
            jz readline_storenum
104
            neg ax
105

106
            readline_storenum:
107
            mov word ptr [di], ax   ; 存储
108
            xor ax, ax              ; 清空
109
            add di, 2               ; 进位
110

111
            mov dl, 0               ; 标志位清空
112
            jmp readline_charover
113

114
        readline_isnumber:
115
            or dl, 1                ; 标志位
116
            and bl, 0Fh             ; ASCII转成数
117
            push dx
118
            mov dx, 10
119
            mul dx                  ; *10
120
            pop dx
121
            add ax, bx              ; 加当前位
122

123
        readline_charover:
124
            inc si
125
        loop readline_loop
126

127
    ; 检查是否有数没有存储
128
    test dl, 01h
129
    jz readline_ok
130

131
    ; 处理末尾
132
    mov word ptr [di], ax
133
    add di, 2
134

135
    jmp readline_ok
136

137
    readline_invalid:   ; 非法输入
138
        mov input_invalid, 1
139

140
    readline_ok:
141

142
    lea si, input_nums
143
    sub di, si
144
    sar di, 1
145

146
    mov input_cnt, di   ; 写入个数
147

148
    pop di
149
    pop si
150
    pop dx
151
    pop cx
152
    pop bx
153
    pop ax
154
    ret
155
readline_num endp
156

157
; 输出一行多个整数
158
writeline_num proc near
159
    push ax
160
    push bx
161
    push cx
162
    push dx
163
    push si
164
    push di
165

166
    lea si, input_nums   ; 位置
167
    mov cx, input_cnt   ; 长度
168

169
    writeline_loop:
170
        mov ax, word ptr [si]
171
        mov output_num, ax
172

173
        call write_num
174

175
        mov ah, 02h
176
        mov dl, ' '
177
        int 21h
178

179
        add si, 2
180
        loop writeline_loop
181

182
    pop di
183
    pop si
184
    pop dx
185
    pop cx
186
    pop bx
187
    pop ax
188
    ret
189
writeline_num endp
190

191
; 输出一个整数，存在output_num
192
write_num proc near
193
    push ax
194
    push bx
195
    push cx
196
    push dx
197
    push si
198
    push di
199

200
    lea si, output_buffer
201
    mov ax, output_num
202

203
    ; 负数处理
204
    cmp ax, 0
205
    jge direct_write_num
206
    push ax
207
    mov ah, 02h
208
    mov dl, '-'
209
    int 21h
210
    pop ax
211
    neg ax
212
    direct_write_num:
213

214
    xor dx, dx
215
    mov cx, 10
216
    write_loop:
217
        div cx              ; AX = AX / 10, 商在 AX, 余数在 DX
218
        mov bx, dx          ; BL = 余数
219
        or bl, 030h         ; 转换为 ASCII 字符
220
        mov [si], bl        ; 存储字符
221
        inc si              ; 指向下一个位置
222
        xor dx, dx
223

224
        cmp ax, 0
225
        jne write_loop
226

227
    mov byte ptr [si], '$'
228

229
    lea di, output_buffer
230
    mov cx, si
231
    sub cx, di
232
    dec si
233
    shr cx, 1
234
    jz write_num_print
235

236
    reverse_loop:
237
        mov al, [si]
238
        xchg al, [di]
239
        xchg al, [si]
240
        inc di
241
        dec si
242
        loop reverse_loop
243

244
    write_num_print:
245
        mov ah, 09h
246
        lea dx, output_buffer
247
        int 21h
248

249
    ;    call newline   取决于要不要换行
250

251
    pop di
252
    pop si
253
    pop dx
254
    pop cx
255
    pop bx
256
    pop ax
257
    ret
258
write_num endp
259

260
; 换行
261
newline proc near
262
    push ax
263
    push dx
264
    mov ah, 02h
265

266
    mov dl, 0Dh
267
    int 21h
268
    mov dl, 0Ah
269
    int 21h
270

271
    pop dx
272
    pop ax
273
    ret
274
newline endp
275

276
codeseg ends
277

278
end main

二. 常见任务#

1. 排序#

一个简单的选择排序：

1
dataseg segment
2
    input_buffer        db 20
3
    input_buffer_len    db ?
4
    input_buffer_data   db 20 dup(?)
5
    input_num           dw ?
6

7
    output_num      dw  ?
8
    output_buffer   db  10 dup (?)
9

10
    nums_len    dw  ?
11
    nums        dw  20 dup (?)
12

13
    prompt_input_num    db  'Input the number of numbers: ', '$'
14
    prompt_input_num_d  db  'Input the number: ', '$'
15

16
dataseg ends
17

18
codeseg segment
19
    assume cs:codeseg, ds:dataseg, es:dataseg
20
main proc near
21
    push ds
22
    xor ax, ax
23
    push ax
24
    mov ax, dataseg
25
    mov ds, ax
26
    mov es, ax
27

28
    mov ah, 09h
29
    lea dx, prompt_input_num
30
    int 21h
31
    call read_num
32

33
    mov ah, 09h
34
    lea dx, prompt_input_num_d
35
    int 21h
36

37
    mov cx, input_num
38
    mov nums_len, cx
39
    lea si, nums
40

41
    get_nums_loop:
42
        call read_num
43
        mov ax, input_num
44
        mov word ptr [si], ax
45
        add si, 2
46
        loop get_nums_loop
47

48
    call sort_num
49

50
    mov cx, nums_len
51
    lea si, nums
52
    put_nums_loop:
53
        mov ax, word ptr [si]
54
        mov output_num, ax
55
        call write_num
56
        add si, 2
57
        loop put_nums_loop
58

59
    pop ax
60
    pop ds
61
    mov ax, 4C00h
62
    int 21h
63
main endp
64

65
sort_num proc near
66
    push ax
67
    push bx
68
    push cx
69
    push dx
70
    push si
71
    push di
72

73
    mov si, [nums_len]
74
    sal si, 1
75
    lea bx, [nums + si]     ; 截止位
76
    lea si, nums
77

78
    sort_loop:
79

80
        lea di, [si + 2]
81
        cmp di, bx
82
        je scan_over
83

84
        scan_loop:
85
            mov ax, word ptr [di]
86
            cmp word ptr [si], ax
87
            jna scan_loop_over
88
            ; 开始交换
89
            mov     ax, word ptr [si]
90
            xchg    ax, word ptr [di]
91
            xchg    ax, word ptr [si]
92
            scan_loop_over:
93
            add di, 2
94
            cmp di, bx
95
            jne scan_loop
96

97
        scan_over:
98
        add si, 2
99
        cmp si, bx
100
        jne sort_loop
101

102
    pop di
103
    pop si
104
    pop dx
105
    pop cx
106
    pop bx
107
    pop ax
108

109
    ret
110
sort_num endp
111

112
; 输入一个整数，存入input_num
113
read_num proc near
114
    push ax
115
    push bx
116
    push cx
117
    push dx
118
    push si
119

120
    mov ah, 0Ah
121
    lea dx, input_buffer
122
    int 21h
123

124
    call newline
125

126
    xor ch, ch
127
    mov cl, input_buffer_len
128
    mov ax, 0
129
    lea si, input_buffer_data
130
    mov bx, 10
131
    xor dx, dx
132

133
    read_loop:
134
        mul bx
135
        mov dl, [si]
136
        and dl, 0Fh
137
        add ax, dx
138
        inc si
139
        loop read_loop
140

141
    mov input_num, ax
142

143
    pop si
144
    pop dx
145
    pop cx
146
    pop bx
147
    pop ax
148
    ret
149
read_num endp
150

151
; 输出一个整数，存在output_num
152
write_num proc near
153
    push ax
154
    push bx
155
    push cx
156
    push dx
157
    push si
158

159
    lea si, output_buffer
160
    mov ax, output_num
161

162
    xor dx, dx
163
    mov cx, 10
164
    write_loop:
165
        div cx              ; AX = AX / 10, 商在 AX, 余数在 DX
166
        mov bx, dx          ; BL = 余数
167
        or bl, 030h         ; 转换为 ASCII 字符
168
        mov [si], bl        ; 存储字符
169
        inc si              ; 指向下一个位置
170
        xor dx, dx
171

172
        cmp ax, 0
173
        jne write_loop
174

175
    mov byte ptr [si], '$'
176

177
    lea di, output_buffer
178
    mov cx, si
179
    sub cx, di
180
    dec si
181
    shr cx, 1
182
    jz write_num_print
183

184
    reverse_loop:
185
        mov al, [si]
186
        xchg al, [di]
187
        xchg al, [si]
188
        inc di
189
        dec si
190
        loop reverse_loop
191

192
    write_num_print:
193
        mov ah, 09h
194
        lea dx, output_buffer
195
        int 21h
196

197
        call newline
198

199
    pop si
200
    pop dx
201
    pop cx
202
    pop bx
203
    pop ax
204
    ret
205
write_num endp
206

207
; 换行
208
newline proc near
209
    push ax
210
    push dx
211
    mov ah, 02h
212

213
    mov dl, 0Dh
214
    int 21h
215
    mov dl, 0Ah
216
    int 21h
217

218
    pop dx
219
    pop ax
220
    ret
221
newline endp
222

223
codeseg ends
224

225
end main

2. 进制转换#

输入一个十进制数，转成十六进制输出。

*报错#

`operand must have size`#

1
mov [si], '$'

应该修改为

1
mov byte ptr [si], '$'

`Expected: comma`#

1
shr cx

没有指定位移的位数。

1
shr cx, 1

往年上机题#

2021级：输入一组数，输出中位数#

也就是前面排序的类似的，取出中间的数即可。

1
dataseg segment
2
    input_buffer        db 20
3
    input_buffer_len    db ?
4
    input_buffer_data   db 20 dup(?)
5
    input_num           dw ?
6

7
    output_num      dw  ?
8
    output_buffer   db  10 dup (?)
9

10
    nums_len    dw  ?
11
    nums        dw  20 dup (?)
12

13
    prompt_input_num    db  'Input the number of numbers: ', '$'
14
    prompt_input_num_d  db  'Input the number: ', '$'
15
    prompt_mid          db  'The middle is : ', '$'
16

17
dataseg ends
18

19
codeseg segment
20
    assume cs:codeseg, ds:dataseg, es:dataseg
21
main proc near
22
    push ds
23
    xor ax, ax
24
    push ax
25
    mov ax, dataseg
26
    mov ds, ax
27
    mov es, ax
28

29
    mov ah, 09h
30
    lea dx, prompt_input_num
31
    int 21h
32
    call read_num
33

34
    mov ah, 09h
35
    lea dx, prompt_input_num_d
36
    int 21h
37

38
    mov cx, input_num
39
    mov nums_len, cx
40
    lea si, nums
41

42
    get_nums_loop:
43
        call read_num
44
        mov ax, input_num
45
        mov word ptr [si], ax
46
        add si, 2
47
        loop get_nums_loop
48

49
    call sort_num
50

51

52
    mov ah, 09h
53
    lea dx, prompt_mid
54
    int 21h
55

56
    mov cx, nums_len
57
    inc cx
58
    shr cx, 1   ; (n+1)/2
59
    dec cx      ; 调整为零基
60
    shl cx, 1   ; 2字节一个字
61

62
    lea si, nums
63
    add si, cx
64

65
    mov ax, word ptr [si]
66
    mov output_num, ax
67
    call write_num
68

69

70
    pop ax
71
    pop ds
72
    mov ax, 4C00h
73
    int 21h
74
main endp
75

76
sort_num proc near
77
    push ax
78
    push bx
79
    push cx
80
    push dx
81
    push si
82
    push di
83

84
    mov si, [nums_len]
85
    sal si, 1
86
    lea bx, [nums + si]     ; 截止位
87
    lea si, nums
88

89
    sort_loop:
90

91
        lea di, [si + 2]
92
        cmp di, bx
93
        je scan_over
94

95
        scan_loop:
96
            mov ax, word ptr [di]
97
            cmp word ptr [si], ax
98
            jna scan_loop_over
99
            ; 开始交换
100
            mov     ax, word ptr [si]
101
            xchg    ax, word ptr [di]
102
            xchg    ax, word ptr [si]
103
            scan_loop_over:
104
            add di, 2
105
            cmp di, bx
106
            jne scan_loop
107

108
        scan_over:
109
        add si, 2
110
        cmp si, bx
111
        jne sort_loop
112

113
    pop di
114
    pop si
115
    pop dx
116
    pop cx
117
    pop bx
118
    pop ax
119

120
    ret
121
sort_num endp
122

123
; 输入一个整数，存入input_num
124
read_num proc near
125
    push ax
126
    push bx
127
    push cx
128
    push dx
129
    push si
130

131
    mov ah, 0Ah
132
    lea dx, input_buffer
133
    int 21h
134

135
    call newline
136

137
    xor ch, ch
138
    mov cl, input_buffer_len
139
    mov ax, 0
140
    lea si, input_buffer_data
141
    mov bx, 10
142
    xor dx, dx
143

144
    read_loop:
145
        mul bx
146
        mov dl, [si]
147
        and dl, 0Fh
148
        add ax, dx
149
        inc si
150
        loop read_loop
151

152
    mov input_num, ax
153

154
    pop si
155
    pop dx
156
    pop cx
157
    pop bx
158
    pop ax
159
    ret
160
read_num endp
161

162
; 输出一个整数，存在output_num
163
write_num proc near
164
    push ax
165
    push bx
166
    push cx
167
    push dx
168
    push si
169

170
    lea si, output_buffer
171
    mov ax, output_num
172

173
    xor dx, dx
174
    mov cx, 10
175
    write_loop:
176
        div cx              ; AX = AX / 10, 商在 AX, 余数在 DX
177
        mov bx, dx          ; BL = 余数
178
        or bl, 030h         ; 转换为 ASCII 字符
179
        mov [si], bl        ; 存储字符
180
        inc si              ; 指向下一个位置
181
        xor dx, dx
182

183
        cmp ax, 0
184
        jne write_loop
185

186
    mov byte ptr [si], '$'
187

188
    lea di, output_buffer
189
    mov cx, si
190
    sub cx, di
191
    dec si
192
    shr cx, 1
193
    jz write_num_print
194

195
    reverse_loop:
196
        mov al, [si]
197
        xchg al, [di]
198
        xchg al, [si]
199
        inc di
200
        dec si
201
        loop reverse_loop
202

203
    write_num_print:
204
        mov ah, 09h
205
        lea dx, output_buffer
206
        int 21h
207

208
        call newline
209

210
    pop si
211
    pop dx
212
    pop cx
213
    pop bx
214
    pop ax
215
    ret
216
write_num endp
217

218
; 换行
219
newline proc near
220
    push ax
221
    push dx
222
    mov ah, 02h
223

224
    mov dl, 0Dh
225
    int 21h
226
    mov dl, 0Ah
227
    int 21h
228

229
    pop dx
230
    pop ax
231
    ret
232
newline endp
233

234
codeseg ends
235

236
end main

2021级：输入字符串，改成小写后按字母表输出#

终端输入一个字符串

程序要求：

将大写字母改为小写。

按a-z的顺序输出出现过的字母

如果字母没有出现就用空格代替，不能重复输出相同字母

（大概从0开始写了20min）

1
dataseg segment
2
    input_buffer        db 20
3
    input_buffer_len    db ?
4
    input_buffer_data   db 20 dup (?)
5

6
    answer_buffer       db 26 dup (' '), '$'
7

8
dataseg ends
9

10
codeseg segment
11
    assume cs:codeseg, ds:dataseg, es:dataseg
12
main proc near
13
    push ds
14
    xor ax, ax
15
    push ax
16
    mov ax, dataseg
17
    mov ds, ax
18
    mov es, ax
19

20
    mov ah, 0ah
21
    lea dx, input_buffer
22
    int 21h
23

24
    call newline
25

26
    xor ch, ch
27
    mov cl, input_buffer_len
28
    lea si, input_buffer_data
29

30
    mov bl, byte ptr 'a'
31
    sub bl, byte ptr 'A'
32

33
    ; 改成小写
34
    search_loop:
35
        mov al, byte ptr [si]
36
        cmp al, byte ptr 'A'
37
        jb no_match
38
        cmp al, byte ptr 'Z'
39
        ja no_match
40

41
        add al, bl
42
        mov byte ptr [si], al
43

44
        no_match:
45

46
        inc si
47
        loop search_loop
48

49
    mov byte ptr [si], '$'
50

51
    ; mov ah, 09h
52
    ; lea dx, input_buffer_data
53
    ; int 21h
54

55
    ; call newline
56

57
    xor ch, ch
58
    mov cl, input_buffer_len
59
    lea si, input_buffer_data
60

61
    solve_loop:
62
        mov al, byte ptr [si]
63

64
        cmp al, byte ptr 'a'
65
        jb solve_loop_over
66
        cmp al, byte ptr 'z'
67
        ja solve_loop_over
68

69
        mov bl, al
70
        sub bl, byte ptr 'a'
71

72
        xor bh, bh
73
        lea di, answer_buffer
74
        add di, bx
75

76
        mov [di], byte ptr 'a'
77
        add [di], bl
78

79
        solve_loop_over:
80
        inc si
81
        loop solve_loop
82

83
    mov ah, 09h
84
    lea dx, answer_buffer
85
    int 21h
86

87
    call newline
88

89
    pop ax
90
    pop ds
91
    mov ax, 4C00h
92
    int 21h
93
main endp
94

95
newline proc near
96
    push ax
97
    push ds
98
    mov ah, 02h
99

100
    mov dl, 0Dh
101
    int 21h
102
    mov dl, 0ah
103
    int 21h
104

105
    pop dx
106
    pop ax
107
    ret
108
newline endp
109

110
codeseg ends
111

112
end main

2020级：接受十进制数输入朝代，将朝代转成对应年份输出#

自行设计数据存储朝代

接收一个十进制年份输入

将年份转为相应的朝代字符串输出

查询可重复，如不是合法输入则退出程序

1
dataseg segment
2
    input_buffer        db 20
3
    input_buffer_len    db ?
4
    input_buffer_data   db 20 dup(?)
5
    input_num           dw ?
6

7
    input_prompt        db 'Input Year: ', '$'
8

9
    year_cnt dw 7
10
    year_ans dw -10000, -500, 800, 1000, 1300, 1500, 1700, 10000
11
    dyna_ans db 'Qin $Han $Tang$Song$Yuan$Ming$Qing$'
12

13
    invalid_tag         db 0
14

15
dataseg ends
16

17
codeseg segment
18
    assume cs:codeseg, ds:dataseg, es:dataseg
19
main proc near
20
    push ds
21
    xor ax, ax
22
    push ax
23
    mov ax, dataseg
24
    mov ds, ax
25
    mov es, ax
26

27
main_loop:
28
    mov ah, 09h
29
    lea dx, input_prompt
30
    int 21h
31

32
    call read_num
33
    mov al, invalid_tag
34
    cmp al, 1
35

36
    je main_over
37
    call answer
38
    jmp main_loop
39

40
main_over:
41
    pop ax
42
    pop ds
43
    mov ax, 4C00h
44
    int 21h
45
main endp
46

47
answer proc near
48
    mov cx, year_cnt
49
    lea si, year_ans
50
    lea di, dyna_ans
51

52
    mov dx, input_num
53
    answer_loop:
54
        mov ax, [si]
55
        mov bx, [si+2]
56
        cmp dx, ax
57
        jl no_answer
58
        cmp dx, bx
59
        jge no_answer
60
        jmp answer_find
61
        no_answer:
62
        add si, 2
63
        add di, 5
64
        loop answer_loop
65

66
    answer_find:
67
    mov ah, 09h
68
    mov dx, di
69
    int 21h
70

71
    call newline
72

73
    ret
74
answer endp
75

76
read_num proc near
77
    push ax
78
    push bx
79
    push cx
80
    push dx
81
    push si
82
    push di
83

84
    mov ah, 0Ah
85
    lea dx, input_buffer
86
    int 21h
87

88
    call newline
89

90
    xor ch, ch
91
    mov cl, [input_buffer_len]
92
    mov ax, 0
93
    lea si, input_buffer_data
94
    mov bx, 10
95
    xor dx, dx
96

97
    mov dl, [si]
98
    cmp dl, '-'
99
    jne read_loop
100
    inc si
101
    dec cx
102

103
    read_loop:
104
        mul bx
105
        mov dl, [si]
106

107
        cmp dl, '0'
108
        jb read_invalid
109
        cmp dl, '9'
110
        ja read_invalid
111

112
        and dl, 0Fh
113
        add ax, dx
114
        inc si
115
        loop read_loop
116

117
    lea si, input_buffer_data
118
    mov dl, [si]
119
    cmp dl, '-'
120
    jne read_store
121
    neg ax
122
    read_store:
123
    mov [input_num], ax
124

125
    jmp read_num_over
126

127
    read_invalid:
128
    mov ax, 1
129
    mov invalid_tag, al
130
    read_num_over:
131
    pop di
132
    pop si
133
    pop dx
134
    pop cx
135
    pop bx
136
    pop ax
137
    ret
138
read_num endp
139

140
newline proc near
141
    push ax
142
    push dx
143
    mov ah, 02h
144

145
    mov dl, 0Dh
146
    int 21h
147
    mov dl, 0Ah
148
    int 21h
149

150
    pop dx
151
    pop ax
152
    ret
153
newline endp
154

155
codeseg ends
156

157
end main

2020级：加减法表达式#

1
dataseg segment
2
    input_nums          dw 20 dup(?)
3
    input_cnt           dw ?
4

5
    input_invalid       db 0
6

7
    input_buffer        db 100
8
    input_buffer_len    db ?
9
    input_buffer_data   db 100 dup(?)
10

11
    fuhao       db ?
12

13
    output_num      dw  ?
14
    output_buffer   db  10 dup (?)
15

16
    nums_len    dw  ?
17
    nums        dw  20 dup (?)
18

19
dataseg ends
20

21
stackseg segment
22
    db 100 dup (?)
23
stackseg ends
24

25
codeseg segment
26
    assume cs:codeseg, ds:dataseg, es:dataseg, ss:stackseg
27
main proc near
28
    push ds
29
    xor ax, ax
30
    push ax
31
    mov ax, dataseg
32
    mov ds, ax
33
    mov es, ax
34
    mov ax, stackseg
35
    mov ss, ax
36

37
    call readline_num
38

39
    mov ax, [input_nums]
40
    mov bx, [input_nums+2]
41

42
    mov cl, fuhao
43
    cmp cl, '+'
44
    je adddd
45
    jne deccc
46

47
adddd:
48
    add ax, bx
49
    jmp main_over
50
deccc:
51
    sub ax, bx
52
main_over:
53
    mov input_nums, ax
54
    mov ax, 1
55
    mov input_cnt, ax
56
    call writeline_num
57

58
    pop ax
59
    pop ds
60
    mov ax, 4C00h
61
    int 21h
62
main endp
63

64
; 输入一行多个整数，存入
65
readline_num proc near
66
    push ax
67
    push bx
68
    push cx
69
    push dx
70
    push si
71
    push di
72

73
    mov ah, 0Ah
74
    lea dx, input_buffer
75
    int 21h
76

77
    call newline
78

79
    xor ch, ch
80
    mov cl, input_buffer_len
81
    lea si, input_buffer_data   ; 扫描到的原始字符串位置
82

83
    mov ax, 0                   ; 存储当前结果
84
    lea di, input_nums          ; 当前正在写入的位置
85
    mov dl, 0                   ; 标志位，最低位表示是否有数尚未存入结果
86
                                ;        第二位表示是否有负数标志
87

88
    xor bh, bh
89

90
    readline_loop:
91
        mov bl, byte ptr [si]
92

93
        cmp bl, '-'
94
        je readline_isspace
95
        cmp bl, '+'
96
        je readline_isspace
97

98

99
        cmp bl, '0'             ; 检查是否是数字
100
        jb readline_invalid
101
        cmp bl, '9'
102
        ja readline_invalid
103
        jmp readline_isnumber
104

105

106
        readline_isspace:
107
            test dl, 03h            ; 完全没开始
108
            jz readline_charover
109
            and dl, 03h
110
            cmp dl, 02h             ; 检查禁止的情况，仅有一个符号
111
            je readline_invalid
112
            test dl, 02h            ; 是负数
113
            jz readline_storenum
114
            neg ax
115

116
            readline_storenum:
117
            mov word ptr [di], ax   ; 存储
118
            xor ax, ax              ; 清空
119
            add di, 2               ; 进位
120
            mov fuhao, bl
121

122
            mov dl, 0               ; 标志位清空
123
            jmp readline_charover
124

125
        readline_isnumber:
126
            or dl, 1                ; 标志位
127
            and bl, 0Fh             ; ASCII转成数
128
            push dx
129
            mov dx, 10
130
            mul dx                  ; *10
131
            pop dx
132
            add ax, bx              ; 加当前位
133

134
        readline_charover:
135
            inc si
136
        loop readline_loop
137

138
    ; 检查是否有数没有存储
139
    test dl, 01h
140
    jz readline_ok
141

142
    ; 处理末尾
143
    mov word ptr [di], ax
144
    add di, 2
145

146
    jmp readline_ok
147

148
    readline_invalid:   ; 非法输入
149
        mov input_invalid, 1
150

151
    readline_ok:
152

153
    lea si, input_nums
154
    sub di, si
155
    sar di, 1
156

157
    mov input_cnt, di   ; 写入个数
158

159
    pop di
160
    pop si
161
    pop dx
162
    pop cx
163
    pop bx
164
    pop ax
165
    ret
166
readline_num endp
167

168
; 输出一行多个整数
169
writeline_num proc near
170
    push ax
171
    push bx
172
    push cx
173
    push dx
174
    push si
175
    push di
176

177
    lea si, input_nums   ; 位置
178
    mov cx, input_cnt   ; 长度
179

180
    writeline_loop:
181
        mov ax, word ptr [si]
182
        mov output_num, ax
183

184
        call write_num
185

186
        mov ah, 02h
187
        mov dl, ' '
188
        int 21h
189

190
        add si, 2
191
        loop writeline_loop
192

193
    pop di
194
    pop si
195
    pop dx
196
    pop cx
197
    pop bx
198
    pop ax
199
    ret
200
writeline_num endp
201

202
; 输出一个整数，存在output_num
203
write_num proc near
204
    push ax
205
    push bx
206
    push cx
207
    push dx
208
    push si
209
    push di
210

211
    lea si, output_buffer
212
    mov ax, output_num
213

214
    ; 负数处理
215
    cmp ax, 0
216
    jge direct_write_num
217
    push ax
218
    mov ah, 02h
219
    mov dl, '-'
220
    int 21h
221
    pop ax
222
    neg ax
223
    direct_write_num:
224

225
    xor dx, dx
226
    mov cx, 10
227
    write_loop:
228
        div cx              ; AX = AX / 10, 商在 AX, 余数在 DX
229
        mov bx, dx          ; BL = 余数
230
        or bl, 030h         ; 转换为 ASCII 字符
231
        mov [si], bl        ; 存储字符
232
        inc si              ; 指向下一个位置
233
        xor dx, dx
234

235
        cmp ax, 0
236
        jne write_loop
237

238
    mov byte ptr [si], '$'
239

240
    lea di, output_buffer
241
    mov cx, si
242
    sub cx, di
243
    dec si
244
    shr cx, 1
245
    jz write_num_print
246

247
    reverse_loop:
248
        mov al, [si]
249
        xchg al, [di]
250
        xchg al, [si]
251
        inc di
252
        dec si
253
        loop reverse_loop
254

255
    write_num_print:
256
        mov ah, 09h
257
        lea dx, output_buffer
258
        int 21h
259

260
    ;    call newline   取决于要不要换行
261

262
    pop di
263
    pop si
264
    pop dx
265
    pop cx
266
    pop bx
267
    pop ax
268
    ret
269
write_num endp
270

271
; 换行
272
newline proc near
273
    push ax
274
    push dx
275
    mov ah, 02h
276

277
    mov dl, 0Dh
278
    int 21h
279
    mov dl, 0Ah
280
    int 21h
281

282
    pop dx
283
    pop ax
284
    ret
285
newline endp
286

287
codeseg ends
288

289
end main

一. 基础读写#

1. 单个非负整数输入#

2. 单个非负整数输出#

3. 多个非负数输入输出#

（1） 每行一个#

（2） 每行多个#

二. 常见任务#

1. 排序#

2. 进制转换#

*报错#

operand must have size#

Expected: comma#

往年上机题#

2021级：输入一组数，输出中位数#

2021级：输入字符串，改成小写后按字母表输出#

2020级：接受十进制数输入朝代，将朝代转成对应年份输出#

2020级：加减法表达式#

（1）每行一个#

（2）每行多个#

`operand must have size`#

`Expected: comma`#