assembly language programs 8086/80386

Add two arrays assembly language code .asm

.MODEL TINY  ; ADD TWO ARRAYS
.CODE
.386
.STARTUP
.DATA
ARRAY1 DB 30H,31H,32H,33H,34H,35H,36H,37H,39H,40H,41H
ARRAY2 DB 15H,14H,13H,12H,11H,10H,9H,8H,7H,6H,5H,4H
.CODE
MOV SI, OFFSET ARRAY1
MOV DI, OFFSET ARRAY2
MOV CX,12H
CLD
.WHILE CX!=0
  MOV AL,DS:[DI]
  ADD DS:[SI],AL
  INC SI
  INC DI
  DEC CX
.ENDW
.EXIT
END

Addition Subtraction Multiplication Division Assembly .asm

.MODEL TINY  ; ADD,SUB,MUL,DIV
.386
.CODE
.STARTUP
MOV EAX,23H
ADD EAX,23H
MOV EDX,11H
SUB EAX,EDX
MOV EBX,EDX
MUL EBX
MOV EDX,11H
MOV ECX,24H
DIV ECX
.EXIT
END

Ascii to binary conversion .asm

.MODEL TINY
.CODE
.386
.STARTUP

.DATA
PRINTBINARYFORM DB "BINARY FORM IS:$"

.CODE
MOV AH,01H
INT 21H
SUB AL,30H
MOV CX,9
MOV BH,AL
MOV DX,OFFSET PRINTBINARYFORM
MOV AH,09H
INT 21H
MOV AL,BH

PRINTBINARYLOOP:
   SHL AL,1
   SETC DL
   ADD DL,'0'
   SUB CX,1
   .IF CX!=0
   JMP PRINTCHARACTER
   .ENDIF

.IF CX!=0
PRINTCHARACTER :
MOV BH,AL
MOV AH,02H
INT 21H
MOV AL,BH
JMP PRINTBINARYLOOP
.ENDIF


.EXIT
END

BCD addition assembly ( Binary Coded Decimal ) .asm

.MODEL TINY  ;BCD ADDITION
.CODE
.386
.STARTUP
MOV EDX,35353535H
MOV EBX,35353535H
MOV AL,BL
ADD AL,DL
DAA
MOV DS:[1000H],AL
MOV AL,BH
ADC AL,DH
DAA
MOV DS:[1001H],AL
SHR EDX,16
SHR EBX,16
MOV AL,BL
ADC AL,DL
DAA
MOV DS:[1003H],AL
MOV AL,BH
ADC AL,DH
DAA
MOV DS:[1004H],AL
MOV DI,1000H
MOV EAX,DS:[DI]
.EXIT
END

BCD subtraction ( Binary Coded Decimal ) .asm

.MODEL TINY  ; BCD SUBTRACTION
.CODE
.386
.STARTUP
MOV EDX,10101010H
MOV EBX,35353535H
MOV AL,BL
SUB AL,DL
DAS
MOV DS:[1000H],AL
MOV AL,BH
SBB AL,DH
DAS
MOV DS:[1001H],AL
SHR EDX,16
SHR EBX,16
MOV AL,BL
SBB AL,DL
DAS
MOV DS:[1002H],AL
MOV AL,BH
SBB AL,DH
DAS
MOV DS:[1003H],AL
MOV DI,1000H
MOV EAX,DS:[DI]
.EXIT
END

Binary Search in 8086 .asm

.MODEL TINY  ; BINARY SEARCH 8086
.CODE
.386
.STARTUP

.DATA
ARRAY DB 1H,2H,3H,4H,5H,6H,7H,8H,9H
FOUND DB "FOUND$"
NOTFOUND DB "NOT FOUND$"

.CODE
MOV AH,01H
MOV SI,OFFSET ARRAY
MOV CH,0 ; LOW
MOV CL,8 ; HIGH
INT 21H
SUB AL,30H ; CONVERTING TO HEX FROM ASCII
MOV DH,AL  ; DH -> KEY
MOV AH,0H
JMP CALCULATINGOFFSET 

BINARYSEARCH :
  MOV AH,0H  
  MOV SI, OFFSET ARRAY 
  ADD SI,AX
  MOV DL,DS:[SI]
  CMP DH,DL
  JZ FOUNDDATA
  JG GREATER
  JL LESS
  JMP NOTFOUNDPRINT

