Program for to sort numbers into descending order

.MODEL SMALL

.STACK 100

.DATA

            NUM DW 0102H, 0154H, 0070H, 0005H

.CODE

            mov      ax, @data

            mov      ds, ax  

            mov      dx, 2   

loop2:   mov      cx, dx              

            dec       cx        

            mov      si, cx               

            add      si, si     

            mov      ax, num[si]

loop1:   cmp      num[si-2], ax   

            jae        next                 

            mov      di, num[si-2]    

            mov      num[si], di       

            dec       si                     

            dec       si                     

            dec       cx                    

                                               

                                               

            jnz        loop1              

                                               

next:     mov      num[si], ax       

                                               

                                               

            inc        dx                   

                                               

            cmp      dx, 4               

                                               

                                               

            jbe       loop2              

            mov      si, offset num

        mov          dh, 4

        mov          ch, 04h

l3:     mov     ax, num[si]

        inc            si                     

            inc        si

        dec ch

        jnz l3

            mov      ah, 4ch

            int         3h

end

Program for to sort numbers into ascending order

.MODEL SMALL

.STACK 100

.DATA

            NUM DW 0102H, 0154H, 0070H, 0005H

.CODE

            mov      ax, @data       

            mov      ds, ax  

            mov      dx, 2   

loop2 :  mov      cx, dx              

            dec       cx        

            mov      si, cx                           

            add      si, si     

            mov      ax, num[si]

loop1:   cmp      num[si-2], ax

                                               

            jbe       next                 

                                               

            mov      di, num[si-2]    

            mov      num[si], di       

            dec       si                     

            dec       si                     

            dec       cx                    

                                               

            jnz        loop1              

next:     mov      num[si], ax       

                                               

            inc        dx                   

                                               

            cmp      dx, 4               

                                               

            jbe       loop2              

            mov      si, offset num

           

        mov ch,04h

      

l3:        mov     ax, num[si]

        inc            si                     

            inc        si

        dec ch

        jnz l3

        

            mov      ah, 4ch            

            int         3h

end

Program for factorial using recursion.

.model small

data segment

            num      dw 08h                                                                        

data ends

code segment

assume cs:code,ds:data

            mov      ax,data            

            mov      ds, ax

            mov      ax, 01                          

            mov      bx, num                       

            call       fact                              

            mov      di, ax                           

            mov      bp, 2                           

            mov      bx, dx                          

            mov      bx, di                           

            dec       bp                               

            mov      ah, 4ch

            int         3h

fact       proc     near                             

            cmp      bx, 01             

            jz          l11                              

l12:       mul       bx                               

            dec       bx                               

            cmp      bx, 01                         

            jne        l12

            ret

l11:       mov      ax, 01                          

            ret                                           

            fact endp                                 

code ends

            end                   

Program for factorial

.model small

.data

a db 01H

b db 05H

.code

mov      ax, @data                   

mov      ds, ax

mov     al, a           

mov      bl, b                            

mov     bh, 0

x:mul bx

dec bl

jnz x

mov ah, 4cH

int 3H

end

Program for exchange two numbers

.model small

.data

a db 09H

b db 08H

.code

            mov      ax, @data                   

            mov      ds, ax

            mov      ah, 0

            mov      al, a                             

            mov      bl, b                            

        mov  bh, 0

        xchg bl,al

       

        mov ah, 4cH

            int         3H

            end

multiplication of two 16 bit numbers

.model small

data  segment  

a dw 1234H

b dw 0100H

data ends

code  segment

assume cs:code,ds:data

            mov      ax, data           

            mov      ds, ax

            mov      ax, a                

            mov      bx, b               

            mul       bx       

        mov     bx,dx       

            mov      ah, 4cH           

            int         3H

code ends

end

2’s Compliment

.model small

.data

a dw 1234H

.code

            mov      ax, @data       

            mov      ds, ax

            mov      ax, a                

            mov      cx, 16              

up:        rcl        ax, 1                

            cmc                             

            loop     up                   

            rcl        ax, 1                

            add      ax, 1                

           

            mov      ah, 4cH

            int  3H

            end

1’s Compliment

.model small

.data

  a db 04H

.code

            mov      ax, @data       

            mov      ds, ax

            mov      al, a                 

            mov      cx, 08              

up:        rcl        al, 1                 

            cmc                             

            loop     up                   

            rcl        al, 1                 

            add      al, 1                 

           

            mov      ah, 4cH

            int  3H

            end 

PROGRAM FOR TO FIND SMALL NO. BY COMPAIRING TWO Numbers

model small
.data
a db 09H
b db 08H 
.code
mov ax, @data
mov ds, ax
mov ah, 0
mov al, a
mov bl, b
mov bh, 0

cmp bl,al
jnc x
mov al,bl
x: mov ah, 4cH
int 3H
end

DIVISION

.model small

.data
a db 08H
b db 02H 
.code
mov ax, @data
mov ds, ax
mov ah, 0
mov al, a
mov bl, b
mov bh, 0

div bl

mov ah, 4cH
int 3H
end

MULTPLICATION FOR 16 BIT

.model small

data segment
a dw 1234H
b dw 0100H
data ends
code segment 
assume cs:code,ds:data
mov ax, data
mov ds, ax
mov ax, a
mov bx, b
mul bx
mov bx,dx
mov ah, 4cH
int 3H
code ends
end

