;Bai1/Nhap vao

2 so
;Bµi2/Cho
0<a,b<=9.hay in
bl=19.H·y nhËp
ra tong cña
sè ;a,2<=a<=9
chung
vµ in ra th¬ng ;Bµi3/T×m íc
code segment
vµ d cña ;bl chia chung lín nhÊt
assume cs:code
cho a b»ng ph- cña ;1<=a,b<=32 ;Bµi4/NhËp 2
org 100h sè 1<=a,b<=9.
start: jmp over
¬ng ph¸p trõ 767(sö dông th- ;Bµi5/NhËp
dÇn ;viÖn) H·y in mét kÝ tù tuú
xau1 db 'Nhap a=
code segment (cn03.asm) ra ;hiÖu cña ý.H·y in ra ;m·
$'
xau2 db
assume cs:code chóng(cn04.as ASC cña nã ë
org 100h include m)
0ah,0dh,'Nhap b=
start: jmp over mylib.mac d¹ng
$' code segment nhÞ ;ph©n(cn
xau1 db 'Nhap a= code segment
xau3 db assume cs:code 05.asm)
$' assume cs:code
0ah,0dh,'Tong la:
xau2 db org 100h org 100h code segment
$' start: jmp over
over:
0ah,0dh,'Du = $' start: jmp over assume cs:code
xau3 db 0ah,0dh, a dw ? xau1 db 'Nhap org 100h
mov ah,9
'Thuong = $' b dw ? a= $' start: jmp over
lea dx,xau1
int 21h
over: mov ah,9 over: xau2 db xau1 db
lea dx,xau1 @write'Nhap a= ' 0ah,0dh,'Nhap
mov ah,1
int 21h call nhap_so 'Nhap 1 ky tu :
int 21h b= $' $'
mov ah,1 mov a,ax
mov bl,al xau3 db xau2 db
int 21h @xuongdong
mov ah,9
and al,0fh @write'Nhap b= ' 0ah,0dh,'Hieu = 0ah,0dh,'Ma
lea dx,xau2 $'
int 21h
xor bx,bx call nhap_so nhi phan cua ky
mov bh,19 mov b,ax over: mov ah,9 tu la: $'
mov ah,1
lap:inc bl mov bx,a lea dx,xau1 over:
int 21h
add bl,al
sub bh,al @xuongdong int 21h mov ah,9
cmp bh,al lap: cmp ax,bx mov ah,1
sub bl,30h
jae lap ja qua lea dx,xau1
mov ah,9 int 21h int 21h
mov ah,9 je het
lea dx,xau3 mov bl,al mov ah,1
lea dx,xau3 sub bx,ax
int 21h
int 21h jmp lap mov ah,9 int 21h
cmp bl,'9' lea dx,xau2
jbe inra
mov ah,2 qua: mov bl,al
mov dl,bl sub ax,bx int 21h mov ah,9
mov dl,'1'
or dl,30h cmp ax,bx mov ah,1 lea dx,xau2
mov ah,2
int 21h
int 21h jne lap int 21h int 21h
mov ah,9 het: sub bl,al
sub bl,10
lea dx,xau2 @write'UCLN xor bh,bh
inra: mov ah,9 mov ah,2
int 21h cua a va b la: '
mov ah,2 lea dx,xau3 lap:
mov ah,2 mov ax,bx
mov dl,bl
mov dl,bh call in_so int 21h mov dl,30h
int 21h mov ah,2
int 20h
or dl,30h int 20h rol bl,1
int 21h include proc.asm cmp bl,0 adc dl,0
code ends
int 20h code ends jg qua int 21h
end start
code ends end start mov dl,'-' inc bh
end start int 21h cmp bh,4
neg bl jne qua
qua: mov dl,32
mov dl,bl int 21h
add dl,30h qua:
int 21h cmp bh,8
int 20h jb lap
code ends int 20h
end start code ends
end start
;Bµi6/NhËp sè
nguyªn d¬ng ;Bµi7/NhËp
2<=N<=32767. mét kÝ tù
H·y x¸c ®Þnh nÕu ®ã lµ ch÷ ;Bµi8/H·y in
N cã ph¶i ;lµ hoa th× in ra ra b¶ng m·
nguyªn tè hay th«ng b¸o:®ã ASCII më
réng(cn08.asm ;Bµi9/NhËp N ;Bai10/Nhap
kh«ng?(§uîc lµ ch÷ hoa,ng- nguyªn d¬ng mot ki tu neu
sö ;dông th îc l¹i th× th«ng )
code segment x¸c ®Þnh N cã do la chu
viÖn) b¸o ®ã lµ ch÷ ph¶i lµ sè thuong thi
include thêng assume cs:code
org 100h chÝnh ph¬ng thong bao do
mylib.mac code segment ko?(Duoc su la chu ;thuong
code segment assume cs:code start: jmp over
xau db ' dung thu vien) nguoc lai thi
assume cs: org 100h (cn09.asm) thong bao do
code start: jmp over BANG MA
ASCII MO include khong phai la
org 100h xau db 'Nhap 1 mylib.mac chu
start: jmp over ky tu: $' RONG ',
0ah,0dh ,'$' code segment thuong(cn10.a
n dw 0 xau1 db assume cs:code sm)
over: 0ah,0dh,'ky tu xau2 db ' $'
xau3 db org 100h code segment
@write ' vua nhap la chu start: jmp over assume cs:code
Nhap vao 1 so : hoa$' 0ah,0dh,'$'
over: n dw ? org 100h
n=' xau2 db over: start: jmp over
call 0ah,0dh,'ky tu mov ah,9
lea dx,xau @write'Nhap xau db 'Nhap 1
nhap_so vua nhap khong N= ' ky tu: $'
mov n,ax phai chu hoa $' int 21h
xor bh,bh call nhap_so xau1 db
mov cx,2 over: mov n,ax 0ah,0dh,'ky tu
lap: mov ah,9 mov bl,127
lap:mov ah,2 @xuongdong vua nhap la chu
mov ax,n lea dx,xau mov cx,1 thuong$'
xor dx,dx int 21h mov dl,bl
inc bl lap: xau2 db
div cx mov ah,1 mov ax,cx 0ah,0dh,'ky tu
inc cx int 21h int 21h
mov ah,9 mul cx vua nhap khong
cmp dx,0 cmp al,'A' cmp ax,n phai chu
je thoat jb khac lea dx,xau2
int 21h je qua thuong $'
cmp cx,n cmp al,'Z' inc cx over:
jb lap ja khac cmp bl,255
je thoat cmp cx,n mov ah,9
mov ah,9 jb lap lea dx,xau
@xuongdong lea dx,xau1 inc bh
cmp bh,10 @write'So da int 21h
@write' int 21h nhap khong mov ah,1
Day la so jmp het jb lap
xor bh,bh phai la so chinh int 21h
nguyen to ! ' khac: phuong' cmp al,'a'
jmp het mov ah,9 mov ah,9
lea dx,xau3 jmp het jb khac
thoat: lea dx,xau2 qua: cmp al,'z'
@xuongdong int 21h int 21h
jmp lap @write'Day la ja khac
@write ' het: so chinh mov ah,9
Day khong phai int 20h thoat:int 20h
code ends phuong' lea dx,xau1
la so nguyen code ends het: int 21h
to !' end start end start
int 20h jmp het
het: int 20h include khac:
include proc.asm mov ah,9
proc.asm code ends lea dx,xau2
code ends end start int 21h
end start het:
int 20h
code ends
end start
 code ends @write'Day thoat1:mov inra:mov
end start la so hoan ah,9 ax,a[bp]
thien' lea dx,xau3 call in_so
het: int 21h add bp,2
int 20h mov ah,2 mov ah,2
include sub bl,11h mov dl,32
proc.asm mov dl,bl int 21h
code ends int 21h loop inra
end start jmp het @xuongdong
thoat2:mov xor ax,ax
ah,9 xor bp,bp
lea dx,xau3 mov cx,n
int 21h cong:add
mov ah,2 ax,a[bp]
sub bl,31h add bp,2
;Bµi11/NhËp mov dl,bl loop cong
mét ký tù in ra int 21h @write'Tong= '
m· ;ASCII ë ;Bai12/Nhap
mot jmp het call in_so
d¹ng het:int 20h int 20h
Hexa(cn11.as so ;1<=N<=32
767.Hay xac ;Bµi13/ NhËp code ends include
m) mét ch÷ c¸i tõ end start proc.asm
code segment dinh do
co ;phai la so A->F(hoÆc a- Bµi14/NhËp code ends
assume cs:code >f).H·y in ra mét m¶ng end start
org 100h hoan
thien ;khong? sè thËp ph©n word.In m¶ng
start: jmp over t¬ng ;øng. trªn mét dßng
xau1 db 'Nhap (cn12.asm) Bµi15/NhËp
include NÕu sai th× vµ tÝnh N.1<=N<=20.T
mot ky tu: $' yªu cÇu nhËp tæng(CN14.A
xau db mylib.mac ×m sè
code segment l¹i (cn07.asm) SM) Fib«naxi thø
0ah,0dh,'Ma code segment include
ASCII o dang assume cs:code N(§îc dïng th
org 100h assume cs:code mylib.mac viÖn)
Hexa la: $' org 100h code segment
over: start: jmp over
n dw ? start: jmp over assume cs:code include
mov ah,9 xau1 db org 100h
lea dx,xau1 uoc dw 1 mylib.mac
over: 13,10,'Nhap start: jmp over code segment
int 21h mot mot ky tu: a dw 30 dup (?)
mov ah,1 @write'Nhap assume cs:code
N= ' $' n dw ? org 100h
int 21h xau2 db over:
mov bl,al call nhap_so start: jmp over
mov n,ax 0ah,0dh,'Nhap @write'Nhap n dw ?
mov ah,9 lai : $' so phan tu: '
lea dx,xau mov cx,2 over:
lap: xau3 db call nhap_so @write'Nhap
int 21h 0ah,0dh,'Doi ra mov n,ax
mov bh,0 xor dx,dx n= '
mov ax,n thap phan : 1$' mov cx,n call nhap_so
mov ah,2 over: xor bp,bp
lap:xor dl,dl div cx mov n,ax
cmp dx,0 mov ah,9 mov bx,1 @xuongdong
mov cx,4 lea dx,xau1 nhap:@xuongd
lap1: jne qua @write'So
add uoc,cx int 21h ong Fibonaxi thu '
shl bl,1 mov ah,1 @write'Nhap
rcl dl,1 qua: call in_so
inc cx int 21h phan tu thu ' @write' = '
loop lap1 mov bl,al mov ax,bx
cmp dl,9 cmp cx,n cmp ax,2
jl lap cmp al,'A' call in_so ja qua
ja qua jb nhaplai inc bl
add dl,30h mov ax,1
cmp al,'F' @write' : ' call in_so
jmp inra @xuongdong jbe thoat1 call nhap_so
qua:add dl,37h mov ax,n jmp het
cmp al,'a' mov a[bp],ax qua:
inra: int 21h cmp ax,uoc jb nhaplai add bp,2
inc bh je qua1 mov cx,2
cmp al,'f' loop nhap mov dx,1
cmp bh,2 jbe thoat2 @xuongdong
jb lap @write'Khong mov ax,1
nhaplai: @write'Mang cong:
mov ah,2 phai so hoan mov ah,9 vua nhap la: '
mov dl,'h' thien' add ax,dx
lea dx,xau2 mov cx,n sub dx,ax
int 21h jmp het int 21h xor bp,bp
int 20h qua1: neg dx
jmp over inc cx
 cmp cx,n khac: code ends jmp nhap jmp het
