Задача (Митко)

Даден е масив от 10 трибайтови числа. Да се генерира нов масив, в който да се прехвърлят 
всички елементи с най-младша шестнадесетична цифра 8, като се увеличи с 2 най-старшата 
шестнадесетична цифра. Вход-изход на С, обработка на Асемблер. Да се работи с предаване на 
параметри.

Решение

	.model  small, C
	.data
newval	dd	10 dup (?)

	.code

public  C       asmconv

asmconv proc
	arg     pvalues:dataptr

	.386
	pusha
	mov	si,pvalues
	mov	di,offset newval
	cld
	mov	cx,10
a1:	lodsd
	mov	ebx,eax
	and	ebx,0fh
	cmp	bl,8
	jnz	b1
	add	eax,200000h
	stosd
b1:	loop	a1

	popa
	mov	ax,offset newval
	ret

asmconv	endp
	end


#include	<stdio.h>
#include	<conio.h>

extern  long	*asmconv (long *);

	long	values[10];
	long	*res;
	int	i;

void	main ()
{clrscr ();

 for (i=0; i<10; i++)
     {printf ("Въведете число values[%d]: ", i+1);
      scanf ("%lx", &values[i]);
     }

 res = asmconv (values);

 printf ("Полученият масив е:\n");
 for (i=0; i<10; i++)
     {if (res[i] == 0) break;
      printf ("%d: %lxh\n", i+1, res[i]);
     }

}

Задача (Стефка)

Даден е низ с дължина 20 символа. Да се състави програма, която да генерира три нови низа, 
като в първия се запишат всички букви, във втория всички цифри и в третия всички останали
символи.

Решение

code    segment
        assume  cs:code, ds:code, es:code

main    proc
        mov     ax,cs
        mov     ds,ax
        mov     es,ax
        call    input   ; Въвеждане на първоначалния стринг
        call    digits  ; Претърсва входния низ за цифри
        call    alpha   ; Претърсва входния низ за букви
        call    any
        call    output  ; Извеждане на низовете на екрана
	mov     ax,4c00h
	int     21h
main    endp

input   proc
	mov     ah,9
	mov     dx,offset inp_msg
	int     21h
	mov	ah,0ah
	mov	dx,offset string
	int	21h
        ret
input   endp

digits  proc
        mov     si,offset string
        add     si,2
        mov     di,offset niz1
        mov     cx,20
again:
        lodsb
        cmp     al,30h
        jl      not_dig
        cmp     al,39h
        ja      not_dig
        stosb
        mov     byte ptr ds:[si-1],0ffh
not_dig:
        loop    again
        ret
digits  endp

alpha   proc
        mov     si,offset string
        add     si,2
        mov     di,offset niz2
        mov     cx,20
again1:
        lodsb
        cmp     al,41h
        jl      not_alpha
        cmp     al,7ah
        ja      not_alpha
        stosb
        mov     byte ptr ds:[si-1],0ffh
not_alpha:
        loop    again1
        ret
alpha   endp

any     proc
        mov     si,offset string
        add     si,2
        mov     di,offset niz3
        mov     cx,20
again2:
        lodsb
        cmp     al,0ffh
        je      empty
        stosb
empty:
        loop    again2
        ret
any     endp

output  proc
        mov     ah,9
        mov     dx,offset new_ln
        int     21h
        mov     ah,9
        mov     dx,offset niz1
        int     21h
        mov     dx,offset niz2
        int     21h
        mov     dx,offset niz3
        int     21h
        ret
output  endp

inp_msg db      'Въведете входен стринг:',10,13,'$'
new_ln  db      10,13,'$'
string  db      20,0, 20 dup (0)
niz1    db      20 dup (0),10,13,'$'
niz2    db      20 dup (0),10,13,'$'
niz3    db      20 dup (0),10,13,'$'
code    ends
	end     


Задача (Деян)

Да се сортира масив от елементи long int във възходящ ред по даден метод за сортиране. 
Вход-изход на C, обработка на асемблер.

#include	<stdio.h>
#include	<conio.h>
#include	<stdlib.h>

extern	void	asmsort (long *, int);

long	*values;
int	broi, i;

void	main ()
{clrscr ();

 printf ("Въведете броя на числата за сортиране: ");
 scanf ("%d", &broi);
 values = (long *) malloc (broi);
 if (!values)
    {printf ("Няма достатъчно памет");
     exit (1);
    }
 for (i=0; i<broi; i++)
     {printf ("Въведете стойност за Values[%d]: ", i);
      scanf ("%lx", (values+i));
     }

 asmsort (values, broi);

 printf ("Подредените числа са:\n");
 for (i=0; i<broi; i++)
     printf ("%lxh\n", values[i]);
}

	.model	small,C
	.data
	.code

