Multiplication Table Program

A multiplication table program that accepts up to 10 as n value

Source Code:

jmp start

newLine db 10,13,"$"
space db " $"
cont_mess db 10,13," Do you want to continue (y/n) :$"
msg1 db 10,13," Enter number: $"
mulframe1 db 10,13," ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»"
db 10,13," º Multiplcation Table º"
db 10,13," ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ$"
cnt_num db 0
num1 db 0
num2 db 0
num_final db 0
product db 0
temp1 db 0
temp2 db 0
temp3 db 0

start:

mov ax,3
int 10h
mov product,0
mov num1,0
mov num2,0


lea dx,mulframe1
mov ah,9
int 21h

call new_Line

lea dx,msg1
mov ah,9
int 21h

mov ah,1
int 21h
sub al,30h

mov num1,al

mov ah,1
int 21h
cmp al,13
je execute

sub al,30h
mov num2,al

mov al,num1
mov bl,10

mul bl
mov num1,al

execute:

mov al,num1
mov bl,num2
add al,bl

cmp al,1
jl start
cmp al,10
jg start

mov num_final,al

call clear


call new_Line

mov al,num_final
mov ah,0
mov si,ax

mov cnt_num,1
mov di,0
outerloop:
call new_Line
mov product,0

mov al,num_final
mov ah,0

mov cx,ax

mov al,0
innerloop:
mov al,product
mov bl,cnt_num
add al,bl
mov product,al
mov product,al

call spacer
call spacer
call spacer2
call mul_display

loop innerloop

inc cnt_num
inc di
cmp di,si
jne outerloop

call continue



new_Line:
lea dx,newLine
mov ah,9
int 21h
ret
clear:
xor ax,ax
xor bx,bx
ret

mul_display:
call clear

mov al,product

mov bl,10

div bl
mov temp1,ah
mov temp2,al

call clear
mov bl,10
mov al,temp2

div bl
mov temp3,al
mov temp2,ah

call clear

cmp temp3,0
je tens

mov al,temp3

hundred:

mov dl,al
or dl,30h
mov ah,2
int 21h

tens:

mov al,temp2
mov bl,temp3

add al,bl
cmp al,0
je ones
mov al,temp2

mov dl,al
or dl,30h
mov ah,2
int 21h

ones:
mov al,temp1
mov dl,al
or dl,30h
mov ah,2
int 21h
ret
spacer:
lea dx,space
mov ah,9
int 21h

ret
spacer2:
mov al,product
cmp al,9
jg return

lea dx,space
mov ah,9
int 21h
return:
ret

continue:
call new_Line
xor dx,dx

lea dx,cont_mess
mov ah,9
int 21h

mov ah,1
int 21h

cmp al,'y'
je start_bridge
cmp al,'n'
je con_quit

jmp continue

start_bridge:
call start
con_quit:
int 20h
fullclear:
xor ax,ax
xor bx,bx
xor cx,cx
xor dx,dx
ret

Password Program

This is a password program i made the password must be pre-declared in the program which is "aces_word" variable and also the user is only allowed to 3 mistakes in typing the right password


source code:

jmp start

mess2 db 10,13," Enter Password: $"
passframe1 db 10,13," ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»$"
invalid db 10,13," º Invalid password (hit) any key º$"
valid db 10,13," º Valid password º$"
timeout db 10,13," º Time is up! you are allowed 3 tries º$"
passframe2 db 10,13," ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ$"
bSpace db 8,"$"
choice db 0
pass_word db 100 dup 0 ;comment: "user input"
aces_word db 'p','o','w','e','r' ;comment: "pre-define password"
aces_cnt dw 5 ;comment: "pre-define number of characters in the password"
word_cnt dw 0
try dw 1 ;comment: "Counts the number of invalid"
newLine db 10,13,"$"
space db " $"
cont_mess db 10,13," Do you want to continue (y/n) :$"



start:
mov try,1
password:
mov ax,3
int 10h


