8086 Programs

Title Addition of two 8/16-bit numbers

Program .model small .model small
.data .data
Num1 DB 80H Num1 DW 1234H
Num2 DB 70H Num2 DW 2073H
Res DB ? Res DW ?
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV AL, Num1 MOV AX, Num1
MOV BL, Num2 MOV BX, Num2
ADD AL, BL ADD AX, BX
MOV Res, AL MOV Res, AX
HLT HLT
Title Addition of two 8/16-bit numbers (Result more than 8/16-bit in size)
Program .model small .model small
.data .data
Num1 DB 0F0H Num1 DW 0F234H
Num2 DB 070H Num2 DW 01870H
Res_lb DB ? Res_lw DW ?
Res_hb DB 0 Res_hw DW 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV AL, Num1 MOV AX, Num1
MOV BL, Num2 MOV BX, Num2
ADD AL, BL ADD AX, BX
JNC DOWN JNC DOWN
INC Res_hb INC Res_hw
DOWN: DOWN:
MOV Res_lb, AL MOV Res_lw, AX
HLT HLT
 8086 Programs
Title Subtration of two 8/16-bit numbers
Program .model small .model small
.data .data
Num1 DB 80H Num1 DW 3234H
Num2 DB 70H Num2 DW 2073H
Res DB ? Res DW ?
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV AL, Num1 MOV AX, Num1
MOV BL, Num2 MOV BX, Num2
SUB AL, BL SUB AX, BX
MOV Res, AL MOV Res, AX
HLT HLT

Title Subtraction of two 8/16-bit numbers (Result more than 8/16-bit in size)
Program .model small .model small
.data .data
Num1 DB 070H Num1 DW 01870H
Num2 DB 0F0H Num2 DW 0F234H
Res_lb DB ? Res_lw DW ?
Res_hb DB 0 Res_hw DW 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV AL, Num1 MOV AX, Num1
MOV BL, Num2 MOV BX, Num2
SUB AL, BL SUB AX, BX
JNC DOWN JNC DOWN
INC Res_hb INC Res_hw
DOWN: DOWN:
MOV Res_lb, AL MOV Res_lw, AX
HLT HLT
 8086 Programs

Title Multiplication of two 8/16-bit numbers (Result is 16/32-bit max)

Program .model small .model small
.data .data
Num1 DB 080H Num1 DW 03234H
Num2 DB 070H Num2 DW 02073H
Res DW ? Res_lw DW ?
.code Res_hw DW ?
MOV AX, @data .code
MOV DS, AX MOV AX, @data
MOV AL, Num1 MOV DS, AX
MOV BL, Num2 MOV AX, Num1
MUL BL MOV BX, Num2
MOV Res, AX MUL BX
HLT MOV Res_lw, AX
MOV Res_hw, DX
HLT
Title Multiplication of two signed 8/16-bit numbers, both negative. (Result is 16/32-bit max)
Program .model small .model small
.data .data
Num1 DB -080H Num1 DW -03234H
Num2 DB -070H Num2 DW -02073H
Res DW ? Res_lw DW ?
.code Res_hw DW ?
MOV AX, @data .code
MOV DS, AX MOV AX, @data
MOV AL, Num1 MOV DS, AX
MOV BL, Num2 MOV AX, Num1
IMUL BL MOV BX, Num2
MOV Res, AX IMUL BX
HLT MOV Res_lw, AX
MOV Res_hw, DX
HLT
 8086 Programs
Title Multiplication of two signed 8/16-bit numbers, one negative. (Result is 16/32-bit max)
Program .model small .model small
.data .data
Num1 DB -080H Num1 DW -03234H
Num2 DB 070H Num2 DW 02073H
Res DW ? Res_lw DW ?
.code Res_hw DW ?
MOV AX, @data .code
MOV DS, AX MOV AX, @data
MOV AL, Num1 MOV DS, AX
MOV BL, Num2 MOV AX, Num1
IMUL BL MOV BX, Num2
MOV Res, AX IMUL BX
HLT MOV Res_lw, AX
MOV Res_hw, DX
HLT
Title Division of word by byte/Division of double word by word.
Program .model small .model small
.data .data
dividend DW 000A2H dividend_lw DW 0FF1AH
divisor DB 070H dividend_hw DW 00023H
Quo DB ? divisor DW 02073H
Rem DB ? Quo DW ?
.code Rem DW ?
MOV AX, @data .code
MOV DS, AX MOV AX, @data
MOV AX, dividend MOV DS, AX
DIV divisor MOV AX, dividend_lw
MOV Quo, AL MOV DX, dividend_hw
MOV Rem, AH DIV divisor
HLT MOV Quo, AX
MOV Rem, DX
HLT
 8086 Programs