CALCULATINGOFFSET:
  ADD CL,CH
  MOV AH,0H
  MOV AL,CL
  MOV BL,2 
  DIV BL   
  MOV BL,AL ; SAVING THE INDEX
  JMP BINARYSEARCH

GREATER :
  ADD BL,1
  MOV CH,BL
  JMP CALCULATINGOFFSET
  
LESS :
  SUB BL,1
  MOV CL,BL
  JMP CALCULATINGOFFSET

NOTFOUNDPRINT:
  MOV DX, OFFSET NOTFOUND
  MOV AH,09H
  INT 21H


FOUNDDATA:
  MOV DX,OFFSET FOUND
  MOV AH,09H
  INT 21H

.EXIT
END

Binary to Ascii assembly code .asm

.MODEL TINY
.CODE
.386
.STARTUP

.DATA

INPUT DB 10,13,'Enter BINARY No.:$'
OUTPUT DB 10,13,'THE ASCII CHARACTER IS :$'
ARR DB ?

.CODE

MOV AH,0AH
MOV DX,OFFSET INPUT
INT 21H
MOV BL,1H
MOV CL,08H
MOV SI,DX
ADD SI,9
MOV DX,0H

.WHILE CL!=0H
  MOV AH,0H
  MOV AL,DS:[SI]
  SUB AL,30H
  MUL BL
  ADD DX,AX
  MOV AL,BL
  MOV BL,2
  MUL BL
  MOV BL,AL
  DEC CL
  DEC SI
.ENDW

MOV AX,DX
MOV AH,02H
MOV AL,DL
INT 21H

.EXIT
END

Chapter 4 Q30 Book Barry Intel .asm

.MODEL TINY
.CODE
.386
.STARTUP
.DATA
NUMB DB 44H,45H
.CODE
MOV BX,NUMB
MOV DX,NUMB
MOV SI,NUMB
.EXIT
END

Copy 12 bytes from Memory to memory .asm

.MODEL TINY  ;MOVSB
.CODE
.386
.STARTUP
.DATA
SOURCE DB 30H,31H,32H,33H,34H,35H,36H,37H,39H,40H,41H
DEST DB 12 DUP(?)
.CODE
MOV SI, OFFSET SOURCE
MOV DI, OFFSET DEST
MOV CX,12H
CLD
REP MOVSB
.EXIT
.END

Copy data segment to extra segment assembly .asm

.MODEL TINY  ; DS TO ES
.CODE
.STARTUP
MOV CX,50
MOV SI,1000H
MOV DI,2000H
MOV CX,50
CLD
REP MOVS
.EXIT
END

gggs

.MODEL SMALL

.386

.DATA
SORTARRAY DB 0AAH,0FFH,44H,88H,93H,56H,20H,0BBH,37H,36H,35H,"$"
.CODE
.STARTUP
MOV SI,OFFSET SORTARRAY
MOV CX,10
MOV DI,0
CLD
MOV AH,09H
MOV DX,OFFSET SORTARRAY
INT 21H


SORT:
 .IF CX!=0 
  MOV DI,0
  MOV SI,OFFSET SORTARRAY ; THE INCREMENT OFFSET
  MOV BP,OFFSET SORTARRAY ; WHEN FIRST IS THE MAXIMUM ELEMENT 
  MOV AH,DS:[SI]          ; MAX ELEMENT TO BE COMPARED AGAINST
INNER:
  INC SI                  ; NEXT ELEMENT IN ARRAY
  INC DI                  ; KEEPING A CHECK ON ARRAY LENGHT
  CMP AH,DS:[SI]          
  JB MAXIMUM              ; JUMP IS NEW MAX ELEMENT IS FOUND
  BACK :                  
   .IF DI<CX              ; IF INCREMENTER HAS NOT REACHED ARRAY END
     JMP INNER 
   .ELSEIF DI==CX         ; IF DI AT END THEN START AGAIN FROM 0
     MOV BH,DS:[SI]       ; SWAP PORTION
     MOV DS:[SI],AH
     MOV DS:[BP],BH
     DEC CX               ; DECREMENT ARRAY SIZE
     JMP SORT             ; LOOP AGAIN
   .ENDIF    
.ENDIF

.IF CX!=0                 ; TO PROTECT LABEL FROM EXECUTING DIRECTLY
MAXIMUM :                 ; NEW MAX ELEMENT AND IT'S OFFSET
 MOV AH,DS:[SI]
 MOV BP,SI 
 JMP BACK
.ENDIF