mov word_cnt,0


lea dx,mess2
mov ah,9
int 21h

mov bx,0
input:
mov ah,8
int 21h

cmp al,13
je safety
cmp al,8
je backspace

mov pass_word[bx],al
inc bx

mov dl,'*'
mov ah,2
int 21h

jmp safetyzone

backspace:
cmp bx,0
je input

lea dx,bSpace
mov ah,9
int 21h

mov dl,' '
mov ah,2
int 21h

lea dx,bSpace
mov ah,9
int 21h

dec bx

safetyzone:
jmp input

safety:
mov word_cnt,bx

mov ax,aces_cnt

cmp ax,bx
jne mismatch

mov bx,word_cnt
mov cx,bx
mov bx,0

checking:

mov al,pass_word[bx]
mov ah,aces_word[bx]
cmp al,ah
jne mismatch
inc bx

loop checking
call ok_message
call exit
mismatch:
mov ax,try

cmp ax,3
je timesup

inc try

call error
mov ah,1
int 21h

call password

timesup:
call timesup_message

exit:
call continue


error:
lea dx,passframe1
mov ah,9
int 21h

lea dx,invalid
mov ah,9
int 21h

lea dx,passframe2
mov ah,9
int 21h
ret

ok_message:
lea dx,passframe1
mov ah,9
int 21h

lea dx,valid
mov ah,9
int 21h

lea dx,passframe2
mov ah,9
int 21h
ret

timesup_message:
lea dx,passframe1
mov ah,9
int 21h

lea dx,timeout
mov ah,9
int 21h

lea dx,passframe2
mov ah,9
int 21h
ret


new_Line:
lea dx,newLine
mov ah,9
int 21h
ret
clear:
xor ax,ax
xor bx,bx
ret

spacer:
lea dx,space
mov ah,9
int 21h

ret
continue:
call new_Line
xor dx,dx

lea dx,cont_mess
mov ah,9
int 21h

mov ah,1
int 21h

cmp al,'y'
je start_bridge
cmp al,'n'
je con_quit

jmp continue

start_bridge:
call start
con_quit:
int 20h
fullclear:
xor ax,ax
xor bx,bx
xor cx,cx
xor dx,dx
ret

String Manipulation

String manipulation in assembly is quite confusing sometimes, when i was making an assembly program for it

this is how you declare a string

string db 12,10 dup 0


In this example a variable string is declared in byte, we want the string to have 10 elements, but in assembly you have to add 2 more elements those we 12 elements in total. The index [0] of the string hold the maximum size of the array which is 10 and index [1] holds that actual size of the string that the user inputed.

in this sample program, we want a user to input a string and displays the string, displays the alphabet characters, numbers, and special characters.


jmp start
string db 100,101 dup 0
mess1 db 10,13," Enter a string: $"
mess2 db 10,13, " Inputted String: $"
alphamess db 10,13, " Alphabet letters: $"
nummess db 10,13, " Numerical Values: $"
charmess db 10,13, " Special characters: $"
contmess db 10,13, " Do you want to continue (y/n): $"
space db " $"
newline db 10,13,"$"
start:
xor ax,ax
xor bx,bx
xor dx,dx
xor cx,cx
xor si,si
xor di,di

mov ax,3
int 10h

call new_Line

lea dx,mess1
mov ah,9
int 21h

lea dx,string
mov ah,10
int 21h
;------------------------displaying string----------------------
call new_Line
lea dx,mess2
mov ah,9
int 21h

lea si,string+1
mov cl,[si]
lea di,string+2
cmp cl,0
je start
display:
mov dl,[di]
mov ah,2
int 21h
inc di
loop display

;------------------------Sorting alpha-----------------------
lea dx,alphamess
mov ah,9
int 21h

lea si,string+1
mov cl,[si]
lea di,string+2

alphasorting:
mov al,[di]
cmp al,65
jl safety