public	C	asmsort

asmsort	proc
	arg	pval:dataptr, broi:word

	.386
	pusha
	mov	bx,broi
	dec	bx
again:
	mov	si,pval
	mov	cx,broi
	dec	cx
a1:
	lodsd
	cmp	eax,dword ptr [si]
	jl	cont
	xchg	eax,dword ptr [si]
	mov	dword ptr [si-4],eax
cont:
		l	oop	a1
	dec	bx
	jnz	again
	popa
	ret

asmsort	endp
	end


Задача (Вирус 1 брой)

Да се сортира масив от 10 букви в нарастващ ред. Вход-изход на С, обработка на Асемблер

#include	<stdio.h>
#include	<conio.h>

extern  char	*asmsort (char *);

	char	bukvi[10], *res;
	int	i;

void	main ()
{clrscr ();

 printf ("Въведете стринг (до 10 символа):\n");
 for (i=0; i<10; i++)
    bukvi[i] = getchar ();
 res = asmsort (bukvi);

 printf ("Въведения стринг е: %s\n", bukvi);
 printf ("Подреденият стринг е: %s", res);


	.model	small,C
	.data
newbuk	db	10 dup (?), 0
	.code

public	C	asmsort

asmsort	proc
	arg	bukvi:dataptr

	.286
	pusha
	mov	si,bukvi
	mov	di,offset newbuk
	push	si
	push	di
	mov	cx,10
	cld
	repnz	movsb

	pop	di
	pop	si
	mov	bx,9
again:
	mov	si,offset newbuk
	mov	cx,9
a1:
	lodsb
	cmp	al,byte ptr [si]
	jl	cont
	xchg	al,byte ptr [si]
	mov	byte ptr [si-1],al
cont:
	loop	a1
	dec	bx
	jnz	again
	popa
	mov	ax,offset newbuk
	ret

asmsort	endp
	end

}

Задача (Вержи)

Да се въведат 10 числа от клавиатурата в диапазона от 0-9 и да се подредат в увеличаващ 
(намаляващ) ред.

code    segment        
	assume  cs:code, ds:code, es:code
	
main    proc    
	mov     ax,cs
	mov     ds,ax
	mov     es,ax
	call    input
        call    copy
	call    sort
; Разпечатваме първо входния масив
        mov     ah,9
        mov     dx,offset res
        int     21h
        mov     si,offset val
	call    output
;   а сега разпечатваме подредения масив
        mov     ah,9
        mov     dx,offset sortmsg
        int     21h
        mov     si,offset sval
        call    output
	mov     ax,4c00h
	int     21h
main    endp

copy    proc
        mov     cx,10
        mov     si,offset val
        mov     di,offset sval
        cld
        rep     movsb
        ret
copy    endp

input   proc
	mov     cx,10
	mov     di,offset val
	cld
a1:
	mov     ah,9
	mov     dx,offset in_msg
	int     21h
	mov     ah,1
	int     21h
        sub     al,30h
	cmp     al,9
        ja      a1
	inc     byte ptr [in_msg+27]
	stosb
	loop    a1
	ret
input   endp

output  proc
	mov     cx,10
b1:
	mov     ah,9
	mov     dx,offset out_msg
	int     21h
	lodsb
	add     al,90h
	daa
	adc     al,40h
	daa
	mov     dl,al                   ; символа за печат е в DL
	mov     ah,2
	int     21h
	inc     byte ptr [out_msg+23]
	loop    b1
	ret
output  endp

sort    proc
	mov     bx,9
again:
        mov     si,offset sval          ; ще сортираме в масив sval
	mov     cx,9
c1:
	lodsb   
	cmp     al,byte ptr [si]
        ja      cont
	xchg    al,byte ptr [si]
	mov     byte ptr [si-1],al
cont:
	loop    c1
	dec     bx
	jnz     again
	ret
sort    endp    

in_msg  db      10, 13, 'Въведете стойност за Val[',30h,']: $'
res     db      10, 13, 10, 13, 'Стойности в първоначалния масив:$'
sortmsg db      10, 13, 10, 13, 'Стойности в подредения масив:$'
out_msg db      10, 13, 'Стойност за Val[',30h,']: $'
val     db      10 dup (?)      ; Масив за входните числа (несортиран)
sval    db      10 dup (?)      ; Масив, в който сте пазим подредените числа 

code    ends        
	end