jb cong mov ah,9 end start hetnhap: sole:
call in_so lea dx,xau2 mov ah,9
het: int 21h @xuongdong lea dx,xau2
int 20h het: @write'Xau int 21h
include int 20h da nhap la: ' het:
proc.asm code ends xor bx,bx int 20h
code ends end start xor bp,bp code ends
end start chuyen: end start
mov
al,xau[bx]
mov
xau1[bp],al
inc bx
inc bp
cmp bx,n
jbe chuyen
mov
xau1[bp],'$'
inra:mov ah,9
lea dx,xau1
int 21h
int 20h
include
proc.asm
code ends
end start
Bµi16/NhËp
mét ký tù nÕu
®ã lµ ch÷ sè Bµi17/Cho
th× in ra: ®ã AX=1 sè
lµ ch÷ sè ngîc nguyªn 2 byte Bµi18/Cho
l¹i: §ã kh«ng d¹ng thËp AX=1 sè Bµi19/NhËp
ph¶i ch÷ lµ sè ph©n in ra sè nguyªn 2 byte mét sè cã mét
code segment ngîc l¹i d¹ng thËp ch÷ sè. H·y Bµi20/Cho
assume cs:code ph©n in ra sè cho biÕt sè ®ã BX=1 sè Hexa
org 100h include ngîc l¹i lµ ch½n hay lÎ. in ra d¹ng nhÞ
start: jmp over mylib.mac include ph©n mçi
xau db 'Nhap 1 code segment mylib.mac code segment nhãm 4 bit
ky tu: $' assume cs:code code segment assume cs:code c¸ch nhau bëi
xau1 db org 100h assume cs:code org 100h mét dÊu c¸ch.
0ah,0dh,'ky tu start: jmp over org 100h start: jmp over
vua nhap la chu n dw ? start: jmp over xau1 db include
so$' over: xau db 80 'nhap so co mot mylib.mac
xau2 db mov dup (?) chu so: $' code segment
0ah,0dh,'ky tu ax,12345 xau1 db 80 xau2 db assume cs:code
vua nhap khong mov n,ax dup (?) 0ah,0dh,'Day la org 100h
phai chu so $' @write'So n dw ? so le$' start:
over: nguoc la: ' over: xau3 db mov
mov ah,9 mov cx,10 0ah,0dh,'Day la bx,0F5C4h
lea dx,xau chia: @write'Nhap so chan$' @write'so o
int 21h xor dx,dx xau: ' over: dang nhi phan
mov ah,1 mov ax,n mov ah,1 mov ah,9 la : '
int 21h div cx xor bx,bx lea dx,xau1 mov cx,16
cmp al,'0' mov n,ax nhap: int 21h xor dh,dh
jb khac mov ax,dx int 21h mov ah,1 mov ah,2
cmp al,'9' call in_so cmp al,0dh int 21h lap:
ja khac cmp n,0 je hetnhap test al,1 rol bx,1
mov ah,9 ja chia mov jne sole mov dl,0
lea dx,xau1 int 20h xau[bx],al mov ah,9 adc dl,30h
int 21h include inc bx lea dx,xau3 int 21h
jmp het proc.asm mov n,bx int 21h inc dh
cmp dh,4 je het1 call nhap_so je hetnhap xor cx,cx
jne het mov mov n,ax mov mov cl,N
mov ah,2 xau1[bx],al @xuongdong xau[bx],al and cl,0fh
mov dl,32 inc bx call in_so inc bx inra:
int 21h jmp nhap1 @write'!= ' jmp nhap mov ax,1
xor dh,dh het1:mov n,bx cmp n,0 hetnhap: nhan:mul cx
het: @xuongdong je qua @xuongdong loop nhan
loop lap @write'Nhap mov cx,n @write'Ten la: ' push ax
int 20h xau thu hai: ' mov ax,1 mov dl,32 mov ah,9
code ends xor bp,bp lap: dec bx lea dx,tb2
end start mov ah,1 mul cx xor bp,bp int 21h
nhap2:int 21h loop lap kt: pop ax
cmp al,0dh mov cx,10 cmp mov bx,10
je het2 div cx xau[bx],dl xor cx,cx
mov call in_so jne qua chiatiep:xor
xau2[bp],al mov ax,dx dec bx dx,dx
inc bp call in_so jmp kt div bx
jmp nhap2 jmp het qua:xor cx,cx push dx
het2:@xuongd qua: tru:cmp inc cx
ong mov ah,2 xau[bx],dl cmp ax,0
sosanh:cmp mov dl,'1' je qua1 jmp chiatiep
bx,bp int 21h dec bx mov ah,2
jne thoat het: inc cx layra:pop dx
mov bx,n int 20h jmp tru or dl,30h
xor bx,bx include qua1:inc bx int 21h
xor bp,bp proc.asm mov loop layra
sosanh2:mov code ends dl,xau[bx] int 20h
dl,xau1[bx] end start mov code ends
cmp ten[bp],dl end start
dl,xau2[bp] inc bp
jne thoat loop qua1
inc bx mov
inc bp ten[bp],'$'
cmp bx,n mov ah,9
jb sosanh2 lea dx,ten
@write'Hai xau int 21h
Bµi21/NhËp da cho co noi het:int 20h
hai x©u tuú ý dung nhu nhau' include
cho biÕt hai jmp het Bµi22/NhËp proc.asm code
x©u ®ã cã thoat:@write'ha mét x©u chøa ends end start
b»ng nhau i xau da cho hä tªn mét ng- Bµi24/NhËp
kh«ng (vÒ ®é khac nhau' êi, t¸ch tªn vµ 1<=N<=8.H·y
dµi vµ néi het:int 20h in ra x©u chøa tÝnh N!
dung). include tªn.(Sd th (khong dïng
include proc.asm viÖn). th viÖn) Bµi25/Cho
mylib.mac code ends include BX= mét sè
code segment end start mylib.mac code segment Hexa in ra sè
assume cs:code Bµi23/NhËp 1 code segment assume cs:code ®ã.
org 100h assume cs:code org 100h
≤ N ≤ 8. H·y
start: jmp over org 100h start:jmp over code segment
tÝnh N!. ( §îc
n dw ? start: jmp over tb1 db 'Nhap assume cs:code
dïng th viÖn ).
xau1 db 80 xau db 80 N=$' org 100h
dup (?) dup (?) tb2 db 13,10 start: jmp over
include
xau2 db 80 ten db 30 N db ?,'?=$' xau db 'So da
mylib.mac
dup (?) dup (?) over: cho la: $'
code segment
over: over: mov dx,offset over:
assume cs:code
@write'Nhap @write'Ho va tb1 mov
org 100h
xau thu nhat: ' ten: ' mov ah,9 bx,0D3F4h
start: jmp over
xor bx,bx xor bx,bx int 21h mov ah,9
n dw ?
mov ah,1 mov ah,1 mov N,al lea dx,xau
over:
nhap1:int 21h nhap: int 21h cmp al,'0' int 21h
@write'Nhap
cmp al,0dh cmp al,0dh je inra mov cl,12
n= '
mov ah,2 @write 'Nhap max dw ? xau1 db start: jmp over
lap: N=' min dw ? 'nhap mot so xau1 db 'Nhap
mov dx,bx call Nhap_so n dw ? nhi phan: $' ky tu thu nhat:
shr dx,cl mov N,ax over: xau2 db $'
and dl,0fh xor ax,ax @write'Nhap 0ah,0dh,'Cac xau2 db
cmp dl,9 mov cx,N so phan tu n= ' bit co nghia: $' 0ah,0dh,'Nhap
jbe so cong:add ax,cx call nhap_so over: ky tu thu 2: $'
add dl,7 loop cong mov n,ax mov ah,9 xau3 db
so: @xuongdong @write'Nhap lea dx,xau1 0ah,0dh,'In
add dl,30h @write 'tong tu mang: ' int 21h theo thu tu tu
int 21h 1-->' mov cx,n mov ah,1 dien: $'
sub cl,4 push ax xor bx,bx xor bx,bx over:
cmp cl,0 mov ax,N nhap:@xuongd nhap:int 21h mov ah,9
jge lap call in_so ong cmp al,0dh lea dx,xau1
int 20h @write 'la:' @write'Nhap je thoat int 21h
code ends pop ax mot phan tu: ' sub al,30h mov ah,1
end start mov bx,10 call nhap_so shl bx,1 int 21h
xor dx,dx mov a[bx],ax or bl,al mov bl,al
div bx add bx,2 jmp nhap mov ah,9
cmp ax,0 loop nhap thoat:mov ah,9 lea dx,xau2
je qua xor bp,bp lea dx,xau2 int 21h
call in_so mov cx,n int 21h mov ah,1
qua:mov ax,dx push a[bp] cmp bx,0 int 21h
call in_so a[bp] je inso0 mov bh,al
int 20h pop min max mov cx,16 mov ah,9
include timmax:mov xoa:rol bx,1 lea dx,xau3
proc.asm ax,a[bp] jc qua int 21h
code ends cmp ax,max dec cx mov cl,bl
end start jbe timmin jmp xoa cmp bh,cl
mov max,ax qua:mov ah,2 ja inbl
jmp het jmp inso1 xchg bh,bl
timmin:cmp inso:rol bx,1 inbl:mov ah,2
min,ax jc inso1 mov dl,bl
jb het mov dl,'0' int 21h
mov min,ax jmp inra mov ah,2
het:add bp,2 inso1:mov dl,'1' mov dl,' '
loop timmax inra:int 21h int 21h
@xuongdong dec cx mov ah,2
@write'Max= ' cmp cx,0 mov dl,bh
mov ax,max ja inso int 21h
call in_so jmp het het:int 20h
@xuongdong inso0:mov ah,2 code ends
@write'Min= ' mov dl,'0' end start
mov ax,min int 21h
call in_so het:int 20h
int 20h code ends
Bµi26/NhËp 1 include end start
≤ N ≤ 360. H·y proc.asm
tÝnh tæng S = code ends
1 + 2 + … + N. Bµi27/ NhËp end start
(§îc dïng th mét m¶ng Bµi28/NhËp
viÖn). Word. H·y vµo mét sè
t×m Max, Min nhÞ ph©n tèi
include vµ in ra.(Sö ®a 16 bite in
dông th viÖn). ra c¸c bÝt cã Bµi29/NhËp
mylib.mac
include nghÜa. hai kÝ tù in
code segment
mylib.mac theo thø tù tõ
assume cs:code Bµi30/Cho 1 ≤
code segment code segment ®iÓn.
org 100h a,b ≤ 9. TÝnh
start:jmp over assume cs:code assume cs:code TBC cña
org 100h org 100h code segment
N dw ? chóng.
start: jmp over start: jmp over assume cs:code
over:
a dw 30 dup (?) org 100h
code segment
assume cs:code xøng kh«ng. Bµi32/Cho AX code ends
org 100h (CN30.ASM) = 1 sè nguyªn 2 Bµi33/NhËp end start
start: jmp over byte cã dÊu. mét x©u.§Õm
xau1 db 'Nhap include H·y in sè n®ã sè tõ cña mét Bµi34/Cho 1 ≤
a= $' mylib.mac ra mµn h×nh. x©u
xau2 db code segment (CN33.ASM) a,b ≤ 360.
include TÝnh tÝch
0ah,0dh,'Nhap assume cs:code mylib.mac
b= $' org 100h code segment A*B b»ng
code segment thuËt to¸n
xau3 db start: jmp over assume cs:code assume cs:code
0ah,0dh,'TBC= xau db 80 org 100h nh©n Ên §é.
org 100h include
$' dup (?) start: jmp over start: jmp over
xau4 db '.5$' over: xau db 'So mylib.mac
xau db 80 dup code segment
over: da cho la: $' (?)
mov ah,9 @write'Nhap over: assume cs:code
over: org 100h
lea dx,xau1 mot xau tuy y: ' mov ah,9
int 21h xor bx,bx lea dx,xau start: jmp over
@write'Nhap a dw ?,
mov ah,1 mov ah,1 int 21h xau: '
int 21h nhap: mov ax,- 0ah,0dh,'$'
xor bx,bx b dw ?
mov bl,al int 21h 54321 mov ah,1
mov ah,9 cmp al,0dh push ax over:
nhap: @write'Nhap
lea dx,xau2 je hetnhap mov ah,2 int 21h
int 21h mov mov dl,'-' a= '
cmp al,0dh call nhap_so
mov ah,1 xau[bx],al int 21h je hetnhap
int 21h inc bx pop ax mov a,ax
mov @xuongdong
xor ah,ah jmp nhap neg ax xau[bx],al
add bx,ax hetnhap: xor cx,cx @write'Nhap
inc bx b= '
mov ah,9 mov bx,10 jmp nhap
lea dx,xau3 @xuongdong chia: call nhap_so
hetnhap: @xuongdong
int 21h xor bp,bp xor dx,dx mov dl,32
mov cx,bx sosanh: div bx mov b,ax
xor bp,bp mov bx,b
shr bx,1 dec bx inc cx kt:
mov ah,2 mov push dx mov dx,bx
cmp mov ax,a
mov dx,bx dl,xau[bx] cmp ax,0 xau[bp],dl
int 21h cmp jg chia xor cx,cx
jne lap1 lap:
test cx,1 dl,xau[bp] mov ah,2 inc bp
je qua jne thoat inra: test dl,1
jmp kt je qua
mov ah,9 inc bp pop dx lap1:xor cx,cx
lea dx,xau4 cmp bx,bp add dx,30h add cx,ax
dec bx qua:
int 21h jae sosanh int 21h lap:
qua: @write'Xau loop inra shl ax,1
cmp shr bx,1
int 20h da cho la doi int 20h xau[bx],dl
code ends xung' code ends mov dx,bx
jne qua cmp bx,0
end start jmp het end start dec bx
thoat: jne lap
jmp lap mov ax,cx
@write'Xau qua:cmp
da cho khong @write'Tich = '
xau[bx],dl cmp ax,10
doi xung' je qua1
het: jb qua2
dec bx mov cx,10
int 20h jmp qua
include div cx
qua1:inc cl call in_so
proc.asm cmp bx,bp
code ends mov ah,2
jge lap add dx,30h
end start het: int 21h
@xuongdong jmp het
@write'So qua2:call in_so
tu cua xau la: ' het:
xor ah,ah int 20h
Bµi31/NhËp mov al,cl include
mét x©u. X©u call inso proc.asm
®ã cã ®èi int 20h code ends
include end start
proc.asm
 End start Include @write'mang
