Assignment 2
Assignment 2
; ADDITION
MOV CARRY,00H
MOV AX,NUM1 ; ADD FIRST NUMBER
ADD AX,NUM2 ; ADD SECOND NUMBER
JNC STORE1 ; IF CARRY FOUND
INC CARRY ; INCREMENT CARRY
STORE1:
MOV RESULT,AX ; STORE THE RESULT
LEA DX,OUTMSGS
CALL OUTPT ; DISPLAY SUM
; SUBTRACTION
MOV CARRY,00H
MOV AX,NUM1 ; ADD FIRST NUMBER
SUB AX,NUM2 ; ADD SECOND NUMBER
MOV RESULT,AX ; STORE THE RESULT
LEA DX,OUTMSGD
CALL OUTPT ; DISPLAY SUM
TATA:
MOV AH,4CH ; TERMINATE
INT 21H
MAIN ENDP
MOV DX,0000H
MOV CL,4
GETCH:
MOV AH,01H ; REQUEST CHARACTER INPUT
INT 21H
CMP AL,0DH ; CHECK IF ENTER
JE DONE
CMP AL,0AH ; CHECK IF LINEFEED
JE DONE
ISNUM:
OR DL,AL ; STORE THE CHARACTER
JMP GETCH ; LOOP TO TAKE NEXT CHARACTER
DONE:
MOV AX,DX ; STORE THE NUMBER
POP DX
RET
INPT ENDP
; DISPLAY SUM
; -----------
OUTPT PROC NEAR
MOV AH,09H ; DISPLAY OUTPUT PROMPT
INT 21H
MOV DL, CARRY
CMP DL, 00H ; CHECK IF CARRY IS NON-ZERO
JE DISPSUM
MOV AH, 02H ; DISPLAY CARRY
ADD DL, 48
INT 21H
DISPSUM:
MOV CL,4
MOV DX,RESULT
MOV DL,DH ; TAKE FIRST 4 BITS
SHR DL,CL
CALL DISPCH
MOV DX,RESULT
MOV DL,DH ; THE NEXT 4 BITS
CALL DISPCH
MOV DX,RESULT
SHR DL,CL ; THE NEXT 4 BITS
CALL DISPCH
END MAIN
Q2:-
;PROGRAM TO CONVERT A BINARY DIGIT TO DECIMAL AND VICE VERSA
PRINTM MACRO MESS
LEA DX,MESS
MOV AH,09H
INT 21H
ENDM
NEW_LINE MACRO
MOV AH,02H
MOV DL,0DH
INT 21H
MOV DL,0AH
INT 21H
ENDM
DEC_INPUT MACRO
LOCAL INPUT,SKIP
; OUTPUT: BX
XOR BX,BX
MOV AH,01H
INT 21H
;IF \R
CMP AL,0DH
JE SKIP
INPUT:
AND AX,000FH
PUSH AX
; BX=BX*10+AX
MOV AX,10
MUL BX
MOV BX,AX
POP AX
ADD BX,AX
; TAKE INPUT
MOV AH,01H
INT 21H
CMP AL,0DH
JNE INPUT
SKIP:
ENDM
DEC_OUTPUT MACRO
LOCAL START,REPEAT,DISPLAY
START: ; JUMP LABEL
MOV AX, BX ; SET AX=BX
XOR CX, CX ; CLEAR CX
MOV BX, 10 ; SET BX=10
REPEAT: ; LOOP LABEL
XOR DX, DX ; CLEAR DX
DIV BX ; DIVIDE AX BY BX
PUSH DX ; PUSH DX ONTO THE STACK
INC CX ; INCREMENT CX
OR AX, AX ; TAKE OR OF AX WITH AX
JNE REPEAT ; JUMP TO LABEL REPEAT IF ZF=0
MOV AH, 2 ; SET OUTPUT FUNCTION
DISPLAY: ; LOOP LABEL
POP DX ; POP A VALUE FROM STACK TO DX
OR DL, 30H ; CONVERT DECIMAL TO ASCII CODE
INT 21H ; PRINT A CHARACTER
LOOP DISPLAY
ENDM
BIN_INPUT MACRO
LOCAL SKIP,INPUT
; OUTPUT: BX
XOR BX,BX
MOV AH,01H
INT 21H
CMP AL,0DH
JE SKIP
INPUT:
XOR AH,AH
SUB AX,'0'
SHL BX,1
OR BX,AX
; TAKE INPUT
MOV AH,01H
INT 21H
CMP AL,0DH
JNE INPUT
SKIP:
ENDM
.MODEL SMALL
.STACK 100H
.DATA
INPMSG1 DB "BINARY NUMBER ? $"
INPMSG2 DB "DECIMAL NUMBER ? $"
OUPMSG1 DB "EQUIVALENT DECIMAL NUMBER -> $"
OUPMSG2 DB "EQUIVALENT BINARY NUMBER -> $"
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
;BINARY TO DECIMAL
;INPUT
PRINTM INPMSG1
BIN_INPUT
;OUTPUT
PRINTM OUPMSG1
DEC_OUTPUT
NEW_LINE
;DECIMAL TO BINARY
;INPUT
PRINTM INPMSG2
DEC_INPUT
;OUTPUT
PRINTM OUPMSG2
BIN_OUTPUT
EXITP
MAIN ENDP
END MAIN
Q3:-
;PROGRAM TO PRINT PAIRS OF EVEN NUMBERS WHERE THE SUM OF THE NUMBERS IN EACH PAIR IS
100.
PRINTM MACRO MESS
LEA DX,MESS
MOV AH,09H
INT 21H
ENDM
NEW_LINE MACRO
MOV AH,02H
MOV DL,0DH
INT 21H
MOV DL,0AH
INT 21H
ENDM
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
SPACE MACRO
MOV AH,02H
MOV DL,' '
INT 21H
ENDM
.MODEL SMALL
.STACK 100H
.DATA
OUPMSG DB "PAIRS OF EVEN NUMBERS WITH SUM 100: $"
TEMPB DW ?
TEMPC DW ?
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
PRINTM OUPMSG
NEW_LINE
MOV BX,0
MOV CX,100
@PRINT_LOOP:
MOV TEMPB,BX
MOV TEMPC,CX
BRACKET '('
DEC_OUTPUT
SPACE
MOV BX,TEMPC
DEC_OUTPUT
BRACKET ')'
SPACE
MOV BX,TEMPB
MOV CX,TEMPC
INC BX
INC BX
DEC CX
DEC CX
CMP BX,100
JLE @PRINT_LOOP
NEW_LINE
EXITP
MAIN ENDP
END MAIN
Q4:-
;PROGRAM TO MULTIPLY TWO NUMBERS
PRINTM MACRO MESS
LEA DX,MESS
MOV AH,09H
INT 21H
ENDM
DEC_INPUT MACRO
LOCAL INPUT,SKIP
; OUTPUT: BX
XOR BX,BX
MOV AH,01H
INT 21H
;IF \R
CMP AL,0DH
JE SKIP
INPUT:
AND AX,000FH
PUSH AX
; BX=BX*10+AX
MOV AX,10
MUL BX
MOV BX,AX
POP AX
ADD BX,AX
; TAKE INPUT
MOV AH,01H
INT 21H
CMP AL,0DH
JNE INPUT
SKIP:
ENDM
DEC_OUTPUT MACRO
LOCAL START,REPEAT,DISPLAY
START: ; JUMP LABEL
MOV AX, BX ; SET AX=BX
XOR CX, CX ; CLEAR CX
MOV BX, 10 ; SET BX=10
REPEAT: ; LOOP LABEL
XOR DX, DX ; CLEAR DX
DIV BX ; DIVIDE AX BY BX
PUSH DX ; PUSH DX ONTO THE STACK
INC CX ; INCREMENT CX
OR AX, AX ; TAKE OR OF AX WITH AX
JNE REPEAT ; JUMP TO LABEL REPEAT IF ZF=0
MOV AH, 2 ; SET OUTPUT FUNCTION
DISPLAY: ; LOOP LABEL
POP DX ; POP A VALUE FROM STACK TO DX
OR DL, 30H ; CONVERT DECIMAL TO ASCII CODE
INT 21H ; PRINT A CHARACTER
LOOP DISPLAY
ENDM
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
.MODEL SMALL
.STACK 100H
.DATA
INPMSG1 DB "FIRST NUMBER ? $"
INPMSG2 DB "SECOND NUMBER ? $"
OUPMSG DB "PRODUCT -> $"
NUM1 DW ?
NUM2 DW ?
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
XOR BH,BH
;INPUT PROMPT
PRINTM INPMSG1
DEC_INPUT
MOV NUM1,BX
PRINTM INPMSG2
DEC_INPUT
MOV NUM2,BX
PRINTM OUPMSG
MOV AX,NUM1
MUL NUM2
MOV BX,DX
PUSH AX
DEC_OUTPUT
POP AX
MOV BX,AX
DEC_OUTPUT
EXITP
MAIN ENDP
END MAIN
Q5:-
;PROGRAM TO DIVIDE A 16 BIT NUMBER BY A 8 BIT NUMBER.
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
PUSHALL MACRO
PUSH AX
PUSH BX
PUSH CX
PUSH DX
ENDM
POPALL MACRO
POP DX
POP CX
POP BX
POP AX
ENDM
.MODEL SMALL
.STACK 100H
.DATA
INPMSG1 DB "16-BIT NUMBER ? $"
INPMSG2 DB "8-BIT NUMBER ? $"
OUPMSG1 DB 10,13,"QUOTIENT -> $"
OUPMSG2 DB 10,13,"REMAINDER -> $"
NUM1 DW ?
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
;INPUT
PRINTM INPMSG1
HEX_INPUT
MOV NUM1,BX
PRINTM INPMSG2
HEX_INPUT
MOV AX,NUM1
XOR DX,DX
DIV BX
;OUTPUT
MOV BX,AX
MOV NUM1,DX
PRINTM OUPMSG1
PUSHALL
HEX_OUTPUT
POPALL
MOV BX,NUM1
PRINTM OUPMSG2
PUSHALL
HEX_OUTPUT
POPALL
EXITP
MAIN ENDP
END MAIN
Q6:-
Q7:-
;PROGRAM FOR SUBSTRING DELETION FROM A GIVEN STRING
.MODEL MEDIUM
.STACK 100H
.DATA
PROMPT_1 DB 10,13,'ENTER THE STRING : $'
PROMPT_2 DB 10,13,'ENTER THE SUBSTRING TO BE DELETED : $'
PROMPT_3 DB 10,13,'THE FINAL STRING IS : $'
NEWLINE DB 10,13,'$'
;INPUT STRING
BUFFERSIZE_1 DB 51 ; 50 CHAR + RETURN
INPUTLENGTH_1 DB 0 ; NUMBER OF READ CHARACTERS
STRING DB 51 DUP(0) ; ACTUAL BUFFER
END_1 DB '$'
INDEX1 DB 0 ;INDEX FOR LOOPING
;INPUT SUBSTRING
BUFFERSIZE_2 DB 21 ; 20 CHAR + RETURN
INPUTLENGTH_2 DB 0 ; NUMBER OF READ CHARACTERS
SUBSTRING DB 21 DUP(0) ; ACTUAL BUFFER
INDEX2 DB 0 ;INDEX FOR LOOPING
;MODIFIED OUTPUT STRING
INDEX3 DB 0 ;INDEX FOR LOOPING
NEWSTRING DB 50 DUP('$')
;MACRO TO CHECK WHETHER TWO CHARACTER OF THE INPUT STRING AND SUBSTRING ARE
SAME OR NOT
COMPARE MACRO
MOV DL,[ SI ] ; LOAD THE CHARACTER OF INPUT STRING IN DL
MOV DI,OFFSET SUBSTRING
MOV AL,INDEX2
MOV AH,AH
ADD DI,AX
MOV DH,[ DI ] ; LOAD THE CHARACTER OF INPUT SUBSTRING
IN DH
CMP DL,DH ; COMPARE DL AND DH
ENDM
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
DISPLAY PROMPT_1
GET_STRING BUFFERSIZE_1 ; INPUT THE STRING
DISPLAY PROMPT_2
GET_STRING BUFFERSIZE_2 ; INPUT THE SUBSTRING
MOV SI,OFFSET STRING ; LOAD OUR POINTER TO THE
BEGINNING OF THE STRUCTURE
MOV CL,INPUTLENGTH_1 ; MOVE LENGTH OF THE STRING
IN CL
@LOOP1:
MOV DI,OFFSET SUBSTRING ; LOAD OUR POINTER TO THE
BEGINNING OF THE STRUCTURE
MOV INDEX2,0
STRING_COPY
COMPARE
JNE @LABEL1
MOV BL,INPUTLENGTH_2
XOR BH,BH
DEC BX
@LOOP2:
INC SI
DEC CL
INC INDEX2
STRING_COPY
COMPARE
JNE @LABEL1
DEC BL
JNZ @LOOP2
;IF THE SUBSTRING IS PRESENT
MOV BL,INPUTLENGTH_2 ;MOVE SUBSTRING LENGTH TO BL
MOV AL,INDEX3 ; MOVE NEW STRING INDEX TO
AL
SUB AL,BL ; SUBTRACT BL FROM AL
MOV INDEX3,AL ; SAVE AL IN NEW STRING
INDEX
@LABEL1:
INC SI
LOOP @LOOP1
@PRINT:
STRING_COPY ; ADD '$' AFTER THE OUTPUT STRING
DISPLAY PROMPT_3
DISPLAY NEWSTRING ; DISPLAY THE OUTPUT STRING
MOV AH,4CH
INT 21H
MAIN ENDP
END MAIN
Q8:-
;PROGRAM TO IDENTIFY THE GCD AND LCM OF THREE NUMBERS
NEW_LINE MACRO
MOV AH,02H
MOV DL,0DH
INT 21H
MOV DL,0AH
INT 21H
ENDM
;MACRO TO EXIT
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
DEC_INPUT MACRO
LOCAL INPUT,SKIP
; OUTPUT: BX
XOR BX,BX
MOV AH,01H
INT 21H
;IF \R
CMP AL,0DH
JE SKIP
INPUT:
AND AX,000FH
PUSH AX
; BX=BX*10+AX
MOV AX,10
MUL BX
MOV BX,AX
POP AX
ADD BX,AX
; TAKE INPUT
MOV AH,01H
INT 21H
CMP AL,0DH
JNE INPUT
SKIP:
ENDM
.MODEL SMALL
.STACK 100H
.DATA
INPMSG1 DB "FIRST NUMBER ? $"
INPMSG2 DB "SECOND NUMBER ? $"
INPMSG3 DB "THIRD NUMBER ? $"
OUPMSG1 DB 10,13,"GCD -> $"
OUPMSG2 DB 10,13,"LCM -> $"
NUM1 DW ?
NUM2 DW ?
NUM3 DW ?
GCDN DW ?
LCMN DW ?
.CODE
;PROCEDURE TO FIND GCD OF TWO NUMBERS
GCD PROC
; INPUT: BX,AX
; OUTPUT: GCD
; ASSUMPTION: AX IS GREATER THAN BX
UP:
CMP AX,BX ;COMPARE THE TWO NUMBERS.
JE EXIT ;IF EQUAL, GO TO EXIT LABEL.
JB EXCG ;IF FIRST NUMBER IS BELOW THAN SECOND,
;GO TO EXCG LABEL.
UP1:
MOV DX,0 ;INITIALIZE THE DX.
DIV BX ;DIVIDE THE FIRST NUMBER BY SECOND NUMBER.
CMP DX,0 ;COMPARE REMAINDER IS ZERO OR NOT.
JE EXIT ;IF ZERO, JUMP TO EXIT LABEL.
MOV AX,DX ;IF NON-ZERO, MOVE REMAINDER TO AX.
JMP UP
;JUMP TO UP LABEL.
EXCG:
XCHG AX,BX ;EXCHANGE THE REMAINDER AND QUOTIENT.
JMP UP1 ;JUMP TO UP1.
EXIT:
MOV GCDN,BX ;STORE THE RESULT IN GCD.
RET
GCD ENDP
LCM PROC
; INPUT: BX,AX
; OUTPUT: DX
XOR DX,DX
MUL BX;PRODUCT OF NUMBERS
DIV GCDN ;BY GCD OF NUMBERS
MOV LCMN,AX
RET
LCM ENDP
MAIN PROC
MOV AX,@DATA
MOV DS,AX
;INPUT
; FIRST NUMBER
PRINTM INPMSG1
DEC_INPUT
MOV NUM1,BX
;SECOND NUMBER
PRINTM INPMSG2
DEC_INPUT
MOV NUM2,BX
;THIRD NUMBER
PRINTM INPMSG3
DEC_INPUT
MOV NUM3,BX
; FINDING GCD
;FIND GCD OF FIRST TWO
MOV AX,NUM1
MOV BX,NUM2
CALL GCD
; GCD OF GCD AND THIRD
MOV AX,NUM3
MOV BX,GCDN
CALL GCD
;OUTPUT
PRINTM OUPMSG1
MOV BX,GCDN
DEC_OUTPUT
; FINDING LCM
; FIND GCD OF TWO
MOV AX,NUM1
MOV BX,NUM2
CALL GCD
; FIND LCM
MOV AX,NUM1
MOV BX,NUM2
CALL LCM
; FIND GCD OF TWO
MOV AX,LCMN
MOV BX,NUM3
CALL GCD
; FIND LCM
MOV AX,LCMN
MOV BX,NUM3
CALL LCM
;OUTPUT
PRINTM OUPMSG2
MOV BX,LCMN
DEC_OUTPUT
EXITP
MAIN ENDP
END MAIN
;MACRO TO EXIT
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
PUSHALL MACRO
PUSH AX
PUSH BX
PUSH CX
PUSH DX
ENDM
POPALL MACRO
POP DX
POP CX
POP BX
POP AX
ENDM
.MODEL SMALL
.STACK 100H
.DATA
INPMSG1 DB "ENTER SIZE OF ARRAY: $"
INPMSG2 DB "ENTER ELEMENTS OF ARRAY IN SORTED ORDER: $"
INPMSG3 DB 10,13,"ENTER ELEMENT TO BE SEARCHED: $"
OUPMSG1 DB "ELEMENT FOUND AT INDEX $"
OUPMSG2 DB "ELEMENT NOT FOUND $"
ARR DW 50 DUP(?)
S DW ?
START DW ?
STOP DW ?
MIN_IDX DW ?
TEMP DW ?
.CODE
MAIN PROC
MOV AX,@DATA ; INITIALIZE SEGMENT REGISTERS
MOV DS,AX
PRINTM INPMSG1 ; ACCEPT SIZE OF ARRAY
DEC_INPUT
MOV S,BX ; S = SIZE
LEA SI,ARR ; SI = OFFSET ADDRESS OF ARR
MOV CX,BX ; CX = SIZE
PRINTM INPMSG2
NEW_LINE
@ARRAY_INPUT:
PUSHALL
DEC_INPUT
MOV WORD PTR[SI],BX ; COPY THE ENTERED NUMBER INTO ARR
POPALL
INC SI ; 2 INC BECAUSE IT IS A WORD
INC SI
LOOP @ARRAY_INPUT
CALL SORT ; SORT THE ARRAY
PRINTM INPMSG3
DEC_INPUT ; INPUT ELEMENT TO SEARCH
@BINARY_SEARCH:
LEA SI,ARR ; SI = OFFSET ADDRESS OF ARR
MOV CX,STOP
ADD CX,START
SHR CX,1 ; CX = MIDDLE INDEX = (STOP + START) / 2
ADD SI,CX ; SI=SI+CX
ADD SI,CX ; 2 TIMES BECAUSE OF WORD
@FOUND: ; IF FOUND
PRINTM OUPMSG1
MOV BX,CX
DEC_OUTPUT
@EXIT:
EXITP
MAIN ENDP
; SELECTION SORT
SORT PROC
LEA SI,ARR ; SI = OFFSET ADDRESS OF ARR
MOV CX,S
DEC CX ; CX = SIZE - 1
@OUTER_LOOP:
MOV DX,CX ; DX IS THE INNER LOOP COUNTER
MOV DI,SI
INC DI
INC DI ; DI POINTS AT THE NUMBER AT
SECOND INDEX
MOV MIN_IDX,SI ; MIN_INDEX = SI
PUSH SI ; SAVE SI
@INNER_LOOP:
MOV SI,MIN_IDX ; SI = MIN_INDEX
MOV BX,WORD PTR[SI] ; BX = VALUE AT MIN_INDEX
CMP WORD PTR[DI],BX ; CHECK IF ARR VALUE AT DI >= ARR VALUE AT
MIN_IDX
JGE @INCR
MOV MIN_IDX,DI ; IF NOT, SET MIN_IDX TO DI
POP SI ; RETRIVE SI
MOV DI,MIN_IDX ; SWAP CONTENTS OF WORD
AT SI AND WORD AT MIN_IDX
MOV BX,WORD PTR[DI]
XCHG WORD PTR[SI],BX
MOV WORD PTR[DI],BX
;MACRO TO EXIT
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
PUSHALL MACRO
PUSH AX
PUSH BX
PUSH CX
PUSH DX
ENDM
POPALL MACRO
POP DX
POP CX
POP BX
POP AX
ENDM
PRINTM INPMSG1
DEC_INPUT ; INPUT SIZE
PRINTM INPMSG2
NEW_LINE
MOV S,BX ; S = SIZE
@ARRAY_INPUT:
PUSHALL
DEC_INPUT
MOV WORD PTR[SI],BX ; ACCEPT ARRAY ELEMENTS
POPALL
INC SI ; INCREMENT TO POINT TO THE NEXT
WORD
INC SI
LOOP @ARRAY_INPUT
PRINTM INPMSG3
DEC_INPUT ; INPUT ELEMENT TO BE SEARCHED
LEA SI,ARR ; SI = OFFSET ADDRESS OF ARR
MOV CX,S ; CX = SIZE
@LINEAR_SEARCH:
CMP BX,WORD PTR[SI]
JE @FOUND
INC SI
INC SI
LOOP @LINEAR_SEARCH
@FOUND: ; IF FOUND
PRINTM OUPMSG1
MOV BX,S
SUB BX,CX ; GET THE INDEX FROM BEGINNING
DEC_OUTPUT
@EXIT:
EXITP
MAIN ENDP
END MAIN
Q10:-
NEW_LINE MACRO
MOV AH,02H
MOV DL,0DH
INT 21H
MOV DL,0AH
INT 21H
ENDM
;MACRO TO EXIT
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
.MODEL SMALL
.STACK 100H
.DATA
MSG DB "PRIME NUMBERS FROM 1 TO 100 -> $"
NUM DB ?
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
PRINTM MSG
NEW_LINE
MOV CL,02H
START:
MOV NUM,CL
MOV AL,CL
MOV BL,01H
MOV BH,00H
MOV DX,0000H
MOV AH,00H
TRUE:
MOV CH,00H
MOV BX,CX
DEC_OUTPUT ; DISPLAY THE NUMBER
SPACE
FALSE:
MOV CL,NUM
INC CL ; PROCEED TO THE NEXT NUMBER
CMP CL,64H ; TILL NUMBER <= 100
JNE START
EXITP
MAIN ENDP
END MAIN
Q11:-
;PROGRAM TO IMPLEMENT SELECTION AND INSERTION SORT
NEW_LINE MACRO
MOV AH,02H
MOV DL,0DH
INT 21H
MOV DL,0AH
INT 21H
ENDM
;MACRO TO PRINT SPACE
SPACE MACRO
MOV AH,02H
MOV DL,' '
INT 21H
ENDM
;MACRO TO EXIT
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
PUSHALL MACRO
PUSH AX
PUSH BX
PUSH CX
PUSH DX
ENDM
POPALL MACRO
POP DX
POP CX
POP BX
POP AX
ENDM
.MODEL SMALL
.STACK 100H
.DATA
INPMSG1 DB "ENTER SIZE OF ARRAY: $"
INPMSG2 DB "ENTER ELEMENTS OF ARRAY IN SORTED ORDER: $"
PRINTM INPMSG2
NEW_LINE
@ARRAY_INPUT:
PUSHALL
DEC_INPUT
MOV WORD PTR[SI],BX ; COPY THE ENTERED NUMBER INTO ARR
POPALL
INC SI ; 2 INC BECAUSE IT IS A WORD
INC SI
LOOP @ARRAY_INPUT
CALL SELECTION_SORT ; SORT THE ARRAY
PRINTM OUPMSG1
PUSHALL
MOV CL, 0
LEA SI,ARR ; SI = OFFSET ADDRESS OF ARR
@ARRAY_OUTPUT:
MOV BX, WORD PTR[SI]
DEC_OUTPUT ; PRINT THE NUMBER
SPACE
INC SI
INC SI ; 2 INC BECAUSE IT IS A WORD
INC CL
CMP CL, S
JL @ARRAY_OUTPUT
POPALL
NEW_LINE
EXITP
MAIN ENDP
; SELECTION SORT
SELECTION_SORT PROC
LEA SI,ARR ; SI = OFFSET ADDRESS OF ARR
MOV CX,S
DEC CX ; CX = SIZE - 1
@SEC_OUTER:
MOV DX,CX ; DX IS THE INNER LOOP COUNTER
MOV DI,SI
INC DI
INC DI ; DI POINTS AT THE NUMBER AT
SECOND INDEX
MOV MIN_IDX,SI ; MIN_INDEX = SI
PUSH SI ; SAVE SI
@SEC_INNER:
MOV SI,MIN_IDX ; SI = MIN_INDEX
MOV BX,WORD PTR[SI] ; BX = VALUE AT MIN_INDEX
CMP WORD PTR[DI],BX ; CHECK IF ARR VALUE AT DI >= ARR VALUE AT
MIN_IDX
JGE @INCR
MOV MIN_IDX,DI ; IF NOT, SET MIN_IDX TO DI
POP SI ; RETRIVE SI
MOV DI,MIN_IDX ; SWAP CONTENTS OF WORD
AT SI AND WORD AT MIN_IDX
MOV BX,WORD PTR[DI]
XCHG WORD PTR[SI],BX
MOV WORD PTR[DI],BX
INSERTION_SORT PROC
PUSHALL
MOV CL, 1
MOV BX, OFFSET ARR ; BX = OFFSET ADDRESS OF ARR
@INS_OUTER:
MOV CH, 0
MOV DI, CX ; DI IS OUTER LOOP INDEX
SHL DI ; MULTIPLY BY 2 BECAUSE IT IS
A WORD
MOV DL, ARR[DI] ; DL = ARR[DI]
MOV SI, DI
DEC SI
DEC SI ; SI = DI - 2
@INS_INNER: ; SI IS INNER LOOP INDEX
CMP SI, 0 ; WHILE (SI >= 0)
JL @INS_OUTER_UPDATE
CMP ARR[SI], DL ; WHILE (ARR[SI] > DL)
JBE @INS_OUTER_UPDATE
MOV CH, ARR[SI] ; ARR[DI] = ARR[SI]
MOV ARR[DI], CH
DEC DI
DEC DI
DEC SI
DEC SI
JMP @INS_INNER
@INS_OUTER_UPDATE:
MOV ARR[SI+1], DL ; ARR[SI+1] = DL
INC CL
CMP CL, S ; INCREMENT COUNTER TILL CL
= SIZE
JL @INS_OUTER
POPALL
RET
INSERTION_SORT ENDP
END MAIN
Q12:-
;MACRO TO PRINT A MESSAGE
PRINTM MACRO MESS
LEA DX,MESS
MOV AH,09H
INT 21H
ENDM
;MACRO TO EXIT
EXITP MACRO
MOV AH,4CH
INT 21H
ENDM
.MODEL SMALL
.STACK 100H
.DATA
OLDFILENAME DB "OLD_FILE.TXT", 0
NEWFILENAME DB "NEW_FILE.TXT", 0
OUPMSG DB 10,13,"FILE RENAMED $"
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
MOV ES, AX
LEA DX,OLDFILENAME
LEA DI,NEWFILENAME
MOV AH,56H ;TO RENAME FILE
INT 21H
PRINTM OUPMSG
EXITP ;EXIT
MAIN ENDP
END MAIN
Q13:-