cmp al,122
jg safety
cmp al,91
je safety
cmp al,92
je safety
cmp al,93
je safety
cmp al,95
je safety
cmp al,96
je safety

mov dl,al
mov ah,2
int 21h
call spacer
safety:
inc di
loop alphasorting

;------------------------Sorting Numerical-----------------------
lea dx,nummess
mov ah,9
int 21h

lea si,string+1
mov cl,[si]
lea di,string+2

numsorting:
mov al,[di]

cmp al,48
jl numsafety
cmp al,57
jg numsafety

mov dl,al
mov ah,2
int 21h
call spacer

numsafety:
inc di
loop numsorting

;-----------------------special character sorting-------------------
lea dx,charmess
mov ah,9
int 21h

lea si,string+1
mov cl,[si]
lea di,string+2

charsorting:
mov al,[di]

cmp al,32
je charsafety
cmp al,58
je specialchar
cmp al,59
je specialchar
cmp al,60
je specialchar
cmp al,61
je specialchar
cmp al,62
je specialchar
cmp al,63
je specialchar
cmp al,64
je specialchar
cmp al,91
je specialchar
cmp al,92
je specialchar
cmp al,93
je specialchar
cmp al,94
je specialchar
cmp al,95
je specialchar
cmp al,96
je specialchar
cmp al,58
je specialchar
cmp al,48
jl specialchar
cmp al,122
jle charsafety

specialchar:
mov dl,al
mov ah,2
int 21h
call spacer

charsafety:
inc di
loop charsorting

continue:
call new_Line
xor dx,dx

lea dx,contmess
mov ah,9
int 21h

mov ah,1
int 21h

cmp al,'y'
je start_bridge
cmp al,'n'
je quit

jmp continue
quit:
int 20h
new_Line:
lea dx,newline
mov ah,9
int 21h
spacer:
lea dx,space
mov ah,9
int 21h

ret
start_bridge:
call start

Array Manipulation

This project is an array manipulation that accepts an array of 15 single digit numbers and arranges it ascending and descending order. Also displays in even- odd and odd-even format


jmp start
mess1 db 10,13," Enter an array of 15 (0-9) : $"
mess2 db 10,13," Array content: $"
mess3 db 10,13," Enter Choice: $"
mess4 db 10,13," Original Array: $"
evenodd db 10,13," Even-odd sequence: $"
oddeven db 10,13," Odd-even sequence: $"
ascend db 10,13," Ascending order: $"
descend db 10,13," Descending order: $"

menu0 db 10,13," €€€€€€€€€€€€€€ menu €€€€€€€€€€€€€$"
twoline db 10,13," €€ €€$"
menu1 db 10,13," €€ (1) Ascending order €€$"
menu2 db 10,13," €€ (2) Descending order €€$"
menu3 db 10,13," €€ (3) Even-odd format €€$"
menu4 db 10,13," €€ (4) Odd-even fomrat €€$"
menu5 db 10,13," €€ (5) Enter new array €€$"
menu6 db 10,13," €€ (6) Quit €€$"
menu7 db 10,13," €€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€$"
cont_mess db 10,13," Do you want to continue (y/n): $"

newline db 10,13,"$"
space db " $"

arrayNum db 15 dup 0
origNum db 15 dup 0
even_num db 15 dup 0
odd_num db 15 dup 0
choice db 0
temp db 0
count_even db 0
count_odd db 0
start:
xor ax,ax
xor bx,bx
xor cx,cx
xor dx,dx

mov arrayNum,0
mov origNum,0
mov even_num,0
mov odd_num,0

mov choice,0
mov temp,0
mov count_even,0
mov count_odd,0

mov ax,3
int 10h

lea dx,mess1
mov ah,9
int 21h

mov bx,0
mov cx,15
mov ah,0

fillArray:

lea dx,space
mov ah,9
int 21h

mov ah,1
int 21h
sub al,30h

cmp al,0
jl start
cmp al,9
jg start

mov arrayNum[bx],al
mov origNum[bx],al

