Добавил:
Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:
KPiYaP_Shpory.doc
Скачиваний:
45
Добавлен:
11.05.2015
Размер:
309.76 Кб
Скачать

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

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]