Arranging in desending:

LXI H,5000 ;Set pointer for array

MOV C,M ;Load the Count
DCR C ;Decrement Count
REPEAT: MOV D,C
LXI H,5001 ;Load starting address of data array
LOOP: MOV A,M ;copy content of memory location to Accumulator
INX H
CMP M
JNC SKIP ;Jump to skip if carry not generated
MOV B,M ;copy content of memory location to B - Register
MOV M,A ;copy content of A - Register to memory location
DCX H ;Decrement content of HL pair of registers
MOV M,B
INX H ;Increment content of HL pair of registers
SKIP: DCR D
JNZ LOOP ;Jump to LOOP if not Zero
DCR C ;Decrement Count
JNZ REPEAT ;Jump to REPEAT if not Zero
HLT ;Terminate Program

Nth power of a number:

2000H Base Data Byte for base

2001H Exponent Data Byte for exponent
2002H Result Result of factorial
2003H LXI H, 2000H Load data from memory
2006H MOV B, M Load base to B register
2007H INX H Increment memory
2008H MOV C, M Load exponent to C register
2009H MVI D, 01H Set D register to 1
200BH POWER_LOOP CALL MULTIPLY Subroutine call for multiplication
200EH DCR C Decrement C
200FH JNZ POWER_LOOP Call power_loop till C becomes 0
2012H INX H Increment memory
2013H MOV M, D Store result in memory
2014H HLT Halt
2100H MULTIPLY MOV E, B Transfer contents of B to E
2101H MVI A, 00H Clear accumulator to store result
2103H MULTIPLYLOOP ADD D Add contents of D to A
2104H DCR E Decrement E
2105H JNZ MULTIPLYLOOP Repeated addition
2108H MOV D, A Transfer contents of A to D
2109H RET Return from subroutine

bcd tobinary:

2000H LDA 201FH

2001H
2002H
2003H MOV B, A
2004H ANI 0FH
2005H
2006H MOV C, A
2007H MOV A, B
2008H ANI F0H
2009H
200AH JZ SKIPMULTIPLY
200BH
200CH
200DH RRC
200EH RRC
200FH RRC
2010H RRC
2011H MOV D, A
2012H XRA A
2013H MVI E, 0AH
2014H
2015H SUM ADD D
2016H DCR E
2017H JNZ SUM
2018H
2019H
201AH SKIPMULTIPLY ADD C
201BH STA 2020H
201CH
201DH
201EH HLT

binary to bcd:

LXI H,0000H
MVI B,0AH
MVI C,00H
MOV A,M
S1: CMP B
JC SAVE
SUB B
INR C
JMP S1
SAVE: MOV B,A
MOV A,C
RLC
RLC
RLC
RLC
ORA B
STA 0006H
HLT

Number of 1's:

2000 MVI B 75 B ? 75
2002 MVI C 08 C ? 75
2004 MVI D 00 D ? 00
2006 MOV A, B A ? B
2007 RRC Rotate right without carry
2008 JNC 200C Jump if Not Carry
200B INR D D ? D+1
200C DCR C C ? C-1
200D JNZ 2007 Jump if Not Zero
2010 MOV A, D A ? D
2011 STA 3050 A ? 3050
2014 HLT Stops execution

hex to bcd:
LXI H,5000 ;Initialize memory pointer
 MVI D,00 ;Clear D- reg for Most significant Byte
XRA A ;Clear Accumulator
MOV C,M ;Get HEX data
LOOP2: ADI 01 ;Count the number one by one
DAA ;Adjust for BCD count
JNC LOOP1
INR D
LOOP1: DCR C
JNZ LOOP2
STA 5001 ;Store the Least Significant Byte
MOV A,D
STA 5002 ;Store the Most Significant Byte
HLT
bcd to hex:

2000 LXI H, 2050

2003 MOV A, M A<-M
2004 ADD A A<-A+A
2005 MOV B, A B<-A
2006 ADD A A<-A+A
2007 ADD A A
2008 ADD B A<-A+B
2009 INX H
200A ADD M A<-A+M
200B INX H
200C MOV M, A M<-A
200D HLT TERMINATE THE PROGRAM

ascii to hex:

2000 LDA 2050 A<-[2050]

2003 SUI 30H A<-A-30
2005 CPI 0AH
2007 JC 200D Check for carry
200B SUI 07H A<-A-07H
200D STA 3050 [3050]<-A
2010 HLT Stop execution

hex to ascii:

LDA 5000 Get Hexa Data

MOV B,A
ANI 0F ;Mask Upper Nibble
CALL SUB1 ;Get ASCII code for upper nibble
STA 5001
MOV A,B
ANI F0 ;Mask Lower Nibble
RLC
RLC
RLC
RLC
CALL SUB1 ;Get ASCII code for lower nibble
STA 5002
HLT ;Halt the program.

SUB1: CPI 0A
JC SKIP
ADI 07
SKIP: ADI 30
 RET ;Return Subroutine

1's and 2's complement:

2000 LDA [3000] [A] <- [3000]

2003 CMA [A] <- [A^]
2004 STA [3001] 1�s complement
2007 ADI 01 [A] <- [A] + 01
2009 STA [3002] 2�s complement
200C HLT Stop

sum of even numbers of an array:

LDA 2200H [A] <- 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
STA 2210H store sum
HLT Terminate program execution

selection sort:

LXI H, 0060H

MVI B, 05H

LOOP1: MOV C, B

MOV D, H

MOV E, L

INR E

LOOP2: LDAX D

CMP M

JNC NO_SWP

SWAP: MOV D, M

MOV M, A

MOV A, D

MOV D, H
STAX D

NO_SWP: INR E

DCR C

JNZ LOOP2

INX H

DCR B

JNZ LOOP1

HLT

