[ADDITION]
DATA SEGMENT
NO1 DB 99H
NO2 DB 88H
RES DB ?
CAY DB ?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AL, NO1
ADD AL, NO2
MOV RES, AL
MOV AL, 00H
MOV CAY, AL
INT 3
CODE ENDS
END START
Output:
[SUBTRACTION]
ORG 0000H
CODE SEGMENT
MOV DX,02H
MOV AX,08H
SUB AX,DX
HLT
Output:
[MULTIPLICATION SIGNED]
DATA SEGMENT
NO1 DB 02H
NO2 DB 03H
ANS DB ?
DATA ENDS
CODE SEGMENT
START:
ASSUME CS:CODE, DS:DATA
MOV AX,DATA
MOV DS,AX
MOV AL,NO1
MOV BL,NO2
MUL BL
MOV ANS,AL
MOV AH,4CH
INT 21H
CODE ENDS
END START
Output:
[MULTIPLICATION UNSIGNED]
DATA SEGMENT
NO1 DB 02H
NO2 DB 03H
ANS DB ?
DATA ENDS
CODE SEGMENT
START:
ASSUME CS:CODE, DS:DATA
MOV AX,DATA
MOV DS,AX
MOV AL,NO1
MOV BL,NO2
IMUL BL
MOV ANS,AL
MOV AH,4CH
INT 21H
CODE ENDS
END START
Output:
[DIVISON SIGNED]
DATA SEGMENT
NO1 DD 0006H
NO2 DW 03H
Q DW ?
R DW ?
DATA ENDS
CODE SEGMENT
START:
ASSUME CS:CODE, DS:DATA
MOV AX,DATA
MOV DS,AX
LEA SI, NO1
MOV AX,[SI]
MOV DX,[SI+2]
DIV NO2
MOV Q,AX
MOV R,DX
MOV AH,4CH
INT 21H
CODE ENDS
END START
Output:
[DIVISION UNSIGNED]
DATA SEGMENT
NO1 DD 0006H
NO2 DW 03H
Q DW ?
R DW ?
DATA ENDS
CODE SEGMENT
START:
ASSUME CS:CODE, DS:DATA
MOV AX,DATA
MOV DS,AX
LEA SI, NO1
MOV AX,[SI]
MOV DX,[SI+2]
IDIV NO2
MOV Q,AX
MOV R,DX
MOV AH,4CH
INT 21H
CODE ENDS
END START
ret
Output:
[ADD,SUB.MUTLIPY,DIVIDE TWO BCD NUMBER]
DATA SEGMENT
NO1 DB 29H
NO2 DB 35H
RES DB ?
DATA ENDS
CODE SEGMENT
START:
ASSUME CS:CODE, DS:DATA
MOV AX,DATA
MOV DS,AX
MOV AL, NO1
ADD AL, NO2
DAA
MOV RES,AL
INT 3H
CODE ENDS
END START
Output:
[BLOCK TRANSFER OPERATIONS]
DATA SEGMENT
ARRAY1 DB 10 DUP(?)
ARRAY2 DB 10 DUP(?)
DATA ENDS
CODE SEGMENT
START:
ASSUME CS:CODE, DS:DATA
MOV AX,DATA
MOV DS,AX
LEA SI, ARRAY1
LEA BX, ARRAY2
MOV CL,0AH
UP:
MOV AL,[SI]
MOV [BX],AL
INC SI
INC BX
DEC CL
JNZ UP
INT 3H
CODE ENDS
END START
Output:-
[SUM OF SERIES]
CODE SEGMENT
MOV CL,05
MOV SI,1000
MOV AX,0000
NEXT:
ADD AX,[SI]
INC SI
INC SI
DEC CL
JNZ NEXT
MOV [SI],AX
HLT
Output:
[LARGEST NUMBER]
data segment
STRING1 DB 08h,14h,05h,0Fh,09h
res db ?
data ends
code segment
assume cs:code, ds:data
start: mov ax, data
mov ds, ax
mov cx, 04h
mov bl, 00h
LEA SI, STRING1
up: mov al, [SI]
cmp al, bl
jl nxt
mov bl, al
nxt:
inc si
dec cx
jnz up
mov res,bl
int 3
code ends
end start
output:
[SMALLEST NUMBER]
data segment
STRING1 DB 08h,14h,05h,0Fh,09h
res db ?
data ends
code segment
assume cs:code, ds:data
start: mov ax, data
mov ds, ax
mov cx, 04h
mov bl, 79h
LEA SI, STRING1
up:
mov al, [SI]
cmp al, bl
jge nxt
mov bl, al
nxt:
inc si
dec cx
jnz up
mov res,bl
int 3
code ends
end start
OUTPUT:
[STRING REVERSE AND STRING COPY]
.MODEL SMALL
.STACK 100H
.DATA
STR_S DB 'COMPUTER DEPARTMENT$'
STR_D DB 50 DUP('$')
MSG1 DB 10,13, 'THE SOURCE STRING: $',10,13
MSG2 DB 10,13, 'THE STRING AFTER REVERSE: $',10,13
COUNT DB 0
.CODE
MOV AX, @DATA
MOV DS, AX
MOV SI, OFFSET STR_S
NEXT:
MOV AL, [SI]
CMP AL, '$'
JE EXIT
INC SI
INC COUNT
JMP NEXT
EXIT:
MOV DI, OFFSET STR_D
UP:
DEC SI
MOV AL, [SI]
MOV [DI], AL
INC DI
DEC COUNT
JNZ UP
MOV AH, 09H
LEA DX, MSG1
INT 21H
MOV AH, 09H
LEA DX, STR_S
INT 21H
MOV AH, 09
LEA DX, MSG2
INT 21H
MOV AH, 09H
LEA DX, STR_D
INT 21H
MOV AH, 4CH
INT 21H
ENDS
END
OUTPUT:
[STRING REVERSE AND STRING COPY]
.MODEL SMALL
.STACK 100H
.DATA
SOURCE DB 'MICROPROCESSOR$'
DEST DB 20 DUP (0)
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
MOV ES, AX
LEA SI, SOURCE
LEA DI,DEST
COPY_LOOP:
MOV AL, [SI]
MOV [DI], AL
INC SI
INC DI
CMP AL, '$'
JNE COPY_LOOP
LEA DX, DEST
MOV AH, 09H
INT 21H
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
OUTPUT:
[COMPARE TWO STRINGS]
.MODEL SMALL
.STACK 100H
.DATA
str1 DB 'Hello', 0
str2 DB 'Hello', 0
equal_msg DB 'Strings are equal!', '$'
not_equal_msg DB 'Strings are not equal!', '$'
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
MOV ES, AX
LEA SI, str1
LEA DI, str2
CLD
COMPARE_LOOP:
CMPSB
JNE NOT_EQUAL
CMP BYTE PTR [SI-1], 0
JNE COMPARE_LOOP
LEA DX, equal_msg
MOV AH, 09H
INT 21H
JMP EXIT
NOT_EQUAL:
LEA DX, not_equal_msg
MOV AH, 09H
INT 21H
EXIT:
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
OUTPUT:
[FIND THE LENGTH]
.MODEL SMALL .STACK 100H
.DATA
STR_S DB 'AVENGERS$'
LEN DB 0
.CODE
MOV AX, @DATA
MOV DS, AX
MOV SI, OFFSET STR_S
NEXT:
MOV AL, [SI]
CMP AL, '$'
JE EXIT
INC SI
INC LEN
JMP NEXT
EXIT:
ENDS
END
OUTPUT:
[CONCATENATE TWO STRINGS]
.MODEL SMALL
.STACK 100H
.DATA
STR_S DB 'MICROPROCESSOR$'
STR_D DB 'PROGRAMMING$'
MSG1 DB 'AFTER CONCATENATION: $'
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
MOV AH, 09H
LEA DX, MSG1
INT 21H
MOV SI, OFFSET STR_S
NEXT:
MOV AL, [SI]
CMP AL, '$'
JE EXIT
INC SI
JMP NEXT
EXIT:
DEC SI
MOV DI, OFFSET STR_D
UP:
MOV AL, [DI]
CMP AL, '$'
JE EXIT1
MOV [SI], AL
INC SI
INC DI
JMP UP
EXIT1:
MOV AL, '$'
MOV [SI], AL
MOV AH, 09H
LEA DX, STR_S
INT 21H
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
Output:
[ASCENDING ORDER]
ORG 100H
MOV [3000H],25H
MOV [3001H],15H
MOV [3002H],45H
MOV [3003H],35H
MOV [3004H],55H
MOV SI,3000H
MOV DX,3001H
MOV CH,04H
BACK1:
MOV CL,CH
MOV DI,DX
BACK:
MOV AL,[SI]
MOV BL,[DI]
CMP AL,BL
JC NEXT
MOV [SI],BL
MOV [DI],AL
NEXT:
INC DI
DEC CL
JNZ BACK
INC SI
INC DX
DEC CH
JNZ BACK1
RET
[DESCENDING ORDER]
MOV AX, 2000H
MOV DS, AX
MOV CL, 05H
DEC CL
Z:
MOV SI, 0200H
MOV DL, CL
Y:
MOV AL, [SI]
INC SI
MOV BL, [SI]
CMP AL, BL
JGE X
MOV [SI], AL
DEC SI
MOV [SI], BL
INC SI
X:
DEC DL
JNZ Y
LOOP Z
HLT
[CHECK EVEN OR ODD]
DATA SEGMENT
ARRAY DB 20 DUP(?)
NODD DB 0
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
LEA SI, ARRAY
MOV CL, 14H
MOV DL, 00H
UP:
MOV AL, [SI]
ROR AL, 1
JNC DN
INC DL
DN:
INC SI
DEC CL
JNZ UP
MOV [NODD], DL
MOV AH, 4CH
INT 21H
CODE ENDS
END START
[CHECK EVEN OR ODD]
DATA SEGMENT
ARRAY DB 20 DUP(?)
NEVEN DB 0
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
LEA SI, ARRAY
MOV CL, 14H
MOV DL, 00H
UP:
MOV AL, [SI]
ROR AL, 1
JC DN
INC DL
DN:
INC SI
DEC CL
JNZ UP
MOV [NEVEN], DL
MOV AH, 4CH
INT 3
CODE ENDS
END START
