Tuesday, 1 March 2016

Assembly Program to convert string from lower case to upper case

 
;Program to convert string from lower case to upper case      org 100h
; add your code here
mov bx, offset str      ;load address of fisrt byte of str

repeat:
mov al, [bx]            ;load first byte of address store in bx
cmp al, '$'             ;check is it $ i.e. end of string
je print                ;if yes then goto print label

sub al, 20h             ;otherwise convert it into upper case by subtracting 20h
mov [bx], al            ;move back to str
inc bx                  ;move to next byte of str
jmp repeat              ;goto repeat

;this code section print str
print:
mov ah, 09h
mov dx, offset str
int 21h
ret
;data section
str db 'abcdefghijklmnopqrstuvwxyz','$'

Assembly Program to convert a number to ASCII string


;Assembly program to convert a number to ASCII string
org 100h   
jmp start               ;to start of code
number dw 19348         ;number to display
string db 10 dup('$')   ;string to store number in string format

start:
mov ax, number          ;load number

printnum:
mov cx, 0               ;set counter to 0, this will count no. of digits in number   
mov bx, 10              ;set divider value 10
repeat:      
mov dx, 0               ;set remainder empty
div bx                  ;divide ax by bx
add dx, '0'             ;convert to byte to digit
push dx                 ;push digit on stack
inc cx                  ;count digit
cmp ax, 0               ;check remaining num is 0
jne repeat              ;if not then goto repeat label

mov bx, offset string   ;load address of first byte of string
loadstring:
pop dx                  ;load digit from stack
mov [bx], dl            ;move digit to string
inc bx                  ;move to next byte of string
dec cx                  ;decrease counter
cmp cx, 0               ;check counter is 0
jne loadstring          ;if not then goto label loadstring

;print string generated
printstring:           
mov ah, 09h            
mov dx, offset string   ;load address of first byte of string ended by $ sign

int 21h                 ;DOS interrupt

ret                     ;return control to O/S




Friday, 28 March 2014

Induction v/s Deduction

Induce and Deduce

Induce : a form of reasoning under which a conclusion is drawn on the basis of a large number of positive examples. For example, after seeing a large number of cows, we conclude a cow has four legs, white colour, two horns symmetrically placed on the head etc. Inductive reasoning, though usually leads to correct conclusions, yet the conclusions may not be irrefutable.

Deduce/Infer : to derive as a conclusion from something known or assumed. It is an irrefutable form of reasoning. By irrefutable form of reasoning we mean that the conclusion arrived at through deductive (i.e., any irrefutable) reasoning process is always correct, if the hypotheses (or given facts) are correct. This is the form of reasoning which is dominantly applied in Mathematics.

String Search and Replacement function in C Language

/* A case-sensitive string replacement program
The Basic principle behind this program depends upon three cases
Case 1: If replacement string equals to 'find' string in length
    then no. more space is required so character are simply replaced
Case 2:    If replacement string is less than 'find' string in length
    then some is created after replacing the characters
    so another loop is required for removing that holes
Case 3:    If replacement string is greater than 'find' string in length
    then more space is required to be created between characters for
    replacement string, after that replacement is done.
*/

//Note: This program can be modified by using list and stack
//    to make it more efficient, robust and  flexible.
#include<stdio.h>
#include<conio.h>
#include<string.h>

char* replace(char[],char[],char[]);

void main ()
{
    char str[50]="Look Hook Nook";
    clrscr();
    printf("Before: %s",str);
    printf("\nAfter: %s", replace(str,"k","am"));
    printf("\nBefore: %s",str);
    printf("\nAfter: %s", replace(str,"Loo","S"));
    printf("\nBefore: %s",str);
    printf("\nAfter: %s", replace(str,"Hoo","Dre"));
    printf("\nBefore: %s",str);
    printf("\nAfter: %s", replace(str,"ooam","ame"));
    getch();

}