Title Signed Division of word by byte/double word by word
Program .model small .model small
.data .data
dividend DW -000A2H dividend_lw DW 0FF1AH
divisor DB 070H dividend_hw DW 00023H
Quo DB ? divisor DW -02073H
Rem DB ? Quo DW ?
.code Rem DW ?
MOV AX, @data .code
MOV DS, AX MOV AX, @data
MOV AX, dividend MOV DS, AX
IDIV divisor MOV AX, dividend_lw
MOV Quo, AL MOV DX, dividend_hw
MOV Rem, AH IDIV divisor
HLT MOV Quo, AX
MOV Rem, DX
HLT
 8086 Programs
Title ALP to add two 8\16-bit numbers

Program .model small .model small

.data .data
Num1 DB 80H Num1 DW 1234H
Num2 DB 70H Num2 DW 2073H
Res DB ? Res DW ?
ADDITION MACRO x,y,sum ADDITION MACRO x,y,sum
MOV AL, x MOV AX, x
MOV BL, y MOV BX, y
ADD AL, BL ADD AX, BX
MOV sum, AL MOV sum, AX
ENDM ENDM
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
ADDITION Num1, Num2, Res ADDITION Num1, Num2, Res
HLT HLT

Title ALP to find smallest number from the array of 8/16 bit numbers.

Program .model small .model small

.data .data
array DB 005H, 015H, 011H,023H,004H,023H,002H,035H,057H,008H array DW 00115H, 02115H, 01021H,00023H,00104H
Smallest DB 0 Smallest DW 0
CHECK MACRO x,y CHECK MACRO x,y
MOV SI, offset x MOV SI, offset x
MOV AL, [SI] MOV AX, [SI]
MOV CL,10 MOV CL,5
DEC CL DEC CL
COMPARE:INC SI COMPARE:INC SI
CMP AL, [SI] INC SI
JC DOWN CMP AX, [SI]
MOV AL, [SI] JC DOWN
DOWN:LOOP COMPARE MOV AX, [SI]
MOV y, AL DOWN:LOOP COMPARE
ENDM MOV y, AX
.code ENDM
MOV AX, @data .code
MOV DS, AX MOV AX, @data
CHECK array, Smallest MOV DS, AX
HLT CHECK array, Smallest
HLT
 8086 Programs
Title ALP to find largest number from the array of 8/16 bit numbers.

Program .model small .model small

.data .data
array DB 005H, 015H, 011H,023H,004H,023H,002H,035H,057H,008H array DW 00115H, 02115H, 01021H,00023H,00104H
Largest DB 0 Largest DW 0
CHECK MACRO x,y CHECK MACRO x,y
MOV SI, offset x MOV SI, offset x
MOV AL, [SI] MOV AX, [SI]
MOV CL,10 MOV CL,5
DEC CL DEC CL
COMPARE:INC SI COMPARE:INC SI
CMP AL, [SI] INC SI
JNC DOWN CMP AX, [SI]
MOV AL, [SI] JNC DOWN
DOWN:LOOP COMPARE MOV AX, [SI]
MOV y, AL DOWN:LOOP COMPARE
ENDM MOV y, AX
.code ENDM
MOV AX, @data .code
MOV DS, AX MOV AX, @data
CHECK array, Largest MOV DS, AX
HLT CHECK array, Largest
HLT
Title ALP to concatenate two strings
.model small INC SI
.data INC DI
str_s DB 'RAJENDRA$' JMP UP2
str_d DB 'SONI$' EXIT1: MOV AL,'$'
msg1 DB 'After concatenation: $' MOV [SI], AL
CONCATE MACRO x,y,z MOV AH, 09H
MOV SI, offset x LEA DX, z
UP1: MOV AL, [SI] INT 21H
CMP AL, '$' MOV AH, 09H
JE EXIT LEA DX, x
INC SI INT 21H
JMP UP1 MOV AH, 4CH
EXIT: MOV DI, offset y INT 21H
UP2: MOV AL, [DI] ENDM
CMP AL, '$' .code
JE EXIT1 MOV AX, @data
MOV [SI], AL MOV DS, AX
CONCATE str_s, str_d, msg1
HLT
 8086 Programs