inc bx

loop fillArray

call new_Line
;----------------------------sorting---------------------------
sorter:
call clear
mov di,15
mov ah,0
mov bx,0

outerloop:
mov si,0
mov cx,15
innerloop:
mov al,arrayNum[bx]
mov ah,arrayNum[si]

cmp al,ah
jg skip

mov al,arrayNum[bx]
mov ah,arrayNum[si]

mov temp,al
mov al,ah
mov ah,temp
mov arrayNum[bx],al
mov arrayNum[si],ah

skip:
inc si
loop innerloop

safety:
inc bx
dec di
cmp di,0
jg outerloop
cmp di,0
jl safetyzone

safetyzone:
;-------------------sorting even------------------------
call clear

mov cx,15
mov si,0
mov di,0
sorteven:
xor ax,ax

mov al,arrayNum[si]
xor bx,bx
mov bl,2
div bl

call even_numbers

inc si

loop sorteven

;-------------------------- Sorting odd --------------------------
call clear

mov cx,15
mov si,0
mov di,0
oddsorter:
xor ax,ax

mov al,arrayNum[si]
xor bx,bx
mov bl,2
div bl

call odd_numbers

inc si

loop oddsorter
;------------------------- menu ------------------------------
menu:
mov ax,3
int 10h
;--------------------- shows the original array --------------
lea dx,mess4
mov ah,9
int 21h

mov cx,15
mov bx,0

showArray:

mov dl,origNum[bx]
or dl,30h
mov ah,2
int 21h

lea dx,space
mov ah,9
int 21h

inc bx

loop showArray

;------------------------------ end of show -----------------------
call new_Line

lea dx,menu0
mov ah,9
int 21h

lea dx,twoline
mov ah,9
int 21h


lea dx,menu1
mov ah,9
int 21h

lea dx,menu2
mov ah,9
int 21h

lea dx,menu3
mov ah,9
int 21h

lea dx,menu4
mov ah,9
int 21h

lea dx,menu5
mov ah,9
int 21h

lea dx,menu6
mov ah,9
int 21h

lea dx,twoline
mov ah,9
int 21h

lea dx,menu7
mov ah,9
int 21h


call new_Line

lea dx,mess3
mov ah,9
int 21h

mov ah,1
int 21h
sub al,30h

cmp al,1
jl menu_bridge

cmp al,6
jg menu_bridge

mov choice,al

cmp al,1
je ascend1
cmp al,2
je descend1
cmp al,3
je even_odd1
cmp al,4
je odd_even1
cmp al,5
je new
cmp al,6
je quit
menu_bridge:
call menu
new:
call start
ascend1:
call ascending
descend1:
call descending
even_odd1:
call even_odd
odd_even1:
call odd_even
quit:
int 20h
new_Line:
lea dx,newline
mov ah,9
int 21h
ret
clear:
xor ax,ax
xor bx,bx
xor cx,cx
xor dx,dx
ret
display_array:
lea dx,ascend
mov ah,9
int 21h

mov cx,15
mov bx,0

dispArray:

mov dl,arrayNum[bx]
or dl,30h
mov ah,2
int 21h

lea dx,space
mov ah,9
int 21h

inc bx

loop dispArray
ret
even_numbers:

cmp ah,0
jne odd_counter

mov al,arrayNum[si]
mov even_num[di],al

inc di

inc count_even

jmp return

odd_counter:
inc count_odd
return:
ret
showEven:

call clear

xor ax,ax

mov si,0
mov cl,count_even
cmp cl,0
je evenNumbers
dispEven:

mov dl,even_num[si]
or dl,30h
mov ah,2
int 21h

lea dx,space
mov ah,9
int 21h

inc si
dec cl
cmp cl,0
jg dispEven
cmp cl,0
jl evenNumbers
evenNumbers:
ret

odd_numbers:

cmp ah,0
je oddreturn

mov al,arrayNum[si]
mov odd_num[di],al
inc di
oddreturn:
ret
showOdd:

call clear

xor ax,ax

mov si,0
mov cl,count_odd
cmp cl,0
je oddNumbers

dispOdd:

mov dl,odd_num[si]
or dl,30h
mov ah,2
int 21h

lea dx,space
mov ah,9
int 21h

inc si
dec cl
cmp cl,0
jg dispOdd
cmp cl,0
jl oddNumbers
oddNumbers:
ret

ascending:
call display_array
call continue
descending:
lea dx,descend
mov ah,9
int 21h

mov cx,15
mov bx,14

dispdescend:

mov dl,arrayNum[bx]
or dl,30h
mov ah,2
int 21h

lea dx,space
mov ah,9
int 21h

dec bx

loop dispdescend

call continue
even_odd:
lea dx,evenodd
mov ah,9
int 21h

call showEven
call showOdd
call continue
odd_even:
lea dx,oddeven
mov ah,9
int 21h

call showOdd
call showEven
call continue
continue:
call new_Line
xor dx,dx

lea dx,cont_mess
mov ah,9
int 21h

mov ah,1
int 21h

cmp al,'y'
je start_bridge
cmp al,'n'
je quit2


jmp continue

start_bridge:
call menu
quit2:

int 20h

Array manipulation

In declaring an array in assembly is quite different from other programming language

eg.

array db 15 dup 0

in this example, a variable array is defined as a byte and has 15 elements in the array. And each element has a default value of 0.

here is a sample program that asks a 15 single-digit numerical input and displays its total, average, also its even and odd numbers.

source code:



jmp start
arrayNum db 15 dup 0
mess1 db 10,13," Input an array of (0 - 9) 15 numbers: $"
mess2 db 10,13," Array content: $"
sum_mess db 10,13," Summation : $"
ave_mess db 10,13," Average : $"
tot_mess db 10,13," Total numbers: "
space db " $"
newline db 10,13,"$"
point db ".$"
even_mess db 10,13," Even numbers: $"
odd_mess db 10,13," Odd numbers: $"
cont_mess db 10,13," Do you want to continue (y/n): $"
even_num db 15 dup 0
odd_num db 15 dup 0

sum db 0
temp1 db 0
temp2 db 0
temp3 db 0
count_even db 0
count_odd db 0
divisor db 0
zero db "0.00$"
start:
xor ax,ax
xor bx,bx
xor cx,cx

mov even_num,0
mov odd_num,0
mov count_even,0
mov count_odd,0

mov ax,3
int 10h

lea dx,mess1
mov ah,9
int 21h

mov bx,0
mov cx,15
mov ah,0

fillArray:

lea dx,space
mov ah,9
int 21h

mov ah,1
int 21h
sub al,30h

cmp al,0
jl start
cmp al,9
jg start

mov arrayNum[bx],al

inc bx

loop fillArray

call new_Line

lea dx,mess2
mov ah,9
int 21h

mov cx,15
mov bx,0

dispArray:

mov dl,arrayNum[bx]
or dl,30h
mov ah,2
int 21h

lea dx,space
mov ah,9
int 21h

inc bx

loop dispArray


;-------------------getting sum of the array---------------

mov bx,0
mov cx,15

mov ah,0

sumArray:

mov al,arrayNum[bx]
add ah,al
inc bx

loop sumArray
mov sum,ah


;------------------------Displaying sum--------------------

lea dx,sum_mess
mov ah,9
int 21h

call sum_display

;-----------------------calculating average-----------------

lea dx,ave_mess
mov ah,9
int 21h

call clear
mov divisor,15
call averaging

;-------------------------sorting array----------------------
call clear

mov cx,15
mov si,0
mov di,0
sorter:
xor ax,ax

mov al,arrayNum[si]
xor bx,bx
mov bl,2
div bl

call even_numbers

inc si

loop sorter

;--------------------- displaying even --------------------
call new_Line
call clear

lea dx,even_mess
mov ah,9
int 21h