bubble sort:

2000H START LXI H, 2040H Load size of array

2003H MVI D, 00H Clear D register to set up a flag
2005H MOV C, M Set C register with number of elements in list
2006H DCR C Decrement C
2007H INX H Increment memory to access list
2008H CHECK MOV A, M Retrieve list element in Accumulator
2009H INX H Increment memory to access next element
200AH CMP M Compare Accumulator with next element
200BH JC NEXTBYTE If accumulator is less then jump to NEXTBYTE
200EH MOV B, M Swap the two elements
200FH MOV M, A
2010H DCX H
2011H MOV M, B
2012H INX H
2013H MVI D, 01H If exchange occurs save 01 in D register
2015H NEXTBYTE DCR C Decrement C for next iteration
2016H JNZ CHECK Jump to CHECK if C>0
2019H MOV A, D Transfer contents of D to Accumulator
201AH CPI 01H Compare accumulator contents with 01H
201CH JZ START Jump to START if D=01H
201FH HLT HALT

binary search:

LXI H,0000H
MVI M,01
INX H
MVI M,02
INX H
MVI M,03
INX H
MVI M,04
INX H
MVI M,05
INX H
MVI M,06
INX H
MVI M,07
INX H
MVI M,08
MVI A,03
STA 0011H

LDA 0011H
MOV C,A
MVI A,0H
MVI B,7H
LXI H,0000H

LOOP: MVI A,0H

ADD B
STC
CMC
RAR
MOV B,A
MVI D,00H
MOV E,A
MOV A,H
STA 000BH
MOV A,L
STA 000AH
DAD D
MOV A,M
CMP C
JZ FOUND
JC RIGHT
LHLD 000AH
MOV A,B
CPI 0
JZ NOT
JMP LOOP
RIGHT: MOV A,B
CPI 0
JZ NOT
JMP LOOP
FOUND: MVI A,01H
STA 0018H
HLT
NOT: MVI A,02H
STA 0018H
HLT

fibo:

;MVI A,08H
;STA 0000H
LXI H,0000H
MOV C,M ;n>2
MVI A,00H
MVI D,01H ;Sum
MVI B,00H ;(n-2)th term
MVI E,01H ;(n-1)th term
DCR C
DCR C
loop: MOV A,B
ADD E
MOV E,A
SUB B
MOV B,A
MOV A,E
ADD D
MOV D,A
DCR C
JNZ loop
STA 0001H

hlt

linear search:

MVI A,0AH
STA 000H ;no. of elements
MVI A,07H
STA 001H
MVI A,04H
STA 002H
MVI A,06H
STA 003H
MVI A,03H
STA 004H
MVI A,08H
STA 005H
MVI A,01H
STA 006H
MVI A,00H
STA 007H
MVI A,09H
STA 008H
MVI A,05H
STA 009H
MVI A,02H
STA 00AH
MVI A,05H ;no. to be searched
STA 010H
MOV E,A ;element

LXI H,000H
MOV C,M ;count
INR C
INX H
loop: DCR C
JZ notfound
MOV A,M
INX H
CMP E
JNZ loop
MVI A,01H
STA 0011H
hlt
notfound: MVI A,00H
STA 0011H
hlt

prime:
LXI H,000H
MVI M,1DH
MOV A,M
MOV C,A
MOV E,A
MVI B,02H
div: MOV A,E
SUB B
MOV E,A
CMP B
JZ comp ;B is a factor of C
JNC div ;A is greater than B
MOV A,C
SUI 01H
CMP B
JZ prime ;B is equal to C-1
loop: INR B
MOV E,C
JMP div
MOV A,C
SUI 01H
CMP B
JNZ loop
prime: MVI A,01H
STA 0001H
HLT
comp: MVI A,00H
STA 0001H
HLT

;B=i C=num

prime series:

LXI H,0000H
MVI M,09H
MOV D,M
INX H
MVI C,02H
MVI E,01H
MVI B,02H
MVI A,02H
MOV M,A
INX H
DCR D
l1: INR C
MOV E,C
MVI B,02H
JMP div
div: MOV A,E
SUB B
MOV E,A
CMP B
JZ l1 ;B is a factor of C
JNC div ;A is greater than B
MOV A,C
SUI 01H
CMP B
JZ prime ;B is equal to C-1
loop: INR B
MOV E,C
JMP div
MOV A,C
SUI 01H
CMP B
JNZ loop
prime: MOV A,C
MOV M,A
INX H
DCR D
JNZ l1
HLT

factorial:

2000H Data Data Byte

2001H Result Result of factorial
2002H LXI H, 2000H Load data from memory
2005H MOV B, M Load data to B register
2006H MVI D, 01H Set D register with 1
2008H FACTORIAL CALL MULTIPLY Subroutine call for multiplication
200BH DCR B Decrement B
200CH JNZ FACTORIAL Call factorial till B becomes 0
200FH INX H Increment memory
2010H MOV M, D Store result in memory
2011H HLT Halt
2100H MULTIPLY MOV E, B Transfer contents of B to C
2101H MVI A, 00H Clear accumulator to store result
2103H MULTIPLYLOOP ADD D Add contents of D to A
2104H DCR E Decrement E
2105H JNZ MULTIPLYLOOP Repeated addition
2108H MOV D, A Transfer contents of A to D
2109H RET Return from subroutine

division :

2000 LXI H, 2050

2003 MOV B, M B<-M
2004 MVI C, 00 C<-00H
2006 INX H
2007 MOV A, M A<-M
2008 CMP B
2009 JC 2011 check for carry
200C SUB B A<-A-B
200D INR C C<-C+1
200E JMP 2008
2011 STA 3050 3050<-A
2014 MOV A, C A<-C
2015 STA 3051 3051<-A
2018 HLT terminate the program