Title ALP to perform (A+B)*(C+D) ALP to perform x2+y2

Program .model small . .model small

.data .data
A DB 08H X DB 05H
B DB 07H Y DB 06H
C DB 05H sq_X DW ?
D DB 04H sq_Y DW ?
sum1 DB ? res DB ?
res DW ? MULTI MACRO a
ADDITION MACRO x,y MOV AL, a
MOV AL, x MUL a
MOV BL, y ENDM
ADD AL, BL .code
ENDM MOV AX, @data
.code MOV DS, AX
MOV AX, @data MULTI X
MOV DS, AX MOV sq_X, AX
ADDITION A, B MULTI Y
MOV sum1, AL ADD AX, sq_X
ADDITION C, D HLT
MUL sum1
MOV res, AX
HLT
Title ALP to find factorial of a number. ALP to display string on screen.

Program .model small .model small

.data .data
num DW 8 Msg DB 'Hello Everyone$'
fact_lsw DW 0 DISPLAY MACRO x
fact_msw DW 0 MOV AH, 09H
Fact MACRO a, b, c
MOV AX, a
LEA DX, x
MOV BX, AX INT 21H
DEC BX ENDM
UP: MUL BX .code
MOV b, AX MOV AX, @data
MOV c, DX MOV DS, AX
DEC BX DISPLAY Msg
CMP BX,0 HLT
JNZ UP
ENDM
.code
MOV AX, @data
MOV DS, AX
Fact num, fact_lsw, fact_msw
HLT
 8086 Programs
Title ALP to find sum of series of 8/16-bit numbers.

Program .model small .model small

.data .data
array DB 012H, 005H, 023H, 034H, 025H array DW 00212H, 00125H, 03023H, 004534H, 01225H
Res_lb DB 0 Res_lw DW 0
Res_hb DB 0 Res_hb DB 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset array MOV SI, offset array
MOV CL,05 MOV CL,05
MOV AL,0 MOV AX,0
UP: ADD AL, [SI] UP: ADD AX, [SI]
JNC DOWN JNC DOWN
INC Res_hb INC Res_hb
DOWN:INC SI DOWN:INC SI
LOOP UP INC SI
MOV Res_lb, AL LOOP UP
HLT MOV Res_lw, AX
HLT
Title ALP to arrange numbers in array of 8/16-bit numbers in descending order.

Program .model small .model small

.data .data
array DB 005H,013H,004H,023H,010H array DW 00235H,01213H,00044H,02033H,01010H
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV BX,5 MOV BX,5
UP1:MOV SI, offset array UP1:MOV SI, offset array
MOV CX,4 MOV CX,4
UP2:MOV AL,[SI] UP2:MOV AX,[SI]
CMP AL,[SI+1] CMP AX,[SI+2]
JNC DOWN JNC DOWN
XCHG AL,[SI+1] XCHG AX,[SI+2]
XCHG AL,[SI] XCHG AX,[SI]
DOWN:INC SI DOWN:INC SI
LOOP UP2 INC SI
DEC BX LOOP UP2
JNZ UP1 DEC BX
HLT JNZ UP1
HLT
 8086 Programs
Title ALP to arrange numbers in array of 8/16-bit numbers in ascending order.

Program .model small .model small

.data .data
array DB 005H,013H,004H,023H,010H array DW 00235H,01213H,00044H,02033H,01010H
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV BX,5 MOV BX,5
UP1:MOV SI, offset array UP1:MOV SI, offset array
MOV CX,4 MOV CX,4
UP2:MOV AL,[SI] UP2:MOV AX,[SI]
CMP AL,[SI+1] CMP AX,[SI+2]
JC DOWN JC DOWN
XCHG AL,[SI+1] XCHG AX,[SI+2]
XCHG AL,[SI] XCHG AX,[SI]
DOWN:INC SI DOWN:INC SI
LOOP UP2 INC SI
DEC BX LOOP UP2
JNZ UP1 DEC BX
HLT JNZ UP1
HLT
Title ALP to find smallest number from the array of 8/16 bit numbers.

