a. Store the data byte 32H into memory location 4000H.

Program 1:

MVI A, 52H : Store 32H in the accumulator

STA 4000H : Copy accumulator contents at address 4000H
HLT : Terminate program execution

Program 2:

LXI H : Load HL with 4000H

MVI M : Store 32H in memory location pointed by HL register pair
(4000H)
HLT : Terminate program execution

b. Exchange the contents of memory locations 2000H and 4000H

Program 1:

LDA 2000H : Get the contents of memory location 2000H into

accumulator
MOV B, A : Save the contents into B register
LDA 4000H : Get the contents of memory location 4000Hinto
accumulator
STA 2000H : Store the contents of accumulator at address 2000H
MOV A, B : Get the saved contents back into A register
STA 4000H : Store the contents of accumulator at address 4000H
The result of both programs will be the same. In program 1 direct addressing
instruction is used, whereas in program 2 indirect addressing instruction is
used.

Program 2:
LXI H 2000H : Initialize HL register pair as a pointer to memory
location 2000H.
LXI D 4000H : Initialize DE register pair as a pointer to memory
location 4000H.
MOV B, M : Get the contents of memory location 2000H into B
register.
LDAX D : Get the contents of memory location 4000H into A
register.
MOV M, A : Store the contents of A register into memory location
2000H.
MOV A, B : Copy the contents of B register into accumulator.
STAX D : Store the contents of A register into memory location
4000H.

1
 HLT : Terminate program execution.

In Program 1, direct addressing instructions are used, whereas in Program 2,

indirect addressing instructions are used.

c. One’s compliment of a number

(4400H) = 55H
Result = (4300B) = AAB
Source program:

LDA 4400B : Get the number

CMA : Complement number
STA 4300H : Store the result
HLT : Terminate program execution
d. Write a program to shift an eight bit data four bits right. Assume
that data is in register C.
MOV A, C
RAR
RAR
RAR
RAR
MOV C, A
HLT
e. Write a set of instructions to alter the contents of flag register in
8085
PUSH PSW : Save flags on stack
POP H : Retrieve flags in 'L'
MOV A, L : Flags in accumulator
CMA : Complement accumulator
MOV L, A : Accumulator in 'L'
PUSH H : Save on stack
POP PSW : Back to flag register
HLT :Terminate program execution

f. Calculate the sum of series of numbers. The length of the series is

in memory location 4200H and the series begins from memory
location 4201H.
a. Consider the sum to be 8 bit number. So, ignore carries. Store the sum at
memory location 4300H.
b. Consider the sum to be 16 bit number. Store the sum at memory locations
4300H and 4301H.

2
Sample problem 1

4200H = 04H
4201H = 10H
4202H = 45H
4203H = 33H
4204H = 22H
Result = 10 +41 + 30 + 12 = H
4300H = H

Source program:

LDA 4200H
MOV C, A : Initialize counter
SUB A : sum = 0
LXI H, 420lH : Initialize pointer
BACK: ADD M : SUM = SUM + data
INX H : increment pointer
DCR C : Decrement counter
JNZ BACK : if counter 0 repeat
STA 4300H : Store sum
HLT : Terminate program execution

b. Sample problem 2

4200H = 04H
420lH = 9AH
4202H = 52H
4203H = 89H
4204H = 3EH
Result = 9AH + 52H + 89H + 3EH = H
4300H = B3H Lower byte
4301H = 0lH Higher byte

Source program:

LDA 4200H
MOV C, A : Initialize counter
LXI H, 4201H : Initialize pointer
SUB A :Sum low = 0
MOV B, A : Sum high = 0
BACK: ADD M : Sum = sum + data
JNC SKIP
INR B : Add carry to MSB of SUM

3
 SKIP: INX H : Increment pointer
DCR C : Decrement counter
JNZ BACK : Check if counter 0 repeat
STA 4300H : Store lower byte
MOV A, B
STA 4301H : Store higher byte
HLT :Terminate program execution

g. Multiply two 8-bit numbers stored in memory locations 2200H and

2201H by repetitive addition and store the result in memory
locations 2300H and 2301H.

Sample problem:

(2200H) = 03H
(2201H) = B2H
Result = B2H + B2H + B2H = 216H
= 216H
(2300H) = 16H
(2301H) = 02H

Source program

LDA 2200H
MOV E, A
MVI D, 00 : Get the first number in DE register pair
LDA 2201H
MOV C, A : Initialize counter
LX I H, 0000 H : Result = 0
BACK: DAD D : Result = result + first number
DCR C : Decrement count
JNZ BACK : If count 0 repeat
SHLD 2300H : Store result
HLT : Terminate program execution
h. Divide 16 bit number stored in memory locations 2200H and 2201H
by the 8 bit number stored at memory location 2202H. Store the
quotient in memory locations 2300H and 2301H and remainder in
memory locations 2302H and 2303H.
Sample problem
(2200H) = 60H
(2201H) = A0H
(2202H) = l2H

4
 Result = A060H/12H = 8E8H Quotient and 10H remainder