call clear

xor ax,ax

mov si,0
mov cl,count_even
dispEven:

mov dl,even_num[si]
or dl,30h
mov ah,2
int 21h

lea dx,space
mov ah,9
int 21h

inc si
dec cl
cmp cl,0
jg dispEven
cmp cl,0
jl evenNumbers
evenNumbers:
;--------------------- displaying numbers of even ----------------
lea dx,tot_mess
mov ah,9
int 21h

mov al,count_even
mov sum,al
call sum_display

summationEven:
;---------------------- calculating sum for even ------------------
call clear
mov al,count_even
mov ah,0

cmp al,0
je safety

mov bx,0
mov cx,ax
mov ah,0

sumEven:

mov al,even_num[bx]
add ah,al
inc bx

loop sumEven
safety:
mov sum,0
mov sum,ah
;------------------------Displaying sum--------------------
call clear

lea dx,sum_mess
mov ah,9
int 21h

call sum_display

;---------------------- average for even ---------------------------
call clear
lea dx,ave_mess
mov ah,9
int 21h

mov al,count_even
cmp al,0
je zero_num

call clear
mov al,count_even
mov divisor,al
call averaging
jmp safetyzone
zero_num:
lea dx,zero
mov ah,9
int 21h
safetyzone:
;---------------------------sorting odd--------------------------
call clear

mov cx,15
mov si,0
mov di,0
oddsorter:
xor ax,ax

mov al,arrayNum[si]
xor bx,bx
mov bl,2
div bl

call odd_numbers

inc si

loop oddsorter
;-------------------- displaying odd ---------------------
call new_Line
call clear

lea dx,odd_mess
mov ah,9
int 21h

call clear

xor ax,ax

mov si,0
mov cl,count_odd
dispOdd:

mov dl,odd_num[si]
or dl,30h
mov ah,2
int 21h

lea dx,space
mov ah,9
int 21h

inc si
dec cl
cmp cl,0
jg dispOdd
cmp cl,0
jl oddNumbers
oddNumbers:
;---------------------display number of odd-------------------
lea dx,tot_mess
mov ah,9
int 21h

mov al,count_odd
mov sum,al
call sum_display
;---------------------- calculating sum for odd ------------------
call clear
mov al,count_odd
mov ah,0

cmp al,0
je oddsafety


mov bx,0
mov cx,ax
mov ah,0

sumOdd:

mov al,odd_num[bx]
add ah,al
inc bx

loop sumOdd
oddsafety:
mov sum,0
mov sum,ah
;------------------------Displaying sum--------------------
call clear

lea dx,sum_mess
mov ah,9
int 21h

call sum_display
;------------------------ averaging for odd --------------------
call clear
lea dx,ave_mess
mov ah,9
int 21h

mov al,count_odd
cmp al,0
je zero_sum

call clear
mov al,count_odd
mov divisor,al
call averaging
jmp oddsafetyzone
zero_sum:
lea dx,zero
mov ah,9
int 21h
oddsafetyzone:

continue:
call new_Line
xor dx,dx

lea dx,cont_mess
mov ah,9
int 21h

mov ah,1
int 21h

cmp al,'y'
je start_bridge
cmp al,'n'
je quit

jmp continue

start_bridge:
call start
quit:
int 20h

even_numbers:

cmp ah,0
jne odd_counter

mov al,arrayNum[si]
mov even_num[di],al

inc di

inc count_even

jmp return

odd_counter:
inc count_odd

return:
ret

odd_numbers:

cmp ah,0
je return

mov al,arrayNum[si]
mov odd_num[di],al
inc di

jmp oddreturn

oddreturn:
ret


new_Line:

lea dx,newline
mov ah,9
int 21h
ret

clear:

xor ax,ax
xor bx,bx
xor cx,cx
xor dx,dx
ret

sum_display:
call clear
mov al,sum

mov bl,10

div bl
mov temp1,ah
mov temp2,al