MOV AH,09H
MOV DX,OFFSET SORTARRAY
INT 21H

.EXIT
END

Linear Search .asm

.MODEL TINY  ; LINEAR SEARCH
.CODE
.386
.STARTUP

.DATA
ARRAY DB 1H,2H,33H,4H,5H,6H,7H,8H,9H
FOUND DB "FOUND$"
NOTFOUND DB "NOT FOUND$"

.CODE
MOV AH,01H
MOV SI,OFFSET ARRAY
MOV CX, OFFSET ARRAY
ADD CX,10H
INT 21H
SUB AL,30H
MOV AH,0H
MOV BL,0H

LINEARSEARCH:
  MOV BL,DS:[SI]
  CMP AL,BL   
  JZ FOUNDDATA
  INC SI 
  .IF CX==SI
      JMP NOTFOUNDPRINT
  .ENDIF
  JNZ  LINEARSEARCH


NOTFOUNDPRINT:
  MOV DX, OFFSET NOTFOUND
  MOV AH,09H
  INT 21H


FOUNDDATA:
  MOV DX,OFFSET FOUND
  MOV AH,09H
  INT 21H

.EXIT
END

Sorting.asm

.MODEL TINY
.CODE
.386
.STARTUP
.DATA
SORTARRAY DB 0AAH,0FFH,44H,88H,93H,56H,20H,0BBH,37H,36H,35H
.CODE
MOV SI, OFFSET SORTARRAY
MOV CX,10
MOV DI,0
CLD
SORT:
 .IF CX!=0 
  MOV DI,0
  MOV SI,OFFSET SORTARRAY ; THE INCREMENT OFFSET
  MOV BP,OFFSET SORTARRAY ; WHEN FIRST IS THE MAXIMUM ELEMENT 
  MOV AH,DS:[SI]          ; MAX ELEMENT TO BE COMPARED AGAINST
INNER:
  INC SI                  ; NEXT ELEMENT IN ARRAY
  INC DI                  ; KEEPING A CHECK ON ARRAY LENGHT
  CMP AH,DS:[SI]          
  JB MAXIMUM              ; JUMP IS NEW MAX ELEMENT IS FOUND
  BACK :                  
   .IF DI<CX              ; IF INCREMENTER HAS NOT REACHED ARRAY END
     JMP INNER 
   .ELSEIF DI==CX         ; IF DI AT END THEN START AGAIN FROM 0
     MOV BH,DS:[SI]       ; SWAP PORTION
     MOV DS:[SI],AH
     MOV DS:[BP],BH
     DEC CX               ; DECREMENT ARRAY SIZE
     JMP SORT             ; LOOP AGAIN
   .ENDIF    
.ENDIF

.IF CX!=0                 ; TO PROTECT LABEL FROM EXECUTING DIRECTLY
MAXIMUM :                 ; NEW MAX ELEMENT AND IT'S OFFSET
 MOV AH,DS:[SI]
 MOV BP,SI 
 JMP BACK
.ENDIF

.EXIT
END

Subtract two arrays assembly .asm

.MODEL TINY  ; SUBTRACT TWO ARRAYS
.CODE
.386
.STARTUP
.DATA
ARRAY1 DB 30H,31H,32H,33H,34H,35H,36H,37H,39H,40H,41H
ARRAY2 DB 15H,14H,13H,12H,11H,10H,9H,8H,7H,6H,5H,4H
.CODE
MOV SI, OFFSET ARRAY1
MOV DI, OFFSET ARRAY2
MOV CX,12H
CLD
.WHILE CX!=0
  MOV AL,DS:[DI]
  ADD DS:[SI],AL
  INC SI
  INC DI
  DEC CX
.ENDW
.EXIT
END

swap data from memory locations assembly .asm

.MODEL TINY   ; SWAP DATA
.CODE
.386
.STARTUP
MOV EBX,1000H
MOV ECX,1005H
MOV EAX,DS:[EBX]
MOV EDX,DS:[ECX]
MOV DS:[ECX],EAX
MOV DS:[EBX],EDX
.EXIT
END

XLAT in 8086 .asm

.MODEL TINY  ;XLAT
.CODE
.386
.STARTUP
.DATA
TABLE DB 30H,31H,32H,33H,34H,35H,36H,37H,38H,39H
.CODE
MOV BX,OFFSET TABLE
MOV AL,9H
XLAT
.EXIT
END

Updated binary search and made separate file for each program