- •24. Ввод символа. Определить его позицию в строке и вывести на экран
- •Int 21h
- •30. Найти сумму элементов четных строк матрицы.
- •37. Перевод числа из одной системы счисления в другую. Данные вводить с клавиатуры.
- •Int 21h
- •42. Работа с окнами в текстовом режиме.
- •Inc si ;перейти к следующему элементу
- •Int 21h
- •59. Арифметические операции со знаковыми и беззнаковыми числами.
- •60. Процедуры в ассемблере, передача параметров, возврат значений.
- •61. Операции с файлами: создание, открытие, закрытие.
- •Int 21h ;открываем файл
- •Int 21h ;закрываем файл
- •62. Операции с файлами: чтение и запись данных.
- •Int 13h ;
- •Int 25h ;функция чтения секторов
30. Найти сумму элементов четных строк матрицы.
.model small
.stack 100h
.data
mes1 db 10,13,"Vvedite elementy matricy(5*4)!!$"
mes3 db 10,13,"Suuma 4etnyx strok(5*4):$",10,13
mes2 db 10,13,"$"
mas db 20 dup(0)
sum dw 5 dup(0)
.code
begin:
mov ax,@data
mov ds,ax
lea dx,mes1
mov ah,9h
int 21h
xor bx,bx
mov cx,20
again:
mov ah,1
int 21h
sub al,'0'
mov mas[bx],al
inc bx
loop again
lea dx,mes2
mov ah,9
int 21h
mov cx,20
xor bx,bx
xor dh,dh
output:
mov dl,mas[bx]
add dx,30h
mov ah,2
int 21h
inc bx
loop output
xor cx,cx
mov cl, 4 ;4islo strok
lea bx,mas ;adres matricy
add bx,4 ;perexod na 4etnuju str
mov si,0
p2: push cx
mov di,0
xor dx,dx ; dlja xranenija summy
mov cx,4 ; kol-vo stolbcov
p1:
mov al,[bx+di]
cbw
add dx,ax
inc di
loop p1
mov sum[si],dx
add si,2
add bx,8 ;na sled 4etnuju stroku
pop cx
dec cx
loop p2
xor dx,dx
lea dx,mes3
mov ah,9
int 21h
mov dx,sum[0]
add dx,30h
mov ah,09h
int 21h
mov dx,sum[2]
add dx,30h
mov ah,09h
int 21h
exit:
mov ah,4ch
int 21h
end begin
31 Ввести массив чисел, найти min и max, вывести на экран
.model small
.stack 100h
.data
massiv dw 80 dup(?)
msg1 db 0ah,0dh,"Vvodite chisla ",0ah,0dh,"$"
msg2 db 0ah,0dh,"max = $"
msg3 db 0ah,0dh,"min = $"
c10 dw 10
.code
start:
mov ax,@data
mov ds,ax
mov ah,09h ; вывод приглашения для ввода чисел
lea dx,msg1
int 21h
mov di,0 ; в di - max
mov si,32767 ; в si - min
xor dx,dx ; в dx - очередное число
input_loop:
mov ah,01h ; ввод символа
int 21h
cmp al,0dh ; если enter
je chislo ; то занести число в массив
cmp al,20h ; если пробел
je chislo ; то занести число в массив
sub al,30h ; вычитаем '0'
mov cl,al ; сохраняем цифру в cl
mov ax,dx ; в ax - введенное число
mul c10 ; умножаем на 10
xor ch,ch
add ax,cx ; добавляем цифру из al
mov dx,ax ; число снова в dx
jmp input_loop
chislo:
mov bx,cx ; в bx - порядковый номер очередного числа
shl bx,1 ; теперь - смещение очередного числа в массиве
mov massiv[bx],dx ; записываем в массив число
inc cx ; увеличиваем счетчик введенных чисел
cmp dx,si ; сравниваем число с минимальным
jb minimum ; если оно меньше, то jmp на minimum
cmp dx,di ; сравниваем число с максиальным
jg maximum ; если оно больше, то jmp на maximum
jmp chislo_cont ; иначе jmp на chislo_cont
minimum:
mov si,dx ; запоминаем минимальное число в si
jmp chislo_cont
maximum:
mov di,dx ; запоминаем максимальное число в di
chislo_cont:
xor dx,dx ; dx в ноль
cmp cx,80 ; если ввели 80-ое число
je end_input ; то конец ввода
cmp al,0dh ; если был нажат enter
je end_input ; то конец ввода
jmp input_loop
end_input:
mov ah,09h ; вывод на экран msg2
lea dx,msg2
int 21h
mov ax,di ; передаем в функцию output max через ax
call output ; выводим это число
lea dx,msg3 ; вывод на экран msg3
mov ah,9
int 21h
mov ax,si ; передаем в ouptput min через ax
call output ; выводим это число
mov ah,4ch ; завершение программы
int 21h
output proc ; процедура вывода числа, находящегосы в ax
xor cx,cx ; счетчик цифр
div_loop:
xor dx,dx ; подготовка к делению
div c10 ; деление
add dx,30h ; в dx - ASCII-код остатка от деления
push dx ; сохраняем его в стеке
inc cx ; инкремент счетчика
cmp ax,0 ; деление, покуда частное не нулевое
je out_loop
jmp div_loop
out_loop: ; цикл вывода числа
pop dx ; извлекаем из стека очередной остаток
mov ah,02h ; и выводим его на экран
int 21h
loop out_loop ; цикл продолжается cx раз
ret
output endp
end start
32. В сегменте данных расположены числа в формате двойного слова. С клавиатуры вводится число и определяется, имеется ли это число в сегменте данных.
.model small
.stack 100h
.data
massiv dd 12345678,13579246,24681357
chislo dd 0
c10 dw 10
str1 db 0ah,0dh,"Vvedite chislo:",0ah,0dh,'$'
str2 db 0ah,0dh,"Vvedennoe chislo ne naydeno.",0ah,0dh,'$'
str3 db 0ah,0dh,"Vvedennoe vami chislo naydeno!",'$'
.code
.386
start:
mov ax,@data
mov ds,ax
mov ah,09h
lea dx,str1
int 21h
input_loop:
mov ah,01h
int 21h
cmp al,0dh
je end_input
sub al,30h
xor bx,bx
mov bl,al
xor dx,dx ; ввод длинного числа
mov ax,word ptr[chislo+2]
mul c10
mov word ptr[chislo+2],ax
mov ax,word ptr[chislo]
mul c10
add dx,word ptr[chislo+2]
add ax,bx
mov word ptr[chislo],ax
mov word ptr[chislo+2],dx
jmp input_loop
end_input:
mov cx,offset chislo ; в сх - количество чисел
sub cx,offset massiv
shr cx,2
mov ax,word ptr[chislo] ; в ax - младшее слово числа
mov dx,word ptr[chislo+2] ; в dx - старшее слово числа
cmp_loop: ; цикл сравнения
mov bx,cx
dec bx
shl bx,2
add bx,offset massiv
cmp ax,word ptr[bx]
je continue_cmp
jmp cmp_end
continue_cmp:
add bx,2
cmp dx,word ptr[bx]
je find
cmp_end: ; если ничего не найдено
loop cmp_loop
mov ah,09h
mov dx,offset str2
int 21h
jmp end_start
find: ; если число найдено
mov ah,09h
mov dx,offset str3
int 21h
end_start:
mov ah,4ch
int 21h
end star
33. Ввести массив чисел и отсортировать методом пузырька
.model small
.stack 100h
.data
massiv dw 80 dup(?)
msg db "Vvodite chisla cherez probel, okonchanie vvoda - ENTER",0ah,0dh,'$'
c10 dw 10
.code
start:
mov ax,@data
mov ds,ax
mov ah,09h ; вывод msg
lea dx,msg
int 21h
xor bx,bx ; bx - смещение в массиве вводимого числа
xor dx,dx ; dx - вводимое число
input_loop:
mov ah,01h ; считваем очередной символ
int 21h
cmp al,0dh ; если это enter
je chislo
cmp al,20h ; или пробел
je chislo
sub al,30h ; иначе - получаем цифру
mov cl,al ; сохраняем ее в cl
mov ax,dx ; в ax - вводимое число
mul c10 ; умножаем на 10
xor ch,ch
add ax,cx ; добавляем к результату последнюю цифру
mov dx,ax ; в dx - полученное число
jmp input_loop
chislo: ; если окончен ввод числа
mov massiv[bx],dx ; запись этого числа в массив
add bx,2 ; смещаемся к следующему элементу
cmp bx,160 ; если массив заполнен
je end_input ;
cmp al,0dh ; или последнее число
je end_input ; то конец ввода
xor dx,dx ; обнуляем dx для ввода следующего числа
jmp input_loop
end_input:
mov cx,bx ; в cx - (количество введенных чисел + 1) * 2
shr cx,1 ; cx = cx \ 2
dec cx ; теперь в cx - количество введенных чисел
call sort ; сортировка
mov ah,4ch
int 21h
sort proc
loop1:
xor bx,bx ; bx - смещение в массиве
push cx ; сохраняем cx в стеке
loop2:
mov ax,massiv[bx]
cmp ax,massiv[bx][2] ; сравниваем два соседних элемента
jl cont_loop2 ; если правый больше левого, то продолжить цикл
mov dx,massiv[bx][2] ; иначе - перестановка
push massiv[bx][2]
push massiv[bx]
pop massiv[bx][2]
pop massiv[bx]
cont_loop2:
add bx,2 ; смещаемся к следующему элементу в массиве
loop loop2
pop cx ; восстанавливаем cx
loop loop1
ret
sort endp
end start
34.Вывести строку в обратном порядке.
.model small
.stack 100h
.data
msg1 db 0Ah,0Dh,"Enter string <80(char)",0Ah,0Dh,'$'
string db 80 dup(?)
msg2 db 0Ah,0Dh,"Reversing string",0Ah,0Dh,'$'
.code
start: mov ax,@data
mov ds,ax
lea dx,msg1
mov ah,09h
int 21h
mov cx,80
xor si,si
l1: mov ah,01h
int 21h
cmp al,0Dh
je continue
mov string[si],al
inc si
loop l1
continue: mov ah,09h
lea dx,msg2
int 21h
cmp si,0
je exit
dec si
mov cx,si
l2: mov si,cx
mov dl,string[si]
mov ah,02h
int 21h
loop l2
mov dl,string[0]
mov ah,02h
int 21h
exit:
mov ah,4Ch
int 21h
end start
35. Ввести с клавиатуры массив чисел. Найти суммы положительных и отрицательных чисел. Вывести результат.
.model small
.stack 256
.data
mas dw 8 dup(0)
zz db 0Dh, 0Ah,'-$'
.code
start:
mov ax,@data
mov ds,ax
mov cx,8
mas_in:
xor bx,bx
num_s_in:
cmp bx,6
je end_num_s_in
mov ah,01h
int 21h
cmp al,0Dh
je end_num_s_in
inc bx
xor ah,ah
push ax
jmp num_s_in
end_num_s_in:
mov bp,1
xor di,di
num_p:
cmp bx,1
je end_num_p
pop ax
sub al,'0'
mul bp
add di,ax
mov ax,bp
mov bp,10
mul bp
mov bp,ax
dec bx
jmp num_p
end_num_p:
pop ax
cmp al,'-'
jne ee
neg di
ee:
mov ax,cx
;sub ax,2
shl ax,1
mov si,offset mas
add si,ax
mov word ptr [si],di
loop mas_in
____SOBSTVENNO SLOGENIE____
mov di,offset mas
xor ax,ax ;summa bolhih 0
xor bx,bx ;summa menshih 0
mov cx,9
add_num:
cmp word ptr[di],0
jl add_less_zero
add ax,word ptr [di]
jmp e
add_less_zero:
add bx,word ptr [di]
e:
add di,2
loop add_num
___VYVOD_______
div_num_s:
mov cx,10
xor bp,bp
div_num:
cmp ax,0
je end_div_num
xor dx,dx
div cx
add dx,'0'
push dx
inc bp
jmp div_num
end_div_num:
vyvod:
cmp bp,0
je end_vyvod
pop ax
mov ah,02h
mov dl,al
int 21h
dec bp
jmp vyvod
end_vyvod:
cmp bx,0
je exit
neg bx
mov ah,9
mov dx,offset zz
int 21h
mov ax,bx
xor bx,bx
jmp div_num_s
exit:
mov ax,4C00h
int 21h end start
36.Дан массив строк. Найти строку с max длинной и вывести ее на экран.
.model small
.stack 100h
.data
str0 db "Hello",'$'
str1 db "Good day",'$'
str2 db "Hi!",'$'
str3 db "How do you do?",'$'
str4 db "I greet you",'$'
StrArray dw offset str0
dw offset str1
dw offset str2
dw offset str3
dw offset str4
StrCount dw 5
.code
program:
mov ax, @data
mov ds, ax
mov si, offset StrArray ; si - начало массива строк
mov cx, StrCount ; инициализация счетчика
xor ax, ax ; в ax - макс. длина строки
calc_length:
mov bx, [si] ; bx - смещение текущей строки
add si, 2 ; si сдвигается на следующую строку
push cx ; сохраняем счетчик
call str_len ; определяем длину строки
cmp ax, cx
ja end_loop ; если найденная длмна больше макс.
mov ax, cx ; сохраняем эту длину в ax
mov dx, bx ; сохраняем в dx смещение строки
end_loop:
pop cx ; восстанавливаем счетчик
loop calc_length
mov ah, 9 ; выводим макс. строку на экран
int 21h
mov ax, 4c00h
int 21h
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Находит длину строки
; bx - смещение строки
; Результат: cx - искомая длина
str_len proc near
push bx
push ax
xor cx, cx
mov al, '$'
mov ah, 0
len_lp:
cmp al, [bx]
je end_len
cmp ah, [bx]
je end_len
inc cx
inc bx
jmp len_lp
end_len:
pop ax
pop bx
ret
str_len endp
end program