proc.asm da dao la:'
Code ends call in_mang
End start int 20h
include
proc.asm
in_mang proc
Bµi35/Sö dông push ax bx cx
chøc n¨ng Bµi36/NhËp lea bx,a
AH=8 ®Ó mét m¶ng mét mov cx,n
nhËp mét d·y chiÒu c¸c Bµi37/NhËp inra:mov ax,
kÝ tù nÕu lµ word.TÝnh mét m¶ng mét [bx]
kÝ tô vµ dÊu tæng c¸c phÇn chiÒu c¸c call in_so
c¸ch th× in ra. tö ch½n cña word.TÝnh @write ' '
Bµi38/ViÕt
m¶ng vµ in ra tæng c¸c phÇn thñ tôc in add bx,2
code segment tæng(Th viÖn) tö lÎ cña m¶ng loop inra
assume cs:code m¶ng ®Ó in
vµ in ra m¶ng 1 chiÒu pop cx bx ax
org 100h Include tæng(Th viÖn) ret in_mang
start: jmp over c¸c word(c¸c
mylib.mac byte).H·y endp
xau db Code segment Include code ends
'Nhap day ky tu nhËp1m¶ng,g
Assume mylib.mac äi thñ tôc vµ end start
chi in chu cai cs:code Code segment
va dau cach: $' in ra
Org 100h Assume m¶ng.§¶o ngîc Bµi39/NhËp 1
xau2 db Start:jmp over cs:code x©u kÝ tù
0ah,0dh,'$' c¸c phÇn tö
N dw 0 Org 100h trong chuyÓn c¸c kÝ
over: A dw 80 dup(?) Start:jmp over tù lµ ch÷ th-
mov ah,9 m¶ng,gäi thñ
Over: N dw 0 tôc ®ã ®Ó in êng cña x©u
lea dx,xau @write’nhap so A dw 80 dup(?) ®ã ra x©u
int 21h ra m¶ng ®¶o
phan tu cua Over: include kh¸c vµ in ra
lea dx,xau2 mang:’ @write’nhap so x©u thø hai(sö
int 21h mylib.mac
Call nhap_so phan tu cua code segment dông th viÖn)
nhaptiep: Mov n,ax mang:’
mov ah,8 assume cs:code
@xuongdong Call nhap_so org 100h include
int 21h @write’nhap Mov n,ax mylib.mac
cmp al,32 start:jmp over
mang vao:’ @xuongdong a dw 20 dup(?) code segment
je inra Lea di,a @write’nhap assume cs:code
cmp al,'A' n dw ?
Mov cx,n mang vao:’ over: org 100h
jb qua Cld Lea di,a start:jmp over
cmp al,'Z' @write'cho so
Lap: Mov cx,n phan tu n=' xau1 db 80
jbe inra @xuongdong Cld dup('$')
cmp al,'a' call nhap_so
Call nhap_so Lap: mov n,ax xau2 db 80
jb qua Stosw @xuongdong dup('$')
cmp al,'z' lea bx,a
Loop lap Call nhap_so mov cx,n over:
ja qua Xor si,si Stosw @write'nhap
inra: nhap:@xd
Xor ax,ax Loop lap @write'nhap xau:'
mov ah,2 Mov cx,n Xor si,si lea di,xau1
mov dl,al mot phan tu:'
Lap1: Xor ax,ax call nhap_so xor cx,cx
int 21h test a[si],1 Mov cx,n cld
jmp mov [bx],ax
Jnz sole Lap1: push ax mov ah,1
nhaptiep Add ax,a[si] Test a[si],1 lap:int 21h
qua: add bx,2
Sole: Jz sochan loop nhap cmp al,13
cmp al,27 add si,2 Add ax,a[si] je chuyen
jne nhaptiep @xuongdong
Loop lap1 Sochan: @write'mang stosb
int 20h @xuongdong add si,2 inc cx
code ends da nhap la:'
@write’tong loop lap1 call in_mang jmp lap
end start cac phan tu @xuongdong chuyen:xor si,si
xor bx,bx
chan la:’ @write’tong mov cx,n lea di,xau2
Call in_so cac phan tu le dao:pop a[bx] duyet:mov
Int 20h la:’ add bx,2 al,xau1[si]
Include Call in_so loop dao cmp al,'a'
proc.asm Int 20h @xuongdong jb qua
Code ends cmp al,'z'
ja qua inc si Call Call IN_SO Qua:
stosb loop duyet Nhap_so @Write ' ' MOV
qua:inc si @xuongdong mov a[bx],ax ADD BX,2 [DI],AL
loop duyet @write'xau thu LOOP INC DI
@xuongdong hai la:' @Xuong_dong @LapIN INC CX
@write'xau thu mov ah,9 Add bx,2 INT 20h JMP
hai la:' lea dx,xau2 inc cx Include LapNhap
mov ah,9 int 21h cmp cx,n PROC.ASM ; EndLapNhap:
lea dx,xau2 int 20h JB lapnhap Khai bao thu
int 21h include ;Sap xep vien thu tuc @Xuong_dong
int 20h proc.asm mang code ends @Write 'Xau
include code ends MOV I,0 End start chu hoa:'
proc.asm end start LEA DX,xau
code ends @FOR_I: ;For MOV AH,9
end start i:=0 To N-1 INT 21h
DO INT 20h
PUSH I Include
POP J PROC.ASM ;
MOV BX,I Khai bao thu
Bµi40/NhËp 1 ADD BX,I vien thu tuc
x©u kÝ tù code ends
chuyÓn c¸c kÝ Bµi41/NhËp @FOR_J: ;For End start
tù lµ ch÷ hoa mét m¶ng J:=1 To N DO
cña x©u ®ã ra Byte hoÆc INC J
x©u kh¸c vµ in Word, s¾p MOV BP,J
ra x©u thø xÕp m¶ng vµ CMP BP,N
hai(sö dông th in ra m¶ng ®· JAE
viÖn) s¾p xÕp. (Sö @ENDFOR_J
dông ADD BP,J Bµi42/NhËp
include PROC.ASM MOV mét x©u ch÷
mylib.mac vµ AX,A[BP] thêng, in ra Bµi43/NhËp
code segment MYLIB.MAC) CMP x©u ch÷ hoa. mét m¶ng,
assume cs:code . A[BX],AX (Sö kiÓm tra
org 100h JBE Qua dông)MYLIB. m¶ng cã ph¶i
start:jmp over include MOV MAC). lµ mét d·y
xau1 db 80 MYLIB.MAC BX,BP Include ®¬n ®iÖu hay
dup('$') Code Segment Qua: MYLIB.MAC kh«ng? (Sö
xau2 db 80 org 100h JMP ;Khai bao thu dông
dup('$') assume cs:code @FOR_J vien MACRO PROC.ASM
over: start: JMP over @ENDFOR_J: Code Segment vµ
@write'nhap A DW 20 MOV BP,I org 100h MYLIB.MAC)
xau:' DUP (0) ADD assume cs:code .
lea di,xau1 N DW ? BP,BP start: JMP over
xor cx,cx I DW ? PUSH xau DB 80 include
cld J DW ? A[BP] A[BX] Dup ('$') MYLIB.MAC
mov ah,1 Over: POP Over: ;Khai bao thu
lap:int 21h @write A[BP] A[BX] @Write vien MACRO
cmp al,13 'Nhap so phan INC I 'Nhap mot xau:' Code Segment
je chuyen tu=' MOV AX,I MOV AH,1 org 100h
stosb Call CMP AX,N LEA DI,Xau assume cs:code
inc cx Nhap_so JB XOR CX,CX start: JMP over
jmp lap Mov n,ax @FOR_I LapNhap: A DW 20 DUP
chuyen:xor si,si xor bx,bx INT 21h (0)
lea di,xau2 xor cx,cx CMP AL,13 N DW ?
@ENDFOR_I: JE
duyet:mov @Writeln Over:
al,xau1[si] @Xuong_dong EndLapNhap @write 'Nhap
'----->>> In Cmp AL,'a'
cmp al,'A' LapNhap:@Wr mang <<<-----' so phan tu='
jb qua ite 'Nhap so thu JB Qua Call Nhap_so
XOR BX,BX CMP AL,'z'
cmp al,'Z' ' MOV CX,N MOV N,AX
ja qua Mov ax,cx JA Qua XOR BX,BX
@LapIN: XOR
stosb Call IN_SO MOV XOR CX,CX
qua: @Write ':' AL,20h @Xuong_dong
AX,A[BX]
LapNhap: MOV Tiep: Include
@Write 'Nhap AX,A[BX] ADD BX,2 PROC.ASM ;
so thu ' CMP LOOP Khai bao thu
MOV AX,CX AX,A[BX+2] Lap_KTr vien thu tuc
Call IN_SO JL Qua XOR DX,DX code ends
@Write ':' INC DX Thoat: End start
Call Nhap_so Qua: Cmp DX,0
MOV INC DX JNE Qua2
A[BX],AX Lap_KTr: @Write 'Day la
@Xuong_dong MOV mot day don
ADD BX,2 AX,A[BX] dieu'
INC CX CMP jmp Ketthuc
CMP CX,N AX,A[BX+2] Qua2:
JB LAPNhap JG Qua1 @Write 'Day
XOR BX,BX CMP DX,1 khong phai la
XOR DX,DX JNE Thoat mot day don
DEC CX Jmp Tiep dieu'
CMP N,2 Qua1: Ketthuc:
JB Thoat CMP DX,2 INT 20h
JNE Thoat