Program .model small .model small

.data .data
array DB 005H, 015H, 011H,023H,004H,023H,002H,035H,057H,008H array DW 00115H, 02115H, 01021H,00023H,00104H
Smallest DB 0 Smallest DW 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset array MOV SI, offset array
MOV AL, [SI] MOV AX, [SI]
MOV CL,10 MOV CL,5
DEC CL DEC CL
COMPARE:INC SI COMPARE:INC SI
CMP AL, [SI] INC SI
JC DOWN CMP AX, [SI]
MOV AL, [SI] JC DOWN
DOWN:LOOP COMPARE MOV AX, [SI]
MOV Smallest, AL DOWN:LOOP COMPARE
HLT MOV Smallest, AX
HLT
 8086 Programs
Title ALP to find largest number from the array of 8/16 bit numbers.

Program .model small .model small

.data .data
array DB 005H, 015H, 011H,023H,004H,023H,002H,035H,057H,008H array DW 00115H, 02115H. 01021H,00023H,00104H
Largest DB 0 Largest DW 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset array MOV SI, offset array
MOV AL, [SI] MOV AX, [SI]
MOV CL,10 MOV CL,4
DEC CL DEC CL
COMPARE:INC SI COMPARE:INC SI
CMP AL, [SI] INC SI
JNC DOWN CMP AX, [SI]
MOV AL, [SI] JNC DOWN
DOWN:LOOP COMPARE MOV AX, [SI]
MOV Largest, AL DOWN:LOOP COMPARE
HLT MOV Largest, AX
HLT
Title ALP to perform block transfer of 8/16-bit data without using string instruction.

Program .model small .model small

.data .data
src_array DB 015H, 021H. 010H,023H,014H src_array DW 00015H, 00021H. 00010H,00023H,00014H
des_array DB 5DUP(0) des_array DW 5DUP(0)
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset src_array MOV SI, offset src_array
MOV DI, offset des_array MOV DI, offset des_array
MOV CL,5 MOV CX,5
TRANSFER: MOV AL, [SI] TRANSFER: MOV AX, [SI]
MOV [DI], AL MOV [DI], AX
INC SI ADD SI, 2
INC DI ADD DI, 2
LOOP TRANSFER LOOP TRANSFER
HLT HLT
 8086 Programs
Title ALP to perform block transfer of 8/16 bit data using string instruction.

Program .model small .model small

.data .data
src_array DB 015H, 021H. 010H,023H,014H src_array DW 00015H, 00021H. 00010H,00023H,00014H
des_array DB 5DUP(0) des_array DW 5DUP(0)
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset src_array MOV SI, offset src_array
MOV DI, offset des_array MOV DI, offset des_array
MOV CL,5 MOV CX,5
TRANSFER: MOVSB TRANSFER: MOVSW
LOOP TRANSFER LOOP TRANSFER
HLT HLT
Title ALP to check if number is odd or even. (8/16-bit)

Program .model small .model small

.data .data
Number DB 022H Number DW 00224H
msg1 DB 'The number is odd$' msg1 DB 'The number is odd$'
msg2 DB 'The number is even$' msg2 DB 'The number is even$'
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV AL, Number MOV AX, Number
ROR AL,1 ROR AX,1
JNC EXIT1 JNC EXIT1
MOV AH,09H MOV AH,09H
LEA DX, msg1 LEA DX, msg1
INT 21H INT 21H
JMP EXIT2 JMP EXIT2
EXIT1: MOV AH,09H EXIT1: MOV AH,09H
LEA DX, msg2 LEA DX, msg2
INT 21H INT 21H
EXIT2:MOV AH, 4CH EXIT2:MOV AH, 4CH
INT 21H INT 21H
HLT HLT
 8086 Programs
Title ALP to count odd numbers in an array of 8/16-bit numbers.

Program .model small .model small

