-
本版专家分：0结帖率 0% -
求大神下面程序具体解释
DATA SEGMENT
NOTE0 DB 'Note: The character that separates the integers can be any visible ASCII except ten digits(',27H,'0',27H,'-',27H,'9',27H,').',0DH,0AH,'$'
NOTE1 DB 0DH,0AH,'==================================================================',0DH,0AH ;0DH和0AH分别是回车和换行的ASCII码
DB 'Please input 20 (or less) decimal integers (-32768 to +32767):',0DH,0AH,'$' ;'$'是字符串的结束标志
NOTE2 DB 0DH,0AH,'==================================================================',0DH,0AH
DB 0DH,0AH,'The inputed integers: ','$'
NOTE3 DB 0DH,0AH,'==================================================================',0DH,0AH
DB 0DH,0AH,'How many decimal integers? ','$'
NOTE4 DB 0DH,0AH,'The sorted result: ',0DH,0AH,'$'
ERR_STR DB 0DH,0AH,'******************************************************************',0DH,0AH
DB 'Input error!',0DH,0AH
CON_STR DB 0DH,0AH,'******************************************************************',0DH,0AH
DB 0DH,0AH,'Continue? Y or N?','$'
DEC_STR DB 200 ;用来存放输入的原始数据
DB 60 ;db 60意思是定义一个字节初始值为60
DB 150 DUP('$') ;db 100 dup (?)意思是定义100个未经初始化的字节; db ?意思是定义一个未经初始化的字节
TOTAL DB 3 DUP('$') ;用来记录输入的数字个数
DEC_NUM DW 30 DUP(?) ;用来存放将输入的ASCII码转换成2进制数以便比较的结果
OUT_STR DB 150 DUP('$') ;存放待输出的字符组信息
DATA ENDS
STACK SEGMENT STACK
STT DB 100 DUP(60) ;堆栈
STACK ENDS
CODE SEGMENT
MAIN PROC FAR
ASSUME CS:CODE,DS:DATA,SS:STACK
START: MOV AX,STACK
MOV SS,AX ;初始化ss
MOV AX,DATA
MOV DS,AX
;---------------------------------- 输出提示信息
LEA DX,NOTE0 ;直接显示NOTE0
MOV AH,09H ;显示
INT 21H ;调用dos
DISP0: LEA DX,NOTE1 ;直接显示NOTE1
MOV AH,09H
INT 21H
LEA DX,DEC_STR ;将原始数据存入该空间
MOV AH,0AH ;字符串
INT 21H
MOV AL,BYTE PTR[DEC_STR+2] ;输入合法性的标志:开头是数字或者符号 ；将DEC_STR的偏移地址+2指向的第一个字节赋值给AL
CMP AL,'0' ;条件判转指令本身占两个字节
JAE CMP1 ;A为大于，B为小于，E为等于
CMP AL,'+' ;检验AL寄存器内的值是不是+
JE DISP2
CMP AL,'-'
JE DISP2
JMP DISP1 ;JMP 无条件跳转
CMP1: CMP AL,'9'
JBE DISP2 ; 0〈=？〈=9 跳转到DISP2
DISP1: LEA DX,ERR_STR
MOV AH,09H ;显示
INT 21H
CON_YN: MOV AH,01H ;程序结束处询问是否需要继续
INT 21H
CMP AL,'Y' ;检验AL寄存器内的值是不是Y
JE DISP0
CMP AL,'y'
JE DISP0
CMP AL,'N'
JE OVER0
CMP AL,'n'
JE OVER0
OVER0: JMP OVER ;用以结束程序
DISP2: LEA DX,NOTE2 ;将输入的数据输出以便用户对照其正确性
MOV AH,09H ;显示NOTE2
INT 21H
LEA DX,[DEC_STR+2]
MOV AH,09H
INT 21H
;===============================COUNT HOW MANY DECIMAL INTEGERS 计算个数
LEA SI,DEC_STR
MOV CL,BYTE PTR[SI+1] ;CL中存放输入的总字符数 ；BYTE PTR用来定义所存入的是字节单元。[si+1]以字节单元存入SI中
MOV CH,0
PUSH CX ;cx的值压入堆栈保存
MOV AL,0 ;AL用来计数数字个数
LP1: MOV DL,BYTE PTR[SI+2] ;如果输入数字,符号则继续读下一位,如果输入其他字符则AL加一,这也是开头第一个字母不能为其他字符的原因
CMP DL,'+'
JE MOV_PTR
CMP DL,'-'
JE MOV_PTR
CMP DL,'0'
JL MOV_INC ;JL小于0跳转到MOV_INC
CMP DL,'9'
JLE MOV_PTR
MOV_INC:INC AL ;加一
MOV_PTR:INC SI
LOOP LP1
INC AL
CBW ;将AL拓展到AX中
MOV DEC_NUM,AX ;将2进制形式的计数结果放入该单元
MOV CL,10
DIV CL ;除以10后,AL中放的是结果（十位数）,AH中放的是余数（个位数）
ADD AX,3030H ;加3030H后将十位数和个位数分别转换成ASCII码
LEA DI,TOTAL
MOV BYTE PTR[DI],AL
MOV BYTE PTR[DI+1],AH
MOV BYTE PTR[DI+2],'$' ;将ASCII形式的计数结果放入单元以便输出,$符号为代码的结束
LEA DX,NOTE3 ;显示NOTE3，输出计数结果
MOV AH,9
INT 21H
LEA DX,TOTAL ;小小的处理使得第一位是0时自动缺省
CMP0: MOV BX,DX
CMP BYTE PTR [BX],'0'
JNE DISPLAY
INC DX
DISPLAY:MOV AH,9
INT 21H
;==================================ASCII to DECIMAL
LEA DX,[DEC_STR+2] ;从DX指向的单元读入
MOV CX,DEC_NUM
LEA BX,DEC_NUM ;写进BX指向的单元
ADD BX,2
T1: CALL ASC2DEC ;调用ASCII码转换
MOV [BX],AX ;将处理后的数放入储存单元
ADD BX,2
ADD DX,SI ;DX指向新位置
LOOP T1
;==================================Sort binary gigits
CALL COMP ;冒泡排序,算法很经典,就不过多标注了
;==================================NOTE4 ;输出结果提示
LEA DX,NOTE4
MOV AH,09H
INT 21H
;==================================DECIMAL TO ASCII ;将排序后的2进制数用ASCII码表示并打印出来
LEA BX,DEC_NUM
mov cx,DEC_NUM
ADD BX,2
D2A: MOV AX,[BX] ;读出二进制数放在AX中
CALL DEC2ASC ;调用转化和打印过程
MOV DL,' ' ;输出空格
MOV AH,2 ;在DOS系统功能调用（INT 21H）这个表里：ah放2，是2号功能,字符输出，并且要输出的字符是已经放在dl里面的
INT 21H
ADD BX,2 ;后移，空两个字节
LOOP D2A
LEA DX,CON_STR
MOV AH,09H
INT 21H
JMP CON_YN ;询问是否继续
OVER: MOV AH,4CH ;带返回码的结束，AL=返回码
INT 21H
MAIN ENDP
;-----------------------------------ASCII TO DECIMAL NUMBER ASCII码转十进制数
ASC2DEC PROC NEAR ;定义函数
PUSH BX ;入栈保护
PUSH CX
PUSH DX
MOV AX,0 ;AX初始为0,采用乘10相加的方式转换
MOV SI,DX
PUSH SI
MOV DL,[SI]
CMP DL,'-' ;如果读入的是负数则置CL为1最后处理
JNE L0
MOV CL,1
INC SI
MOV DL,[SI]
JMP L4
L0: CMP Dl,'+'
JNE L1
INC SI
MOV DL,[SI]
L1: MOV CL,0 ;正数置CL为0
L4: AND DL,0FH
MOV DH,0
ADD AX,DX
INC SI
MOV DL,[SI]
CMP DL,'0'
JL L2
CMP DL,'9'
JG L2
CALL TIMBY10 ;调用乘10进程
JMP L4
L2: CMP CL,1 ;如果是负数,对其求反
JNE L3
NEG AX
L3: POP DI ;DI出栈
SUB SI,DI ;SI减去初始位置,计算相对位移量
INC SI
POP DX
POP CX
POP BX
RET
ASC2DEC ENDP
;==================================AX TIME BY 10
TIMBY10 PROC NEAR
MOV BX,AX
SHL AX,1 ;乘2
SHL AX,1 ;再乘2
ADD AX,BX ;加一倍,现在相当于乘了5
SHL AX,1 ;乘2,总共是乘了10
RET
TIMBY10 ENDP
;==================================SORT DECIMAL NUMBERS 十进制数排序
COMP PROC NEAR ;保护
PUSH AX
PUSH BX
PUSH CX
PUSH DI
MOV AX,DATA
MOV DS,AX
LEA DI,DEC_NUM
MOV CX,WORD PTR[DI] ;计数
DEC CX
C1: MOV DX,CX
MOV BH,0
C2: ADD DI,2
MOV AX,[DI]
CMP AX,[DI+2]
JLE CONT1
XCHG AX,[DI+2]
MOV [DI],AX
MOV BH,1
CONT1: LOOP C2
CMP BH,0
JE STOP
MOV CX,DX
LEA DI,DEC_NUM
LOOP C1
STOP: LEA BX,DEC_NUM
MOV AX,[BX+8]
POP DI
POP CX
POP BX
POP AX
RET
COMP ENDP
;==================================DECIMAL NUMBER TO ASCII转换成ASCII码
DEC2ASC PROC
PUSH BX ;保护
PUSH CX
LEA DI,OUT_STR ;将处理后的放入DI
MOV DX,DI
CMP AX,0
JNE NON_0
ZERO: MOV BYTE PTR[DI],'0' ;如果是0
MOV BYTE PTR[DI+1],'$'
JMP OUT_ASC
NON_0: TEST AX,8000H ;不是0
JZ PTIVE ;判断符号,是正号跳转
NTIVE: NEG AX ;取反
MOV BYTE PTR[DI],'-' ;置负号
JMP CON
PTIVE: MOV BYTE PTR[DI],'+' ;置正号
CON: INC DI
MOV DX,0
MOV CX,10000 ;万位
IDIV CX ;带符号数除法
ADD AL,30H ;加30H变成ASCII
MOV BYTE PTR[DI],AL
MOV AX,DX
MOV DX,0
MOV CX,1000 ;千位
IDIV CX
ADD AL,30H ;加30H变成ASCII
MOV BYTE PTR[DI+1],AL ;写入
MOV AX,DX
MOV CL,100 ;百位
IDIV CL
ADD AL,30H
MOV BYTE PTR[DI+2],AL
MOV AL,AH
MOV AH,0
MOV CL,10 ;十位
IDIV CL
ADD AL,30H
MOV BYTE PTR[DI+3],AL
ADD AH,30H
MOV BYTE PTR[DI+4],AH ;个位
OUT_SIG:LEA DI,OUT_STR
MOV DL,BYTE PTR[DI]
MOV AH,2
INT 21H
INC DI
MOV DX,DI
B2: CMP BYTE PTR[DI],'0'
JNE OUT_ASC
INC DI
INC DX
JMP B2
OUT_ASC:MOV AH,09H ;打印
INT 21H
POP CX
POP BX
RET
DEC2ASC ENDP
;==================================
CODE ENDS
END START
-
本版专家分：0
-
注释已经够多了。
-
本版专家分：596 -
DATA SEGMENT
NOTE0 DB 'Note: The character that separates the integers can be any visible ASCII except ten digits(',27H,'0',27H,'-',27H,'9',27H,').',0DH,0AH,'$'
NOTE1 DB 0DH,0AH,'==================================================================',0DH,0AH ;0DH和0AH分别是回车和换行的ASCII码
DB 'Please input 20 (or less) decimal integers (-32768 to +32767):',0DH,0AH,'$' ;'$'是字符串的结束标志
NOTE2 DB 0DH,0AH,'==================================================================',0DH,0AH
DB 0DH,0AH,'The inputed integers: ','$'
NOTE3 DB 0DH,0AH,'==================================================================',0DH,0AH
DB 0DH,0AH,'How many decimal integers? ','$'
NOTE4 DB 0DH,0AH,'The sorted result: ',0DH,0AH,'$'
ERR_STR DB 0DH,0AH,'******************************************************************',0DH,0AH
DB 'Input error!',0DH,0AH
CON_STR DB 0DH,0AH,'******************************************************************',0DH,0AH
DB 0DH,0AH,'Continue? Y or N?','$'
DEC_STR DB 200 ;用来存放输入的原始数据，第一个字节为200
DB 60 ; 第二个字节为60
DB 150 DUP('$') ;定义(?)意思是定义100个未经初始化的字节; db ?意思是定义一个未经初始化的字节
TOTAL DB 3 DUP('$') ;用来记录输入的数字个数
DEC_NUM DW 30 DUP(?) ;用来存放将输入的数字的ASCII码转换成2进制数以便进行排序
OUT_STR DB 150 DUP('$') ;存放排好顺序待输出的字符组信息
DATA ENDS
STACK SEGMENT STACK
STT DB 100 DUP(60) ;堆栈
STACK ENDS
CODE SEGMENT
MAIN PROC FAR
ASSUME CS:CODE,DS:DATA,SS:STACK
START: MOV AX,STACK
MOV SS,AX ;初始化ss
MOV AX,DATA ;初始化ds
MOV DS,AX
;---------------------------------- 输出提示信息
LEA DX,NOTE0 ;直接显示NOTE0
MOV AH,09H ;显示
INT 21H ;调用dos
DISP0: LEA DX,NOTE1 ;直接显示NOTE1 Please input 20 个数字
MOV AH,09H
INT 21H
LEA DX,DEC_STR ;将DEC_STR首地址给DX
MOV AH,0AH ;将输入的数字输入缓冲区,DS:DX=缓冲区首地址,(DS:DX)=缓冲区最大字符数,(DS:DX+1)=实际输入的字符数
INT 21H ;下面的[DEC_STR+2]=(DS:DX+1)=实际输入的第一个数字
MOV AL,BYTE PTR[DEC_STR+2] ;判断第一个输入数据是否为数字?；将DEC_STR的偏移地址+2指向的第一个字节赋值给AL
CMP AL,'0' ;条件判转指令
JAE CMP1 ;A为大于，B为小于，E为等于,如是数字跳转到CMP1
CMP AL,'+' ;检验AL寄存器内的值是不是ascii字符+(正号)
JE DISP2 ;如果是跳转到DISP2
CMP AL,'-' ;检验AL寄存器内的值是不是ascii字符-(负号）
JE DISP2 ;如果是跳转到DISP2
JMP DISP1 ;如果第一个输入数据不是数字或者正负号，JMP 无条件跳转DISP1，显示输入错误信息
CMP1: CMP AL,'9'
JBE DISP2 ; 如果第一个输入数据是0-9之间的数字，跳转到DISP2
DISP1: LEA DX,ERR_STR
MOV AH,09H ;输入错误信息显示
INT 21H
CON_YN: MOV AH,01H ;程序运行结束后，询问是否继续，读取键盘输入并回显，al=输入字符
INT 21H
CMP AL,'Y' ;检验AL寄存器内的值是不是Y
JE DISP0 ;是Y跳转到DISP0 ,重新开始运行程序
CMP AL,'y'
JE DISP0
CMP AL,'N'
JE OVER0
CMP AL,'n'
JE OVER0 ;是N跳转到OVER0,结束程序
OVER0: JMP OVER ;用以结束程序
DISP2: LEA DX,NOTE2 ;将输入的数据输出以便用户对照其正确性
MOV AH,09H ;显示NOTE2
INT 21H
LEA DX,[DEC_STR+2];将输入数字的第一个字节地址给DX
MOV AH,09H ;显示所有输入数字直到读到终止符号 $
INT 21H
;===============================COUNT HOW MANY DECIMAL INTEGERS 计算个数
LEA SI,DEC_STR ;将输入数字缓冲区的首地址给si
MOV CL,BYTE PTR[SI+1] ;将输入的数字总个数给cl
MOV CH,0
PUSH CX ;输入的数字总个数压栈
MOV AL,0 ;AL用来计数非数字数据,即分隔符个数
LP1: MOV DL,BYTE PTR[SI+2] ;将输入的第一个数据给dl
CMP DL,'+' ;以下判断是否为正负号
JE MOV_PTR
CMP DL,'-'
JE MOV_PTR ;是的话跳转MOV_PTR
CMP DL,'0'
JL MOV_INC ;JL小于0,即读取的数据是否为输入数字时输入的分隔符,这条指令在第一次执行时并不执行,因为第一个输入的是数字和正负号
CMP DL,'9'
JLE MOV_PTR ;是数字0-9跳转到MOV_PTR
MOV_INC:INC AL ;每有一个分隔符,就相当于有一个数字,加一
MOV_PTR:INC SI;读取下一个字节
LOOP LP1;将所有字节读入求和输入数字个数
INC AL;这里将总个数加1是因为实际数字个数比分割符多1,因为最后一个数字输入后输入了回车
CBW ;将AL拓展到AX中
MOV DEC_NUM,AX ;将输入数字总个数给DEC_NUM
MOV CL,10
DIV CL ;除以10后,AL中放的是结果（十位数）,AH中放的是余数（个位数）
ADD AX,3030H ;加3030H后将十位数和个位数分别转换成ASCII码
LEA DI,TOTAL ;将total地址给di
MOV BYTE PTR[DI],AL;将分隔符总个数的ASCII形式的计数结果给连续的两个字节
MOV BYTE PTR[DI+1],AH
MOV BYTE PTR[DI+2],'$' ;$符号为结束标志
LEA DX,NOTE3 ;显示NOTE3，输出计数结果
MOV AH,9
INT 21H
LEA DX,TOTAL ;将数字总个数存储地址给dx
CMP0: MOV BX,DX
CMP BYTE PTR [BX],'0';数字总个数的十位数是否为0
JNE DISPLAY;不是0跳转到DISPLAY
INC DX;是0将dx地址指针加1，即指向数字总个数的个位数
DISPLAY:MOV AH,9
INT 21H;输出总个数结果
;==================================ASCII to DECIMAL
LEA DX,[DEC_STR+2] ;将输入的第一个数字地址给dx
MOV CX,DEC_NUM ;将输入数字总个数给cx
LEA BX,DEC_NUM ;将存储数字总个数的DEC_NUM地址给bx
ADD BX,2 ;首地址+2,即跳过存储数字总个数的两个字节
T1: CALL ASC2DEC ;调用ASCII码转换十进制
MOV [BX],AX ;将处理后的数存放在DEC_NUM中首地址+2开始的内存
ADD BX,2;将存储内存指针加一个字
ADD DX,SI ;DX指向下一个输入字符
LOOP T1;将所有处理后的输入字符存入DEC_NUM
;==================================Sort binary gigits
CALL COMP ;冒泡排序,算法很经典,就不过多标注了
;==================================NOTE4 ;输出结果提示
LEA DX,NOTE4
MOV AH,09H
INT 21H
;==================================DECIMAL TO ASCII ;将排序后的2进制数用ASCII码表示并打印出来
LEA BX,DEC_NUM ;将DEC_NUM首地址给bx
mov cx,DEC_NUM ;将DEC_NUM首地址内容(输入数字总个数)给cx，102行指令
ADD BX,2 ;指向DEC_NUM中下一个字内存地址 ,即经过转换后的数字
D2A: MOV AX,[BX] ;读出二进制数放在AX中
CALL DEC2ASC ;调用十进制转ascii码程序
MOV DL,' ' ;输出空格
MOV AH,2 ;在DOS系统功能调用（INT 21H）这个表里：ah放2，是2号功能,字符输出，并且要输出的字符是已经放在dl里面的
INT 21H
ADD BX,2 ;后移，空两个字节
LOOP D2A
LEA DX,CON_STR
MOV AH,09H
INT 21H
JMP CON_YN ;询问是否继续
OVER: MOV AH,4CH ;带返回码的结束，AL=返回码
INT 21H
MAIN ENDP
;-----------------------------------ASCII TO DECIMAL NUMBER ASCII码转十进制数
ASC2DEC PROC NEAR ;定义函数
PUSH BX ;入栈保护
PUSH CX
PUSH DX
MOV AX,0 ;AX初始为0,采用乘10相加的方式转换
MOV SI,DX ;将[DEC_STR+2] 中输入的第一个数字地址给si,125行指令
PUSH SI
MOV DL,[SI] ;将输入的第一个数字给dl
CMP DL,'-' ;如果读入的是负数则置CL为1最后处理
JNE L0 ;如果是0或者正数跳转到l0
MOV CL,1 ;负数将CL置1
INC SI ;读取下一个输入字符
MOV DL,[SI]
JMP L4 ;跳转到L4
L0: CMP Dl,'+' ; 比较是数字还是正号
JNE L1 ;数字跳转到L1
INC SI ;正号读取下一个输入字符
MOV DL,[SI]
L1: MOV CL,0 ;正数置CL为0
L4: AND DL,0FH ;对数字进行逻辑与运算,判断是正数还是负数
MOV DH,0
ADD AX,DX
INC SI ;读取下一个输入字符
MOV DL,[SI]
CMP DL,'0';如果是分隔符
JL L2 ;跳转到L2
CMP DL,'9';如果是分隔符
JG L2 ;跳转到L2
CALL TIMBY10 ;调用乘10进程,将当前数字的各个位数乘10,即每次循环时都将现有ax中数字扩大十倍，
JMP L4 ;跳转到L4,循环执行将所有每一个字节中的输入数字各位数读入AX
L2: CMP CL,1 ;如果是负数,对其求反
JNE L3 ;正是跳转到L3
NEG AX
L3: POP DI ;DI出栈，将total首地址给di ，107行指令
SUB SI,DI ;SI减去初始位置,计算相对位移量
INC SI
POP DX ;将输入的第一个数字地址给dx,170行指令参考125行指令
POP CX ;将输入数字总个数给cx,170行指令参考126行指令
POP BX ;首地址+2,即跳过存储数字总个数的两个字节,170行指令参考128行指令
RET
ASC2DEC ENDP
;==================================AX TIME BY 10
TIMBY10 PROC NEAR
MOV BX,AX
SHL AX,1 ;乘2
SHL AX,1 ;再乘2
ADD AX,BX ;加一倍,现在相当于乘了5
SHL AX,1 ;乘2,总共是乘了10
RET
TIMBY10 ENDP
;==================================SORT DECIMAL NUMBERS 十进制数排序
-
本版专家分：596
-
COMP PROC NEAR ;保护
PUSH AX
PUSH BX
PUSH CX
PUSH DI
MOV AX,DATA
MOV DS,AX
LEA DI,DEC_NUM
MOV CX,WORD PTR[DI] ;计数
DEC CX
C1: MOV DX,CX
MOV BH,0
C2: ADD DI,2
MOV AX,[DI]
CMP AX,[DI+2]
JLE CONT1
XCHG AX,[DI+2]
MOV [DI],AX
MOV BH,1
CONT1: LOOP C2
CMP BH,0
JE STOP
MOV CX,DX
LEA DI,DEC_NUM
LOOP C1
STOP: LEA BX,DEC_NUM
MOV AX,[BX+8]
POP DI
POP CX
POP BX
POP AX
RET
COMP ENDP
;==================================DECIMAL NUMBER TO ASCII转换成ASCII码
DEC2ASC PROC
PUSH BX ;保护
PUSH CX
LEA DI,OUT_STR ;将处理后数字的ascii码存放在OUT_STR开始的内存
MOV DX,DI
CMP AX,0 ;二进制数放在AX中，149行指令
JNE NON_0 ;不是0,跳转到NON_0
ZERO: MOV BYTE PTR[DI],'0' ;如果是0
MOV BYTE PTR[DI+1],'$';终止符
JMP OUT_ASC ;跳转到OUT_ASC
NON_0: TEST AX,8000H ;不是0
JZ PTIVE ;判断符号,是正号跳转
NTIVE: NEG AX ;取反
MOV BYTE PTR[DI],'-' ;置负号
JMP CON
PTIVE: MOV BYTE PTR[DI],'+' ;置正号
CON: INC DI ;以下将数字各位变成 ASCII
MOV DX,0
MOV CX,10000 ;万位
IDIV CX ;带符号数除法
ADD AL,30H ;加30H变成ASCII
MOV BYTE PTR[DI],AL
MOV AX,DX
MOV DX,0
MOV CX,1000 ;千位
IDIV CX
ADD AL,30H ;加30H变成ASCII
MOV BYTE PTR[DI+1],AL ;写入
MOV AX,DX
MOV CL,100 ;百位
IDIV CL
ADD AL,30H
MOV BYTE PTR[DI+2],AL
MOV AL,AH
MOV AH,0
MOV CL,10 ;十位
IDIV CL
ADD AL,30H
MOV BYTE PTR[DI+3],AL
ADD AH,30H
MOV BYTE PTR[DI+4],AH ;个位
OUT_SIG:LEA DI,OUT_STR
MOV DL,BYTE PTR[DI]
MOV AH,2
INT 21H
INC DI
MOV DX,DI
B2: CMP BYTE PTR[DI],'0'
JNE OUT_ASC
INC DI
INC DX
JMP B2
OUT_ASC:MOV AH,09H ;打印
INT 21H
POP CX
POP BX
RET
DEC2ASC ENDP
;==================================
CODE ENDS
END START
-
本版专家分：3062
-
- 状元 2017年 总版技术专家分年内排行榜第一
-
- 榜眼 2014年 总版技术专家分年内排行榜第二
-
- 探花 2013年 总版技术专家分年内排行榜第三
-
-
进士
2018年总版新获得的技术专家分排名前十
2012年 总版技术专家分年内排行榜第七
-
-
代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。
提醒：再牛×的老师也无法代替学生自己领悟和上厕所！
- 汇编复习（从键盘上输入10个字符并按顺序存放在存储单元中；然后按逆向顺序在显示器上输出（利用堆栈“先进后出”的特点来实现）
- 先上代码nSSEG SEGMENT PARA STACK'STACK' ;定义堆栈段n DW 256 DUP(?)nSSEG ENDSnnCSEG SEGMENTn ASSUME CS:CSEG,SS:SSEG,DS:DATA ;代码段nSTART:n MOV AX,SSEG ;将堆栈段的地址给SSn MOV SS,AX n MOV CX,10 ;设置循环次数n...
- 汇编语言实验 从键盘读入两个两位十进制数，显示其和与差
- 从键盘读入两个两位十进制数，<em>显示</em>其和与差
- 计算机组成原理实验一：基础汇编语言程序设计实验
- 实验一：基础<em>汇编语言</em><em><em>程序</em>设计</em>实验n1.实验目的:n ~~~~ 1.学习和了解TEC-XP+教学实验监控命令的用法;n ~~~~ 2.学习和了解TEC-XP+教学实验系统的指令系统;n &nb...
- 编写程序，接受从键盘输入的10个十进制数字，输入中遇到回车符则停止输入，各个数经过bcd码处理，以十六进制显示在屏幕上
- 汇编编程代码编写<em>程序</em>，接受从键盘<em>输入</em>的10个十进制数字，<em>输入</em>中遇到回车符则停止<em>输入</em>，各个数经过bcd码处理，以十六进制<em>显示</em>在<em>屏幕</em>上
- 汇编语言: 从键盘上输入 2 个一位数，求出它们的和（假设和不超过 1 位）。
- data segmentdata endsstack segment stackndw <em>20</em>h dup(?)ntop label wordnstack endscode segmentn assume ds:data,cs:code,ss:stacknp proc far mov ax,datan mov ds,ax mov ax,stackn mov ss,ax
- 利用汇编语言编程实现在键盘上输入两个一位数，在屏幕上显示它们的积。
- 在键<em>盘上</em><em>输入</em>两个一位数，在<em>屏幕</em>上<em>显示</em>它们的积。stack segment db <em>20</em>0 dup(0)stack endscode segment assume cs:code,ss:stackbegin: mov ah,1 int 21h ；从键盘<em>输入</em>第一个数字al mov bl,al mov ah,2 mov dl,0dh in
- 从键盘输入两个十六进制数，转换为十进制显示在屏幕
- 从键盘<em>输入</em>两个十六进制数，转换为十进制<em>显示</em>在<em>屏幕</em> 从键盘<em>输入</em>两个十六进制数，转换为十进制<em>显示</em>在<em>屏幕</em>
- 汇编程序从键盘输入数据并显示
- 用汇编<em><em>程序</em>设计</em>，从键盘<em>输入</em>相干数据并<em>显示</em>
- 汇编语言七 从键盘上读入一个正整数N(<=65535),转换成十六进制数存入AX，并在屏幕上显示出来。
- 1.题目要求： n从键<em>盘上</em>读入一个正整数N(n2.编写代码：nnnnSTACK SEGMENTn DW 100H DUP (?)nTOP LABEL WORDnSTACK ENDSnDATA SEGMENTn N DW 0n F DB 0n T DB '0123456789ABCDEF'n MSG0 DB 'INPUT:$'n MSG1 DB 'R
- 汇编十六进制排序
- 汇编80X86...对<em>输入</em>的十个十六进制数<em>排序</em>并<em>显示</em>输出...!
- 从键盘输入一个数字并在屏幕上输出该数字
- 提示：要先判断用户<em>输入</em>的是否是数字 n涉及到的知识点： n n代码如下 n
- C语言：从键盘上输入10个整数，求他们的平均值以及正数的个数，并加以输出
- #include <stdio.h>n#define n 10nint main(void){n/*n从键<em>盘上</em><em>输入</em>10个整数，求<em>他们</em>的平均值以及正数的个数，并加以输出n*/nint a[n];nint i;ndouble sum=0,average=0;nint number=0;nnprintf("请<em>输入</em>10个整数，用空格隔开:\n");nfor(i=0;i<n;i++){n ...
- 【汇编语言】从键盘上输入3个有符号的双字整数，按照又大到小的顺序输出这3个数
- .datana_ sdword ?nb_ sdword ?nc_ sdword ?nnformat byte "%d %d %d",0;form_str don't need oahnformat_out byte "after sort:%d %d %d",0n.codennmain procnpushadninvoke scanf ,offset format, offset a_,offs...
- 汇编复习(从键盘上输入n个字符（n小于128）并按顺序存放在存储单元中，键入“Enter”键结束输入，然后按顺序在显示器上输出)
- ;从键<em>盘上</em><em>输入</em>n个字符(n&amp;lt;128)并按顺序存放在存储单元中,键入“Enter”键结束<em>输入</em>；然后按顺序在<em>显示</em>器上输出（“Enter”键ASCII码为0DH）ndata segmentn msg db 13,10,&quot;please input:$&quot;n msg2 db 128 dup(&quot;$&quot;)ndata endsnncode segmentn assume cs:code,ds...
- 用汇编编写一个从键盘上输入并排序的程序
- 用汇编编写一个从键<em>盘上</em><em>输入</em>并<em>排序</em>的<em>程序</em>rndata segment n shuzi_w db 0n key DW 100 dup(0) ;<em>输入</em>的数的存放位置n buffer dw 0 ;<em>输入</em>数字的暂存位置 <em>输入</em>的数字大于10 需要缓冲n n db 1 ; 总共<em>输入</em>的数字个数 注意从1开始 loop循环原因n n1 db
- （汇编复习）从键盘上输入两个一位十进制无符号数字符，并对其做加法，以十进制的形式输出结果
- CODE SEGMENTn ASSUME CS:CODEnstart:n mov dl,'?'n mov ah,02hn int 21hn mov ah,01hn int 21hn cmp al,'0'n jb startn cmp al,'9'n ja startn ...
- 汇编语言: 试编写一段程序，从键盘接收一个 0-65535 间的十进制无符号数，并在终端上显示与 它等值的二进制数。
- 试编写一段<em>程序</em>，从键盘接收一个 0-65535 间的十进制无符号数，<em>并在</em>终端上<em>显示</em>与 它等值的二进制数。 n <em>20</em>17年6月2日15:57:50ndata segmentnmeg db 0dh,0ah,' bad number !','$'ndata endsstack segment stackn dw <em>20</em>h dup(?) ntop label wordnstack endscode se
- 【汇编程序】从键盘输入一个大写字母，将其转换成小写字母
- n <em>程序</em>需求:从键<em>盘上</em><em>输入</em>一个大写英文字母，将其转换成小写字母并<em>显示</em>出来，要求<em>输入</em>其他字符，能够有出错提示信息nn编程思路:首先需要先定义一个数据段，定义一个变量，在汇编中 定义字符串只能使用db 以$作为结束标志nn 将段地址和偏移地址都赋值，因为要进行键盘的<em>输入</em> 所以 <em>程序</em>需要调用dos系统 01H的作用是接收从键<em>盘上</em><em>输入</em>的一个nn字符，<em>并在</em><em>屏幕</em>上<em>显示</em>，将接收的到值和al 和 A和 Z 进行比...
- 【note】Java程序设计基础第五版（上）
- 第 1 章 Java语言概述nJava语言有哪些特点？ n答：简单易学、面向对象、平台无关性、可靠性、安全性、支持多线程、支持网络编程、编译与<em>解释</em>并存 n什么是Java的虚拟机？ n答：任何一种可以运行Java字节码的软件均可看成是Java的虚拟机n什么是字节码？采用字节码的最大好处是什么？ n答：字节码是Java虚拟机的指令组，和CPU上的微指令很相似 。字节码最大的好处是可跨平台运
- 从键盘上输入三个整数，分别赋给整型变量a，b,c. 然后将输入的整数按照从小到大的顺序放在a，b，c中， 并输出三个变量的值。
- 从键<em>盘上</em><em>输入</em>三个整数，分别赋给整型变量a，b,c. 然后将<em>输入</em>的整数按照从小到大的顺序放在a，b，c中， 并输出三个变量的值。
- 从键盘输入N个十进制数，求它们的和
- 从键盘<em>输入</em>N个十进制数，求它们的和（累加和要求不大于65535），并将累加结果在<em>屏幕</em>上<em>显示</em>出来。要求给出必要的提示信息（用宏调用完成）；累加功能由子<em>程序</em>调用实现；二进制数形式的累加和转换为十进制数并<em>显示</em>由子<em>程序</em>调用实现。悬赏分：100 | 解决时间：<em>20</em>11-11-08 15:15:00;==============================================最佳答案：;从键盘
- 汇编语言：从键盘输入有符号十进制数的子程序
- data segmentn count =0ahn array dw count dup(0)n over db 'read over','$'ndata endsncode segment;nassume cs:code,ds:datanstart: mov ax,datan mov ds,axn xor ax,axn...
- c语言：从键盘输入BOY三个字符，然后把它们输出到屏幕。
- 从键盘<em>输入</em>BOY三个字符，然后把它们输出到<em>屏幕</em>。<em>程序</em>：#includeint main(){char a,b,c;printf("请<em>输入</em>字符：");a=getchar();//注意getchar一次只能读入1个字符b=getchar();c=getchar();putchar(a);putchar(b);putchar(c);putchar('\n');return 0;}结果：请<em>输入</em>字符：BOY
- Python实现从键盘接收若干个整数，存放在列表中。自己实现某种排序算法，将输入数据进行升序排列，并将排序结果在屏幕上输出，并对比该算法与列表自带sort方法的性能。
- 代码：n#-*-coding:utf_8-*-nimport timenn#从键盘<em>输入</em>ns=input()nlist1=s.split(' ')nlist2=[]nfor a in list1:n list2.append(int(a))nlist3=list2nprint(&quot;<em>排序</em>前：&quot;,list2)nnn#自定义<em>排序</em>方法ndef use_my():n k = len(list3)n ...
- 汇编：从9个有符号数中找出最小数，并将最小数与负数的个数以十进制的形式显示到屏幕上
- 汇编代码：从9个<em>有符号数</em>中找出最小数，并将最小数与负数的个数以十进制的形式<em>显示</em>到<em>屏幕</em>上
- 输入20个整数，输出它们的和及平均值
- 这道题并不是很难，但是作为一道作业题，对初学c的人，也不失为一道不错的练习数组题目，老规矩，先放上<em>流程</em>图，（那个 Y,N是没处理好，不要在意）nn其实只是为了练手。。。n放个代码n#include&lt;stdio.h&gt;nint main()n{int a[<em>20</em>],i,sum=0;n float aver;n printf("please enter <em>20</em> numbers:\n");n f...
- 汇编：从键盘录入20个数（-128~127），求最大值
- 汇编：从键盘录入<em>20</em>个数（-128~127），求最大值include 一套工具.macndata segmentn show db "Please Input twenty numbers:$"n iit1 db "The $"n iit2 db " number is:$"n buf db <em>20</em> dup(?)n x db ?,?,?,? ;x[0]用来存负号n w db ? ;用于显...
- 用汇编实现接收键盘字符并打印出其扫描码和ascii码
- 等待按键，读取并按16进制在固定位置<em>显示</em>（例如：第24行，第1列，第3列）<em>显示</em>按键的ASCII和SCAN码 如果是Esc键，<em>程序</em>退出，否则继续！
- 利用汇编语言编程实现屏幕上输出十进制数字00-29功能
- 利用<em>汇编语言</em>编程实现<em>屏幕</em>上输出十进制数字00-29功能stack segment stack db 64 dup(?)stack endscode segment assume cs:codestart: mov dl,0dh mov ah,2 int 21h mov dl,0ah int 21h mov bl,0next: mo
- 汇编语言程序设计练习题
- n 所有代码见n n https://github.com/Lemonreds/assembly-solutionnnnnn<em>汇编语言</em><em><em>程序</em>设计</em>练习题 n一、字符与串处理类 1.逆序输出字符串“BASED ADDRESSING”。 2.试编写一段<em>程序</em>，要求对键盘<em>输入</em>的小写字母用大写字母<em>显示</em>出来。 3.编写<em>程序</em>，从键盘接收一个小写字母，然后找出它的前导字符和后续字符，再按顺序 <em>显示</em>这三个字符。 4...
- 汇编语言——第1次上机实验
- 准备：nnn硬件：pc机，32位win操作系统，能够运行dos，某些64位win10系统可能会不支持n软件：masm<em>程序</em>nnn实验内容：nnn1.win+r运行dos，cd到指定的masm目录（为了调试方便，所有的文件和<em>程序</em>都放在该目录下）nnn2.edit filename.asm回车后进行编辑，<em>输入</em>相应的汇编<em>程序</em>。（也可以用nodepad++，vim等二进制文本编辑
- 程从键盘上输入待输入的整数个数和整数值，求去掉最大值和最小值以后的整数的平均值
- 程从键<em>盘上</em><em>输入</em>待<em>输入</em>的整数个数（不多于<em>20</em>个整数）和整数值，求去掉最大值和最小值以后的整数的平均值。n<em>输入</em>描述n连续<em>输入</em><em>20</em>个整数，用空格作为分隔n输出描述n用"max element:%d\n"的格式输出最大值n用"min element:%d\n"的格式输出最小值n如果可以计算平均值用"average is %5.2f\n"的格式输出平均值，否则输出"no solution\n"n#inclu...
- 依次从键盘输入20个无序整数，删除数组重复元素并按从小到大排序
- #include&amp;lt;stdio.h&amp;gt; //依次从键盘<em>输入</em><em>20</em>个无序整数,删除数组重复元素并按从小到大<em>排序</em>rn#includern#includernusing namespace std;rn#define maxn 1000rnint a[maxn];rnbool cmp ( int a, int b ) {rnreturn a &amp;gt; b;rn}int main()rn{rn...
- 写个程序，要求创建一个文件，写入从键盘输入的一串字符，然后再读该文件并将文件内容显示在屏幕上
- package com.my.test01;nimport java.io.BufferedReader;nimport java.io.BufferedWriter;nimport java.io.FileReader;nimport java.io.FileWriter;nimport java.io.IOException;nimport java.util.Scanner;nclass S...
- 将键盘输入的字符串送到用户自定义的数据缓存区中并输出
- 从键盘<em>输入</em>到缓冲区需要调用dos21h的0Ah号功能，该功能的使用方法如下:n定义一个缓冲区，设定<em>输入</em>字符为个数为n个，则缓冲区大小为n+2。缓冲区的第一个字节存放缓冲区的长度，所以这个要求<em>输入</em>的字符不能大于255个，最后一个应该留给回车字符。第一个字符存放实际<em>输入</em>字符的长度，第三个字节开始存放<em>输入</em>的字符串。n将<em>输入</em>字符串<em>显示</em>到<em>屏幕</em>上，需要调用09h号功能，该功能以DS:DX为<em>显示</em>字符串的内存
- 进制转化：从键盘接收一个4位的十进制数，将它转化为16进制并输出
- ;从键盘接收一个4位的十进制数，将它转化为16进制并<em>输入</em>nDATA SEGMENTnNUM DW 0nCRLF DB 0AH,0DH,24HnDATA ENDSnnSTACK SEGMENT PARA STACKn DW 128 DUP(?)nTOP LABEL WORDnSTACK ENDSnnCODE SEGMENTn ASSUME CS:CODE,DS:DATA,SS...
- 80x86 汇编语言编程：输入数字串，排序、并求最大和最小
- ;从键盘<em>输入</em>一个ENTER结束的十进制数字串, 按ASCII码值降序排列这个数字串，;举报|<em>20</em>13-12-10 21:36鼬风行 | 分类：<em>汇编语言</em> | 浏览61次;并另起一行，<em>显示</em>出ASCII码制最大和最小的两个数;题目链接：;http://zhidao.baidu.com/question/1429974384330700699.html;做而论道编程如下：;================
- 从键盘输入一系列字符（以回车键结束），并按字母、数字及其它字符分类统计，最后显示这三类的统计结果
- ;从键盘<em>输入</em>一系列字符（以回车键结束），并按字母、数字及其它;字符分类统计，最后<em>显示</em>这三类的统计结果DATA SEGMENTBUFFER DB 128,?,128 DUP(0)NUM DB 0WORDS DB 0OTHER DB 0CRLF DB 0AH,0DH,'$'DATA ENDSSTACK SEGMENT PARA STACK DW 128 DUP(?)TOP LABEL W...
- 从键盘输入3个学生的有关数据，然后把它们转存到磁盘文件上。
- 解题思路：n我们先审题，题目中说从键<em>盘上</em><em>输入</em>学生的有关数据，我们就用scanf函数来对学生的有关信息进行<em>输入</em>，然后定义一个input函数来实现这个功能，接下来题目中说到要把它们转存到磁盘文件上；那么，这时候我们需要从键<em>盘上</em>读取所<em>输入</em>的信息到磁盘文件上，然后对它进行保存。readfile函数就是实现了读取功能，<em>具体</em>是怎样实现的呢，就是通过定一个指向文件的指针变量p，来判断文件是否存在，并用fread...
- 【汇编程序】从键盘上输入一个10进制数字，查表求键入数字的平方值
- 需求:从键<em>盘上</em><em>输入</em>一个10进制数字，查表求键入数字的平方值nn实现思路:定义数据段 一个提示信息,使用db字节来存储 并以'$'符号作为结束标志，定义一个变量存储 0-9对应的平方值nn先赋值代码段段地址和偏移量地址，调用dos9号功能 <em>显示</em>以$结束的标志字符串，提示用户<em>输入</em>.接着调用dos1号功能 接收用户<em>输入</em>的，<em>并在</em><em>屏幕</em>上<em>显示</em>。这里用and(与) 进行相与之后获取了键<em>盘上</em><em>输入</em>的值，将存储...
- 从键盘输入两个正整数，求它们的最大公约数和最小公倍数
- //求两个正整数的最大的公约数和最小公倍数n#includen#include int k=1;void divide();nvoid subtract();nvoid enumerate();nvoid menu(); nvoid divide() //辗转相除法 n{ n int a,b,c,x,y;n printf("
- 汇编程序：求最大数
- 【任务】求最大数 n 在BUFFER处给出了多个无符号数，请找出其中的最大值，放至MAX指定的存储单元中。data segmentn buffer dw 35098, 17758, 54582, 61504, 46054, 58513, 4409, 7902, 14255n dw 40623, 47645, 15575, 51572, 18110, 26511, 14880,
- 汇编程序 给定三个无符号数，求出最大值，并将最大值存入max单元，并在屏幕显示
- data segmentn max dw ?n num dw 35h,34h,33hnendsnncode segmentnstart:n mov ax, datan mov ds, axn mov es, axn n mov si,0n mov ax,num[si] n mov bx,num[si+2h]n cmp bx,axn ...
- 从一个磁盘文件顺序读入字符并在屏幕上显示出来
- #includenmain()n{nFILE() *fp;nchar ch;nif((fp=fopen("d:\\my.dat","r"))==NULL)n{n printf("\n this file does not exit\n");n exit(1);n}while((ch=fgetc(fp))!=EOF)n putchar(ch);n fclose(fp); }
- 汇编语言————实验2：多整数求和程序的编写
- 实验名称nn多整数求和<em>程序</em>的编写nn实验目的nn熟悉<em>汇编语言</em>的基本指令和条件指令的使用，理解汇编<em>程序</em>中，如何实现高级语言中的条件语句。nn实验要求nn1) 编写多个整数求和的<em>程序</em>：对用户<em>输入</em>的多个整数进行求和，并输出结果。nn阅读然后修改附录A中的求和<em>程序</em>（该<em>程序</em>实现了3个整数求和的功能），使用一个常量决定数组的大小（即<em>程序</em>最大可以求和的整数个数）：nn ARRAY_SIZE =...
- 利用汇编语言编程实现，输入显示字符
- 利用<em>汇编语言</em>编程实现，要求从键<em>盘上</em>逐一<em>输入</em>字符，<em>并在</em><em>显示</em>器上<em>显示</em>输出，当<em>输入</em>到“$”时，则停止操作。assume cs:codecode segmentg1: mov ah,1 int 21h ;从键盘<em>输入</em>字符->al cmp al,'$' jz exit ;若字符为$则结束 mov dl,al mov ah,2 int 21h ;输出字符
- 汇编语言冒泡排序
- <em>汇编语言</em>asm，sort实现
- C语言：高难度程序填空改错：从键盘上读入5个乱序的整数，将5个数从小到大排序，然后再从键盘读入一个数字并将它插入到排好序的数列中
- 题目来源：大工慕课 链接 n作者：Caleb Sungnnnn题目要求nn(24)将一个数插入到已经排好序的数组中，本题要用到 24.sort.c 文件。（可参考上机指导书p131E6.4，当然这道题目指导书上的写法也不是很简洁，大家也可以不用按照指导书的思路，按照自己的思路用下标或指针实现题干中的要求）要求：先从键<em>盘上</em>读入5个乱序的整数，将5个数从小到大<em>排序</em>（冒泡和选择法，哪个你掌握的不好就...
- 汇编语言: 编写一个程序，从键盘输入一个 0～65535 之间的 10 进制无符号数，然后以 16 进制 和四进制数形式显示出所输入的数。
- 编写一个<em>程序</em>，从键盘<em>输入</em>一个 0～65535 之间的 10 进制无符号数，然后以 16 进制 n 和四进制数形式<em>显示</em>出所<em>输入</em>的数。 n <em>20</em>17年6月5日19:25:02ndata segmentncarryout db 0dh,0ah,' carry out!','$'ncrlfmsg db 0dh,0ah,'$'ndata endsstacks segment stackndw <em>20</em> d
- 汇编语言: 从键盘上输入一串字符（用回车键结束，使用 10 号功能调用。）放在 STRING 中，试 编制一个程序测试字符串中是否存在数字。如有，则把 CL 的第 5 位置 1，否则将该位置置 0。
- 从键<em>盘上</em><em>输入</em>一串字符（用回车键结束，使用 10 号功能调用。）放在 STRING 中，试 编制一个<em>程序</em>测试字符串中是否存在数字。如有，则把 CL 的第 5 位置 1，否则将该位置置 0。 ndata segmentnstring db 101,?,101 dup(?)ndata endscode segmentn assume ds:data,cs:coden p proc far
- 程序设计入门11 三个数之间排序（按a,b,c）输出版
- 题目描述nn从键盘<em>输入</em>3个实数a, b, c，通过比较交换，将最小值存储在变量a中，最大值存储在变量c中，中间值存储在变量b中，并按照从小到大的顺序输出这三个数a, b, c。nn末尾输出换行。nn<em>输入</em>nn<em>输入</em>以空格分隔的三个实数nn输出nn按照从小到大的顺序输出这三个实数，中间以空格分隔，最小值在前，最大值在后。小数点后保留2位小数。nn注意末尾的换行。nn样例<em>输入</em>nnn3 7 1nn样例输出n...
- 从键盘传入多个字符串到程序中,并将它们按逆序输出在屏幕上
- 从键盘传入多个字符串到<em>程序</em>中,并将它们按逆序输出在<em>屏幕</em>上nimport java.util.Scanner;npublic class ScannerDemo{npublic static void main(String[] args) throws Exception{nScanner scan=new Scanner(System.in);nSystem.out.println("
- 编写一个源程序，在键盘上按一个键，将从AL返回的ASCII码值显示出来，如果按下 ESC键则程序退出
- 编写一个源<em>程序</em>，在键<em>盘上</em>按一个键，将从AL返回的ASCII码值<em>显示</em>出来，如果按下ESC键则<em>程序</em>退出。请调用书中的HTOASC子<em>程序</em>。
- 汇编实现显示键盘的字母的ASCII 和扫描码、功能码
- 1）每次接受一个字母，即时<em>显示</em>到<em>屏幕</em>上 2）同时<em>显示</em>键盘的字母的ASCII 和扫描码 3）<em>显示</em>键盘的功能码（按功能给分） 4）按ESC键退出
- 用Mips汇编语言编写下面程序：输入10个无符号数，从大到小一次输出
- 这应该算的上第一次写mips<em>汇编语言</em>博客，刚学，打这个小<em>程序</em>花了我不少时间。最后菜菜的我还在学长的帮助下，debug一个始终找不出来的错误。这也让我懂得一个道理：不熟悉的指令尽量少用，因为你可能不知道它的机制，可能会出错。nn废话少说，首先切入正题。我们先用c++代码来进行实现nn nnn #include&lt;iostream&gt; n ...
- 汇编语言：键盘录入五个整数，编程实现求和
- 要求：1. 查看CPU和内存，用机器指令和汇编指令编程，查看对应机器指令2. 学习编程，编译，连接，跟踪；3. 要求编译链接后用debug跟踪执行代码：assume cs:codesgncodesg segment ;键盘<em>输入</em>5个8位的16进制数(每个数8位二进制，即2位十六进制)，累加求和输出 和为16位n mov dx,0 ;这里存放累加和n mov cx,5hnns...
- 【例3.9】从键盘输入BOY3个字符,然后把它们输出到屏幕
- n运行结果为：nnn
- 字符串的输入与显示（汇编程序）
- 汇编临近考试，虽然只是考察科目，但学了的东西不能白学，就把自己复习的东西拿出来，以后要回顾也方便nnn方法一：通过02号单个字符的输出功能，循环输出得到字符串ndata segmentnstrs db "please input a string:$"nbuf db <em>20</em>n db ?n db <em>20</em> dup(?)ncrlf db 0ah,0dh,'$'ndata endsnstacks se
- 超完整汇编子程序小实验（附思考题）
- 汇编子<em>程序</em>小实验 编写<em>程序</em>，将字符串STING1的内容复制到字符串STRING2中。要求由子<em>程序</em>来实现字符串的复制，并采用寄存器来传递参数。
- 【汇编】两个有符号十进制数相乘：从键盘输入两个有符号十进制数相乘,显示结果。
- 两个有符号十进制数相乘：从键盘<em>输入</em>两个有符号十进制数相乘,<em>显示</em>结果。rninclude io32.incrn.datarn.codernstart: call readsid ;读取的整数存放在寄存器eaxrnmov ebx,eax ; 把上一个读取的整数放到寄存器ebxrncall readsid ;再次读取一个整数rnxor edx,edx ;将edx置0，以便检查是否乘法结果的高位是否存到edx中rnimu...
- 汇编语言 学生成绩统计排序程序
- 从键盘读入某班学生（人数 £ 15）的考试成绩，用逗号或空格分隔各学生成绩，然后对该班的成绩进行递减<em>排序</em>，要求<em>显示</em><em>排序</em>结果，并对全班成绩进行统计，给出小于60分、60分段、70分段、80分段和90分段各段的人数以及全班的平均分数
- 编写程序，从键盘输入三个数字，分别求他们的和、平均数、积、最大值和最小值。
- #include<iostream>nusing namespace std;nint main()n{n int num1,num2,num3,temp;n float sum,ave,pro,min,max;n cout<<"请<em>输入</em>3个数字\n"<<"它们分别是：";n cin>>num1>>num2>>num3;n /...
- 汇编实现键盘输入冒泡排序
- 用<em>汇编语言</em>实现在键<em>盘上</em><em>输入</em>数字，两位，<em>排序</em>后在<em>屏幕</em>上<em>显示</em>！
- 某班有20名学生，从键盘输入这20名学生的成绩存放在数组中，实现由大到小输出。
- using System;rnusing System.Collections.Generic;rnusing System.Linq;rnusing System.Text;rnrnrnnamespace _118_3._3rn{rn class Programrn {rn static void Main(string[] args)rn {rn
- 12．编写程序，其功能是从键盘输入n*n个整型数（n≤20）,组成n行n列数组，打印出其上三角数组。
- #include &lt;stdio.h&gt;nnint main()n{n int Matrix[<em>20</em>][<em>20</em>];n int size;n int i, j;n n scanf("%d", &amp;size);n for(i = 0; i &lt; size; i++){n for(j = 0; j &lt; size; j++){n scanf("%d", &amp;Matrix[i...
- 用选择排序法编写c语言，实现从键盘上输入10个数，按从大到小的顺序排序输出。
- 用选择<em>排序</em>法编写c语言，实现从键<em>盘上</em><em>输入</em>10个数，按从大到小的顺序<em>排序</em>输出。#include&lt;stdio.h&gt;int main(){ int i,j,a[10],t; printf("请<em>输入</em>十个数："); for (i = 0; i &lt; 10; i++) scanf("%d",&amp;a[i]); for (i = 0; i &lt; 10; i++) { for (j =...
- 汇编语言: 编写一个程序，新建一个文件：d:\abc.txt,从键盘输入文件的内容（不超过100个字 符）。然后新建一个文件：d:\def.txt,将d:\abc.txt文件的内容复制到d:\def.
- 编写一个<em>程序</em>，新建一个文件：d:\abc.txt,从键盘<em>输入</em>文件的内容（不超过100个字 符）。然后新建一个文件：d:\def.txt,将d:\abc.txt文件的内容复制到d:\def.ndata segmentbuf db 100,?,100 dup(?)file db 'abc.txt',0nfh dw ?copyfile db 'def.txt',0ncopyfh dw ?copybuf d
- 编程从键盘输入一个一位十六进制数，定义一个子程序将其以二进制形式输出到屏幕
- 必要参考<em>程序</em>，能让人容易解决 很多问题的
- 汇编语言: 从键盘上输入一串字符（用回车键结束，使用10号功能调用。），将其中的小写英文 字母变换为大写英文字母，其他字符保持不变。然后将变换后的字符串显示出来。
- 从键<em>盘上</em><em>输入</em>一串字符（用回车键结束，使用10号功能调用。），将其中的小写英文 字母变换为大写英文字母，其他字符保持不变。然后将变换后的字符串<em>显示</em>出来。 ndata segmentnbuf db 101,?,101 dup(?)ndata endsstack segment stackndw <em>20</em>h dup(?)ntop label wordnstack endscode segmentn as
- 80x86汇编语言：输入数字，输出对应月份的英文
- ;从键盘<em>输入</em>1,2,3,4,5,6.....12,输出相对应的月份的英文，;eg，<em>输入</em>5，则输出may。;不想<em>输入</em>就<em>输入</em>e或者E，结束<em>程序</em>。;要求：<em>输入</em>前有提示语。;若<em>输入</em>的是大于12或者小于0或者是字母，则<em>显示</em><em>输入</em>错误。;做而论道编写的<em>程序</em>如下：ASSUME CS:CODE, DS:DATA;---------------------------------DATA SEGMENT
- 汇编语言实现输入一个四位十六进制数一十六位二进制输出
- DATAS SEGMENTrn string db 'please input four char between 0 and f(hex):$'rn ;此处<em>输入</em>数据段代码 rnDATAS ENDSrnrnrnSTACKS SEGMENTrn ;此处<em>输入</em>堆栈段代码rnSTACKS ENDSrnrnrnCODES SEGMENTrn ASSUME CS:CODES,DS:D
- 写一个Java应用程序，从键盘输入一个整数，然后输出它的平方值立方值
- 这是一个跟<em>输入</em>/输出流有关的面试题。下面我们来分析怎么实现该功能。rn解析：在java中没有像C语言那样有一个专供接收从键盘<em>输入</em>值的scanf函数，所以一般的做法是从键盘<em>输入</em>一行字符，保存到字符串s中，再将字符组成的字符串s转换为整型数据返回。rn代码如下：rnimport java.io.BufferedReader;nimport java.io.IOException;nimport jav
- 由键盘输入两个实数，交换后输出
- #includernint main()rn{rn float a,b,t;rn scanf("%f%f",&a,&b);rn t=a,a=b,b=t;rn printf("\n");rn printf("%f\t%f\n",a,b);rnrnrn}
- 从键盘输入不多于四位的16进制数，以十六位二进制数形式输出
- ;从键盘<em>输入</em>四位16进制数，以2进制输出;=============================================DATA SEGMENTSTR1 DB 'INPUT A HEX NUM: $'HEX DB 5 ;计划<em>输入</em>的字符个数(含回车符)NNN DB 0 ;存
- 汇编语言: 从键盘上输入一系列以$为结束符的字符串，然后对其中的非数字字符计数，
- 从键<em>盘上</em><em>输入</em>一系列以$为结束符的字符串，然后对其中的非数字字符计数，并<em>显示</em> 计数结果。ndata segmentnbuf db 101,?,101 dup (?)ndata endsstack segment stackndw <em>20</em>h dup(?)ntop label wordnstack endscode segmentn assume ds:data,cs:code,ss:stack
- 【汇编程序】编一个程序，从键盘输入一个不长于40个字符的串，然后将其反转输出
- STACKS SEGMENT STACKn DW 100H DUP(?) n TOP LABEL WORDn STACKS ENDS --定义栈nnDATAS SEGMENTn TABLE DB 100H DUP(?)n DATAS ENDS --定义变量nn...
- 编写程序，从键盘上输入两个数，比较两个数的大小，并输出比较结果。
- 编写<em>程序</em>，从键<em>盘上</em><em>输入</em>两个数，比较两个数的大小，并输出比较结果。nn<em>程序</em>运行结果参考下图：nn nn 代码：nnnimport java.util.Scanner;nnpublic class Compare_Number {nn public static void main(String[] args) {n n Scanner scan = new Scanner(System...
- 从按下键盘到屏幕上显示字符计算机经过了哪些过程
- 参考了相关论坛以及书籍，总结起来就是：键盘有个键盘控制芯片，时时刻刻都在检测通过键盘的电流变化，如果有键盘按下，控制芯片会反馈给相应的中断<em>程序</em>，中断<em>程序</em>反应给CPU，CPU会把之前所做的一些任务停下，在晶振电路的控制下，通过相关的<em>程序</em>从内存或者I/O中读取出数据来，然后在CPU的内部进行一系列的二进制的计算，<em>输入</em>到内存或I/O中，最后通过GUI来实现字符的<em>显示</em>。
- 汇编 从键盘输入一个数字N（0～9），然后显示N个大写字母“A”
- （1）键盘<em>输入</em>使用21H功能调用 MOV AH，1 INT 21H ；<em>输入</em>字符的ASCII码将保存在AL寄存器中 （2）将<em>输入</em>数字的ASCII码转换成数字本身 （3）循环输出
- 用scanner从键盘输入3个整数,输出最大的值.
- import java.util.Scanner;rnrnrnpublic class Max {rnpublic static void main(String[] args) {rnSystem.out.println("请<em>输入</em>三个整数:");rnScanner sc = new Scanner(System.in);rnrnint a = sc.nextInt();rnint b = sc.
- 汇编语言: 试编制一个程序：从键盘输入一行字符，要求第一个键入的字符必须是空格符，如不 是，则退出程序；如是，则开始接收键入的字符并顺序存放在首地址为buffer的缓冲区中（空 格符不存入），直到接收
- 试编制一个<em>程序</em>：从键盘<em>输入</em>一行字符，要求第一个键入的字符必须是空格符，如不 是，则退出<em>程序</em>；如是，则开始接收键入的字符并顺序存放在首地址为buffer的缓冲区中（空 格符不存入），直到接收到第二个空格符时退出<em>程序</em>。 ndata segmentnbuf db 101,0,101 dup(?)nsapce db 0ah,'it is not a space !',0ah,'$'ndata endssta
- C语言 基础练习40题
- 一、题目rn1.<em>输入</em>2个整数，求两数的平方和并输出。 rn2. <em>输入</em>一个圆半径（r）当r>＝0时，计算并输出圆的面积和周长，否则，输出提示信息。rn3、函数y=f(x)可表示为：rnrn4、编写一个<em>程序</em>,从4个整数中找出最小的数,并<em>显示</em>此数。rn5．有一函数当x0时，y=3，当x=0时y=5，编程，从键盘<em>输入</em>一个x值，输出y值。rn6．从键盘<em>输入</em>两个数，求出其最大值（要求使用函数完成求最大值，
- 计算从键盘输入的任意个浮点数的平均值，结合动态内存
- #include &lt;stdio.h&gt;n#include &lt;stdlib.h&gt; //malloc()函数的头文件nnint main()n{n int i;n int count = 0;n float *p = NULL;n float number = 0.0f;n float sum = 0.0f;nn p = (float *)malloc(sizeof(float)...
- 从键盘输入一个大写字母将其转换为小写字母，将转换后的小写字母及其十进制的ASCII码显示到屏幕上
- #includenint main()n{n char ch;n printf("请<em>输入</em>一个大写子母：");n ch=getchar();n ch=ch+32;n printf("%c,%d\n",ch,ch);n return 0;n}
- 从键盘输入两个数，计算两个数的和，然后输出
- 简单的c语言编程，在同学们学习C语言的初期，还是很有帮助的
- 渣渣小白学R（每日一题）--从键盘输入一个数n，然后再从键盘输入n个数，这n+1个数用空格隔开，输出这后面n个数的和、平均数。
- nn=as.numeric(readline('<em>输入</em>数字的个数：'))nnt=array()nfor(i in 1:n)n{n a=as.numeric(readline('<em>输入</em>一个数字：'))n t[i]=a#每次循环<em>输入</em>的数字给向量tn n}nv=list(t)#看一下t是不是我们<em>输入</em>的n个数字nvntmean=mean(t)#后n个数的均值（也就是循环里<em>输入</em>的n个数字）ntmeannt...
- 2、编写程序，从键盘上输入两个电阻的值，求它们并联和串连的电阻值，输出结果保留两位小数。
- #include nint main()n{n float R1,R2,Rc,Rb;n printf("please input R1 R2\n"); n scanf("%f,%f",&R1,&R2); Rc=R1+R2;n Rb=R1*R2/(R1+R2); printf("串联电阻Rc=%0.2f\n并联电阻Rb=%0.2f\n",Rc,Rb
- java读取从键盘输入的字符
- import java.io.BufferedReader;rnimport java.io.IOException;rnimport java.io.InputStreamReader;rnpublic class test {rnpublic static void main(String[] args) {rnBufferedReader in=new BufferedReader(new
- 编制程序，输入n个整数（n从键盘输入，n>0），输出它们的偶数和。
- #includernusing namespace std;rnint main()rn{rn int n,i,j,sum=0,a[100];rn cin>>n;rn for(i=1;irn {rn cin>>a[i];rn }rn for(j=2;jrn sum=sum+a[j];rn coutrn return 0;r
- 1.从键盘上输入10个整数的数列，将10个数按从小到大顺序排列，输出原数列和排序后的数列。 ...
- /* * 题目描述 1.从键<em>盘上</em><em>输入</em>10个整数的数列，将10个数按从小到大顺序排列，输出原数列和<em>排序</em>后的数列。 <em>输入</em>描述 <em>输入</em>10个整数，用空格分隔。 输出描述 分为二行，第一行为原数列，第二行为<em>排序</em>结果，提示汉字与数列之间用冒号隔开。 <em>输入</em>样例 24 32 12 15 17 56 33 25 28 11 输出样例 原数列：24 32 12 15 17 56 33 25 28 11 <em>排序</em>结果：11...
- 1、从键盘输入20个整数，输出这20个数中所有仅出现一次的数。如果没有这样的数，则输出：None。请编写相应程序。
- 1、从键盘<em>输入</em><em>20</em>个整数，输出这<em>20</em>个数中所有仅出现一次的数。如果没有这样的数，则输出：None。请编写相应<em>程序</em>。n#include"stdio.h"nint main()n{nint num[<em>20</em>];nint i,j,flag=0,count=0;nfor(i=0;i&lt;<em>20</em>;i++)n{nscanf("%d",&amp;num[i]);n}nfor(i=0;i&lt;<em>20</em>;i++)n{ ...
- 10个汇编程序设计 编一个程序，实现简单的字处理程序功能---光标可以上下左右移动
- 实例1 <em>程序</em>1：编一个<em>程序</em>，实现简单的字处理<em>程序</em>功能---光标可以上下左右移动 实例2<em>程序</em>2：从键<em>盘上</em>获得若干个十进制数，求<em>他们</em>的平均值，并输出到<em>屏幕</em>上 实例3<em>程序</em>3：从键<em>盘上</em><em>输入</em>一串字符，计算每个字符出现的次数，<em>并在</em><em>屏幕</em>上<em>显示</em>这个数字
- 强连通分量及缩点tarjan算法解析
- 强连通分量： 简言之 就是找环（每条边只走一次，两两可达） 孤立的一个点也是一个连通分量 使用tarjan算法 在嵌套的多个环中优先得到最大环( 最小环就是每个孤立点） 定义： int Time, DFN[N], Low[N]; DFN[i]表示 遍历到 i 点时是第几次dfs Low[u] 表示 以u点为父节点的 子树 能连接到 [栈中] 最上端的点 int
- ssh开发案例---网上商城下载
- 主要开发一个商城购物管理,从下单订到结账是有多个模组来分别完在的 相关下载链接：[url=//download.csdn.net/download/johnsonhuang222/2504801?utm_source=bbsseo]//download.csdn.net/download/johnsonhuang222/2504801?utm_source=bbsseo[/url]
- 固定块内存池c语言实现下载
- 固定块内存池c语言实现 也可见链接:http://blog.csdn.net/xinghun_4/archive/2010/10/26/5967840.aspx 相关下载链接：[url=//download.csdn.net/download/xinghun_4/2789566?utm_source=bbsseo]//download.csdn.net/download/xinghun_4/2789566?utm_source=bbsseo[/url]
- struts2.21-spring3.0-hibernate3.6 全部jar包下载
- 最新struts2-hibernate-spring jar包，直接能运行 相关下载链接：[url=//download.csdn.net/download/lantuwzy86/2876009?utm_source=bbsseo]//download.csdn.net/download/lantuwzy86/2876009?utm_source=bbsseo[/url]
我们是很有底线的