(2300H) = E8H
(2301H) = 08H
(2302H= 10H
(2303H) 00H

Source program

LHLD 2200H : Get the dividend

LDA 2202H : Get the divisor
MOV C, A
LXI D, 0000H : Quotient = 0
BACK: MOV A, L
SUB C : Subtract divisor
MOV L, A : Save partial result
JNC SKIP : if CY 1 jump
DCR H : Subtract borrow of previous subtraction
SKIP: INX D : Increment quotient
MOV A, H
CPI, 00 : Check if dividend < divisor
JNZ BACK : if no repeat
MOV A, L
CMP C
JNC BACK
SHLD 2302H : Store the remainder
XCHG
SHLD 2300H : Store the quotient
HLT : Terminate program execution
i. Find the number of negative elements (most significant bit 1) in a
block of data. The length of the block is in memory location 2200H
and the block itself begins in memory location 2201H. Store the
number of negative elements in memory location 2300H
Sample problem

(2200H) = 04H
(2201H) = 56H
(2202H) = A9H
(2203H) = 73H
(2204H) = 82H

Result = 02 since 2202H and 2204H contain numbers with a MSB of 1.

Source program

5
 LDA 2200H
MOV C, A : Initialize count
MVI B, 00 : Negative number = 0
LXI H, 2201H : Initialize pointer
BACK: MOV A, M : Get the number
ANI 80H : Check for MSB
JZ SKIP : If MSB = 1
INR B : Increment negative number count
SKIP: INX H : Increment pointer
DCR C : Decrement count
JNZ BACK : If count 0 repeat
MOV A, B
STA 2300H : Store the result
HLT : Terminate program execution

j. Find the largest number in a block of data. The length of the block
is in memory location 2200H and the block itself starts from
memory location 2201H.
Store the maximum number in memory location 2300H. Assume that the
numbers in the block are all 8 bit unsigned binary numbers.
Sample problem

(2200H) = 04
(2201H) = 34H
(2202H) = A9H
(2203H) = 78H
(2204H) =56H
Result = (2202H) = A9H

Source program

LDA 2200H
MOV C, A : Initialize counter
XRA A : Maximum = Minimum possible value = 0
LXI H, 2201H : Initialize pointer
BACK: CMP M : Is number> maximum
JNC SKIP : Yes, replace maximum
MOV A, M
SKIP: INX H
DCR C
JNZ BACK
STA 2300H : Store maximum number

6
 HLT : Terminate program execution

k. Write a program to count number of l's in the contents of D register

and store the count in the B register. Source program:

MVI B, 00H
MVI C, 08H
MOV A, D
BACK: RAR
JNC SKIP
INR B
SKIP: DCR C
JNZ BACK
HLT
l. Calculate the sum of series of even numbers from the list of
numbers. The length of the list is in memory location 2200H and
the series itself begins from memory location 2201H. Assume the
sum to be 8 bit number so you can ignore carries and store the sum
at memory location 2210H.
Sample problem:

2200H= 4H
2201H= 20H
2202H= l5H
2203H= l3H
2204H= 22H
Result 22l0H= 20 + 22 = 42H
= 42H

Source program:

LDA 2200H
MOV C, A : Initialize counter
MVI B, 00H : sum = 0
LXI H, 2201H : Initialize pointer
BACK: MOV A, M : Get the number
ANI 0lH : Mask Bit l to Bit7
JNZ SKIP : Don't add if number is ODD
MOV A, B : Get the sum
ADD M : SUM = SUM + data
MOV B, A : Store result in B register
SKIP: INX H : increment pointer
DCR C : Decrement counter
JNZ BACK : if counter 0 repeat

7
 STA 2210H : store sum
HLT : Terminate program execution
m. Find the square of the given numbers from memory location 6100H
and store the result from memory location 7000H.
Source Program:

LXI H, 6200H : Initialize lookup table pointer

LXI D, 6100H : Initialize source memory pointer
LXI B, 7000H : Initialize destination memory pointer
BACK: LDAX D : Get the number
MOV L, A : A point to the square
MOV A, M : Get the square
STAX B : Store the result at destination memory location
INX D : Increment source memory pointer
INX B : Increment destination memory pointer
MOV A, C
CPI 05H : Check for last number
JNZ BACK : If not repeat
HLT : Terminate program execution
n. Search the given byte in the list of 50 numbers stored in the
consecutive memory locations and store the address of memory
location in the memory locations 2200H and 2201H. Assume byte is
in the C register and starting address of the list is 2000H. If byte is
not found store 00 at 2200H and 2201H.
Source program:

LX I H, 2000H : Initialize memory pointer 52H

MVI B, 52H : Initialize counter
BACK: MOV A, M : Get the number
CMP C : Compare with the given byte
JZ LAST : Go last if match occurs
INX H : Increment memory pointer
DCR B : Decrement counter
JNZ B : I f not zero, repeat
LXI H, 0000H
SHLD 2200H
JMP END : Store 00 at 2200H and 2201H
LAST: SHLD 2200H : Store memory address
END: HLT : Stop

o. Add 2 arrays having ten 8-bit numbers each and generate a third
array of result. It is necessary to add the first element of array 1
with the first element of array-2 and so on. The starting addresses

8
 of array l, array2 and array3 are 2200H, 2300H and 2400H,
respectively. Source Program:

LXI H, 2200H : Initialize memory pointer 1

LXI B, 2300H : Initialize memory pointer 2
LXI D, 2400H : Initialize result pointer
BACK: LDAX B : Get the number from array 2
ADD M : Add it with number in array 1
STAX D : Store the addition in array 3
INX H : Increment pointer 1
INX B : Increment pointer2
INX D : Increment result pointer
MOV A, L
CPI 0AH : Check pointer 1 for last number
JNZ BACK : If not, repeat
HLT : Stop
p. Write an assembly language program to separate even numbers
from the given list of 50 numbers and store them in the another list
starting from 2300H. Assume starting address of 50 number list is
2200H.

Source Program:
LXI H, 2200H : Initialize memory pointer l
LXI D, 2300H : Initialize memory pointer2
MVI C, 32H : Initialize counter
BACK:MOV A, M : Get the number
ANI 0lH : Check for even number
JNZ SKIP : If ODD, don't store
MOV A, M : Get the number
STAX D : Store the number in result list
INX D : Increment pointer 2
SKIP: INX H : Increment pointer l
DCR C : Decrement counter
JNZ BACK : If not zero, repeat
HLT : Stop

q. A list of 50 numbers is stored in memory, starting at 6000H. Find

number of negative, zero and positive numbers from this list and
store these results in memory locations 7000H, 7001H, and 7002H
respectively

Source Program:

LXI H, 6000H : Initialize memory pointer

9
 MVI C, 00H : Initialize number counter
MVI B, 00H : Initialize negative number counter
MVI E, 00H : Initialize zero number counter
BEGIN:MOV A, M : Get the number
CPI 00H : If number = 0
JZ ZERONUM : Goto zeronum
ANI 80H : If MSB of number = 1i.e. if
JNZ NEGNUM number is negative goto NEGNUM
INR D : otherwise increment positive number counter
JMP LAST
ZERONUM:INR E : Increment zero number counter
JMP LAST
NEGNUM:INR B : Increment negative number counter
LAST:INX H : Increment memory pointer
INR C : Increment number counter
MOV A, C
CPI 32H : If number counter = 5010 then
JNZ BEGIN : Store otherwise check next number
LXI H, 7000 : Initialize memory pointer.
MOV M, B : Store negative number.
INX H
MOV M, E : Store zero number.
INX H
MOV M, D : Store positive number.
HLT : Terminate execution
r. Program to calculate the factorial of a number between 0 to 8
Source program

LXI SP, 27FFH ; Initialize stack pointer

LDA 2200H ; Get the number
CPI 02H ; Check if number is greater than 1
JC LAST
MVI D, 00H ; Load number as a result
MOV E, A
DCR A
MOV C,A ; Load counter one less than number
CALL FACTO ; Call subroutine FACTO
XCHG ; Get the result in HL
SHLD 2201H ; Store result in the memory
JMP END
LAST: LXI H, 000lH ; Store result = 01
END: SHLD 2201H
HLT

10
Subroutine Program:

FACTO:LXI H, 0000H
MOV B, C ; Load counter
BACK: DAD D
DCR B
JNZ BACK ; Multiply by successive addition
XCHG ; Store result in DE
DCR C ; Decrement counter
CNZ FACTO ; Call subroutine FACTO
RET ; Return to main program

s. Write a program to find the Square Root of an 8 bit binary number.

The binary number is stored in memory location 4200H and store
the square root in 4201H.

Source Program:

LDA 4200H : Get the given data(Y) in A register

MOV B,A : Save the data in B register
MVI C,02H : Call the divisor(02H) in C register
CALL DIV : Call division subroutine to get initial value(X) in
D-reg
REP: MOV E,D : Save the initial value in E-reg
MOV A,B : Get the dividend(Y) in A-reg
MOV C,D : Get the divisor(X) in C-reg
CALL DIV : Call division subroutine to get initial value(Y/X) in
D-reg
MOV A, D : Move Y/X in A-reg
ADD E : Get the((Y/X) + X) in A-reg
MVI C, 02H : Get the divisor(02H) in C-reg
CALL DIV : Call division subroutine to get ((Y/X) + X)/2 in D-
reg.This is XNEW
MOV A, E : Get Xin A-reg
CMP D : Compare X and XNEW
JNZ REP : If XNEW is not equal to X, then repeat
STA 4201H : Save the square root in memory
HLT : Terminate program execution

Subroutine:

DIV: MVI D, 00H : Clear D-reg for Quotient

NEXT:SUB C : Subtact the divisor from dividend

11
INR D : Increment the quotient
CMP C : Repeat subtraction until the
JNC NEXT : divisor is less than dividend
RET : Return to main program

12