.data .data
array DB 001H, 004H,015H,023H,024H,037H,022H,008H,009H,012H array DW 00101H, 00234H,01165H,01223H,02423H
odd_count DB 0 odd_count DB 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset array MOV SI, offset array
MOV CX,10 MOV CX,5
CHECK:MOV AL, [SI] CHECK:MOV AX, [SI]
ROR AL, 1 ROR AL, 1
JNC DOWN JNC DOWN
INC odd_count INC odd_count
DOWN: INC SI DOWN: INC SI
LOOP CHECK INC SI
MOV AL, odd_count LOOP CHECK
HLT MOV AL, odd_count
HLT
Title ALP to count even numbers in an array of 8/16-bit numbers.

Program .model small .model small

.data .data
array DB 002H, 004H,015H,023H,024H,037H,022H,008H,009H,012H array DW 00101H, 00234H,01165H,01223H,02423H
even_count DB 0 odd_count DB 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset array MOV SI, offset array
MOV CX,10 MOV CX,5
CHECK:MOV AL, [SI] CHECK:MOV AX, [SI]
ROR AL, 1 ROR AL, 1
JC DOWN JC DOWN
INC even_count INC odd_count
DOWN: INC SI DOWN: INC SI
LOOP CHECK INC SI
MOV AL, even_count LOOP CHECK
HLT MOV AL, odd_count
HLT
 8086 Programs
Title ALP to find sum of odd numbers in an array of 8/16-bit numbers.

Program . .model small .model small

.data .data
array DB 001H, 004H,015H,023H,024H,037H,022H,008H,009H,012H array DW 00211H, 00104H,01215H,02123H,03524H
sum DB 0 sum_lw DW 0
.code sum_hb DB 0
MOV AX, @data .code
MOV DS, AX MOV AX, @data
MOV SI, offset array MOV DS, AX
MOV CX,10 MOV SI, offset array
CHECK:MOV AL, [SI] MOV CX,5
ROR AL, 1 CHECK:MOV AX, [SI]
JNC DOWN ROR AX, 1
ROL AL,1 JNC DOWN
ADD sum, AL ROL AX,1
DOWN: INC SI ADD sum_lw, AX
LOOP CHECK JNC DOWN
MOV AL,sum INC sum_hb
HLT DOWN: ADD SI,2
LOOP CHECK
MOV AX, sum_lw
MOV BH, sum_hb
HLT
Title ALP to find sum of even numbers in an array of 8/16-bit numbers.

Program model small .model small

.data .data
array DB 001H, 004H,015H,023H,024H,037H,022H,008H,009H,012H array DW 00211H, 00104H,01215H,02123H,03524H
sum DB 0 sum_lw DW 0
.code sum_hb DB 0
MOV AX, @data .code
MOV DS, AX MOV AX, @data
MOV SI, offset array MOV DS, AX
MOV CX,10 MOV SI, offset array
CHECK:MOV AL, [SI] MOV CX,5
ROR AL, 1 CHECK:MOV AX, [SI]
JC DOWN ROR AX, 1
ROL AL,1 JC DOWN
ADD sum, AL ROL AX,1
DOWN: INC SI ADD sum_lw, AX
LOOP CHECK JNC DOWN
MOV AL, sum INC sum_hb
HLT DOWN: ADD SI,2
LOOP CHECK
MOV AX, sum_lw
MOV BH, sum_hb
HLT
 8086 Programs
Title ALP to count no of 1s in a 8/16-bit number.

Program .model small .model small

.data .data
number DB 023H number DW 02FF3H
count DB 0 count DB 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV CX,8 MOV CX,16
MOV AL, number MOV AX, number
ROTATE: ROR AL, 1 ROTATE: ROR AX, 1
JNC DOWN JNC DOWN
INC count INC count
DOWN: LOOP ROTATE DOWN: LOOP ROTATE
MOV AL, count MOV BL, count
HLT HLT
Title ALP to count no of 0s in a 8/16-bit number.

Program .model small .model small

.data .data
number DB 023H number DW 02DF3H
count DB 0 count DB 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV CX,8 MOV CX,16
MOV AL, number MOV AX, number
ROTATE: ROR AL, 1 ROTATE: ROR AX, 1
JC DOWN JC DOWN
INC count INC count
DOWN: LOOP ROTATE DOWN: LOOP ROTATE
MOV AL, count MOV BL, count
HLT HLT
 8086 Programs
Title ALP to check if no is positive or negative. (8/16-bit number)

Program .model small .model small .model small