// This function can work with max. of 100 occurence of 'to find' string
// due to static declaration of memory limit.
char* replace(char str[],char find[],char rep[]){
    int occ[100],i,j,loc,c=0,next,start;
    int lens,lenf,lenr;
    int diff,noOfBytes;
    lens=strlen(str);
    lenf=strlen(find);
    lenr=strlen(rep);
    //find the no. of occurence of 'find' string
    for(i=0;i<lens;i++) {
        loc=i;
        for(j=0;j<lenf;j++){
            if(str[i+j]!=find[j]){
                loc=-1;
                break;
            }
        }
        if(loc!=-1){
            occ[c]=loc;
            c++;
        }

    }
    //check difference between length of 'find' and 'replace' strings
    diff=lenr-lenf;
    //Case 1: When length of both strings is equal
    if(diff==0){
        for(i=0;i<c;i++){
            for(j=0;j<lenr;j++){
                str[occ[i]+j]=rep[j];
            }
        }
    }
    //Case 2: When length of replace string < length of find string
    else if(diff<0){
        //replace characters
        for(i=0;i<c;i++){
            for(j=0;j<lenr;j++){
                str[occ[i]+j]=rep[j];
            }
        }
        //fill holes
        for(i=0;i<c;i++){
            next=lens+diff*c;
            if(i<c-1) next=occ[i+1]-1;
            for(j=occ[i]+lenr-i;j<=next;j++){
                str[j]=str[j-diff*(i+1)];
            }
        }
        //append null character at end of string
        for(i=lens-1;i>=lens+diff*c;i--){
            str[i]='\0';
        }
    }
    //Case 3: When length of replace string > length of find string
    else if(diff>0){
        //make space
        next=lens-1;
        for(i=c-1;i>=0;i--){
            for(j=next;j>=occ[i];j--){
                str[j+diff*c-c+i+1]=str[j];
            }
            next=occ[i];
        }
        //replace characters
        for(i=0;i<c;i++){
            for(j=0;j<lenr;j++){
                str[occ[i]+j+i]=rep[j];
            }
        }

    }
    return str;                 //return result
}    //End of function
//END OF PROGRAM

Thursday, 27 March 2014

C Progamm to convert binary number into Octal System

/* To convert a number from binary to octal system,
no. of digit in binary no. should be multiple of three(3),
if not, then append 0's at front of the number,
e.g. 1001101 converted 001 001 101
then these group are converted to number as
    000        0
    001    1
    010    2
    011    3
    100    4
    101    5
    110    6
    111    7
*
/
#include<stdio.h>
#include<conio.h>
#include<math.h>

long binaryToOctal(int[],int);

void main(){
    int b[28],c,i;
    long dec;
    clrscr();
    //Enter binary no.
    printf("Enter a binary no.(max.27 digits longs):");
    c=0;
    while(c<28){
        b[c]=getch();
        if(b[c]==13) break;
        b[c]=b[c]-'0';
        if(b[c]==0||b[c]==1) {
        printf("%d",b[c]);
        c++;
        }
    }
    //Octal no.
    printf("\nOctal equivalent of binary no. ");
    for(i=0;i<c;i++)
        printf("%d",b[i]);
    dec=binaryToOctal(b,c); //Conversion
    printf(". is %ld",dec);//Result
    getch();
}

/*This function receives an array of binary digits
and convert them into a octal number */
/* Note: binary number's digit (e.g. 1001101) from right to left are stored in array from 0 to n-1*/
long binaryToOctal(int bn[],int len){
    int i,position;    //i for position of binary digit, position indicate position of octal-digit under conversion
    long oct,digit;    //oct for octal number, digit for octal-digit under conversion
    i=len-1,oct=0;
    position=0;
    while(i>=0)     {
        //Group of 3 binary digits are processed from left
        digit=bn[i--];       // 1st one from left
        if(i>=0) digit=2*bn[i--]+digit; // 2nd One from left(if exists)
        if(i>=0) digit=4*bn[i--]+digit; // 3rd One from left(if exists)
        oct=digit*pow(10.0,position)+oct; // Octal no.
        position++;                       // next digit to right
    }
    return oct; //return octal no.
}
//end of function
//End of Programm

C program to find out perfect numbers from 1 and 50

/*Perfect no. is a +ve integer that is equal to the sum of its +ve divisors
    e.g. 28 is divible by 1,2,4,7,14 (excluding number itself)
        1+2+4+7+14=28
*/

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

void print_perfect(int,int);  //function declration

void main()
{
    clrscr();              //Clear Screen
    print_perfect(1,50);   //This Function print perfects number
    getch();
}

void print_perfect(int start,int end)
{
    int div,sum;   //div for divisor, s for summation
    int num=start; //num for number under checking
    while(start<=end)      //loop from 1 to 50
    {
        div=1;sum=0;   //factor starts from 1,summation from zero
        while(div<num) //divisor must be less than number itself
        {
            if(num%div==0)  //it checks for divison
            {
                sum=sum+div;  //if it remainder is zero, divisor is added
            }
            div++; //next divisor
        }
        if(sum==num) printf("perfect no =%d\n",num); //if summation equal to number itself, it is perfect no. so print it
        num++;    // next number
    }
}//end of function

//End of the program