SUBSTRACTION

.model small

.data
a db 09H
b db 02H 
.code
mov ax, @data
mov ds, ax
mov ah, 0
mov al, a
mov bl, b
mov bh, 0

sub al,bl

mov ah, 4cH
int 3H
end

ADDITION

.model small

.data
a db 09H
b db 02H 
.code
mov ax, @data
mov ds, ax
mov ah, 0
mov al, a
mov bl, b
mov bh, 0

add al,bl

mov ah, 4cH
int 3H
end

Program for sub and borrow

#include<stdio.h>

#include<conio.h>

void main()

{

  int a,b,c,v,s;

  clrscr();

  printf("Program for sub and borrow: \n");

  printf("\nEnter the 1st number : ");

  scanf("%d",&a);

  printf("\nEnter the 2nd number : ");

  scanf("%d",&b);

  printf("\nEnter the 3rd number : ");

  scanf("%d",&c);

  v=((!a&&b)||(!a&&c)||(a&&b&&c));

  s=((!a&&!b&&c)||(!a&&b&&!c)||(a&&!b&&!c)||(a&&b&&c));

 printf("\ndiff :%d",s);

 printf("\n\nborrow : %d",v);

   getch();

}

/*

OUTPUT:

Program for sub and borrow:

Enter the 1st number :1

Enter the 2nd number :1

Enter the 3rd number :1

diff:1

borrow:1

*/                                           

Restoring Algorithm.

#include<stdio.h>

#include<conio.h>

void main()

{

int a[10],m[10],q[10],i,j,c=0,b[10],mc[10],z=0,s[10],x[10];

clrscr();

printf("\nEnter Divisor [M] : ");

for(i=4;i>=1;i--)

{

scanf("%d",&m[i]);

mc[i]=!m[i];

a[i]=0, x[i]=0;

}

x[1]=1, x[5]=0, m[5]=0, mc[5]=1;

for(i=1;i<=5;i++)

{

s[i]=x[i]^mc[i]^z;

c=(x[i]&&mc[i])||(x[i]&&z)||(mc[i]&&z);

z=c;

mc[i]=s[i];

}

printf("\n\nEnter Divident [Q] : ");

for(i=4;i>=1;i--)

scanf("%d",&q[i]);

printf("\n\n\n Step \t\t Action Performed \t\t A \t\tQ\n");

printf("\n\n 0\t\t Initialization\t 0 0 0 0 0 \t ");

for(i=4;i>=1;i--)

printf(" %d",q[i]);

for(j=1;j<=4;j++)

{

printf("\n\n\n %d",j);

printf("\t\t Left Shift \t\t ");

for(i=5;i>=2;i--)

a[i]=a[i-1];

a[1]=q[4];

for(i=4;i>=2;i--)

q[i]=q[i-1];

for(i=5;i>=1;i--)

printf(" %d",a[i]);

printf("\t ");

for(i=4;i>=2;i--)

printf(" %d",q[i]);

z=0;

for(i=1;i<=5;i++)

{

s[i]=a[i]^mc[i]^z;

c=(a[i]&&mc[i])||(a[i]&&z)||(mc[i]&&z);

z=c;

a[i]=s[i];

}

printf("\n\n\t\t a = a-m\t\t ");

for(i=5;i>=1;i--)

printf(" %d",a[i]);

printf("\t ");

for(i=4;i>=2;i--)

printf(" %d",q[i]);

if(a[5]==1)

{

q[1]=0;

printf(" %d",q[1]);

z=0;

printf("\n\n\t\t Restore a = a+m\t ");

for(i=1;i<=5;i++)

{

s[i]=a[i]^m[i]^z;

c=(a[i]&&m[i])||(a[i]&&z)||(m[i]&&z);

z=c;

a[i]=s[i];

}

for(i=5;i>=1;i--)

printf(" %d",a[i]);

printf("\t ");

for(i=4;i>=1;i--)

printf(" %d",q[i]);

}

else

{

q[1]=1;

printf(" %d",q[1]);

}

}

printf("\n\n\n\n\nQuotient [Q] :");

for(i=4;i>=1;i--)

printf(" %d",q[i]);

printf("\n\n\n\nRemainder [A] :");

for(i=4;i>=1;i--)

printf(" %d",a[i]);

getch();

}

/* OUTPUT */

Enter Divisor [M] : 0 0 1 1

Enter Divident [Q] : 1 0 0 0

Step Action Performed A Q

0 Initialization 0 0 0 0 0 1 0 0 0

1 Left Shift 0 0 0 0 1 0 0 0

a = a-m 1 1 1 1 0 0 0 0 0

Restore a = a+m 0 0 0 0 1 0 0 0 0

2 Left Shift 0 0 0 1 0 0 0 0

a = a-m 1 1 1 1 1 0 0 0 0

Restore a = a+m 0 0 0 1 0 0 0 0 0

3 Left Shift 0 0 1 0 0 0 0 0

a = a-m 0 0 0 0 1 0 0 0 1

4 Left Shift 0 0 0 1 0 0 0 1

a = a-m 1 1 1 1 1 0 0 1 0

Restore a = a+m 0 0 0 1 0 0 0 1 0

Quotient [Q] : 0 0 1 0

Remainder [A] : 0 0 1 0