.data .data .data
number DB 089H number DB 01239H number DW -39H
msg1 DB "The number is negative$" msg1 DB "The number is negative$" msg1 DB "The number is negative$"
msg2 DB "The number is positive$" msg2 DB "The number is positive$" msg2 DB "The number is positive$"
.code .code .code
MOV AX, @data MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX MOV DS, AX
MOV AL, number MOV AX, number MOV AX, number
ROL AL, 1 ROL AX, 1 ROL AX, 1
JNC DOWN JNC DOWN JNC DOWN
MOV AH, 09H MOV AH, 09H MOV AH, 09H
LEA DX, msg1 LEA DX, msg1 LEA DX, msg1
INT 21H INT 21H INT 21H
JMP EXIT JMP EXIT JMP EXIT
DOWN: MOV AH, 09H DOWN: MOV AH, 09H DOWN: MOV AH, 09H
LEA DX, msg2 LEA DX, msg2 LEA DX, msg2
INT 21H INT 21H INT 21H
EXIT: EXIT: EXIT:
HLT HLT
Title ALP to count negative numbers in an array. (8/16-bit number)

Program .model small .model small

.data .data
array DB -019H, 023H,-05H,-12H,025H array DW -01293H, 02431H,-0105H,-0F12H,02B25H
negative_count DB 0 negative_count DB 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset array MOV SI, offset array
MOV CX,5 MOV CX,5
CHECK: MOV AL, [SI] CHECK: MOV AX, [SI]
ROL AL, 1 ROL AX, 1
JNC DOWN JNC DOWN
INC negative_count INC negative_count
DOWN: INC SI DOWN: INC SI
LOOP CHECK LOOP CHECK
MOV BL, negative_count MOV BL, negative_count
HLT HLT
 8086 Programs
Title ALP to count positive numbers in an array. (8/16-bit number)

Program .model small .model small

.data .data
array DB -019H, 023H,-05H,-12H,025H array DW -01293H, 02431H,-0105H,-0F12H,02B25H
positive_count DB 0 positive_count DB 0
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset array MOV SI, offset array
MOV CX,5 MOV CX,5
CHECK: MOV AL, [SI] CHECK: MOV AX, [SI]
ROL AL, 1 ROL AX, 1
JC DOWN JC DOWN
INC positive_count INC positive_count
DOWN: INC SI DOWN: INC SI
LOOP CHECK LOOP CHECK
MOV BL, positive_count MOV BL, positive_count
HLT HLT
 8086 Programs
Title ALP to compare two strings by ALP to compare two strings by
calculating length of the string. calculating length of the string
and also checking the case.
Program .model small .model small
.data .data
str_s DB 'COMPUTER$' str_s DB 'COMPUTER$'
str_d DB 'computer$' str_d DB 'computer$'
count_s DB 0 count_s DB 0
count_d DB 0 count_d DB 0
msg1 DB 'Strings are same$' msg1 DB 'Strings are same$'
msg2 DB 'Strings are not same$' msg2 DB 'Strings are not same$'
.code .code
MOV AX, @data MOV AX, @data
MOV DS, AX MOV DS, AX
MOV SI, offset str_s MOV SI, offset str_s
LENGTH1: LENGTH1:
CMP [SI], '$' CMP [SI], '$'
JE EXIT1 JE EXIT1
INC count_s INC count_s
INC SI INC SI
JMP LENGTH1 JMP LENGTH1
EXIT1: MOV SI, offset str_d EXIT1: MOV SI, offset str_d
LENGTH2: MOV AL, [SI] LENGTH2: MOV AL, [SI]
CMP AL, "$" CMP AL, "$"
JE EXIT2 JE EXIT2
INC count_d INC count_d
INC SI INC SI
JMP LENGTH2 JMP LENGTH2
EXIT2: MOV AL, count_s EXIT2: MOV AL, count_s
CMP AL, count_d CMP AL, count_d
JNE EXIT3 JNE EXIT3
MOV AH, 09H MOV SI, offset str_s
LEA DX, msg1 MOV DI, offset str_d
INT 21H COMPARE:MOV AL,[SI]
JMP EXIT4 CMP AL,[DI]
EXIT3: MOV AH,09H JNE EXIT3
LEA DX, msg2 INC SI
INT 21H INc DI
EXIT4: DEC count_s
MOV AH, 4CH JNZ COMPARE
INT 21H MOV AH,09H
HLT LEA DX, msg1
INT 21H
JMP EXIT4
EXIT3: MOV AH,09H
LEA DX, msg2
INT 21H
EXIT4:
MOV AH, 4CH
INT 21H
HLT
 8086 Programs