call clear
mov bl,10
mov al,temp2

div bl
mov temp3,al
mov temp2,ah

call clear

cmp temp3,0
je tens

mov al,temp3

hundred:
mov dl,al
or dl,30h
mov ah,2
int 21h

tens:
mov al,temp2
mov bl,temp3

add al,bl
cmp al,0
je ones

mov al,temp2

mov dl,al
or dl,30h
mov ah,2
int 21h

ones:
mov al,temp1
mov dl,al
or dl,30h
mov ah,2
int 21h
ret

averaging:
call clear
mov al,sum
mov bl,divisor

div bl
mov bh,ah

xor dx,dx
xor cx,cx

mov dl,al
or dl,30h
mov ah,2
int 21h

lea dx,point
mov ah,9
int 21h

mov cx,2
decimal:
mov bl,10
mov al,bh

mul bl
mov bl,divisor
div bl

mov bh,ah
xor dx,dx
mov dl,al
or dl,30h
mov ah,2
int 21h

loop decimal
ret

Displaying asterisk triangles

Source Code:

jmp start

mess1 db 10,13, "Enter value for (n) [0-9 only]: $"
mess2 db 10,13, "There is nothing to display $"
mess3 db 10,13, "Do you want to continue (y/n): $"
lincar db 10,13, "$"
space db " $"
asterisk db "*$"
value db 0

start:

xor ax,ax
xor bx,bx
xor cx,cx

mov ax,3
int 10h

lea dx,mess1
mov ah,9
int 21h

mov ah,1
int 21h
sub al,30h

cmp al,0
je zero
cmp al,0
jl start
cmp al,9
jg start

mov value,al
mov bh,al
mov ch,bh
mov cl,al
again:

cmp bh,0
je continue

lea dx,lincar
mov ah,9
int 21h

mov al,value
sub cl,al
back:

cmp cl,0
je display

lea dx,space
mov ah,9
int 21h

inc cl

jmp back

display:

lea dx,asterisk
mov ah,9
int 21h

lea dx,space
mov ah,9
int 21h

inc cl

cmp cl,ch
jne display

dec bh
dec ch
dec cl

jmp again
zero:
lea dx,mess2
mov ah,9
int 21h

continue:
xor dx,dx

lea dx,mess3
mov ah,9
int 21h

mov ah,1
int 21h

cmp al,'y'
je start_bridge
cmp al,'n'
je exit

jmp continue

start_bridge:
call start

exit:
int 20h

Displaying asterisk triangles

This one is shape like a quadrilateral triangle


Source Code:

jmp start

mess1 db 10,13, "Enter value for (n) [0-9 only]: $"
mess2 db 10,13, "There is nothing to display $"
mess3 db 10,13, "Do you want to continue (y/n): $"
lincar db 10,13, "$"
space db " $"
asterisk db "*$"
value db 0

start:

xor ax,ax
xor bx,bx
xor cx,cx

mov ax,3
int 10h

lea dx,mess1
mov ah,9
int 21h

mov ah,1
int 21h
sub al,30h

cmp al,0
je zero
cmp al,0
jl start
cmp al,9
jg start

mov bh,al
mov value,al

mov ch,1

again:

cmp bh,0
je continue

lea dx,lincar
mov ah,9
int 21h

mov bl,value
mov al,ch

sub al,bl

mov cl,al

back:

cmp cl,0
je display

lea dx,space
mov ah,9
int 21h

inc cl

jmp back
display:

lea dx,asterisk
mov ah,9
int 21h

lea dx,space
mov ah,9
int 21h

inc cl

cmp cl,ch
jne display

dec bh
inc ch

jmp again
zero:
lea dx,mess2
mov ah,9
int 21h

continue:
xor dx,dx

lea dx,mess3
mov ah,9
int 21h

mov ah,1
int 21h

cmp al,'y'
je start_bridge
cmp al,'n'
je exit

jmp continue

start_bridge:
call start

exit:
int 20h