Title ALP to compare two strings by calculating length of the string and
also checking the case. (Using string instruction)
Program .model small
.data
str_s DB 'COMPUTER$'
str_d DB 'COMPUTER$'
count_s DB 0
count_d DB 0
msg1 DB 'Strings are same$'
msg2 DB 'Strings are not same$'
.code
MOV AX, @data
MOV DS, AX
MOV ES, AX
MOV SI, offset str_s
LENGTH1:
CMP [SI], '$'
JE EXIT1
INC count_s
INC SI
JMP LENGTH1
EXIT1: MOV SI, offset str_d
LENGTH2: MOV AL, [SI]
CMP AL, "$"
JE EXIT2
INC count_d
INC SI
JMP LENGTH2
EXIT2: MOV AL, count_s
CMP AL, count_d
JNE EXIT3
MOV SI, offset str_s
MOV DI, offset str_d
COMPARE:MOV AL,[SI]
CMP AL,[DI]
JNE EXIT3
CLD
MOV CH, 0
MOV CL, count_s
MOV SI, offset str_s
MOV DI, offset str_d
COMPARE2: CMPSB
JNZ EXIT3
LOOP COMPARE2
MOV AH,09H
LEA DX, msg1
INT 21H
JMP EXIT4
EXIT3: MOV AH,09H
LEA DX, msg2
INT 21H
EXIT4:
MOV AH, 4CH
INT 21H
HLT
 8086 Programs
Title ALP to reverse a string. ALP to convert lower case to
upper case
Program .model small .model small
.data .data
str str_l DB 'rajendra$'
str_u DB 20DUP('$')
.code
MOV AX, @data
count DB 0 MOV DS, AX
.code MOV SI, offset str_l
MOV AX, @data MOV DI, offset str_u
MOV DS, AX UP: MOV AL, [SI]
MOV SI, offset str_s CMP AL, '$'
CHECK: MOV AL, [SI] JE EXIT
SUB AL, 20H
JE EXIT MOV [DI], AL
INC SI INC SI
INC count INC DI
JMP CHECK JMP UP
EXIT: MOV DI, offset str_d EXIT:
UP: DEC SI MOV AH, 09H
MOV AL, [SI] LEA DX, str_u
MOV [DI], AL INT 21H
INC DI HLT
DEC count ALP to convert lower case to
JNZ UP
MOV AH, 09H upper case
LEA DX, msg1
INT 21H .model small
MOV AH, 09H .data
LEA DX, str_s str_l DB 'RAJENDRA$'
INT 21H str_u DB 20DUP('$')
MOV AH, 09H .code
LEA DX, msg2 MOV AX, @data
INT 21H MOV DS, AX
MOV AH, 09H MOV SI, offset str_l
LEA DX, str_d MOV DI, offset str_u
INT 21H UP: MOV AL, [SI]
MOV AH, 4CH CMP AL, '$'
INT 21H JE EXIT
HLT ADD AL, 20H
MOV [DI], AL
INC SI
INC DI
JMP UP
EXIT:
MOV AH, 09H
LEA DX, str_u
INT 21H
HLT
 8086 Programs

Title ALP to concatenate two strings

Program .model small
.data
str_s DB 'RAJENDRA$'
str_d DB 'SONI$'
msg1 DB 'After concatenation: $'
.code
MOV AX, @data
MOV DS, AX
MOV SI, offset str_s
UP1: MOV AL, [SI]
CMP AL, '$'
JE EXIT
INC SI
JMP UP1
EXIT: MOV DI, offset str_d
UP2: MOV AL, [DI]
CMP AL, '$'
JE EXIT1
MOV [SI], AL
INC SI
INC DI
JMP UP2
EXIT1: MOV AL,'$'
MOV [SI], AL
MOV AH, 09H
LEA DX, msg1
INT 21H
MOV AH, 09H
LEA DX, str_s
INT 21H
MOV AH, 4CH
INT 21H
HLT