C and C++ Programs

Two Pass Assembler

2009-08-25T07:19:00.001-07:00

#include< stdio.h>
#include< conio.h>
#include< string.h>
#define lines_in_program 9
void print(char *p,int loc,int len,char ra)
{printf("%s\t%d\t%d\t%c\n",p,loc,len,ra);}
void main()
{
char *p[9][4] = {{"PRG1","START","",""},{"","USING","*","15"},
{"","L","1","FIVE"}, {"","A","1","FOUR"},
{"","ST","1","TEMP"}, {"FOUR","DC","F'4'",""},
{"FIVE","DC","F'5'",""}, {"TEMP","DS","1F",""},
{"","END","",""}};
int i,j=0,location_counter=0;
clrscr();
for (i=0;i< 9;i++)
{ for(j=0;j< 4;j++)
printf("%s\t",p[i][j]);
printf("\n");
}
printf("\n\n\n\n Symbol ");
printf("Table:\nSYMBOL\tVALUE\tLENGTH\tRelocatable/Absolute\n");
printf("---------------------------------------------\n");
for(i=0;i< 9;i++)
{ if(strcmp(p[i][1],"START")==0)
print(p[i][0],location_counter,1,'R');
else if(strcmp(p[i][0],"")!=0)
{
print(p[i][0],location_counter,4,'R');
location_counter=4+location_counter;
}
else if(strcmp(p[i][1],"USING")==0){}
else{location_counter=4+location_counter;}
}
getch();
}

/*OUTPUT:
PRG1 START
USING * 15
L 1 FIVE
A 1 FOUR
ST 1 TEMP
FOUR DC F'4'
FIVE DC F'5'
TEMP DS 1F
END

Symbol Table:
SYMBOL VALUE LENGTH Relocatable/Absolute
---------------------------------------------
PRG1 0 1 R
FOUR 12 4 R
FIVE 16 4 R
TEMP 20 4 R */

Two Pass Assembler

2009-08-25T07:16:00.000-07:00

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

void main()
{
char *code[9][4]={
{"PRG1","START","",""},
{"","USING","*","15"},
{"","L","",""},
{"","A","",""},
{"","ST","",""},
{"FOUR","DC","F",""},
{"FIVE","DC","F",""},
{"TEMP","DS","1F",""},
{"","END","",""}
};
char av[2],avail[15]={'N','N','N','N','N','N','N','N','N','N','N','N','N','N','N'};
int i,j,k,count[3],lc[9]={0,0,0,0,0,0,0,0,0},loc=0;
clrscr();
printf("----------------------------------------------------\n");
printf("LABEL\t\tOPCODE\n");
printf("----------------------------------------------------\n\n");
for(i=0;i< =8;i++)
{
for(j=0;j< =3;j++)
{
printf("%s\t\t",code[i][j]);
}
j=0;
printf("\n");
}
getch();
printf("-----------------------------------------------------");
printf("\nVALUES FOR LC : \n\n");
for(j=0;j< =8;j++)
{
if((strcmp(code[j][1],"START")!=0)&&(strcmp(code[j][1],"USING")!=0)&&(strcmp(code[j][1],"L")!=0))
lc[j]=lc[j-1]+4;
printf("%d\t",lc[j]);
}
printf("\n\nSYMBOL TABLE:\n----------------------------------------------------\n");
printf("SYMBOL\t\tVALUE\t\tLENGTH\t\tR/A");
printf("\n----------------------------------------------------\n");

for(i=0;i< 9;i++)
{
if(strcmp(code[i][1],"START")==0)
{
printf("%s\t\t%d\t\t%d\t\t%c\n",code[i][0],loc,4,'R');
}
else if(strcmp(code[i][0],"")!=0)
{
printf("%s\t\t%d\t\t%d\t\t%c\n",code[i][0],loc,4,'R');
loc=4+loc;
}
else if(strcmp(code[i][1],"USING")==0){}
else
{loc=4+loc;}
}
printf("----------------------------------------------------");

printf("\n\nBASE TABLE:\n-------------------------------------------------------\n");
printf("REG NO\t\tAVAILIBILITY\tCONTENTS OF BASE TABLE");
printf("\n-------------------------------------------------------\n");
for(j=0;j< =8;j++)
{
if(strcmp(code[j][1],"USING")!=0)
{}
else
{
strcpy(av,code[j][3]);
}
}
count[0]=(int)av[0]-48;
count[1]=(int)av[1]-48;
count[2]=count[0]*10+count[1];
avail[count[2]-1]='Y';

for(k=0;k< 16;k++)
{
printf(" %d\t\t %c\n",k,avail[k-1]);
}

printf("-------------------------------------------------------\n");
printf("Continue..??");
getchar();
printf("PASS2 TABLE:\n\n");
printf("LABEL\t\tOP1\t\tLC\t\t");
printf("\n----------------------------------------------------\n");
loc=0;
for(i=0;i< =8;i++)
{
for(j=0;j< =3;j++)
{
printf("%s\t\t",code[i][j]);
}
j=0;
printf("\n");
}
printf("-----------------------------------------------------");

getch();

}
/*
----------------------------------------------------
LABEL OPCODE
----------------------------------------------------

PRG1 START
USING * 15
L
A
ST
FOUR DC F
FIVE DC F
TEMP DS 1F
END

-----------------------------------------------------
VALUES FOR LC :

0 0 0 4 8 12 16 20 24

SYMBOL TABLE:
----------------------------------------------------
SYMBOL VALUE LENGTH R/A
----------------------------------------------------

PRG1 0 4 R
FOUR 12 4 R
FIVE 16 4 R
TEMP 20 4 R

----------------------------------------------------

BASE TABLE:
-------------------------------------------------------
REG NO AVAILIBILITY CONTENTS OF BASE TABLE
-------------------------------------------------------
0 -----------------------------------
1 N
2 N
3 N
4 N
5 N
6 N
7 N
8 N
9 N
10 N
11 N
12 N
13 N
14 N
15 Y

-------------------------------------------------------
Continue..??
PASS2 TABLE:

LABEL OP1 LC
----------------------------------------------------
PRG1 START
USING * 15
L
A
ST
FOUR DC F
FIVE DC F
TEMP DS 1F
END
-----------------------------------------------------

*/

Lexical Analizer

2009-08-25T07:15:00.000-07:00

/* TO IMPLEMENT LEXICAL ANALIZER IN C */

#include< conio.h>
#include< string.h>

void main()
{
int i,j,lc;
char *a[9][4]={"PRG","START" ," " ," ",
" " ,"USING" ,"*" ,"15",
" ","L","1","FIVE",
" ","A","1","FOUR",
" ","ST","1","TEMP",
"FOUR ","DC","F","4",
"FIVE","DC","F","5",
"TEMP","DS","1","F",
" " ,"END"," "," ", };
clrscr();
printf("\n \t\t LEXICAL ANALIZER \n");

for(i=0;i< 9;i++)
{ for(j=0;j< 4;j++)
{ if(isalpha(*a[i][j]))
printf("\n STRING : %s",a[i][j]);
if(isdigit(*a[i][j]))
printf("\n DIGIT : %s",a[i][j]);
}
printf("\n");
}

getch();
}
/* OUTPUT:-

LEXICAL ANALIZER

STRING : PRG
STRING : START

STRING : USING
DIGIT : 15

STRING : L
DIGIT : 1
STRING : FIVE

STRING : A
DIGIT : 1
STRING : FOUR

STRING : ST
DIGIT : 1
STRING : TEMP

STRING : FOUR
STRING : DC
STRING : F
DIGIT : 4

STRING : FIVE
STRING : DC
STRING : F
DIGIT : 5

STRING : TEMP
STRING : DS
DIGIT : 1
STRING : F

STRING : END

*/

Free Web Hosting

2009-06-11T11:47:00.000-07:00

If you wish to have a professional shared hosting quality in a free hosting package, come and host with 000webhost.com and experience the best service you can get absolutely free.

Founded in December 2006, 000webhost.com has a trusted free hosting members base of over 60,000 members and still counting! Offering professional quality hosting, support, uptime and reliability, we have a great community of webmasters, you'd love to be a part of!
I have been using it for sometime now and had found it quiet satisfying..

Register now and get it all free:
*** 1500 MB of disk space
*** 100 GB of data transfer
*** PHP and MySQL support with no restrictions
*** cPanel control panel
*** Website Builder
*** Absolutely no advertising!

Join us now: http://www.000webhost.com/173150.html

Diamond In C

2008-12-21T20:17:00.000-08:00

/* C program to display a diamond using arrays */

#include< iostream.h>
#include< conio.h>
void main()
{
int i,j;
clrscr();
int no;
cout< < "Enter A Value";
cin>>no;
for(i=no;i>=1;i--)
{
cout< < endl;
for(int k=1;k< =i;k++)
cout< < " ";

for(j=i;j< =no;j++)
cout< < "*";

for(j=i;j< no;j++)
cout< < "*";
}
//SECOND PART

for(i=no;i>=1;i--)
{
cout< < endl;
cout< < " ";
for(int k=no;k>=i;k--)
cout<<" ";

for(j=i-1;j>=1;j--)
cout< < "*";

for(j=i-1;j>1;j--)
cout<<"*";

}
getch();
}

Call By Reference in C

2008-12-21T20:15:00.000-08:00

/* Program for inerchanging two numbers demonstrating Call By Reference in C */

#include<>
#include<>

void swap(int *,int *);

void main()
{
int x,y;
x=15;y=20;
clrscr();
printf("x=%d,y=%d\n",x,y);
swap(&x,&y);
//printf("\n%x %x",&x,&y);
printf("\n after interchanging x=%d,y=%d\n",x,y);
getch();
}

void swap(int *u,int *v)
{
int temp;
temp=*u;
*u=*v;
*v=temp;

return;
}

Call by Values in C

2008-12-21T20:14:00.000-08:00

/* Program on interchanging two numbers demonstrating Call By Values in C*/
#include< stdio.h>
#include< conio.h>
void main()
{
int x,y;
x=15;y=20;
clrscr();
printf("x=%d,y=%d\n",x,y);
swap(x,y);
printf("\n after interchanging x=%d,y=%d\n",x,y);
getch();
}
swap(int u,int v)
{
int temp;
temp=u;
u=v;
v=temp;
return;
}

Pointers example

2008-12-21T20:11:00.000-08:00

/* Example of pointers in C. Thsi program uses a function to modify a string using pointers */

#include< stdio.h>
#include< conio.h>
void main()
{
void getstr(char *ptr_str,int *ptr_int);
int var=5;
char *pstr="lionel";
clrscr();
getstr(pstr,&var);
printf("The value of var after modification using pointer in a function is %d,var");
}
void getstr (char *ptr_str,int *ptr_int)
{
printf("%s\n",ptr_str);
*ptr_int=6;
getch();
}

Two Dimentional array in C

2008-12-21T20:09:00.000-08:00

/* C program to input and display a 2-d array*/

#include< stdio.h>
#include< conio.h>
void main()
{
int num[3][3],i,j;
clrscr();
for(i=0;i< 3;i++)
{
for(j=0;j< 3;j++)
{
scanf("%d",&num[i][j]);
}
}
for(i=0;i< 3;i++)
{
for(j=0;j< 3;j++)
{
printf("\n%d",num[i][j]);
}
printf("\n");
}
getch();
}

Carlsberg launches Web-TV channel about football and fan life.

2008-12-11T10:36:00.000-08:00

Recently Carlsberg Brewery launched a football web-TV-channel partofthegame.tv.

They launched 5 channels showing all aspects about football from the classic football matches to life as a fan.

Be sure not to miss the video clips about football funnies and rituals from the Football Magic channel or the bizarre story about fans in the stand and how fan culture sometimes go beyond reason.
As an extra feature you can upload your own favourite football and fan moments.

Its an amazing site with loads of features present in it. So log on to partofthegame.tv and experience the diference.

ISO - OSI Model

2008-10-02T04:51:00.000-07:00

/* Draw ISO - OSI Model using C */

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

void main()
{
int driver, mode;
int i,j;
driver = DETECT;
initgraph(&driver,&mode,"");

outtextxy(250,450,"ISO OSI Model");
delay(2000);
outtextxy(90,30,"Sender");
delay(500);
setcolor(6);
for(i=50;i< =350;i+=50)
{
rectangle(200,i,50,i+30);
delay(500);
}
setcolor(10);
outtextxy(70,60,"Application");
delay(500);
outtextxy(70,110,"Presentation");
delay(500);
outtextxy(70,160,"Session");
delay(500);
outtextxy(70,210,"Transport");
delay(500);
outtextxy(70,260,"Network");
delay(500);
outtextxy(70,310,"Data Link");
delay(500);
outtextxy(70,360,"Physical");
delay(500);
setcolor(15);
outtextxy(390,30,"Receiver");
delay(500);
setcolor(6);
for(i=50;i< =350;i+=50)
{
rectangle(350,i,500,i+30);
delay(500);
}
setcolor(10);
outtextxy(370,60,"Application");
delay(500);
outtextxy(370,110,"Presentation");
delay(500);
outtextxy(370,160,"Session");
delay(500);
outtextxy(370,210,"Transport");
delay(500);
outtextxy(370,260,"Network");
delay(500);
outtextxy(370,310,"Data Link");
delay(500);
outtextxy(370,360,"Physical");
delay(500);
// sender Lines
line(120,80,120,100);
delay(500);
line(120,130,120,150);
delay(500);
line(120,180,120,200);
delay(500);
line(120,230,120,250);
delay(500);
line(120,280,120,300);
delay(500);
line(120,330,120,350);
delay(500);
line(120,380,120,400);
delay(500);
// Physical Connection
line(120,400,420,400);
// Receiver Lines
line(420,380,420,400);
delay(500);
line(420,330,420,350);
delay(500);
line(420,280,420,300);
delay(500);
line(420,230,420,250);
delay(500);
line(420,180,420,200);
delay(500);
line(420,130,420,150);
delay(500);
line(420,80,420,100);
//virtual connection
setcolor(15);
delay(500);
outtextxy(210,35,"Virtual Connection");
delay(1000);
for(j=65;j< =365;j+=50)
{
for(i=0;i< 15;i++)
{
setcolor(i);
line(200,j,230,j);
delay(10);
line(235,j,265,j);
delay(10);
line(270,j,300,j);
delay(10);
line(305,j,335,j);
delay(10);
line(340,j,350,j);
delay(10);
}
}
delay(500);
}
/*

*/

PC to PC Communication using RS-232

2008-10-02T04:50:00.000-07:00

/*Aim: PC to PC Communication using RS-232 in 'C'. */

#include
#include
#define COM1 0
#define DATA_READY 0x100
#define SETTINGS ( 0x80 | 0x02 | 0x00 | 0x00)
int main(void)
{
int in, out, status;
bioscom(0, SETTINGS, COM1); /*initialize the port*/
cprintf("Data sent to you: ");
while (1)
{
status = bioscom(3, 0, COM1); /*wait until get a data*/
if (status & DATA_READY)
if ((out = bioscom(2, 0, COM1) & 0x7F) != 0) /*input a data*/
putch(out);
if (kbhit())
{
if ((in = getch()) == 27) /* ASCII of Esc*/
break;
bioscom(1, in, COM1); /*output a data*/
}
}
return 0;
}

/* OUTPUT:-
Data sent to you: HI...how are you??
*/

DIJKSRTRA'S ALGORITHM

2008-10-02T04:48:00.000-07:00

/*Implementation of Shortest Path Algorithm(DIJKSRTRA's ALGORITHM) in C*/

#include< stdio.h>
#include< conio.h>
#include< process.h>
#include< string.h>
#include< math.h>
#define IN 99
#define N 6

int dijkstra(int cost[][N], int source, int target);

void main()
{
int cost[N][N],i,j,w,ch,co;
int source, target,x,y;
clrscr();
printf("\tShortest Path Algorithm(DIJKSRTRA's ALGORITHM\n\n");
for(i=1;i< N;i++)
for(j=1;j< N;j++)
cost[i][j] = IN;
for(x=1;x< N;x++)
{
for(y=x+1;y< N;y++)
{
printf("Enter the weight of the path between node %d and %d: ",x,y);
scanf("%d",&w);
cost [x][y] = cost[y][x] = w;
}
printf("\n");
}
printf("\nEnter The Source:");
scanf("%d", &source);
printf("\nEnter The target");
scanf("%d", &target);
co = dijsktra(cost,source,target);
printf("\nShortest Path: %d",co);
getch();
}

int dijsktra(int cost[][N],int source,int target)
{
int dist[N],prev[N],selected[N]={0},i,m,min,start,d,j;
char path[N];
for(i=1;i< N;i++)
{
dist[i] = IN;
prev[i] = -1;
}
start = source;
selected[start]=1;
dist[start] = 0;
while(selected[target] ==0)
{
min = IN;
m = 0;
for(i=1;i< N;i++)
{
d = dist[start] +cost[start][i];
if(d< dist[i]&&selected[i]==0)
{
dist[i] = d;
prev[i] = start;
}
if(min>dist[i] && selected[i]==0)
{
min = dist[i];
m = i;
}
}
start = m;
selected[start] = 1;
}
start = target;
j = 0;
while(start != -1)
{
path[j++] = start+65;
start = prev[start];
}
path[j]='\0';
strrev(path);
printf("%s", path);
return dist[target];
}
/***** Output *********

Shortest Path Algorithm(DIJKSRTRA's ALGORITHM

Enter the weight of the path between node 1 and 2: 2
Enter the weight of the path between node 1 and 3: 3
Enter the weight of the path between node 1 and 4: 4
Enter the weight of the path between node 1 and 5: 5

Enter the weight of the path between node 2 and 3: 5
Enter the weight of the path between node 2 and 4: 2
Enter the weight of the path between node 2 and 5: 3

Enter the weight of the path between node 3 and 4: 1
Enter the weight of the path between node 3 and 5: 4

Enter the weight of the path between node 4 and 5: 5

Enter The Source:2

Enter The target4
CE
Shortest Path: 2
*/

Calculation Of CRC

2008-10-02T04:44:00.000-07:00

/* Calculation of CRC (Cyclic Redundancy Check)*/

#include< stdlib.h>
#include< conio.h>
#include< stdio.h>
void main()
{
int i,j,n,g,a,arr[20],gen[20],b[20],q[20],s;
clrscr();
printf("Transmitter side:");
printf("\nEnter no. of data bits:");
scanf("%d",&n);
printf("Enter data:");
for(i=0;i< n;i++)
scanf("%d",&arr[i]);

printf("Enter size of generator:");
scanf("%d",&g);
do{
printf("Enter generator:");
for(j=0;j< g;j++)
scanf("%d",&gen[j]);

}
while(gen[0]!=1);
printf("\n\tThe generator matrix:");
for(j=0;j< g;j++)
printf("%d",gen[j]);

a=n+(g-1);
printf("\n\tThe appended matrix is:");
for(i=0;i< j;++i)
arr[n+i]=0;

for(i=0;i< a;++i)

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

for(i=0;i< n;++i)
q[i]= arr[i];

for(i=0;i< n;++i)
{
if(arr[i]==0)
{
for(j=i;j< g+i;++j)
arr[j] = arr[j]^0;
}
else
{
arr[i] = arr[i]^gen[0];
arr[i+1]=arr[i+1]^gen[1];
arr[i+2]=arr[i+2]^gen[2];
arr[i+3]=arr[i+3]^gen[3];
}
}
printf("\n\tThe CRC is :");
for(i=n;i < a;++i)
printf("%d",arr[i]);
s=n+a;
for(i=n;i< s;i++)
q[i]=arr[i];
printf("\n");
for(i=0;i< a;i++)
printf("%d",q[i]);
getch();
}
/* Output

Transmitter side:
Enter no. of data bits:8
Enter data:1 0 1 0 0 0 0 1
Enter size of generator:4
Enter generator:1 0 0 1

The generator matrix:1001
The appended matrix is:10100001000
The CRC is :111
10100001111
*/

LCM and HCM of two numbers

2008-09-13T11:26:00.000-07:00

/* C++ program to calculate LCM and HCM of two numbers */
#include< stdio.h>
#include< conio.h>
void main()
{
int a,b,c;
cout< < "Enter two nos : ;
cin>>a>>b;
c=a*b;
while(a!=b)
{
if(a>b)
a=a-b;
else
b=b-a;
}
cout< < "HCM \t= " < < a;
cout< < "LCM \t= " < < c/a;
getch();
}

Simple C++ program

2008-06-01T03:21:00.000-07:00

/* C++ program on Computer Details */

#include< iostream.h>
#include< conio.h>
#define max 80

int y;
int a = 0;
int b = 0;
long c = 0;
int d,m,p;

class computer
{
private:
char s[10],x[10],h[10];

public:
void getdata()
{
cout< < "Enter Computer Type : ";
cin>>h;
cout< < endl;
cout< < "Enter CPU Type : ";
cin>>x;
cout< < endl;
cout< < "Enter The Type Of OS : ";
cin>>s;
cout< < endl;
cout< < "Enter The Memory In MB : ";
cin>>m;
cout< < endl;
cout< < "Enter The Disk Space In GB : ";
cin>>d;
cout< < endl;
cout< < "Enter Yhe Price : ";
cin>>p;
cout< < endl;
}

int compare(int i)
{
if(m>a)
{
a = m;
b = d;
c = p;
y = i;
}
if((m==a)&&(d< b))
{
a = m;
b = d;
c = p;
y = i;
}
if((m==a)&&(d==b)&&(p< c))
{
a = m;
b = d;
c = p;
y = i;
}
return y;
}

void display()
{
cout< < "The Details Of The Best Computer Are : ";
cout< < endl;
cout< < "Disk Space :"< < d;
cout< < endl;
cout< < "Memory Space :"< < m;
cout< < endl;
cout< <"Price: "< < p;
cout< < endl;
cout< < "OS : "< < s;
cout< < endl;
cout< < "CPU : "< < x;
cout< < endl;
cout< < "Computer : "< < h;
cout< < endl;
}

};
void main()
{
clrscr();
computer d[max];
int r;
cout< < "Enter The Range : ";
cin>>r;
cout< < endl;

for(int i=0;i< r;i++)
{
d[i].getdata();
}
for(int j=0;j< r;j++)
{
d[j].compare(j);
}
d[y].display();
getch();
}

Hybrid inheritance

2008-06-01T03:17:00.000-07:00

/******** IMPLEMENTATION OF HYBRID INHERITANCE ********/

#include< iostream.h>
#include< conio.h>

class student
{
private :
int rn;
char na[20];
public:
void getdata()
{
cout< < "Enter Name And Roll No : ";
cin>>na>>rn;
}
void putdata()
{
cout< < endl< < na< < "\t"< < rn< < "\t";
}
};

class test : public student
{
protected:
float m1,m2;
public:
void gettest()
{
cout< < endl< < "Enter your marks In CP 1 And Cp 2 :";
cin>>m1>>m2;
}
void puttest()
{
cout< < m1< < "\t"< < m2< < "\t";
}
};

class sports
{
protected:
float score;
public:
void getscore()
{
cout< < endl< < "Enter your score :";
cin>>score;
}
void putscore()
{
cout< < score< < "\t";
}
};

class results : public test , public sports
{
private :
float total;
public :
void putresult()
{
total = m1+m2+score;
cout< < total;
}
};

void main()
{
results s[5];
clrscr();
for(int i=0;i< 5;i++)
{
s[i].getdata();
s[i].gettest();
s[i].getscore();
}
cout< < "______________________________________________"< < endl;
cout< < endl< < "Name\tRollno\tCP 1\tCP 2\tScore\tTotal"< < endl;
cout< < "----------------------------------------------"< < endl;
for(i=0;i< 5;i++)
{
s[i].putdata();
s[i].puttest();
s[i].putscore();
s[i].putresult();
}
cout< < endl< < "----------------------------------------------";
getch();
}

/********** OUTPIUT **********
Enter Name And Roll No : Lionel
1

Enter your marks In CP 1 And Cp 2 :45

Enter your score :45
Enter Name And Roll No : Cyril
65

Enter your marks In CP 1 And Cp 2 :49
42

Enter your score :45
Enter Name And Roll No : Mayank
40

Enter your marks In CP 1 And Cp 2 :41
43

Enter your score :46
Enter Name And Roll No : Dylan
78

Enter your marks In CP 1 And Cp 2 :23
24

Enter your score :25
Enter Name And Roll No : Ansha
39

Enter your marks In CP 1 And Cp 2 :45
45

Enter your score :45
______________________________________________

Name Rollno CP 1 CP 2 Score Total
----------------------------------------------

Lionel 1 45 23 45 113
Cyril 65 49 42 45 136
Mayank 40 41 43 46 130
Dylan 78 23 24 25 72
Ansha 39 45 45 45 135
----------------------------------------------
*/

Multilevel Inheritance

2008-06-01T03:15:00.000-07:00

/********* IMPLEMENTATION OF MULTILEVEL INHERITANCE *********/

#include< iostream.h>
#include< conio.h>

class student // Base Class
{
protected:
int rollno;
char *name;
public:
void getdata(int b,char *n)
{
rollno = b;
name = n;
}
void putdata(void)
{
cout< < " The Name Of Student \t: "< < name< < endl;
cout< < " The Roll No. Is \t: "< < rollno< < endl;
}
};

class test:public student // Derieved Class 1
{
protected:
float m1,m2;
public:
void gettest(float b,float c)
{
m1 = b;
m2 = c;
}
void puttest(void)
{
cout< < " Marks In CP Is \t: "< < m1< < endl;
cout< < " Marks In Drawing Is \t: "< < m2< < endl;
}
};

class result:public test // Derieved Class 2
{
protected:
float total;
public:
void displayresult(void)
{
total = m1 + m2;
putdata();
puttest();
cout< < " Total Of The Two \t: "< < total< < endl;
}
};

void main()
{
clrscr();
int x;
float y,z;
char n[20];
cout< < "Enter Your Name:";
cin>>n;
cout< < "Enter The Roll Number:";
cin>>x;
result r1;
r1.getdata(x,n);
cout< < "ENTER COMPUTER PROGRAMMING MARKS:";
cin>>y;
cout< < "ENTER DRAWING MARKS:";
cin>>z;
r1.gettest(y,z);
cout< < endl< < endl< < "************ RESULT **************"< < endl;
r1.displayresult();
cout< < "**********************************"< < endl;
getch();

}
/************ OUTPUT ************
Enter Your Name:Lionel
Enter The Roll Number:44
ENTER COMPUTER PROGRAMMING MARKS:95
ENTER DRAWING MARKS:90

************ RESULT **************
The Name Of Student : Lionel
The Roll No. Is : 44
Marks In CP Is : 95
Marks In Drawing Is : 90
Total Of The Two : 185
**********************************
*/

OPERATOR OVERLOADING - Unary

2008-06-01T03:12:00.000-07:00

/********* IMPLEMENTATION OF OPERATOR OVERLOADING (UNARY)*********/
#include< iostream.h>
#include< conio.h>

class unary
{
private:
int x,y,z;
public:

unary(void)
{
cout< < "Enter Any Three Integer Nos. : ";
cin>>x>>y>>z;
}

void display(void)
{
cout< < endl< < " The Three Nos. Are : "< < x< < " , "< < y< < " , "< < z;
}

void operator --()
{
x = --x;
y = --y;
z = --z;
}

void operator ++()
{
x = ++x;
y = ++y;
z = ++z;
}
};

void main()
{
clrscr();
unary s;
s.display();

--s;
cout< < endl< < endl< < endl< < "******* The Decremented Values ********"< < endl;
s.display();

++s;
cout< < endl< < endl< < endl< < "******* The Incremented Values ********"< < endl;
s.display();
cout< < endl< < endl< < "***************************************";

getch();
}

/************ OUTPUT **************
Enter Any Three Integer Nos. : 4
-8
6

The Three Nos. Are : 4 , -8 , 6

******* The Decremented Values ********

The Three Nos. Are : 3 , -9 , 5

******* The Incremented Values ********

The Three Nos. Are : 4 , -8 , 6

***************************************
*/

Bubble Sort

2008-06-01T03:06:00.000-07:00

/**** C Program For Implementation Of Bubble Sort. Sorting names entered by the user *****/
#include< stdio.h>
#include< conio.h>
#define MAX 10

char name[MAX][15];
void sort(int n)
{
int pa,cp,i,j,k,kk=0;
char temp[15];
pa=n-1;
cp=n-1;
for(i=1;i< =pa;i++)
{
for(j=1;j< =cp;j++)
{
kk=kk+1;
if(strcmp(name[j],name[j+1])>0)
{
strcpy(temp,name[j]);
strcpy(name[j],name[j+1]);
strcpy(name[j+1],temp);
}
}
printf("\n List after %d pass is ",i);
for(k=1;k< =n;k++)
printf("\n\t\t %s",name[k]);
getch();
}
clrscr();
printf("\n\t\t Total Comparisions Done : %d",kk);
}

void main()
{
int n,i,j;
clrscr();
printf("Enter How Many Names : ");
scanf("%d",&n);
if(n>MAX)
printf("\n\t\tArray Size IS Only %d",MAX);
else
{
printf("\n\t\tEnter %d Names :\n",n);
for(i=1;i< =n;i++)
{
printf("\t\t");
scanf("%s",name[i]);
}
sort(n);
printf("\n\n\t\tSorted List ");
for(i=1;i< =n;i++)
printf("\n\t\t%s",name[i]);
}
getch();
}
/********************* OUTPUT *******************
Enter How Many Names : 4

Enter 4 Names :
Malcolm
Lionel
Mayank
Pinto

List after 1 pass is
Lionel
Malcolm
Mayank
Pinto
List after 2 pass is
Lionel
Malcolm
Mayank
Pinto
List after 3 pass is
Lionel
Malcolm
Mayank
Pinto

*/

Binary Search Tree

2008-06-01T03:04:00.000-07:00

/* C Program on binary Search Tree */

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

struct node
{
char data[15];
struct node *left,*right;
};

void insert(struct node *r,struct node *p)
{
if((r->right==NULL)&&(strcmp(p->data,r->data)>0))
r->right=p;
else if((r->right!=NULL)&&(strcmp(p->data,r->data)>0))
insert(r->right,p);
if((r->left==NULL)&&(strcmp(p->data,r->data)< 0))
r->left=p;
else if((r->left!=NULL)&&(strcmp(p->data,r->data)< 0))
insert(r->left,p);

}

void tree(struct node *r,int c)
{
int top,flag;
struct node *w,*stack[20];
if(r!=NULL)
{
if(c!=4)
{
if(c == 1)
printf(" %s ",r->data);
tree(r->left,c);
if(c == 2)
printf(" %s ",r->data);
tree(r->right,c);
if(c == 3)
printf(" %s ",r->data);
}
}
if(c == 4)
{
top = 0;
w = r;
flag = 0;
while((top != -1)&&(w!=NULL))
{
while((flag == 0) && (w->left!=NULL))
{
stack[top] = w;
top++;
w = w->left;
}
printf(" %s ",w->data);
if(w->right != NULL)
{
w = w->right;
flag = 0;
}
else
{
top--;
w = stack[top];
flag = 1;
}
}
}
}
void main()
{
int choice,c,i,flag;
char temp='N',temp1[15];
struct node *s,*root,*r,*q;
root = NULL;
do
{
clrscr();
printf("\n 1. Enter");
printf("\n 2. Delete ");
printf("\n 3. Search ");
printf("\n 4. Display");
printf("\n 5. Exit");
printf("\nEnter Your Choice : ");
scanf("%d",&choice);
switch(choice)
{
case 1:printf("***** Data Entry ***** ");
do
{
s=malloc(sizeof(struct node));
s->left=NULL;
s->right=NULL;
printf("\nEnter Data : ");
scanf("%s",&s->data);
if(root==NULL)
root=s;
else
insert(root,s);
printf("\nEnter Your Elements[y/n] : ");
scanf("%c",&temp);
}
while(temp=='y');
break;

case 2:printf("****** Delete Operation *******\n");
do
{
printf("\nEnter Element To Be Deleted : ");
scanf("%s",temp1);
s=root;i=0;flag=0;
do
{
if(strcmp(s->data,temp1)>0)
{
r=s;
s=s->left;
i=2;
}
if(strcmp(s->data,temp1)==0)
{
flag=1;
if(i==0)
{
if(root->right!=NULL)
{
q=root->left;
root=root->right;
insert(root,q);
}
if(root->right==NULL)
root=root->left;
}
else
{
if(i==1)
{
q=s->left;
r->right=s->right;
if(s->left!=NULL)
insert(r,q);
}
if(i==2)
{
q=s->right;
r->left=s->left;
if(s->right!=NULL)
insert(r,q);
}
}
}
}
while(flag==0&&s!=NULL);
printf("\n Delete Any More[Y/N] : ");
scanf("%c",&temp);
}
while(temp=='y');
break;
case 3:printf("****** Search Operation *******\n");
do
{
printf("\n Enter Name To Be Searched");
scanf("%s",temp1);
i=0;
s=root;
while(s!=NULL&&i==0)
{
if(strcmp(s->data,temp1)< 0)
s=s->right;
if(strcmp(s->data,temp1)>0)
s=s->left;
if(strcmp(s->data,temp1)==0)
i=1;
}
if(i==0)
printf("\nElement Not Found\n");
else
printf("\nElement Found\n");
printf("\nEnter More Elements[Y/N] : ");
scanf("%c",&temp);
}
while(temp=='y');
break;
case 4:clrscr();
do
{
clrscr();
printf("\n 1. Preorder\n 2. Inorder \n 3. Postorder \n 4. Non Recursion \n 5. Exit");
printf("\nEnter Your Choice : ");
scanf("%d",&c);
if(root==NULL)
printf("Tree Not Started Yet");
else
tree(root,c);
printf("\n Press Any Key To Continue......");
getch();
}
while(c!=5);
break;
}
}
while(choice!=5);
}
/****************** OUTPUT ****************

1. Enter
2. Delete
3. Search
4. Display
5. Exit
Enter Your Choice : 1
/****** Data Entry *******

Enter Data : Lionel
Enter More Elements(Y/N) : y
Enter Data : Dylan
Enter More Elements(Y/N) : y
Enter Data : Daniel
Enter More Elements(Y/N) : y
Enter Data : Malcolm
Enter More Elements(Y/N) : y
Enter Data : Cyril
Enter More Elements(Y/N) : y
Enter Data : Jason
Enter More Elements(Y/N) : n

1. Enter
2. Delete
3. Search
4. Display
5. Exit
Enter Your Choice : 4

1. Preorder
2. Inorder
3. Postorder
4. Non Recursion
5. Exit
Enter Your Choice : 1
Lionel Dylan Malcolm Cyril Daniel Jason

Press Any Key to Contiue....

1. Preorder
2. Inorder
3. Postorder
4. Non Recursion
5. Exit
Enter Your Choice : 2
Malcolm Cyril Dylan Lionel Jason Daniel

Press Any Key to Contiue....

1. Preorder
2. Inorder
3. Postorder
4. Non Recursion
5. Exit
Enter Your Choice : 3
Cyril Malcolm Dylan Lionel Jason Daniel

Press Any Key to Contiue....

1. Preorder
2. Inorder
3. Postorder
4. Non Recursion
5. Exit
Enter Your Choice : 4
Malcolm Cyril Dylan Lionel Jason Daniel

Press Any Key to Contiue....

1. Preorder
2. Inorder
3. Postorder
4. Non Recursion
5. Exit
Enter Your Choice : 5

Press Any Key To Continue.....

1. Enter
2. Delete
3. Search
4. Display
5. Exit
Enter Your Choice : 3

Enter Name To Be Searched : Dylan
Element Found

Enter More Elements(Y/N) : n

1. Enter
2. Delete
3. Search
4. Display
5. Exit
Enter Your Choice : 2

****** Delete Operation *******
Enter Element To Be Deleted : Dylan
Delete Any More(Y/n) : n

1. Enter
2. Delete
3. Search
4. Display
5. Exit
Enter Your Choice : 5

*/

Heap Sort

2008-06-01T03:02:00.000-07:00

/************* C Program To Sort An Array Using Heap Sort *************/

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

void swap(int *x,int *y)
{
int temp;
temp=*x;
*x = *y;
*y = temp;
}

void heapsort(int a[],int n)
{
int i,s,f;
for(i=1;i< n;++i)
{
s=i;
f=(s-1)/2;
while( a[f]< a[s])
{
swap(&a[f],&a[s]);
s=f;
if(s==0)
break;
f=(s-1)/2;
}
}
for(i=n-1;i>=1;--i)
{
swap(&a[0],&a[i]);
f=0;
s=1;
if(i==1)
break;
if(i>2)if(a[2]>a[1])s=2;
while( a[f]< a[s] )
{
swap(&a[f],&a[s]);
f=s;
s=2*f+1;
if(i>s+1 )if(a[s+1]>a[s])s=s+1;
if (s>=i)
break;
}
}
}

void main()
{
int a[100],n,i;
clrscr();
printf("\t\tHEAP SORT\n");
printf("\nEnter The Number Of Elements\t: ");
scanf("%d",&n);
printf("\nEnter Elements\n");
for(i=0;i< n;++i)
scanf("%d",&a[i]);
heapsort(a,n);
printf("\n\t\t\tSorted List\n");
for(i=0;i< n;++i)
printf("\t%d",a[i]);
getche();
}
/***************** OUTPUT ******************
HEAP SORT

Enter The Number Of Elements : 6

Enter Elements
45
12
3
1
78
6

Sorted List
1 3 6 12 45 78
*/

Krushkal's Algorithm - 2

2008-06-01T02:59:00.000-07:00

/* C Program on Krushkal's Algorithm */

#include< stdio.h>
#include< stdlib.h>
void main()
{
int graph[15][15],s[15],pathestimate[15],mark[15];
int num_of_vertices,source,i,j,u,predecessor[15];
int count=0;
int minimum(int a[],int m[],int k);
void printpath(int,int,int[]);
printf("\nEnter The No. Of Vertices\n");
m scanf("%d",&num_of_vertices);
if(num_of_vertices< =0)
{
printf("\nThis Is Meaningless\n");
exit(1);
}
printf("\nEnter The Adjacent Matrix\n");
for(i=1;i< =num_of_vertices;i++)
{
printf("\nEnter The Elements Of Row %d\n",i);
for(j=1;j< =num_of_vertices;j++)
scanf("%d",&graph[i][j]);
}
printf("\nEnter The Source Vertex\n");
scanf("%d",&source);
for(j=1;j< =num_of_vertices;j++)
{
mark[j] = 0;
pathestimate[j] = 999;
predecessor[j] = 0;
}
pathestimate[source]=0;

while(count< num_of_vertices)
{
u = minimum(pathestimate,mark,num_of_vertices);
s[++count] = u;
mark[u] = 1;
for(i=1;i< =num_of_vertices;i++)
{
if(graph[u][i]>0)
{
if(mark[i]!=1)
{
if(pathestimate[i]>pathestimate[u]+graph[u][i])
{
pathestimate[i] = pathestimate[u]+graph[u][i];
predecessor[i] = u;
}
}
}
}
}
for(i=1;i< =num_of_vertices;i++)
{
printpath(source,i,predecessor);
if(pathestimate[i]!=999)
printf("->(%d)\n",pathestimate[i]);
}
}

int minimum(int a[],int m[],int k)
{
int mi=999;
int i,t;
for(i=1;i< =k;i++)
{
if(m[i]!=1)
{
if(mi>=a[i])
{
mi = a[i];
t = i;
}
}
}
return t;
}

void printpath(int x,int i,int p[])
{
printf("\n");
if(i==x)
printf("%d",x);
else if(p[i]==0)
printf("Number Path From %d To %d",x,i);
else
{
printpath(x,p[i],p);
printf("..%d",i);
}
}
/****************

Enter The No. Of Vertices
6

Enter The Adjacent Matrix

Enter The Elements Of Row 1
0 1 1 1 0 0

Enter The Elements Of Row 2
0 0 1 0 1 0

Enter The Elements Of Row 3
0 0 0 1 1 1

Enter The Elements Of Row 4
0 0 0 0 0 1

Enter The Elements Of Row 5
0 0 0 0 0 1

Enter The Elements Of Row 6
0 0 0 0 0 0

Enter The Source Vertex
1

1->(0)

1..2->(1)

1..3->(1)

1..4->(1)

1..3..5->(2)

1..4..6->(2)

*/

Krushkal's Algorithm

2008-06-01T02:57:00.001-07:00

/* C Program On Krushkal's Algorithm */

#include < stdio.h>
#include < conio.h>
typedef struct
{
int node1;
int node2;
int wt;
}edge;

void sortedges(edge a[],int n)
{
int i,j;
edge temp;
for(i=0;i< n-1;++i)
for(j=i+1;j< n;++j)
if(a[i].wt>a[j].wt){temp=a[i];a[i]=a[j];a[j]=temp;}
}

int checkcycle(int p[],int i,int j)
{
int v1,v2;
v1 = i;
v2 = j;
while(p[i]>-1)
i = p[i];
while(p[j]>-1)
j = p[j];
if(i!=j)
{
p[j]=i;
printf("%d %d\n",v1,v2);
return 1;
}
return 0;
}
void main()
{
edge e[100];
int parent[100];
int n,i,j,m,k = 1,cost = 0;
clrscr();
printf("KRUSKAL's ALGORITHM\n");
printf("Enter number of nodes\n");
scanf("%d",&n);
for(i=0;i< n;++i)
parent[i]=-1;
i = 0;
printf("Enter number of edges\n");
scanf("%d",&m);
for(i=0;i< m;++i)
{
printf("enter an edge and wt\n");
scanf("%d %d %d", &e[i].node1,&e[i].node2,&e[i].wt);
}
sortedges(e,m);
printf("\n\nEdges of the tree\n");
i = 0;
while(k< n)
{
if(checkcycle(parent,e[i].node1,e[i].node2))
{
k++;
cost=cost+e[i].wt;
i++;
}
}
printf("cost = %d",cost);
getch();
}

Radix Sort Algorithm

2008-06-01T02:54:00.000-07:00

/* C program to sort an array using radix sort LINKED LIST implementation*/

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

void radix(int a[],int n,int m)
{
typedef struct node
{
int data;
struct node * next;
}NODE;

NODE * ptr,*start,*prev;
NODE *front[10], *rear[10];
int k=1,i,j,y,p;;
/*creating initial linked list*/
start=NULL;
for(i=0;i< n;++i)
{
ptr=(NODE *)malloc(sizeof(NODE));
ptr->data=a[i];
ptr->next=NULL;
if(start==NULL)
start=ptr;
else
prev->next=ptr;
prev=ptr;
}

/*radix sort*/

for(i=1;i< =m;++i)
{
for(j=0;j< 10;++j)
front[j]=NULL;
/*placing elements into queues*/
ptr=start;
while(ptr!=NULL)
{y=ptr->data/k %10;/*y is the digit*/
if(front[y]==NULL)
{
front[y]=ptr;
rear[y]=ptr;
}
else
{
rear[y]->next=ptr;
rear[y]=ptr;
}

ptr=ptr->next;
}

start=NULL;
for(j=0;j< 10;++j)
if(front[j]!=NULL)
{
if(start==NULL)
start=front[j];
else rear[p]->next=front[j];
p=j;
}
rear[p]->next=NULL;
k=k*10;
}
/*copying back to array*/
ptr=start;
for(i=0;i< n;++i,ptr=ptr->next)
a[i]=ptr->data;

}

void main()
{
int a[100],n,i,m;
char temp;
do
{
clrscr();
printf("===========================RADIX SORT===========================================\n");
printf("ENTER NUMBER OF NUMBERS AND NUMBER OF DIGITS\n");
scanf("%d%d",&n,&m);
printf("ENTER ELEMENTS\n");
for(i=0;i< n;++i)
scanf("%d",&a[i]);
radix(a,n,m);
printf("SORTED LIST\n");
for(i=0;i< n;++i)
printf("%d ",a[i]);
printf("\nDO YOU wish to continue?[y/n]\n");
scanf("%c",&temp);

}while(temp=='y'|| temp=='Y');
printf("\n---------------------------------------------------------------------------------\n");
getch();
}
/*OUTPUT:
===========================RADIX SORT===========================================

Enter number of numbers and number of digits
4
2
enter elements
25
65
35
45
sorted list
25 35 45 65
Do you wish to continue?[y/n]
n
--------------------------------------------------------------------------------*/

Circle Through Three Points

2008-03-31T11:34:00.000-07:00

Program In C Language for Circle Through Three Points

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

int main()
{
clrscr();
double f,g,m,x1,x2,x3,y1,y2,y3;
double c,d,h,e,k,r,s;
for(;;)
{
if(scanf("%lf %lf %lf %lf %lf %lf",&x1,&y1,&x2,&y2,&x3,&y3)==EOF)
//checking for input
break;

f = x3*x3-x3*x2-x1*x3+x1*x2+y3*y3-y3*y2-y1*y3+y1*y2; //formula
g = x3*y1-x3*y2+x1*y2-x1*y3+x2*y3-x2*y1;

if(g==0)
m = 0;
else
m = (f/g);

c = (m*y2)-x2-x1-(m*y1); //formula
d = (m*x1)-y1-y2-(x2*m);
e = (x1*x2)+(y1*y2)-(m*x1*y2)+(m*x2*y1);

h = (c/2); //formula
k = (d/2);
s = (((h)*(h))+((k)*(k))-e);
r = pow(s,.5);

printf("(x");

if(h>=0)
printf(" + ");
else if(h< 0)
printf(" - ");
if(h< 0)
h=-h;
printf("%.3lf)^2",(h));
printf(" + ");
printf("(y");
if(k>=0)
printf(" + ");
else if(k< 0)
printf(" - ");
if(k< 0)
k=-k;
printf("%.3lf)^2 = %.3lf^2",(k),r);

printf("");

printf("x^2 + y^2");

if(c>=0) printf(" + ");
else if(c< 0) printf(" - ");

if(c< 0) c=-c;
printf("%.3lfx",c);

if(d>=0) printf(" + ");
else if(d< 0) printf(" - ");

if(d< 0) d=-d;
printf("%.3lfy",d);

if(e>=0) printf(" + ");
else if(e< 0) printf(" - ");

if(e< 0) e=-e;
printf("%.3lf = 0",e);
printf("");
}

getch();
return 0;
}

Decimal To Roman Conversion

2008-03-31T11:32:00.000-07:00

/* Program in C for Decimal to Roman Number conversion */

#include< stdio.h>

main()
{
int a,b,c,d,e;
clrscr();
printf("Input a number (between 1-3000):");
scanf("%d",&e);
while (e==0||e>3000)
{
printf ("ERROR: Invalid Input!
");
printf ("Enter the number again:");
scanf ("%d",&e);
}
if (e>3000)
printf("Invalid");
a = (e/1000)*1000;
b = ((e/100)%10)*100;
c = ((e/10)%10)*10;
d = ((e/1)%10)*1;

if (a ==1000)
printf("M");
else if (a ==2000)
printf("MM");
else if (a ==3000)
printf("MMM");

if (b == 100)
printf("C");
else if (b == 200)
printf("CC");
else if (b == 300)
printf("CCC");
else if (b == 400)
printf("CD");
else if (b ==500)
printf("D");
else if (b == 600)
printf("DC");
else if (b == 700)
printf("DCC");
else if (b ==800)
printf("DCCC");
else if (b == 900)
printf("CM");

if (c == 10)
printf("X");
else if (c == 20)
printf("XX");
else if (c == 30)
printf("XXX");
else if (c == 40)
printf("XL");
else if (c ==50)
printf("L");
else if (c == 60)
printf("LX");
else if (c == 70)
printf("LXX");
else if (c ==80)
printf("LXXX");
else if (c == 90)
printf("XC");

if (d == 1)
printf("I");
else if (d == 2)
printf("II");
else if (d == 3)
printf("III");
else if (d == 4)
printf("IV");
else if (d ==5)
printf("V");
else if (d == 6)
printf("VI");
else if (d == 7)
printf("VII");
else if (d ==8)
printf("VIII");
else if (d == 9)
printf("IX");
getch();
}

Shuttle Sort - Simple Insertion Sort

2008-02-27T20:07:00.000-08:00

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

void shutsort(int a[],int n)
{
int j,i=1,mid;

while(i< n)
{
j=i-1;
while(j>=0)
{
if(a[j]>a[j+1])
{
mid = a[j];
a[j] = a[j+1];
a[j+1]=mid;
j--;
}
else
break;
}
i++;
}
}

main()
{
int a[10],i,n;
clrscr();

printf("Enter The number Of Elements\t: ");
scanf("%d",&n);
for(i=0;i< n;i++)
{
printf("\nElement %d\t: ",i+1);
scanf("%d",&a[i]);
}

printf("\nArray Befor Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
shutsort(a,n);

printf("\nArray After Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
getch();
return 0;
}

/* OUTPUT
Enter The number Of Elements : 5

Element 1 : 21

Element 2 : 36

Element 3 : 54

Element 4 : 98

Element 5 : 1

Array Befor Sorting : 21 36 54 98 1
Array After Sorting : 1 21 36 54 98
*/

Shell Sort

2008-02-27T20:06:00.000-08:00

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

void shellsort(int a[],int n)
{
int j,i,k,m,mid;
for(m = n/2;m>0;m/=2)
{
for(j = m;j< n;j++)
{
for(i=j-m;i>=0;i-=m)
{
if(a[i+m]>=a[i])
break;
else
{
mid = a[i];
a[i] = a[i+m];
a[i+m] = mid;
}
}
}
}
}

main()
{
int a[10],i,n;
clrscr();

printf("Enter The number Of Elements\t: ");
scanf("%d",&n);
for(i=0;i< n;i++)
{
printf("\nElement %d\t: ",i+1);
scanf("%d",&a[i]);
}

printf("\nArray Befor Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
shellsort(a,n);

printf("\nArray After Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
getch();
return 0;
}

/* OUTPUT

Enter The number Of Elements : 5

Element 1 : 21

Element 2 : 36

Element 3 : 54

Element 4 : 2

Element 5 : 0

Array Befor Sorting : 21 36 54 2 0
Array After Sorting : 0 2 21 36 54
*/

Merge Sort

2008-02-27T20:04:00.000-08:00

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

void mergesort(int a[],int n)
{
int b[50],c,low1,high1,high2,low2;
int i,k,j;
c=1;
while(c< n)
{
low1=0;
k=0;
while(low1+c< n)
{
low2=low1+c ;
high1=low2-1;
if(low2+c-1< n)
high2=low2+c-1;
else
high2=n-1;
i=low1;
j=low2;
while(i< =high1 && j< =high2)
{
if(a[i]< =a[j])
b[k++] =a[i++];
else
b[k++] = a[j++];

}
while(i< =high1)
b[k++]=a[i++];
while(j< =high2)
b[k++] =a[j++];
low1=high2+1;
}
i=low1;
while(k< n)
b[k++] =a[i++];
for(i=0;i< n;i++)
a[i]=b[i];
c=c*2;
}
}

main()
{
int a[20],i,n;
clrscr();

printf("Enter The number Of Elements\t: ");
scanf("%d",&n);
for(i=0;i< n;i++)
{
printf("\nElement %d\t: ",i+1);
scanf("%d",&a[i]);
}

printf("\nArray Befor Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
mergesort(a,n);

printf("\nArray After Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
getch();
return 0;
}

/* OUTPUT

Enter The number Of Elements : 10

Element 1 : 12

Element 2 : 54

Element 3 : 98

Element 4 : 6566

Element 5 : 45

Element 6 : 12

Element 7 : 5

Element 8 : 1

Element 9 : 156

Element 10 : 21

Array Befor Sorting : 12 54 98 6566 45 12 5 1 156 21
Array After Sorting : 1 5 12 12 21 45 54 98 156 6566

*/

Quicksort

2008-02-27T20:02:00.000-08:00

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

void quicksort(int [],int,int);
int partition(int [],int,int);

main()
{
int a[20],p,q,i,n;
clrscr();

printf("Enter The number Of Elements\t: ");
scanf("%d",&n);
for(i=0;i< n;i++)
{
printf("\nElement %d\t: ",i+1);
scanf("%d",&a[i]);
}

p=0;
q=n-1;
printf("\nArray Befor Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
quicksort(a,p,q);

printf("\nArray After Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
getch();
return 0;
}

void quicksort(int a[],int p,int q)
{
int j;
if(p< q)
{
j=partition(a,p,q+1);
quicksort(a,p,j-1);
quicksort(a,j+1,q);
}
}

int partition(int a[],int m,int p)
{
int v,i,j;
int temp;
v=a[m];
i=m;j=p;
do
{
do
{
i += 1;
}
while(a[i]< v);
do
{
j -= 1;
}
while(a[j]>v);

if(i< j)
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
while(i< j);
a[m] =a[j];
a[j] = v;
return j;
}

/* OUTPUT

Enter The number Of Elements : 10

Element 1 : 12

Element 2 : 54

Element 3 : 98

Element 4 : 6566

Element 5 : 45

Element 6 : 12

Element 7 : 5

Element 8 : 1

Element 9 : 156

Element 10 : 21

Array Befor Sorting : 12 54 98 6566 45 12 5 1 156 21
Array After Sorting : 1 5 12 12 21 45 54 98 156 6566

*/

Simple Selection Sort

2008-02-25T20:49:00.000-08:00

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

void simplesel(int a[],int b[],int n)
{
int j,i=0,k,H;
int L=32760;
k=0;
L=H;
while(i< n)
{
for(j=0;j< n;j++)
{
if(a[j]< L)
{
L = a[j];
k = j;
}
}
a[k] = H;
b[i] = L;
L = H;
i++;
}
}

main()
{
int a[10],b[10],i,n;
clrscr();

printf("Enter The number Of Elements\t: ");
scanf("%d",&n);
for(i=0;i< n;i++)
{
printf("\nElement %d\t: ",i+1);
scanf("%d",&a[i]);
}

printf("\nArray Befor Sorting : ");
for(i=0;i< n;i++)
printf("%5d",a[i]);
simplesel(a,b,n);

printf("\nArray After Sorting : ");
for(i=0;i< n;i++)
printf("%5d",b[i]);
getch();
return 0;
}
/* OUTPUT
Enter The number Of Elements : 10

Element 1 : 21

Element 2 : 25

Element 3 : 63

Element 4 : 45

Element 5 : 1

Element 6 : 147

Element 7 : 10

Element 8 : 78

Element 9 : 96

Element 10 : 5
Array Befor Sorting : 21 25 63 45 1 147 10 78 96 5
Array After Sorting : 1 5 10 21 25 45 63 78 96 147
*/

Factorial

2008-02-12T00:29:00.000-08:00

/* C++ program for calculating factorial of a number entered by the user */

# include < iostream.h>
# include < conio.h>
void fact(int);

void main()
{
clrscr();
int n;
cout < < "Enter limit : ";
cin>>n;
fact(n);
getch();
}
void fact(int x)
{
char a;
int i=1;
for(int j=1;j< =x;j++)
{
i*=j;
}
cout< < "Answer = "< < i< < endl;
cout< < "Want to continue ( y )/or press any key to continue ";
cin>>a;
if(a=='y')
{
main();
}
else
{
cout< < "Good Bye ";
}
getch();
}

Huffman Coding

2008-02-10T02:50:00.000-08:00

/* Huffman Coding in C . This program reads a text file named on the command line, then compresses it using Huffman coding. The file is read twice, once to determine the frequencies of the characters, and again to do the actual compression. */

#include < stdio.h>
#include < stdlib.h>
#include < string.h>
#include < time.h>

/* there are 256 possible characters */

#define NUM_CHARS 256

/* tree node, heap node */

typedef struct _treenode treenode;
struct _treenode {
int freq; /* frequency; is the priority for heap */
unsigned char ch; /* character, if any */
treenode *left, /* left child of Huffman tree (not heap!) */
*right; /* right child of Huffman tree */
};

/* this is a priority queue implemented as a binary heap */
typedef struct _pq {
int heap_size;
treenode *A[NUM_CHARS];
} PQ;

/* create an empty queue */

void create_pq (PQ *p) {
p->heap_size = 0;
}

/* this heap node's parent */

int parent (int i) {
return (i-1) / 2;
}

/* this heap node's left kid */

int left (int i) {
return i * 2 + 1;
}

/* this heap node's right kid */

int right (int i) {
return i * 2 + 2;
}

/* makes the subheap with root i into a heap , assuming left(i) and
* right(i) are heaps
*/
void heapify (PQ *p, int i) {
int l, r, smallest;
treenode *t;

l = left (i);
r = right (i);

/* find the smallest of parent, left, and right */

if (l < p->heap_size && p->A[l]->freq < p->A[i]->freq)
smallest = l;
else
smallest = i;
if (r < p->heap_size && p->A[r]->freq < p->A[smallest]->freq)
smallest = r;

/* swap the parent with the smallest, if needed. */

if (smallest != i) {
t = p->A[i];
p->A[i] = p->A[smallest];
p->A[smallest] = t;
heapify (p, smallest);
}
}

/* insert an element into the priority queue. r->freq is the priority */
void insert_pq (PQ *p, treenode *r) {
int i;

p->heap_size++;
i = p->heap_size - 1;

/* we would like to place r at the end of the array,
* but this might violate the heap property. we'll start
* at the end and work our way up
*/
while ((i > 0) && (p->A[parent(i)]->freq > r->freq)) {
p->A[i] = p->A[parent(i)];
i = parent (i);
}
p->A[i] = r;
}

/* remove the element at head of the queue (i.e., with minimum frequency) */
treenode *extract_min_pq (PQ *p) {
treenode *r;

if (p->heap_size == 0) {
printf ("heap underflow!\n");
exit (1);
}

/* get return value out of the root */

r = p->A[0];

/* take the last and stick it in the root (just like heapsort) */

p->A[0] = p->A[p->heap_size-1];

/* one less thing in queue */

p->heap_size--;

/* left and right are a heap, make the root a heap */

heapify (p, 0);
return r;
}

/* read the file, computing the frequencies for each character
* and placing them in v[]
*/
unsigned int get_frequencies (FILE *f, unsigned int v[]) {
int r, n;

/* n will count characters */

for (n=0;;n++) {

/* fgetc() gets an unsigned char, converts to int */

r = fgetc (f);

/* no more? get out of loop */

if (feof (f)) break;

/* one more of this character */

v[r]++;
}
return n;
}

/* make the huffman tree from frequencies in freq[] (Huffman's Algorithm) */

treenode *build_huffman (unsigned int freqs[]) {
int i, n;
treenode *x, *y, *z;
PQ p;

/* make an empty queue */

create_pq (&p);

/* for each character, make a heap/tree node with its value
* and frequency
*/
for (i=0; i< NUM_CHARS; i++) {
x = malloc (sizeof (treenode));

/* its a leaf of the Huffman tree */

x->left = NULL;
x->right = NULL;
x->freq = freqs[i];
x->ch = (char) i;

/* put this node into the heap */

insert_pq (&p, x);
}

/* at this point, the heap is a "forest" of singleton trees */

n = p.heap_size-1; /* heap_size isn't loop invariant! */

/* if we insert two things and remove one each time,
* at the end of heap_size-1 iterations, there will be
* one tree left in the heap
*/
for (i=0; i< n; i++) {

/* make a new node z from the two least frequent
* nodes x and y
*/
z = malloc (sizeof (treenode));
x = extract_min_pq (&p);
y = extract_min_pq (&p);
z->left = x;
z->right = y;

/* z's frequency is the sum of x and y */

z->freq = x->freq + y->freq;

/* put this back in the queue */

insert_pq (&p, z);
}

/* return the only thing left in the queue, the whole Huffman tree */

return extract_min_pq (&p);
}

/* traverse the Huffman tree, building up the codes in codes[] */

void traverse (treenode *r, /* root of this (sub)tree */
int level, /* current level in Huffman tree */
char code_so_far[], /* code string up to this point in tree */
char *codes[]) {/* array of codes */

/* if we're at a leaf node, */

if ((r->left == NULL) && (r->right == NULL)) {

/* put in a null terminator */

code_so_far[level] = 0;

/* make a copy of the code and put it in the array */

codes[r->ch] = strdup (code_so_far);
} else {

/* not at a leaf node. go left with bit 0 */

code_so_far[level] = '0';
traverse (r->left, level+1, code_so_far, codes);

/* go right with bit 1 */

code_so_far[level] = '1';
traverse (r->right, level+1, code_so_far, codes);
}
}

/* global variables, a necessary evil */

int nbits, current_byte, nbytes;

/* output a single bit to an open file */

void bitout (FILE *f, char b) {

/* shift current byte left one */

current_byte < < = 1;

/* put a one on the end of this byte if b is '1' */

if (b == '1') current_byte |= 1;

/* one more bit */

nbits++;

/* enough bits? write out the byte */

if (nbits == 8) {
fputc (current_byte, f);
nbytes++;
nbits = 0;
current_byte = 0;
}
}

/* using the codes in codes[], encode the file in infile, writing
* the result on outfile
*/
void encode_file (FILE *infile, FILE *outfile, char *codes[]) {
unsigned char ch;
char *s;

/* initialize globals for bitout() */

current_byte = 0;
nbits = 0;
nbytes = 0;

/* continue until end of file */

for (;;) {

/* get a char */

ch = fgetc (infile);
if (feof (infile)) break;

/* put the corresponding bitstring on outfile */

for (s=codes[ch]; *s; s++) bitout (outfile, *s);
}

/* finish off the last byte */

while (nbits) bitout (outfile, '0');
}

/* main program */

int main (int argc, char *argv[]) {
FILE *f, *g;
treenode *r; /* root of Huffman tree */
unsigned int n, /* number of bytes in file */
freqs[NUM_CHARS]; /* frequency of each char */
char *codes[NUM_CHARS], /* array of codes, 1 per char */
code[NUM_CHARS], /* a place to hold one code */
fname[100]; /* what to call output file */

/* hassle user */

if (argc != 2) {
fprintf (stderr, "Usage: %s < filename>\n", argv[0]);
exit (1);
}

/* set all frequencies to zero */

memset (freqs, 0, sizeof (freqs));

/* open command line argument file */

f = fopen (argv[1], "r");
if (!f) {
perror (argv[1]);
exit (1);
}

/* compute frequencies from this file */

n = get_frequencies (f, freqs);
fclose (f);

/* make the huffman tree */

r = build_huffman (freqs);

/* traverse the tree, filling codes[] with the codes */

traverse (r, 0, code, codes);

/* name the output file something.huf */

sprintf (fname, "%s.huf", argv[1]);
g = fopen (fname, "w");
if (!g) {
perror (fname);
exit (1);
}

/* write frequencies to file so they can be reproduced */

fwrite (freqs, NUM_CHARS, sizeof (int), g);

/* write number of characters to file as binary int */

fwrite (&n, 1, sizeof (int), g);

/* open input file again */

f = fopen (argv[1], "r");
if (!f) {
perror (argv[1]);
exit (1);
}

/* encode f to g with codes[] */

encode_file (f, g, codes);
fclose (f);
fclose (g);
/* brag */
printf ("%s is %0.2f%% of %s\n",
fname, (float) nbytes / (float) n, argv[1]);
exit (0);
}

Operator Overloading

2008-02-10T01:00:00.000-08:00

/* C++ Program for the IMPLEMENTATION OF OPERATOR OVERLOADING(BINARY). The Given Program performs Basic Arithematic operation : Addition, Subtraction, Multiplication and Division for Two Complex Numbers. */

#include< iostream.h>
#include< conio.h>
#include< process.h>
class complex
{
float real;
float imag;
public:
complex()
{}
complex(float x,float y)
{
real=x;
imag=y;
}
complex operator + (complex);
complex operator - (complex);
complex operator * (complex);
complex operator / (complex);
void display(void)
{
cout< < real< < " +i" < < i mag< < endl;
}

};

complex complex :: operator +(complex c)
{
complex c2;
c2.real=real+c.real;
c2.imag=imag+c.imag;
return (c2);
}

complex complex :: operator -(complex c)
{
complex c2;
c2.real=real-c.real;
c2.imag=imag-c.imag;
return (c2);
}
complex complex :: operator *(complex c)
{
complex c2;
c2.real = ((real * c.real) - (imag * c.imag));
c2.imag = ((real * c.imag) + (imag * c.imag));
return (c2);
}
complex complex :: operator /(complex c)
{
complex c2;
c2.real=((real * c.real) + (imag * c.imag))/((real * c.real) + (imag * c.imag));
c2.imag=((imag * c.real) - (real * c.imag))/((real * c.real) + (imag * c.imag));
return (c2);
}

void main()
{
clrscr();
complex c1,c2,c3;
int op;
char ch,y,Y;

c1 = complex(5.6,2.7);
c2 = complex(3.5,5.6);
cout< < "Two Complex numbers Are :"< < endl;
c1.display();
c2.display();
do
{
cout< < endl< < "******** MENU *********"< < endl;
cout< < "1. Addition\n2. Subtraction\n3. Multiplication\n4. Division\n5. Exit"< < endl;
cout< < "Enter Your Choice : ";
cin>>op;
switch(op)
{
case 1:
c3 = c1 + c2;
cout< < "Addition of Two complex Nos. :";
c3.display();
break;

case 2:
c3 = c1 - c2;
cout< < "Subtraction of Two complex Nos. :";
c3.display();
break;

case 3:
c3 = c1 * c2;
cout< <" Multiplication of Two complex Nos. :";
c3.display();
break;

case 4:
c3 = c1 / c2;
cout< < "division of Two complex Nos. :";
c3.display();
break;

case 5:exit(0);

default: cout< < endl< < "Aborting!!!!!!!INVALID CHOICE"< < endl;
}
cout< < " Do you want to continue(Y/y)";
cin>>ch;
}
while(ch=='y'||ch=='Y');
getch();
}
/******************* OUTPUT ********************
Two Complex numbers Are :
5.6 +i2.7
3.5 +i5.6

******** MENU *********
1. Addition
2. Subtraction
3. Multiplication
4. Division
5. Exit
Enter Your Choice : 1
Addition of Two complex Nos. :9.1 +i8.3
Do you want to continue(Y/y)y

******** MENU *********
1. Addition
2. Subtraction
3. Multiplication
4. Division
5. Exit
Enter Your Choice : 2
Subtraction of Two complex Nos. :2.1 +i-2.9
Do you want to continue(Y/y)y

******** MENU *********
1. Addition
2. Subtraction
3. Multiplication
4. Division
5. Exit
Enter Your Choice : 3
Multiplication of Two complex Nos. :4.48 +i46.48
Do you want to continue(Y/y)y

******** MENU *********
1. Addition
2. Subtraction
3. Multiplication
4. Division
5. Exit
Enter Your Choice : 4
division of Two complex Nos. :1 +i-0.631048
Do you want to continue(Y/y)n
*/

Friend Function

2008-02-10T00:59:00.001-08:00

/* C++ program for the Implementation Of Friend Function */

#include< iostream.h>
#include< conio.h>
class complex
{
float real;
float imag;
public:
void getdata(float x,float y)
{
real=x;
imag=y;
}
friend complex add (complex c1,complex c2);
void display()
{
cout< < "the complex no is"< < real< < "+i"< < imag< < endl;
}

};
complex add (complex c1,complex c2)
{
complex c3;
c3.real=c1.real+c2.real;
c3.imag=c1.imag+c2.imag;
return (c3);

}
void main()
{
clrscr();
complex c1,c2,c3;

c1.getdata(4.2,5.5);
c2.getdata(3.5,5.6);
c3=add(c1,c2);
c3.display();
}

Implementation Of Destructors

2008-02-10T00:53:00.000-08:00

/* IMPLEMENTATION OF DESTRUCTORS */

#include< iostream.h>
#include< conio.h>

int count = 0;

class data
{
public:
data(void)
{
count++;
cout< < endl< < "The Number of The Object Created Is:"< < count;
}

~data()
{
cout< < endl< < "The Number Of The Object Destroyed Is"< < count;
count--;
}
};

void main()
{
clrscr();
data d1;
data d2;
{
data d3;
data d4;
}
data d5;
data d6;
}

/**********OUTPUT**********
The Number of The Object Created Is: 1
The Number of The Object Created Is: 2
The Number of The Object Created Is: 3
The Number of The Object Created Is: 4
The Number Of The Object Destroyed Is 4
The Number Of The Object Destroyed Is 3
The Number of The Object Created Is: 3
The Number of The Object Created Is: 4
The Number Of The Object Destroyed Is 4
The Number Of The Object Destroyed Is 3
The Number Of The Object Destroyed Is 2
The Number Of The Object Destroyed Is 1

*/

Implementation Of Constructors

2008-02-04T22:16:00.000-08:00

A constructor is a member function with the same name as its class. For example:

class X
{
public:
X(); // constructor for class X
};

Constructors are used to create, and can initialize, objects of their class type.

You cannot declare a constructor as virtual or static, nor can you declare a constructor as const, volatile, or const volatile.

You do not specify a return type for a constructor. A return statement in the body of a constructor cannot have a return value.

Types?

Default Constructor:

Constructor() {
name = "";
size = 0;
text = "";
}

-takes 0 parameters, and initializes them as any other language could.

Parameter List Constructor:

Constructor(String n, int s, String t){
name = t;
size = s;
text = t;
}

-again similar to other languages, but this kind of work is not necessary, this is one of many places C++ shines.

Paramenter List Constructor 2:

Constructor(String n, int s, String t):name(n),size(s),text(t) {}

-this method utilizes a feature similar to the contructor, it is as if your primitive types now have there own constructors!! Simplifying your code.

*There is one more thing you can add to this last modification, it will combine the Default and List Parameter Constructors into one!
It will also allow for only partial constructors (eg: only enter a name or name and size only!)

List Parameter with Defaults Constructor:

Constructor(String n="", int s=0, String t=""):name(n),size(s),text(t) {}

-in this case when information is supplied, if only one field is given, the left most field is assumed to be the field supplied. If any fields are left out, or this constructor is called as the default, the values set equal will be used instead!!

Now that is all well and good for primatives, but what about objects?
C++ to the rescue, there is a copy constructor format wich you can use to initialize an object using another object of the same type!

Copy Constructor:

Constructor(const Constructor& c){
this->name = c.name;
this->size = c.size;
this->text = c.text;
}

/* IMPLEMENTATION OF DIFFERENT TYPES OF CONSTRUCTORS */

#include<>
#include<>

class data
{
private:
int x,y,z;

public:
data(void)
{
x = 0;
y = 0;
z = 0;
cout< <"This Is The First Type Of The Constructor"< < endl;
cout< < " The Three Values Are"< < x< < ","< < y< < ","< < z< < endl< < endl;
}

data(int a)
{
x = a;
y = 0;
z = 0;
cout< < "This Is The Second Type Of The Constructor"< < endl;
cout< < "The Three Values Are"< < x< < ","< < y< < ","< < z< < endl< < endl;
}

data(int a,int b)
{
x = a;
y = b;
z = 0;
cout< < "This Is The Third Type Of The Constructor"< < endl;
cout< < "The Three Values Are"< < x< < ","< < y< < ","< < z< < endl < < endl;
}

data(int a,int b,int c)
{
x = a;
y = b;
z = c;
cout< < "This Is The Fourth Type Of The Constructor"< < endl;
cout< <"The Three Values Are"< < x< <" ,"< < y< < ","< < z< < endl;
}
};

void main()
{
data d1();
data d2 = data(9);
data d3(1,2);
data d4(1,2,4);

getch();
}

/* OUTPUT *

This Is The First Type Of The Constructor
The Three Values Are0,0,0

Is The Second Type Of The Constructor
The Three Values Are9,0,0

This Is The Third Type Of The Constructor
The Three Values Are1,2,0

This Is The Fourth Type Of The Constructor
The Three Values Are1,2,4 */

FUNCTION OVERLOADING in C++

2008-02-04T22:14:00.000-08:00

/* C++ Program For the IMPLEMENTATION OF FUNCTION OVERLOADING. The Program Finds the Area OF A Circle, Square and rectangle */

#include< iostream.h>
#include< conio.h>

int area(int);
int area(int,int);
float area(float);

void main()
{
clrscr();
cout< < " Area Of Square: "< < area(4);
cout< < " Area Of Rectangle: "< < area(4,4);
cout< < " Area Of Circle: "< < area(3.2);
getch();
}

int area(int a)
{
return (a*a);
}

int area(int a,int b)
{
return(a*b);
}

float area(float r)
{
return(3.14 * r * r);
}

/*****OUTPUT******
Area Of Square: 16 Area Of Rectangle: 16 Area Of Circle: 10.048 */

Pass Object As An Argument

2008-02-04T22:11:00.000-08:00

/*C++ PROGRAM TO PASS OBJECT AS AN ARGUMEMT. The program Adds the two heights given in feet and inches. */

#include< iostream.h>
#include< conio.h>

class height
{
int feet,inches;
public:
void getht(int f,int i)
{
feet=f;
inches=i;
}
void putheight()
{
cout< < "\nHeight is:"< < feet< < "feet\t"< < inches< < "inches"< < endl;
}
void sum(height a,height b)
{
height n;
n.feet = a.feet + b.feet;
n.inches = a.inches + b.inches;
if(n.inches ==12)
{
n.feet++;
n.inches = n.inches -12;
}
cout< < endl< < "Height is "< < n.feet< < " feet and "< < n.inches< < endl;
}
};
void main()
{
height h,d,a;
clrscr();
h.getht(6,5);
a.getht(2,7);
h.putheight();
a.putheight();
d.sum(h,a);
getch();
}

/**********OUTPUT***********

Height is:6feet 5inches

Height is:2feet 7inches

Height is 9 feet and 0

*/

Static Data Functions

2008-02-04T22:09:00.000-08:00

/* C++ Program For the IMPLEMENTATION OF STATIC MEMBERS FUNCTIONS */

#include< iostream.h>
#include< conio.h>
class customer
{
private:
static int count;
int accountno;
public:
void setaccountno(void);
void displayaccountno(void);
void static displaycount(void);
};
int customer::count;

void customer::setaccountno(void)
{
count++;
accountno=count;
}

void customer :: displayaccountno(void)
{
cout< < "The Account Number Is:"< < accountno< < endl;
}
void customer :: displaycount(void)
{
cout< < "The Total Numer Of Account Are:"< < count< < endl;
}
void main()
{
customer c1,c2;
clrscr();
c1.setaccountno();
c2.setaccountno();
c1.displayaccountno();
c2.displayaccountno();
c1.displaycount();
getch();
}

/********* OUTPUT *************
The Account Number Is:1
The Account Number Is:2
The Total Numer Of Account Are:2
*/

Static Data members

2008-02-04T22:07:00.000-08:00

/* C++ program For the IMPLEMENTATION OF STATIC DATA MEMBERS */

#include< iostream.h>
#include< conio.h>
class book
{
private:
static int count;
int bookid;
public:
addbook(void)
{
count ++;
bookid=count;
}
displaybook()
{
cout< < "The Number Of The Books Are:"< < count;
}
};
int book::count;
void main()
{
book b1,b2;
clrscr();
b1.addbook();
b2.addbook();
b1.displaybook();
cout< < endl;
b2.displaybook();
getch();
}

/* OUTPUT
The Number Of The Books Are:2
The Number Of The Books Are:2
*/

Student Marks

2008-02-04T22:02:00.000-08:00

/* C++ program for the Implementation Of Class And Objects. The Programs Take inputs of n number of students, their marks and roll number and then displays the ranker. */

#include< iostream.h>
#include< conio.h>
class student
{
int count;
struct stud
{
int rollno;
char name[10];
float marks;
}s[10];

public:
void getcount(void);
void getdata(void);
void putdata(void);
void findranker(void);
};

void student::getcount(void)
{
cout< < "Enter no of Students:";
cin>>count;
}

void student::getdata(void)
{
int i;
for(i=0;i< count;i++)
{
cout< < "Name: ";
cin>>s[i].name;
cout< < "Roll no:";
cin>>s[i].rollno;
cout< < "marks:";
cin>>s[i].marks;
}
}

void student::putdata(void)
{
int i;
cout< < "_______________________________________"< < endl;
cout< < "Name\t"< < "Roll no.\t"< < "Marks"< < endl;
cout< < "---------------------------------------"< < endl;
for(i=0;i< count;i++)
cout< < s[i].name< < "\t"< < s[i].rollno< < "\t\t"< < s[i].marks< < endl;
cout< < "---------------------------------------";
}

void student::findranker(void)
{
int i,loc=0;
float top;
top=s[0].marks;
for(i=0;i< count;i++)
{
if(s[i].marks>top)
{
top=s[i].marks;
loc=i;
}

}
cout< < "\nThe Ranker Is:";
cout< < s[loc].name;
}
void main()
{
clrscr();
student s;
s.getcount();
s.getdata();
s.putdata();
s.findranker();
getch();
}

/***************** OUTPUT ***************
Enter no of Students:4
Name: Lionel
Roll no:1
marks:90
Name: Cyril
Roll no:45
marks:89
Name: Valerian
Roll no:56
marks:87
Name: Noronha
Roll no:56
marks:80
_______________________________________
Name Roll no. Marks
---------------------------------------
Lionel 1 90
Cyril 45 89
Valerian 78 87
Noronha 56 80
---------------------------------------

The Ranker Is : Lionel*/

RSA Algorithm

2008-01-23T22:45:00.000-08:00

/* C Program For The Implementation Of RSA*/

#include<>
#include<>

void main()
{
long int p,q,n,fn,e,s=0,d=1,C[100],M;
char m[100];
unsigned long int b=0,c=0;
int i,j,t;
clrscr();
printf("Enter the value of p and q: ");
scanf("%ld%ld",&p,&q);
n=p*q;
fn=(p-1)*(q-1);
printf("\nEnter the Encryption key e: ");
scanf("%ld",&e);
do
{ s=(d*e)%fn;
d++;
}while(s!=1);
d=d-1;
printf("\n\tPublic key (%ld,%ld) ",e,n);
printf("\n\tPrivate key (%ld,%ld) ",d,n);
printf("\n\nEnter message :\n");
scanf("%s",m);
for(j=0;j< strlen(m);j++)
{
t=(int)m[j];
c=1;
for(i=0;i< e;i++)
c=c*t%n;
c=c%n;
printf("%d ",c);
}
printf("\n\nEnter cipher text :\n");
for(i=0;i< strlen(m);i++)
scanf("%ld",&C[i]);
printf("\n\n\tPlaintext :");

for(j=0;j< strlen(m);j++)
{
M=1;
for(i=0;i< d;i++)
M=M*C[j]%n;
M=M%n;
printf("%c",M);
}
getch();
}
/********************* OUTPUT ***********************
Enter the value of p and q: 7 17

Enter the Encryption key e: 5

Public key (5,119)
Private key (77,119)

Enter message :
Lionel_Noronha
111 56 76 94 33 75 23 57 76 88 76 94 83 20

Enter cipher text :
111 56 76 94 33 75 23 57 76 88 76 94 83 20

Plaintext :Lionel_Noronha
****************************************************/

Run Length Encoding

2008-01-23T22:43:00.000-08:00

/* C Program For The Implementation Of RUN LENGTH ENCODING */

#include< stdio.h>
#include< conio.h>
#include< string.h>
void main()
{
int i,j,cnt,l,count[50]={0};
char str[50];
clrscr();
printf("Enter the string: ");
scanf("%s",str);
printf("\n\tOriginal String is: %s",str);
printf("\n\n\tEncoded String is: ");
l = strlen(str);
for(i=0;i< l;i*=1)
{
j = 0;
count[i] = 1;
do
{
j++;
if(str[i+j] == str[i])
count[i]++;
}while(str[i+j]==str[i]);
if(count[i]==1)
printf("%c",str[i++]);
else
{
printf("$%d%c",count[i],str[i]);
i += count[i];
}
}
getch();
}
/************************* OUTPUT ************************
Enter the string: sleepzzzzzzzzzzzzzzzzzzz

Original String is: sleepzzzzzzzzzzzzzzzzzzz

Encoded String is: sl$2ep$19z */

RSA Algorithm

2008-01-23T22:04:00.000-08:00

/* C program for the Implementation Of RSA Algorithm */

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

int phi,M,n,e,d,C,FLAG;

int check()
{
int i;
for(i=3;e%i==0 && phi%i==0;i+2)
{
FLAG = 1;
return;
}
FLAG = 0;
}

void encrypt()
{
int i;
C = 1;
for(i=0;i< e;i++)
C=C*M%n;
C = C%n;
printf("\n\tEncrypted keyword : %d",C);
}

void decrypt()
{
int i;
M = 1;
for(i=0;i< d;i++)
M=M*C%n;
M = M%n;
printf("\n\tDecrypted keyword : %d",M);
}

void main()
{
int p,q,s;
clrscr();
printf("Enter Two Relatively Prime Numbers\t: ");
scanf("%d%d",&p,&q);
n = p*q;
phi=(p-1)*(q-1);
printf("\n\tF(n)\t= %d",phi);
do
{
printf("\n\nEnter e\t: ");
scanf("%d",&e);
check();
}while(FLAG==1);
d = 1;
do
{
s = (d*e)%phi;
d++;
}while(s!=1);
d = d-1;
printf("\n\tPublic Key\t: {%d,%d}",e,n);
printf("\n\tPrivate Key\t: {%d,%d}",d,n);
printf("\n\nEnter The Plain Text\t: ");
scanf("%d",&M);
encrypt();
printf("\n\nEnter the Cipher text\t: ");
scanf("%d",&C);
decrypt();
getch();
}

/*************** OUTPUT *****************

Enter Two Relatively Prime Numbers : 7 17

F(n) = 96

Enter e : 5

Public Key : {5,119}
Private Key : {77,119}

Enter The Plain Text : 19

Encrypted keyword : 66

Enter the Cipher text : 66

Decrypted keyword : 19 */

Shanno - Fano Code

2008-01-23T22:00:00.000-08:00

/*
The Shannon-Fano Algorithm

This is a basic information theoretic algorithm. A simple example will be used to illustrate the algorithm:

Symbol A B C D E
----------------------------------
Count 15 7 6 6 5

Encoding for the Shannon-Fano Algorithm:

A top-down approach
1. Sort symbols according to their frequencies/probabilities, e.g., ABCDE.

2. Recursively divide into two parts, each with approx. same number of counts.

Symbol Count log(1/p) Code Subtotal (# of bits)
------ ----- -------- --------- --------------------
A 15 1.38 00 30
B 7 2.48 01 14
C 6 2.70 10 12
D 6 2.70 110 18
E 5 2.96 111 15
TOTAL (# of bits): 89

*/

#include< stdio.h>
#include< conio.h>
#include< string.h>
struct node
{
char sym[10];
float pro;
int arr[20];
int top;
}s[20];

typedef struct node node;

void prints(int l,int h,node s[])
{
int i;
for(i=l;i< =h;i++)
{
printf("\n%s\t%f",s[i].sym,s[i].pro);
}
}

void shannon(int l,int h,node s[])
{
float pack1=0,pack2=0,diff1=0,diff2=0;
int i,d,k,j;
if((l+1)==h || l==h || l>h)
{
if(l==h || l>h)
return;
s[h].arr[++(s[h].top)]=0;
s[l].arr[++(s[l].top)]=1;
return;
}
else
{
for(i=l;i< =h-1;i++)
pack1=pack1+s[i].pro;
pack2=pack2+s[h].pro;
diff1=pack1-pack2;
if(diff1< 0)
diff1=diff1*-1;
j=2;
while(j!=h-l+1)
{
k=h-j;
pack1=pack2=0;
for(i=l;i< =k;i++)
pack1=pack1+s[i].pro;
for(i=h;i>k;i--)
pack2=pack2+s[i].pro;
diff2=pack1-pack2;
if(diff2< 0)
diff2=diff2*-1;
if(diff2>=diff1)
break;
diff1=diff2;
j++;
}
k++;
for(i=l;i< =k;i++)
s[i].arr[++(s[i].top)]=1;
for(i=k+1;i< =h;i++)
s[i].arr[++(s[i].top)]=0;
shannon(l,k,s);
shannon(k+1,h,s);
}
}

void main()
{
int n,i,j;
float x,total=0;
char ch[10];
node temp;
clrscr();
printf("Enter How Many Symbols Do You Want To Enter\t: ");
scanf("%d",&n);
for(i=0;i< n;i++)
{
printf("Enter symbol %d ---> ",i+1);
scanf("%s",ch);
strcpy(s[i].sym,ch);
}
for(i=0;i< n;i++)
{
printf("\n\tEnter probability for %s ---> ",s[i].sym);
scanf("%f",&x);
s[i].pro=x;
total=total+s[i].pro;
if(total>1)
{
printf("\t\tThis probability is not possible.Enter new probability");
total=total-s[i].pro;
i--;
}
}
s[i].pro=1-total;
for(j=1;j< =n-1;j++)
{
for(i=0;i< n-1;i++)
{
if((s[i].pro)>(s[i+1].pro))
{
temp.pro=s[i].pro;
strcpy(temp.sym,s[i].sym);
s[i].pro=s[i+1].pro;
strcpy(s[i].sym,s[i+1].sym);
s[i+1].pro=temp.pro;
strcpy(s[i+1].sym,temp.sym);
}
}
}
for(i=0;i< n;i++)
s[i].top=-1;

shannon(0,n-1,s);
printf("---------------------------------------------------------------");
printf("\n\n\n\tSymbol\tProbability\tCode");
for(i=n-1;i>=0;i--)
{
printf("\n\t%s\t%f\t",s[i].sym,s[i].pro);
for(j=0;j< =s[i].top;j++)
printf("%d",s[i].arr[j]);
}
printf("\n---------------------------------------------------------------");
getch();
}

/********************* OUTPUT **************************

Enter How Many Symbols Do You Want To Enter : 6
Enter symbol 1 ---> a
Enter symbol 2 ---> b
Enter symbol 3 ---> c
Enter symbol 4 ---> d
Enter symbol 5 ---> e
Enter symbol 6 ---> f

Enter probability for a ---> 0.3

Enter probability for b ---> 0.25

Enter probability for c ---> 0.20

Enter probability for d ---> 0.12

Enter probability for e ---> 0.08

Enter probability for f ---> 0.05

---------------------------------------------------------------
Symbol Probability Code
a 0.300000 00
b 0.250000 01
c 0.200000 10
d 0.120000 110
e 0.080000 1110
f 0.050000 1111
---------------------------------------------------------------
*/

Convolutional Codes

2008-01-23T00:24:00.000-08:00

/* C Porgram To Find convolutional Codes or Code Vectors */

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

void main()
{
int i,j,k,n,gb,mb,g[10][10],x[10][10],c[10],m[10],t[10];
clrscr();
for(i=0;i< 10;i++)
{
for(j=0;j< 10;j++)
g[i][j]=0;x[i][j]=0;c[i]=0;m[i]=0;t[i]=0;
}
printf("\t\t\t¦ Convolutional Code ¦");
printf("\n\nEnter The No. Of Generator Sequences\t: ");
scanf("%d",&n);
printf("Enter The No. Of Bits In Each Generator Sequence\t: ");
scanf("%d",&gb);
for(i=0;i< n;i++)
{
printf("\n\nEnter The Values Of G%d\t:\n",i);
for(j=0;j< gb;j++)
scanf("%dt",&g[i][j]);
}
printf("\nEnter The No. Of Message Bits\t: ");
scanf("%d",&mb);
printf("Enter The Message Bits\t:\n");
for(i=0;i< mb;i++)
scanf("%d",&c[i]);
for(i=0;i< mb;i++)
{
for(j=0;j< gb;j++)
{
t[j]=m[j];
if(j==0)
m[j]=c[i];
else
m[j]=t[j-1];
}
for(k=0;k< gb;k++)
{
for(j=0;j< gb;j++)
{
if(g[k][j]==1)
x[k][i]=x[k][i]^m[j];
}
}
}
printf("\n\n¦ The Code Vectors Are: ¦\n");
for(i=0;i< mb;i++)
{
printf("¦ \n¦ ");
for(j=0;j< gb;j++)
printf("%d\t",x[j][i]);
}
getch();
}

/*************** OUTPUT ******************
¦ Convolutional Code ¦

Enter The No. Of Generator Sequences : 2
Enter The No. Of Bits In Each Generator Sequence : 3

Enter The Values Of G0 :
1
1
1

Enter The Values Of G1 :
1
0
1

Enter The No. Of Message Bits : 8
Enter The Message Bits :
1
1
0
1
1
0
1
1

¦ The Code Vectors Are: ¦
¦
¦ 1 1 0 ¦
¦ 0 1 0 ¦
¦ 0 1 0 ¦
¦ 0 0 0 ¦
¦ 0 1 0 ¦
¦ 0 1 0 ¦
¦ 0 0 0 ¦
¦ 0 1 0

*/

Cyclic Code

2008-01-23T00:21:00.000-08:00

/* C Program For Implementation Of Cyclic Code */

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

void main()
{
int n,k,g[10],C[10],M[10],I,T[10];
int i,j,r;
clrscr();
printf("\t\t\t³ CYCLIC ENCODER ³\n");

printf("\n\nEnter The Value Of n and k\t:\n");
scanf("%d%d",&n,&k);
printf("\nEnter The Generator Polynomial Of Dergee %d",(n-k));
printf(" of the form 1+x+xý+x³+...\n");

for(i=0;i< n-k;i++)
scanf("%d",&g[i]);
printf("\nEnter Msg\n");
for(i=0;i< k;i++)
scanf("%d",&M[i]);
printf("\n\n");

for(i=0;i< n-k;i++)
{
T[i]=0;
}
for(i=0;i< k;i++)
{
I = (M[i] + T[n-k-1])%2;
C[0] = I;

for(j=1;j< n-k;j++)
{
if(g[j]==1)
C[j]=(I + T[j-1])%2;
else
C[j]=T[j-1];

}
for(r=0;r< n-k;r++)
{
T[r]=C[r];
}
}
printf("-----------------------------------------------------");
printf("\n³\tGenerated Cyclic code is\t: ");
for(i=0;i< k;i++)
printf("%d",M[i]);
printf(" ");
for(i=0;i< n-k;i++)
printf("%d",C[i]);
printf("\t\n-------------------------------------------------------");
getch();
}
/********************* OUTPUT *************************
³ CYCLIC ENCODER ³

Enter The Value Of n and k :
7
4

Enter The Generator Polynomial Of Dergee 3 of the form 1+x+xý+x³+...
1
1
0

Enter Msg
1
0
1
0

-------------------------------------------------------
Generated Cyclic code is : 1010 110
-------------------------------------------------------

*/

Entropy Of Given Message

2008-01-23T00:17:00.000-08:00

/* C Program to find Entropy Of Given Message */

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

void main()
{
int c,i;
float p,sum=0,it;
clrscr();
printf("**** INFORMATION CONTENT OF FIVE MESSEGES *****\n\n");
printf("Enter No Of Messages : ");
scanf("%d",&c);
printf("\n");
for(i=1;i< =c;i++)
{
printf("\tEnter The %d Probability\t: ",i);
scanf("%f",&p);
it = p* (log(1/p)) / log(2);
sum=sum+it;
}
printf("\nEntropy Of The Given Message : %f",sum);
getch();
}
/******************** OUTPUT *************************

**** INFORMATION CONTENT OF FIVE MESSEGES *****

Enter No Of Messages : 5

Enter The 1 Probability : 0.1
Enter The 2 Probability : 0.2
Enter The 3 Probability : 0.3
Enter The 4 Probability : 0.36
Enter The 5 Probability : 0.04

Entropy Of The Given Message : 2.034038 */

Linear Block Code

2008-01-22T22:35:00.001-08:00

/* C Program For Implementation Of Linear Block Code.
The User Should Enter the following details :
For A Generator Matrix
1. The No Of Message Bits(n)
2. The No Of Parity Bits(k)
3. And The Message Bits */

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

void main()
{
int i,j,n,k,M[10],C[10],G[10][10],par[10][10];
clrscr();
printf(" For A Generator Matrix Enter :\n");
printf("1. The No Of Message Bits(n)\t: ");
scanf("%d",&n);
printf("2. The No Of Parity Bits(k)\t: ");
scanf("%d",&k);
printf("\nEnter The Elements Of Generator Matrix:\n");
for(i=0;i< k;i++)
for(j=0;j< n;j++)
scanf("%d",&G[i][j]);
printf("\nEnter The Message Bits\n");
for(i=0;i< k;i++)
scanf("%d",&M[i]);
printf("\t\t\tResult\n");
printf("____________________________________________________");
printf("\n\tThe Generator Matrix Is :\n\t");
for(i=0;i< k;i++)
{
for(j=0;j< n;j++)
printf("%d\t",G[i][j]);
printf("\n\t");
}
printf("\n\tThe Parity Matrix Is :\n\t");
for(i=0;i< k;i++)
{
for(j=0;j< n-k;j++)
{
par[i][j]=G[i][j+k];
printf("%d\t",par[i][j]);
}
printf("\n\t");
}
printf("\n\tThe Messege Bits :\n\t");
for(i=0;i< k;i++)
printf("%d ",M[i]);
printf("\n\n\tThe Parity Bits :");
for(i=0;i< n-k;i++)
{
C[i] = 0;
for(j=0;j< k;j++)
C[i]=(C[i] + M[j] * par[j][i])%2;
printf("\n\tC%d = %d",i+1,C[i]);
}
printf("\n\n\tCode Word For Given Messege Bit:\n\t");
for(i=0;i< k;i++)
printf("%d ",M[i]);
for(i=0;i< n-k;i++)
printf("%d ",C[i]);
printf("\n____________________________________________________");
getch();
}
/********************** OUTPUT **************************
For A Generator Matrix Enter :
1. The No Of Message Bits(n) : 6
2. The No Of Parity Bits(k) : 3

Enter The Elements Of Generator Matrix:
1
0
0
1
1
1
0
1
0
1
1
0
0
0
1
1
0
1

Enter The Message Bits
0
0
1
Result
____________________________________________________
The Generator Matrix Is :
1 0 0 1 1 1
0 1 0 1 1 0
0 0 1 1 0 1

The Parity Matrix Is :
1 1 1
1 1 0
1 0 1

The Messege Bits :
0 0 1

The Parity Bits :
C1 = 1
C2 = 0
C3 = 1

Code Word For Given Messege Bit:
0 0 1 1 0 1
____________________________________________________ */

Information Content

2008-01-22T22:33:00.000-08:00

/* C Program to find th information Content OF the 5 message entered by the user */

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

void main()
{
int c,i;
float p,sum=0,it;
clrscr();
printf("***** INFORMATION CONTENT OF FIVE MESSEGES *****\n\n");
printf("Enter No Of Messages : ");
scanf("%d",&c);
for(i=1;i< =c;i++)
{
printf("\tEnter The %d Probability\t: ",i);
scanf("%f",&p);
it=(log(1/p)) / log(2);
sum=sum+it;
}
printf("Information Content Of Given Message : %f",sum);
getch();
}
/********************* OUTPUT ***********************

***** INFORMATION CONTENT OF FIVE MESSEGES *****

Enter No Of Messages : 5
Enter The 1 Probability : 0.1
Enter The 2 Probability : 0.2
Enter The 3 Probability : 0.3
Enter The 4 Probability : 0.36
Enter The 5 Probability : 0.04
Information Content Of Given Message : 13.498609 */

Even / Odd Number

2008-01-22T22:31:00.000-08:00

/* C Program For Checking whether a number is even or odd */

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

void main()
{
int a;
clrscr();
printf("Enter A number : ");
scanf("%d",&a);
if(a%2 != 0)
{
printf("\nThe Number %d Is Odd",a);
}
else if(a%2 == 0)
{
printf("\nThe Number %d Is Even",a);
}
getch();
}
/******************* OUTPUT ********************

Enter A number : 66
The Number 66 Is Even

Enter A number : 37
The Number 37 Is Odd */

Non - Restoring Division

2008-01-22T22:28:00.000-08:00

/* C Program For Implementation Of Non - Restoring Division */

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

int a[5]={0,0,0,0,0},q[4],b[5],b2c[5];

comp()
{
int i=4;
do
{
b2c[i]=b[i];
i--;
}while(b[i+1]!=1);
while(i>=0)
{
b2c[i]=(b[i]+1)%2;
i--;
}
printf("\n\tB's complement:");
for(i=0;i< 5;i++)
printf("%d",b2c[i]);
printf("\n");
}

nonresdiv()
{
shiftleft();
if(a[0]==0)
a_minus_b();
else
a_plus_b();
q[3]=(a[0]+1)%2;
}

shiftleft()
{
int i;
for(i=0;i< 4;i++)
a[i]=a[i+1];
a[4]=q[0];
for(i=0;i< 3;i++)
q[i]=q[i+1];
}

a_minus_b()
{
int i,carry=0,sum=0;
for(i=4;i>=0;i--)
{
sum=(a[i]+b2c[i]+carry);
a[i]=sum%2;
carry=sum/2;
}
}

a_plus_b()
{
int i,carry=0,sum=0;
for(i=4;i>=0;i--)
{
sum=(a[i]+b[i]+carry);
a[i]=sum%2;
carry=sum/2;
}
}

void main()
{
int i,j,k;
clrscr();
printf("Enter dividend in binary form\t: ");
for(i=0;i< 4;i++)
scanf("%d",&q[i]);
printf("Enter divisor in binary form\t: ");
for(i=0;i< 5;i++)
scanf("%d",&b[i]);
comp();
printf("\n\t[A]\t[M]\n");
for(i=0;i< 4;i++)
{
nonresdiv();
printf("\t");
for(j=0;j< 5;j++)
printf("%d",a[j]);
printf("\t");
for(k=0;k< 4;k++)
printf("%d",q[k]);
printf("\n");
}
if(a[0]==1)
a_plus_b();printf("\t");
for(j=0;j< 5;j++)
printf("%d",a[j]);
printf("\t");
for(k=0;k< 4;k++)
printf("%d",q[k]);
printf("\n");
printf("\n\tThe Quotient Is\t: ");
for(k=0;k< 4;k++)
printf("%d",q[k]);
printf("\n\tThe Remainder Is\t: ");
for(j=0;j< 5;j++)
printf("%d",a[j]);
getch();
}

/********************** OUTPUT ****************
Enter dividend in binary form : 0 1 0 1
Enter divisor in binary form : 0 0 0 1 1

B's complement:11101

[A] [M]
11101 1010
11110 0100
11111 1000
00010 0001
00010 0001

The Quotient Is : 0001
The Remainder Is : 00010

Enter dividend in binary form : 1 1 1 1
Enter divisor in binary form : 0 0 1 1 1

B's complement:11001

[A] [M]
11010 1110
11100 1100
00000 1001
11010 0010
00001 0010

The Quotient Is : 0010
The Remainder Is : 00001

Enter dividend in binary form : 1 1 0 1
Enter divisor in binary form : 0 0 0 1 1

B's complement:11101

[A] [M]
11110 1010
00000 0101
11101 1010
11110 0100
00001 0100

The Quotient Is : 0100
The Remainder Is : 00001
*/

Restoring Division

2008-01-22T22:20:00.000-08:00

/* C Program for the implentation of Restoring Division
*/
#include< stdio.h>
#include< conio.h>
#include< math.h>

int getsize(int x)
{
int c;
if(x< =1)
c = 2;
else if(x < 4)
c = 2;
else if(x< 8)
c = 3;
else if(x< 16)
c = 4;
else if(x< 32)
c = 5;
else if(x< 64)
c = 6;
else if(x< 128)
c = 7;
else if(x< 256)
c = 8;
else if(x< 512)
c = 9;
return c;
}

int max(int x,int y)
{
if(x< y)
return(y);
else
return(x);
}

void main()
{
int B,Q,Z,M,c,c1,e,f,g,h,i,j,x,y,ch,in,S,G,P;
int a[24],b[12],b1[12],q[12],carry=0,count=0,option;
long num;
do
{
clrscr();
printf("¦-----------------------------------------------¦\n");
printf("¦\t\tPROGRAM FOR DIVISION\t\t¦\n");
printf("¦-----------------------------------------------¦");
printf("\n\nENTER DIVIDEND\t: ");
scanf("%d",&Q);
y = getsize(Q);
printf("ENTER DIVISOR\t: ");
scanf("%d",&M);
x = getsize(M);
Z = max(x,y);
printf("\n\tTOTAL BITS CONSIDERED FOR RESULT => %d",2*Z+1);
printf("\n\tINITiALLY A IS RESET TO ZERO:");
for(i=0;i< =Z;i++)
printf("%d ",a[i]=0);
for(i=Z;i>=0;i--)
{
b1[i] = b[i] = M%2;
M = M/2;
b1[i] = 1-b1[i];
}
carry = 1;
for(i=Z;i>=0;i--)
{
c1 = b1[i]^carry;
carry = b1[i]&&carry;
b1[i]=c1;
}
for(i=2*Z;i>Z;i--)
{
a[i] = Q%2;
Q = Q/2;
}
printf("\n\n\tDivisor\t\t(M)\t: ");
for(i=0;i< =Z;i++)
printf("%d ",b[i]);
printf("\n\t2'C Divisor\t(M)\t: ");
for(i=0;i< =Z;i++)
printf("%d ",b1[i]);
printf("\n\tDividend\t(Q)\t: ");
for(i=Z+1;i< =2*Z;i++)
printf("%d ",a[i]);
printf("\n\n\tBITS CONSIDERED:[ A ] [ M ]");
printf("\n\t\t\t");
for(i=0;i< =Z;i++)
printf("%d ",a[i]);
printf(" ");
for(i=Z+1;i< =2*Z;i++)
printf("%d ",a[i]);
count = Z;
do{
for(i=0;i< 2*Z;i++)
a[i] = a[i+1];
printf("\n\nLeft Shift\t\t");
for(i=0;i< =Z;i++)
printf("%d ",a[i]);
printf(" ");
for(i=Z+1;i< 2*Z;i++)
printf("%d ",a[i]);
carry=0;
for(i=Z;i>=0;i--)
{
S=a[i]^(b1[i]^carry);
G=a[i]&&b1[i];
P=a[i]^b1[i];
carry=G||(P&&carry);
a[i]=S ;
}
printf("\nA< -A-M \t\t");
for(i=0;i< =Z;i++)
printf("%d ",a[i]);
printf(" ");
for(i=Z+1;i< 2*Z;i++)
printf("%d ",a[i]);
ch=a[0];
printf("\nBIT Q:%d",ch);
switch (ch)
{
case 0: a[2*Z]=1;
printf(" Q0< -1\t\t");
for(i=0;i< =Z;i++)
printf("%d ",a[i]);
printf(" ");
for(i=Z+1;i< =2*Z;i++)
printf("%d ",a[i]);
break;

case 1: a[2*Z]=0;
printf(" Q0< -0\t\t");
for(i=0;i< =Z;i++)
printf("%d ",a[i]);
printf(" ");
for(i=Z+1;i< 2*Z;i++)
printf("%d ",a[i]);
carry=0;
for(i=Z;i>=0;i--)
{
S=a[i]^(b[i]^carry);
G=a[i]&&b[i];
P=a[i]^b[i];
carry=G||(P&&carry);
a[i]=S ;
}
printf("\nA< -A+M");
printf("\t\t\t");
for(i=0;i< =Z;i++)
printf("%d ",a[i]);
printf(" ");
for(i=Z+1;i< =2*Z;i++)
printf("%d ",a[i]);
break;
}
count--;
}while(count!=0);
num=0;
printf("\n\t\t< < QUOTIENT IN BITS>> :");
for(i=Z+1;i< =2*Z;i++)
{
printf("%d ",a[i]);
num=num+pow(2,2*Z-i)*a[i];
}
printf("\n\t\tOUOTIENT IN DECIMAL :%d",num);
num=0;
printf("\n\t\t< < REMAINDER IN BITS>>:");
for(i=0;i< =Z;i++)
{
printf("%d ",a[i]);
num=num+pow(2,Z-i)*a[i];
}
printf("\n\t\tREMAINDER IN DECIMAL :%d",num);
getche();
printf("\n\tDO YOU WANT TO CONTINUE PRESS 0-ESC 1-CONT.:");
scanf("%d",&option);

}while(option!=0);
getch();
}

/***************** OUTPUT ***********************

¦-----------------------------------------------¦
¦ PROGRAM FOR DIVISION ¦
¦-----------------------------------------------¦

ENTER DIVIDEND : 16
ENTER DIVISOR : 3

TOTAL BITS CONSIDERED FOR RESULT => 11
INITiALLY A IS RESET TO ZERO:0 0 0 0 0 0

Divisor (M) : 0 0 0 0 1 1
2'C Divisor (M) : 1 1 1 1 0 1
Dividend (Q) : 1 0 0 0 0

BITS CONSIDERED: [ A ] [ M ]
0 0 0 0 0 0 1 0 0 0 0

Left Shift 0 0 0 0 0 1 0 0 0 0
A< -A-M 1 1 1 1 1 0 0 0 0 0
BIT Q:1 Q0< -0 1 1 1 1 1 0 0 0 0 0
A< -A+M 0 0 0 0 0 1 0 0 0 0 0

Left Shift 0 0 0 0 1 0 0 0 0 0
A< -A-M 1 1 1 1 1 1 0 0 0 0
BIT Q:1 Q0< -0 1 1 1 1 1 1 0 0 0 0
A< -A+M 0 0 0 0 1 0 0 0 0 0 0

Left Shift 0 0 0 1 0 0 0 0 0 0
A< -A-M 0 0 0 0 0 1 0 0 0 0
BIT Q:0 Q0< -1 0 0 0 0 0 1 0 0 0 0 1

Left Shift 0 0 0 0 1 0 0 0 0 1
A< -A-M 1 1 1 1 1 1 0 0 0 1
BIT Q:1 Q0< -0 1 1 1 1 1 1 0 0 0 1
A< -A+M 0 0 0 0 1 0 0 0 0 1 0

Left Shift 0 0 0 1 0 0 0 0 1 0
A< -A-M 0 0 0 0 0 1 0 0 1 0
BIT Q:0 Q0< -1 0 0 0 0 0 1 0 0 1 0 1
< < QUOTIENT IN BITS>> :0 0 1 0 1
OUOTIENT IN DECIMAL :5
< < REMAINDER IN BITS>>:0 0 0 0 0 1
REMAINDER IN DECIMAL :1 0 0 0 0 1
DO YOU WANT TO CONTINUE PRESS 0-ESC 1-CONT.:0

¦-----------------------------------------------¦
¦ PROGRAM FOR DIVISION ¦
¦-----------------------------------------------¦

ENTER DIVIDEND : 25
ENTER DIVISOR : 6

TOTAL BITS CONSIDERED FOR RESULT = > 11
INITiALLY A IS RESET TO ZERO:0 0 0 0 0 0

Divisor (M) : 0 0 0 1 1 0
2'C Divisor (M) : 1 1 1 0 1 0
Dividend (Q) : 1 1 0 0 1

BITS CONSIDERED:[ A ] [ M ]
0 0 0 0 0 0 1 1 0 0 1

Left Shift 0 0 0 0 0 1 1 0 0 1
A< -A-M 1 1 1 0 1 1 1 0 0 1
BIT Q:1 Q0< -0 1 1 1 0 1 1 1 0 0 1
A< -A+M 0 0 0 0 0 1 1 0 0 1 0

Left Shift 0 0 0 0 1 1 0 0 1 0
A< -A-M 1 1 1 1 0 1 0 0 1 0
BIT Q:1 Q0< -0 1 1 1 1 0 1 0 0 1 0
A< -A+M 0 0 0 0 1 1 0 0 1 0 0

Left Shift 0 0 0 1 1 0 0 1 0 0
A< -A-M 0 0 0 0 0 0 0 1 0 0
BIT Q:0 Q0< -1 0 0 0 0 0 0 0 1 0 0 1

Left Shift 0 0 0 0 0 0 1 0 0 1
A< -A-M 1 1 1 0 1 0 1 0 0 1
BIT Q:1 Q0< -0 1 1 1 0 1 0 1 0 0 1
A< -A+M 0 0 0 0 0 0 1 0 0 1 0

Left Shift 0 0 0 0 0 1 0 0 1 0
A< -A-M 1 1 1 0 1 1 0 0 1 0
BIT Q:1 Q0< -0 1 1 1 0 1 1 0 0 1 0
A< -A+M 0 0 0 0 0 1 0 0 1 0 0
< < QUOTIENT IN BITS>> :0 0 1 0 0
OUOTIENT IN DECIMAL :4
< < REMAINDER IN BITS>>:0 0 0 0 0 1
REMAINDER IN DECIMAL :1 0 0 0 0 1
DO YOU WANT TO CONTINUE PRESS 0-ESC 1-CONT.:0

¦-----------------------------------------------¦
¦ PROGRAM FOR DIVISION ¦
¦-----------------------------------------------¦

ENTER DIVIDEND : 19
ENTER DIVISOR : 7

TOTAL BITS CONSIDERED FOR RESULT = > 11
INITiALLY A IS RESET TO ZERO:0 0 0 0 0 0

Divisor (M) : 0 0 0 1 1 1
2'C Divisor (M) : 1 1 1 0 0 1
Dividend (Q) : 1 0 0 1 1

BITS CONSIDERED:[ A ] [ M ]
0 0 0 0 0 0 1 0 0 1 1

Left Shift 0 0 0 0 0 1 0 0 1 1
A< -A-M 1 1 1 0 1 0 0 0 1 1
BIT Q:1 Q0< -0 1 1 1 0 1 0 0 0 1 1
A < -A+M 0 0 0 0 0 1 0 0 1 1 0

Left Shift 0 0 0 0 1 0 0 1 1 0
A< -A-M 1 1 1 0 1 1 0 1 1 0
BIT Q:1 Q0< -0 1 1 1 0 1 1 0 1 1 0
A< -A+M 0 0 0 0 1 0 0 1 1 0 0

Left Shift 0 0 0 1 0 0 1 1 0 0
A< -A-M 1 1 1 1 0 1 1 1 0 0
BIT Q:1 Q0< -0 1 1 1 1 0 1 1 1 0 0
A< -A+M 0 0 0 1 0 0 1 1 0 0 0

Left Shift 0 0 1 0 0 1 1 0 0 0
A< -A-M 0 0 0 0 1 0 1 0 0 0
BIT Q:0 Q0< -1 0 0 0 0 1 0 1 0 0 0 1

Left Shift 0 0 0 1 0 1 0 0 0 1
A< -A-M 1 1 1 1 1 0 0 0 0 1
BIT Q:1 Q0< -0 1 1 1 1 1 0 0 0 0 1
A< -A+M 0 0 0 1 0 1 0 0 0 1 0
< < QUOTIENT IN BITS>> :0 0 0 1 0
OUOTIENT IN DECIMAL :2
< < REMAINDER IN BITS>>:0 0 0 1 0 1
REMAINDER IN DECIMAL :5 0 0 1 0 1
DO YOU WANT TO CONTINUE PRESS 0-ESC 1-CONT.:0

*/

Booth's Algorithm

2008-01-17T21:30:00.000-08:00

/* C Program For Implementation Of Signed Multiplication
OR
C Program for the Implementation Of Booths Algorithm */

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

int get(int a)
{
char ch='B';
int flag=0;
if(a==1)
ch='A';
do
{
printf("│ ENTER VALUE OF %c: ",ch);
scanf("%d",&a);
if(a< 0)
{
a = a * -1;
flag = 1;
}
if(9< =a)
printf("│\n\t!INVALID NUMBER.ENTER VALUE (-9 < A < 9)!");
}while(9< =a);
if(flag)
a = a *-1;
return(a);
}

void add(int *a,int *b)
{
int x,i,c=0;
for(i=3;i>=0;i--)
{
x=a[i];
a[i]=c^x^b[i];
if(((c==1)&&(x==1))||((x==1)&&(b[i]==1))||((b[i]==1)&&(c==1)))
c = 1;
else
c = 0;
}
}

void binary(int x,int*arr)
{
int i,p=x,c[4]={0,0,0,1};
for(i=0;i< 4;i++)
arr[i] = 0;
if(x < 0)
x = x *-1;
i = 3;
do
{
arr[i]=x%2;
x = x/2;
i--;
}while(x!=0);
if(p< 0)
{
for(i=0;i< 4;i++)
arr[i]=1-arr[i];
add(arr,c);
}
printf("\n\nTHE BINARY EQUIVALENT OF %d IS : ",p);
for(i=0;i< 4;i++)
printf("%d",arr[i]);
}

void rshift(int x,int *y)
{
int i;
for(i=3;i>0;i--)
y[i] = y[i-1];
y[0] = x;
}

void main()
{
int q=0,i,j,a,b,A[4]={0,0,0,0},C[4]={0,0,0,1},C1[8]={0,0,0,0,0,0,0,1};
int s=0,z=0,Q[4],M[4],temp,temp1[4],ans[8],y,x=0,c=0;
clrscr();
printf("\n│----------------------------------------------------\n");
a = get(1);
b=get(0);
printf("\n│---------------------------------------------------\n");
binary(a,M);
binary(b,Q);
printf("\n\n---------------------------------------------------\n");
printf(" OPERATION\t\t A\t Q\tQ'\t M");
printf("\n\n INITIAL\t\t");
for(i=0;i< 4;i++)
printf("%d",A[i]);
printf("\t");
for(i=0;i< 4;i++)
printf("%d",Q[i]);
printf("\t");
printf("%d\t",q);
for(i=0;i< 4;i++)
printf("%d",M[i]);
for(j=0;j< 4;j++)
{
if((Q[3]==0)&&(q==1))
{
printf("\n A:=A+M \t\t");
add(A,M);
for(i=0;i< 4;i++)
printf("%d",A[i]);
printf("\t");
for(i=0;i< 4;i++)
printf("%d",Q[i]);
printf("\t%d\t",q);
for(i=0;i< 4;i++)
printf("%d",M[i]);
}
if((Q[3]==1)&&(q==0))
{
printf("\n A:=A-M \t\t");
for(i=0;i< 4;i++)
temp1[i] = 1-M[i];
add(temp1,C);
add(A,temp1);
for(i=0;i< 4;i++)
printf("%d",A[i]);
printf("\t");
for(i=0;i< 4;i++)
printf("%d",Q[i]);
printf("\t%d\t",q);
for(i=0;i< 4;i++)
printf("%d",M[i]);
}
printf("\n Shift \t\t\t");
y = A[3];
q = Q[3];
rshift(A[0],A);
rshift(y,Q);
for(i=0;i< 4;i++)
printf("%d",A[i]);
printf("\t");
for(i=0;i< 4;i++)
printf("%d",Q[i]);
printf("\t");
printf("%d\t",q);
for(i=0;i< 4;i++)
printf("%d",M[i]);
}
printf("\n\n---------------------------------------------------\n");
printf("\nTHE ANSWER IN BINARY IS : ");
for(i=0;i< 4;i++)
ans[i]=A[i];
for(i=0;i< 4;i++)
ans[i+4]=Q[i];
if(((a< 0)&&(b>0))||((a>0)&&(b< 0)))
{
for(i=0;i< 8;i++)
ans[i]=1-ans[i];
for(i=7;i>=0;i--)
{
x = ans[i];
ans[i]=c^x^C1[i];
if(((c==1)&&(x==1))||((x==1)&&(C1[i]==1))||((C1[i]==1)&&(c==1)))
c=1;
else
c=0;
}
}
for(i=0;i< 8;i++)
printf("%d",ans[i]);
for(i=7;i>=0;i--)
{
s = s + (pow(2,z) * ans[i]);
z = z+1;
}
if(((a< 0)&&(b>0))||((a>0)&&(b< 0)))
printf("\nTHE ANSWER IN DECIMAL IS : -%d\n",s);
else
printf("\nTHE ANSWER IN DECIMAL IS : %d\n",s);
getch();
}

/********************** OUTPUT **********************
│-------------------------------------------------------------
│ ENTER VALUE OF A: 7
│ ENTER VALUE OF B: -3
│-------------------------------------------------------------

THE BINARY EQUIVALENT OF 7 IS : 0111

THE BINARY EQUIVALENT OF -3 IS : 1101

---------------------------------------------------
OPERATION A Q Q' M

INITIAL 0000 1101 0 0111
A:=A-M 1001 1101 0 0111
Shift 1100 1110 1 0111
A:=A+M 0011 1110 1 0111
Shift 0001 1111 0 0111
A:=A-M 1010 1111 0 0111
Shift 1101 0111 1 0111
Shift 1110 1011 1 0111

---------------------------------------------------

THE ANSWER IN BINARY IS : 00010101
THE ANSWER IN DECIMAL IS : -21

Unsigned Multiplication - C Program

2008-01-17T21:27:00.000-08:00

/* C Program For Implementation of Unsigned Multiplication Of Two Numbers */

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

#define max 16

void convert1(int *n1,int *n2)
{
int i,z,j,d=0,n=1;
z=(2*max);
for(i=max-1;i>=0;i--)
{
z--;
if(n1[i]==1)
{
n=1;
for(j=1;j< =z;j++)
n = n * 2;
d = d + n;
}
}
n = 1;
for(i=max-1;i>=0;i--)
{
if(n2[i]==1)
{
n = 1;
for(j=1;j< =i;j++)
n = n * 2;
d = d + n;
}
}
printf("\n\n\tIN DECIMAL FORM: %d",d);
}

void convert2(int x,int *arr)
{
int q=0,j=x;
while(j>=0 && q< max)
{
x=j%2;
arr[q++]=x;
j = j/2;
}
}

int addbin(int *n1,int *n2,int *arr3)
{
int i,c=0,g,p,j,arr[max];
for(i=max-1;i>=0;i--)
{
g = n1[i]&n2[i];
p = n1[i]^n2[i];
arr[i] = p^c;
c = g|(p&c);
}
c = 0;
for(i=0;i< max;i++)
{
if(c==0)
{
if(n1[i]==0 && n2[i]==0)
arr3[i]=0;
if(n1[i]==0 && n2[i]==1)
arr3[i]=1;
if(n1[i]==1 && n2[i]==0)
arr3[i]=1;
if(n1[i]==1 && n2[i]==1)
{
arr3[i] = 0;
c = 1;
}
}
else if(c==1)
{
if(n1[i]==0 && n2[i]==0)
{
arr3[i] = 1;
c = 0;
}
if(n1[i]==0 && n2[i]==1)
arr3[i]=0;
if(n1[i]==1 && n2[i]==0)
arr3[i]=0;
if(n1[i]==1 && n2[i]==1)
arr3[i]=1;
}
}
return c;
}

void shift(int *n1,int *n2,int *arr3)
{
int c=0,i,j,k,temp[max];
for(i=0;i< max;i++)
{
if(arr3[0]==1)
{
c = addbin(n1,n2,temp);
for(j=0;j< max;j++)
n1[j] = temp[j];
}
for(j=0;j< max-1;j++)
arr3[j] = arr3[j+1];
arr3[max-1] = n1[0];
for(j=0;j< max-1;j++)
n1[j] = n1[j+1];
n1[max-1] = c;
}
}

void main()
{
int i,j,a[max],b[max],q[max],x,y;
clrscr();
printf("\n _________________________________________________");
printf("\n|\t\tUnsigned Multiplication\n");
printf("|----------------------------------------------------------------------------");
printf("\n|Enter The First No\t: ");
scanf("%d",&x);
printf("|Enter The Second No\t: ");
scanf("%d",&y);
printf("|_________________________________________________");
while(x>0 && y>0)
{
convert2(0,a);
printf("\n\nTHE 16-bit BINARY FORM OF 0\t: ");
for(i=max-1;i>=0;i--)
printf("%d ",a[i]);
convert2(x,b);
printf("\nTHE 16-bit BINARY FORM OF %d\t: ",x);
for(i=max-1;i>=0;i--)
printf("%d ",b[i]);
convert2(y,q);
printf("\nTHE 16-bit BINARY FORM OF %d\t: ",y);
for(i=max-1;i>=0;i--)
printf("%d ",q[i]);
shift(a,b,q);
printf("\n\n\tCalculating %d * %d ",x,y);
printf("In 16-bit BINARY FORM :\n\n\t");
for(i=max-1;i>=0;i--)
printf("%d ",a[i]);
printf("\n\t");
for(j=max-1;j>=0;j--)
printf("%d ",q[j]);
convert1(a,q);
x = -1;
getch();
}
}

/***************** OUTPUT ********************
_________________________________________________
| Unsigned Multiplication
|-------------------------------------------------------------------------
|Enter The First No : 56
|Enter The Second No : 12
|_________________________________________________

THE 16-bit BINARY FORM OF 0 : 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
THE 16-bit BINARY FORM OF 56 : 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0
THE 16-bit BINARY FORM OF 12 : 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0

Calculating 56 * 12 In 16-bit BINARY FORM :

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0

IN DECIMAL FORM: 672 */

C Program - Look Ahead Carry Adder

2008-01-17T21:25:00.000-08:00

/* C Program For Implementation Of Look Ahead Carry Adder */

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

int get1(int a)
{
char ch='B';
if(a==1)
ch='A';
do
{
printf("\n\tENTER VALUE OF %c:",ch);
scanf("%d",&a);
if(a< =0)
printf("\n\t\t!INVALID NUMBER.ENTER VALUE (0< A)!");
}while(a< =0);
return(a);
}

int and(int a,int b)
{
int c;
if(a< b)
c=a;
else
c=b;
return (c);
}

int or(int a,int b)
{
int x;
if(a>b)
x=a;
else
x=b;
return x;
}

int exor(int a,int b)
{
int x;
if(a==b)
x=0;
else
x=1;
return x;
}

void add()
{
int i=7,A,B,a,b,cin,num;
int n1[8],n2[8],cg[8],cp[8],sum[8];
for(i=0;i< =7;i++)
{
n1[i]=0; // Num 1
n2[i]=0; // Num 2
cg[i]=0; // Gi
cp[i]=0; // Pi
sum[i]=0; // Sum
}
A = a = get1(1);
B = b = get1(0);
i=7;
do
{
n1[i]=a%2;
a=a/2;
n2[i]=b%2;
b=b/2;
i--;
}while((a!=0)||(b!=0));
i=0;
printf("\n\t\t Binary Form",A);
printf("\n\t A = %d : ",A);
for(i=0;i< =7;i++)
printf("%d ",n1[i]);
printf("\n\t B = %d : ",B);
for(i=0;i< =7;i++)
printf("%d ",n2[i]);
cin=0;
for(i=7;i>=0;i--)
{
sum[i]=exor(cin,exor(n1[i],n2[i])); // Sum Pi (+) Bi
cg[i]=and(n1[i],n2[i]); // Gi = Ai . Bi
cp[i]=or(n1[i],n2[i]); // Pi = Ai (+) Bi
cin=or(cg[i],and(cp[i],cin)); // Cin =Gi + PiCi
}
printf("\n\n\t\t SUM: ");
num=0;
for(i=0;i< =7;i++)
{
printf(" %d",sum[i]);
num=num + (sum[i]*pow(2,7-i));
}
printf("\n\n\t\t SUM: %d + %d= %d\n",A,B,num);
printf("\t\t The Carry Is : %d\n\n",cin);
}

void main()
{
int ch,a,b,c,d;
clrscr();
while(1)
{
M: printf("******** MENU FOR LOOK AHEAD CARRY ADDER ********");
printf("\n\t\t1.ADDITION OF TWO NUMBER");
printf("\n\t\t2.EXIT\n");
printf("*************************************************");
printf("\n\t\tEnter Your Option:");
scanf("%d",&ch);
switch(ch)
{
case 1:
add();
getch();
break;

case 2: exit(0);
break;

default:
clrscr();
printf("ERROR!!!!!!!!! INVALID ENTRY...\n");
printf("Back To Main Menu\n\n");
goto M;
}
}
}

/*------------------ OUTPUT --------------------

******** MENU FOR LOOK AHEAD CARRY ADDER ********
1.ADDITION OF TWO NUMBER
2.EXIT
*************************************************
Enter Your Option:1

ENTER VALUE OF A:2

ENTER VALUE OF B:3

Binary Form
A = 2 : 0 0 0 0 0 0 1 0
B = 3 : 0 0 0 0 0 0 1 1

SUM: 0 0 0 0 0 1 0 1

SUM: 2 + 3= 5
The Carry Is : 0

******** MENU FOR LOOK AHEAD CARRY ADDER ********
1.ADDITION OF TWO NUMBER
2.EXIT
*************************************************
Enter Your Option:2 */

Logical Operation On Numbers - C Program

2008-01-17T21:20:00.000-08:00

/* C Program For Implementation Of Logical Operations on Two Numbers, The Logical Operations Include Logical AND, Logical OR and Logical NOT */

#include<>
#include<>
#include<>

void result(int,int,int);
void main()
{
int n1,n2,ch,c; clrscr();
do
{
printf("Enter Two Numbers : \n");
scanf("%d%d",&n1,&n2);
printf("************* MENU FOR LOGICAL OPERATIONS ***********\n");
printf("1. AND\n2. OR\n3. NOT\n\nEnter Your Choice ");
scanf("%d",&ch);
result(n1,n2,ch);
printf("\nDo you want to continue?\n1. Yes\n2. No\n");
scanf("%d",&c);
}
while(c == 1);
getch();
}
void result(int a,int b,int c)
{
int b1[8], b2[8], res[8], c1[8], c2[8];
int i,n,s,s1,s2,x,y;
x = a;
y = b;
if(c!=1 && c!=2 && c!=3)
{
clrscr();
printf("ERROR!!!!!!!!! INVALID ENTRY!!\n");
main();
}
/* Conversion to binary */
if(x< x =" x+256;" y =" y+256;" i="0;i<" x="="0)" x="x/2;" i="0;i<" y="="0)" y="y/2;" c="="1)" n="0;" c="="2)" n="1;" i="0;i<" c="="3)" i="0;i<" c="="1" c="="2)" s="0;" i="0;i<" s =" s" c="="3)" s1="0;" i="0;i<" s1 =" s1" s2="0;" i="0;i<" s2 =" s2" i="7;i">=0;i--)
printf("%d",b1[i]);
printf("\t\t%d",a);
printf("\t\n\t Second\t\t\t");
for(i=7;i>=0;i--)
printf("%d",b2[i]);
printf("\t\t%d",b);
printf("\t\n\t Result\t\t\t");
if(c==1 c==2)
{
for(i=7;i>=0;i--)
printf("%d",res[i]);
printf("\t\t%d",s);
}
if(c==3)
{
for(i=7;i>=0;i--)
printf("%d",c1[i]);
printf("\t\t%d",s1);
printf("\t\n\tResult 2\t\t\t");
for(i=7;i>=0;i--)
printf("%d",c2[i]);
printf("\t\t%d",s2);
}
printf("\t\n\t--------------------------------");
printf("---------------------------------\n");
}

/******************* OUTPUT *****************
Enter Two Numbers :
5
2
************* MENU FOR LOGICAL OPERATIONS ***********
1. AND
2. OR
3. NOT
Enter Your Choice 1
___________________________________________
Number Binary Decimal
-----------------------------------------------------------------
First 00000101 5
Second 00000010 2
Result 00000000 0
-----------------------------------------------------------------
Do you want to continue?
1. Yes
2. No
1
Enter Two Numbers :
6
3
************* MENU FOR LOGICAL OPERATIONS ***********
1. AND
2. OR
3. NOT
Enter Your Choice 2
_________________________________________________________________
Number Binary Decimal
-----------------------------------------------------------------
First 00000110 6
Second 00000011 3
Result 00000111 7
-----------------------------------------------------------------
Do you want to continue?
1. Yes
2. No
1
Enter Two Numbers :
8
5
************* MENU FOR LOGICAL OPERATIONS ***********
1. AND
2. OR
3. NOT
Enter Your Choice 3
_________________________________________________________________
Number Binary Decimal
-----------------------------------------------------------------
First 00001000 8
Second 00000101 5
Result 11110111 247
Result 2 11111010 250
-----------------------------------------------------------------
Do you want to continue?
1. Yes
2. No 2 */

Binary Operation On Two Numbers

2008-01-17T21:10:00.000-08:00

/* C Program For Implementation Of Binary Operations on Two Numbers

Operations Included
Binary Addition
Binary Subtraction

Binary Subtraction Is Done Making Use Of Two's Complement */

#include< stdio.h>
#include< conio.h>
#include< math.h>
int exor(int n1, int n2)
{
if(n1==n2)
return 0;
else
return 1;
}
int min(int n1, int n2)
{
if(n1< n2)
return n1;
else
return n2;
}
int max(int n1, int n2)
{
if(n1>=n2)
return n1;
else
return n2;
}
void main()
{
int a1[10],a2[10],a3[10],a4[10],a5[10],a7[10],a8[10],a11[10];
int j=0,i=0,p=0,n1=0,n3=0,n4=0,n5=0,n6=0,n7=0,n8=0;
int a,b,c,h,v,o, n,q,r,x,y,S,Z,c1,c2,c3,c4,s1,carry;
int g[8],p1[10],p2,p3[10],p4[10],s[8],w[8],z[8];
clrscr();
do
{ printf("\t\tCALCULATIONS OF BINARY ARITHMETIC OPERATIONS\n");
printf("\t --------------------------------------------\n");
printf("1: BINARY ADDITION \n");
printf("2: BINARY SUBTRACTION\n");
L:
printf("\nENTER THE OPERATION YOU WOULD LIKE TO CARRY OUT:");
scanf("%d",&n);
switch(n)
{case 1:
{M:
printf("\nEnter The First Number :");
scanf("%d",&x);
if(x>0)
printf("x = %d\n",x);
else
{ printf("The Entered Number Is Invalid\n");
printf("Please Enter the valid value\n");
goto M;
}
for(i=0;i< =7;i++)
{ z[i]=0; s[i]=0; }
i=7;
do
{ z[i]=x%2;
x=x/2;
i--;
}while(x!=0);
printf("The binary equivalent of x is: ");
for(j=0;j< =7;j++)
{ printf("%d",z[j]); }
N:
printf("\n\nEnter the second number : ");
scanf("%d",&y);
if(y>=0)
printf("y = %d\n",y);
else
{ printf("The entered number is invalid\n");
printf("Please enter the valid value\n");
goto N;
}
i=7;
do
{ s[i]=y%2;
y=y/2;
i--;
}while(y!=0);
printf("The binary equivalent of y is: ");
for(p=0;p< =7;p++)
{ printf("%d",s[p]); }
printf("\n\nBinary of x: ");
for(i=0;i< =7;i++)
{printf("%d",z[i]); }
printf("\nBinary of y: ");
for(i=0;i< =7;i++)
{printf("%d",s[i]); }
for(h=7;h>=0;h--)
{s1=exor(carry,exor(z[h],s[h]));
c1=min(z[h],s[h]);
c2=min(s[h],carry);
c3=min(z[h],carry);
c4=max(c3,max(c1,c2));
carry=c4;
a1[h]=s1; }
printf("\nSum : ");
for(b=0;b< =7;b++)
{ printf("%d",a1[b]); }
for(v=0;v< =7;v++)
{ o=pow(2,7-v);
n1=n1+(a1[v]*o); }
printf("\n\nDecimal Equivalent of Sum : ");
printf("%d",n1);
break;
}
case 2:
{ printf("\nEnter the first number : ");
scanf("%d",&x); Z=x;
printf("x = %d",x);
for(i=0;i< =7;i++)
{ z[i]=0; s[i]=0; }
if(Z>0)
{i=7;
do
{ z[i]=x%2;
x=x/2;
i--;
}while(x!=0);
printf("\nThe binary equivalent of x is: ");
for(j=0;j< =7;j++)
{ printf("%d",z[j]); }
}
if(Z< 0)
{i=7;
do
{ z[i]=x%2;
x=x/2;
if(z[i]< 0)
z[i]=-z[i];
i--;
}while(x!=0);
printf("\nThe binary equivalent of x is: ");
for(j=0;j< =7;j++)
{ printf("%d",z[j]); }
for(h=0;h< =7;h++)
{ w[h]=z[h];p3[h]=1-w[h]; }
printf("\n\nThe 1'S Complement of x is: ");
for(b=0;b< =7;b++)
{ printf("%d",p3[b]); }
if(p3[7]==1)
{ p3[7]=0;carry=1;}
else
if(p3[7]==0)
{p3[7]=1;carry=0;}
for(h=6;h>=0;h--)
{ s1=exor(carry,p3[h]);
c1=min(p3[h],carry);
carry=c1;
p3[h]=s1;
}
printf("\nThe 2'S Complement of x is: ");
for(b=0;b< =7;b++)
{ printf("%d",p3[b]); }
}
printf("\n\nEnter the second number : ");
scanf("%d",&y);S=y;
printf("y = %d",y);
if(S< 0)
{p=7;
do
{ s[p]=y%2;
y=y/2;
if(s[p]< 0)
s[p]=-s[p];
p--;
}while(y!=0);
printf("\nThe binary equivalent of y is: ");
for(q=0;q< =7;q++)
{ printf("%d",s[q]); }
printf("\n________________________________________________");
}
if(S>0)
{p=7;
do
{ s[p]=y%2;
y=y/2;
p--;
}while(y!=0);
printf("\nThe binary equivalent of y is: ");
for(q=0;q< =7;q++)
{ printf("%d",s[q]); }
for(h=0;h< =7;h++)
{ w[h]=s[h];
p4[h]=1-w[h];
}
printf("\nThe 1'S Complement of y is: ");
for(b=0;b< =7;b++)
{ printf("%d",p4[b]); }
if(p4[7]==1)
{ p4[7]=0;carry=0;}
else
if(p4[7]==0)
{ p4[7]=1;carry=0; }
for(h=6;h>=0;h--)
{ s1=exor(carry,p4[h]);
c1=min(p4[h],carry);
carry=c1;
p4[h]=s1; }
printf("\nThe 2'S Complement of y is: ");
for(b=0;b< =7;b++)
{ printf("%d",p4[b]); }
printf("\n_______________________________________________");
}
if(Z< 0 && S< 0)
{ printf("\n2'S Complement of x: ");
for(h=0;h< =7;h++)
{ printf("%d",p3[h]); }
printf("\nBinary of y : ");
for(h=0;h< =7;h++)
{ printf("%d",s[h]); }
for(h=7;h>=0;h--)
{ s1=exor(carry,exor(p3[h],s[h]));
c1=min(p3[h],s[h]);
c2=min(s[h],carry);
c3=min(p3[h],carry);
c4=max(c3,max(c1,c2));
carry=c4;
a2[h]=s1;
}
if(carry==0)
{ printf("\nDifference : ");
for(y=0;y< =7;y++)
{ printf("%d",a2[y]);
a2[y]=1-a2[y]; }
printf("\nAnswer is Negative and is in 2'S Complement form");
printf("\n1'S Complement : ");
for(y=0;y< =7;y++)
{ printf("%d",a2[y]); }
if(a2[7]==1)
{ a2[7]=0; carry=1;}
else
{ a2[7]=1; carry=0; }
for(i=6;i>=0;i--)
{ c1=exor(carry,a2[i]);
c2=min(a2[i],carry);
carry=c2;
a2[i]=c1;
}
printf("\n2'S Complement : ");
for(y=0;y< =7;y++)
{
printf("%d",a2[y]);
n3=n3+(a2[y] *pow(2,7-y));
}
printf("\nDecimal Equivalent of Difference : ");
printf("%d",n3);
}
else
{
if(carry==1)
{
printf("\nDifference : ");
for(y=0;y< =7;y++)
{
printf("%d",a2[y]);
}
for(y=0;y< =7;y++)
{
n4=n4+(a2[y] *pow(2,7-y));
}
printf("\nDecimal Equivalent of Difference : ");
printf("%d",n4);
}
}

}
if(Z>0 && S>0)
{
printf("\nBinary of x : ");
for(h=0;h< =7;h++)
{
printf("%d",z[h]);
}
printf("\n2'S Complement of y : ");
for(h=0;h< =7;h++)
{
printf("%d",p4[h]);
}
for(h=7;h>=0;h--)
{
s1=exor(carry,exor(z[h],p4[h]));
c1=min(z[h],p4[h]);
c2=min(p4[h],carry);
c3=min(z[h],carry);
c4=max(c3,max(c1,c2));
carry=c4;
a5[h]=s1;
}
if(carry==1)
{
printf("\nDifference : ");
for(y=0;y< =7;y++)
{
printf("%d",a5[y]);
}
for(y=0;y< =7;y++)
{
n5=n5+(a5[y] *pow(2,7-y));
}
printf("\nDecimal Equivalent of difference : ");
printf("%d",n5);
}
else
if(carry==0)
{
printf("\nDifference : ");
for(y=0;y< =7;y++)
{
printf("%d",a5[y]);
a5[y]=1-a5[y];
}
printf("\nAnswer is Negative and is in 2'S Complement form");
printf("\n1'S Complement is : ");
for(y=0;y< =7;y++)
printf("%d",a5[y]);
if(a5[7]==1)
{
a5[7]=0; carry=1;
}
else
{
a5[7]=1; carry=0;
}
for(i=6;i>=0;i--)
{
c1=exor(carry,a5[i]);
c2=min(a5[i],carry);
carry=c2;
a5[i]=c1;
}
printf("\n2'S Complement is : ");
for(y=0;y< =7;y++)
{
printf("%d",a5[y]);
n6=n6+(a5[y] *pow(2,7-y));
}
printf("\nDecimal Equivalent of difference : ");
printf("%d",n6);
}
}
if(Z< 0 && S>0)
{
printf("\n2'S Complement of x : ");
for(h=0;h< =7;h++)
{
printf("%d",p3[h]);
}
printf("\n2'S Complement of y : ");
for(h=0;h< =7;h++)
{
printf("%d",p4[h]);
}
for(h=7;h>=0;h--)
{
s1=exor(carry,exor(p3[h],p4[h]));
c1=min(p3[h],p4[h]);
c2=min(p4[h],carry);
c3=min(p3[h],carry);
c4=max(c3,max(c1,c2));
carry=c4;
a8[h]=s1;
}
printf("\nDifference : ");
for(y=0;y< =7;y++)
{
printf("%d",a8[y]);
a8[y]=1-a8[y];
}
printf("\nAnswer is Negative and is in 2'S Complement form");
printf("\n1'S Complement is : ");
for(y=0;y< =7;y++)
printf("%d",a8[y]);
if(a8[7]==1)
{
a8[7]=0; carry=1;
}
else
{
a8[7]=1; carry=0;
}
for(i=6;i>=0;i--)
{
c1=exor(carry,a8[i]);
c2=min(a8[i],carry);
carry=c2;
a8[i]=c1;
}
printf("\n2'S Complement is : ");
for(y=0;y< =7;y++)
{
printf("%d",a8[y]);
n7=n7+(a8[y] *pow(2,7-y));
}
printf("\nDecimal Equivalent of difference : ");
printf("%d",n7);
}
if(Z>0 && S< 0)
{
printf("\nBinary of x : ");
for(h=0;h< =7;h++)
{ printf("%d",z[h]); }
printf("\nBinary of y : ");
for(h=0;h< =7;h++)
{ printf("%d",s[h]); }
for(h=7;h>=0;h--)
{
s1=exor(carry,exor(z[h],s[h]));
c1=min(z[h],s[h]);
c2=min(s[h],carry);
c3=min(z[h],carry);
c4=max(c3,max(c1,c2));
carry=c4;
a11[h]=s1;
}
printf("\nDifference : ");
for(y=0;y< =7;y++)
{ printf("%d",a11[y]); }
for(y=0;y< =7;y++)
{ n8=n8+(a11[y] *pow(2,7-y)); }
printf("\nDecimal Equivalent of difference : ");
printf("%d",n8);
}
break;
default:
clrscr();
printf("ERROR!!!!!!!\nINVALID ENTRY\n");
}
}
printf("\n-------------------------------------------------");
printf("\nWould You Like To Continue\n");
printf("Please Enter '1' For 'YES' And '0' For 'NO': ");
scanf("%d",&r);
if(r==0)
{ printf("\n************** THANK YOU ***************\n") }
}while(r==1);
getch();
}

/******************** OUTPUT **********************
CALCULATIONS OF BINARY ARITHMETIC OPERATIONS
--------------------------------------------
1: BINARY ADDITION
2: BINARY SUBTRACTION

ENTER THE OPERATION YOU WOULD LIKE TO CARRY OUT:1

Enter The First Number :5
x = 5
The binary equivalent of x is: 00000101

Enter the second number : 2
y = 2
The binary equivalent of y is: 00000010

Binary of x: 00000101
Binary of y: 00000010
Sum : 00001001

Decimal Equivalent of Sum : 9
-------------------------------------------------
Would You Like To Continue
Please Enter '1' For 'YES' And '0' For 'NO': 1

CALCULATIONS OF BINARY ARITHMETIC OPERATIONS
--------------------------------------------
1: BINARY ADDITION
2: BINARY SUBTRACTION

ENTER THE OPERATION YOU WOULD LIKE TO CARRY OUT: 2
Enter the first number : 4
x = 4
The binary equivalent of x is: 00000100

Enter the second number : 3
y = 3
The binary equivalent of y is: 00000011
The 1'S Complement of y is: 11111100
The 2'S Complement of y is: 11111101
_______________________________________________
Binary of x : 00000100
2'S Complement of y : 11111101
Difference : 00000001
Decimal Equivalent of difference : 1
-------------------------------------------------
Would You Like To Continue
Please Enter '1' For 'YES' And '0' For 'NO': 1

CALCULATIONS OF BINARY ARITHMETIC OPERATIONS
--------------------------------------------
1: BINARY ADDITION
2: BINARY SUBTRACTION

ENTER THE OPERATION YOU WOULD LIKE TO CARRY OUT:2

Enter the first number : 4
x = 4
The binary equivalent of x is: 00000100

Enter the second number : 9
y = 9
The binary equivalent of y is: 00001001
The 1'S Complement of y is: 11110110
The 2'S Complement of y is: 11110111
_______________________________________________
Binary of x : 00000100
2'S Complement of y : 11110111
Difference : 11111011
Answer is Negative and is in 2'S Complement form
1'S Complement is : 00000100
2'S Complement is : 00000101
Decimal Equivalent of difference : 5
-------------------------------------------------
Would You Like To Continue
Please Enter '1' For 'YES' And '0' For 'NO': 1

CALCULATIONS OF BINARY ARITHMETIC OPERATIONS
--------------------------------------------
1: BINARY ADDITION
2: BINARY SUBTRACTION

ENTER THE OPERATION YOU WOULD LIKE TO CARRY OUT:2
Enter the first number : 6
x = -6
The binary equivalent of x is: 00000110

The 1'S Complement of x is: 11111001
The 2'S Complement of x is: 11111010

Enter the second number : 5
y = 5
The binary equivalent of y is: 00000101
The 1'S Complement of y is: 11111010
The 2'S Complement of y is: 11111011
_______________________________________________
2'S Complement of x : 11111010
2'S Complement of y : 11111011
Difference : 11110101
Answer is Negative and is in 2'S Complement form
1'S Complement is : 00001010
2'S Complement is : 00001011
Decimal Equivalent of difference : 11
-------------------------------------------------
Would You Like To Continue
Please Enter '1' For 'YES' And '0' For 'NO': 0

************** THANK YOU ***************** */

Matrix Multiplication - The C++ Way

2007-07-21T03:46:00.000-07:00

As I promised eariler I have now posted a Matrix Addition And Multiplication, this program is achived by passing an Object as an Argument..............

/* Matrix Multiplication by PASSING OBJECT AS AN ARGUMENT */

class Matrix
{
int A[10][10];
int m,n;
public:
Matrix(int a,int b)
{
m = a;
n = b;
}

void readmatrix();
void printmatrix();
void addmatrix(Matrix b);
Matrix operator * (Matrix b);
};
void Matrix::readmatrix()
{
for(int i=0;i< m;i++)
{
for(j=0;j< n;j++)
cin>>A[i][j];
}
}
}
void Matrix::printmatrix()
{
for(int i=0;i< m;i++)
{
for(int j=0;j< n;j++)
{
cout< < A[i][j]<<" ";
}
cout< < endl;
}
}
void Matrix::addmatrix(Matrix b)
{
Matrix c(m,n);
for(int i=0;i< m;i++)
{
for(int j=0;j< n;j++)
{
c.A[i][j]=A[i][j]+b.A[i][j];
}
}
cout< < "The Addition Of The Two Matrices Is:"< < endl; c.printmatrix();
}

Matrix Matrix::operator*(Matrix b)
{
Matrix c(m,m);
for(int i=0;i< m;i++)
{
for(int k=0;k< m;k++)
{
c.A[i][k]=0;
for(int j=0;j< n;j++)
{
c.A[i][k] = A[i][j] * b.A[j][k] + c.A[i][k];
}
}
}
return c;
}
void main()
{
clrscr();
cout< < "Enter Order The Two Square Matrices: " ;
int a;
cin>>a;

Matrix x(a,a);
Matrix y(a,a);

cout< < endl< < "Enter Elements In First Matrix : ";
x.readmatrix();

cout< < endl< < "Enter Elements In The Second Matrix :";
y.readmatrix();

cout< < endl< < "The First Matrix:"< < endl;
x.printmatrix();

cout< < endl< < "The Second Matrix:"< < endl;
y.printmatrix();
x.addmatrix(y);

Matrix c(a,a);
c = x * y;

cout< < "The Multiplication Of The Two Matrices Are:"< < endl;
c.printmatrix();
getch();
}

/****** OUTPUT *******
Enter Order The Two Square Matrices: 3

Enter Elements In First Matrix : 1 0 0 0 1 0 0 0 1

Enter Elements In The Second Matrix :1 0 0 0 1 0 0 0 1

The First Matrix:
1 0 0
0 1 0
0 0 1

The Second Matrix:
1 0 0
0 1 0
0 0 1
The Addition Of The Two Matrices Is:
2 0 0
0 2 0
0 0 2
The Multiplication Of The Two Matrices Are:
1 0 0
0 1 0
0 0 1
*/

Operator Overloading,Inheritance

2007-07-21T03:35:00.000-07:00

Here's a simple and also a very short program in C++ that makes use of Constructors, Operator Overloading (++,--)and Single Inheritance (cause its a simple program as I mentioned it).......

/* C++ Program For Implementation Of Constructors, Operator Overloading and Inheritance */

class index
{
protected:
int count;
public:
index()
{
count = 0;
}
index(int c)
{
count = c;
}
index operator ++()
{
count++;
}
void display()
{
cout< < endl< < "count = "< < count< < endl;
}
};

class index1 : public index
{
public:
void operator --()
{
count--;
}
};

void main()
{
clrscr();
index1 i;
i++;
i++;
i.display();
i--;
i.display();
getch();
}

Binary Tree Sort

2007-07-10T22:57:00.000-07:00

This has two phases. First phase is creating a binary search tree using the given array elements. Second phase is traverse the given binary search tree in inorder, thus resulting in a sorted array.

Performance
The average number of comparisons for this method is O(nlog₂n)
But in the worst case, the number of comparisons are reduced by O(n²), a case which arises when the sort tree is severely unbalanced .

/****** C Program For Implementation Of Binary Sort ***/

#define TRUE 1
#define FALSE 0

struct btreenode
{
struct btreenode *rightchild;
int data;
struct btreenode *leftchild;
};

insert(struct btreenode **sr,int num)
{
if(*sr==NULL)
{
*sr=malloc(sizeof(struct btreenode));

(*sr)- >leftchild=NULL;
(*sr)- >data=num;
(*sr)- >rightchild=NULL;
return;
}
else
{
if(num< (*sr)- >data)
insert(&((*sr)- >leftchild),num);
else
insert(&((*sr)- >rightchild),num);
}
return;
}

inorder(struct btreenode *sr)
{
if(sr!=NULL)
{
inorder(sr- >leftchild);
printf("%d ",sr- >data);
inorder(sr- >rightchild);
}
else
return;
}

postorder(struct btreenode *sr)
{
if(sr!=NULL)
{
postorder(sr- >rightchild);
printf("%d ",sr- >data);
postorder(sr- >leftchild);
}
else
return;
}

void main()
{
struct btreenode *bt;
int req,i=0,num,a[10],no;

bt=NULL;
clrscr();

while(i < 5)
{
printf("\nEnter value to be inserted: ");
scanf("%d",&a[i]);
insert(&bt,a[i]);
i++;
}
clrscr();
printf("\n\nSorted Binary tree in ascending order== > \n\n");
inorder(bt);
printf("\n\nSortred binary tree in descending order== >\n\n");
postorder(bt);
getch();
}

/************************** OUTPUT ***********************

Enter value to be inserted: 9

Enter value to be inserted: 8

Enter value to be inserted: 4

Enter value to be inserted: 5

Enter value to be inserted: 7

Sorted Binary tree in ascending order== >

4 5 7 8 9

Sortred binary tree in descending order== >

9 8 7 5 4 */

Straight Selection Sort

2007-07-07T00:03:00.000-07:00

One of the easiest sorting methods is selection sort. Beginning with the first element of the given array, a search is made to find the largest element in the array. When the element is found this element is interchanged with the last element of the array. Now the size of the unsorted array will be reduced but one. A search for the largest element of the unsorted array is carried out. When this element is found it will be interchanged with the last element of the unsorted array. Once again the unsorted array will be reduced by 1 and the above process will be repeated till the entire array is sorted in ascending order.

ALGORITHM
1. Establish an array ‘a’ with ‘n’ elements
2. Repeat through step 6 for ‘n-1’ times
3. Repeat the position of the array already sorted
4. Repeat step 5 for the elements in unsorted position of the array
5. Record location of the largest element in the unsorted array
6. Exchange last element in the unsorted array with the largest element

PERFORMANCE OF THE ALGORITHM
During the first pass, in which the largest element is found, n-1 elements are compared. In general, for ith pass of the sort, n-I comparisons are required

So total number of comparisons
n-1 + n-2 + ……… + 1

Time Complexity = O(n²)

/**** C Program For Implementation Of Selection Sort ****/

#define MAX 10
char name[MAX][15];
void sort(int n)
{
int i,j,index;
char temp[15];
for(i=n;i >0;i--)
{
strcpy(temp,name[1]);
index=1;
for(j=1;j< =i;j++) { if(strcmp(name[j],temp) >0)
{
strcpy(temp,name[j]);
index=j;
}
}
strcpy(name[index],name[i]);
strcpy(name[i],temp);
}
}
void main()
{
int i,j,n;
clrscr();
A: printf("\n\nENTER HOW MANY NAMES: ");
scanf("%d",&n);
if(n >MAX)
{
printf("\n\t\tARRAY SIZE IS ONLY %d",MAX);
goto A;
}
else
{
printf("\n\t ENTER %d Names : \n",n);
for(i=1;i< =n;i++) { printf("\t\t"); scanf("%s",name[i]); } sort(n); printf("\n\n\t\t*********** SORTED LIST ************"); for(i=1;i< =n;i++) printf("\n \t\t\t\t%s",name[i]); } getch(); } /********** OUTPUT ************** ENTER HOW MANY NAMES: 12 ARRAY SIZE IS ONLY 10 ENTER HOW MANY NAMES: 4 ENTER 4 Names : Lionel Cyril Valerian Noronha *********** SORTED LIST ************ Cyril Lionel Noronha Valerian **************************************/

Matrix Multiplication

2007-07-05T10:36:00.001-07:00

Multiplication in C language is very useful, below is a simple example on matrix multiplication, later on i will post matrix arithematic operations using C++

#include<>
void main()
{
int a[10][10],b[10][10],c[10][10],i,j,k,m,n,p,q;
clrscr();

printf("Enter The Rows And Cloumns And Of The First Matrix:");
scanf("%d %d",&m,&n);
printf("\nEnter The Rows And Cloumns And Of The Second Matrix:");
scanf("%d %d",&p,&q);

printf("\nEnter Elements Of The First Matrix:\n");
for(i=0;i< m;i++)
{
for(j=0;j< n;j++)
scanf("%d",&a[i][j]);
}

printf("\nEnter Elements Of The Second Matrix:\n");
for(i=0;i< p;i++)
{
for(j=0;j< q;j++)
scanf("%d",&b[i][j]);
}
printf("The First Matrix Is:\n");
for(i=0;i< m;i++)
{
for(j=0;j< n;j++)
printf(" %d ",a[i][j]); //print the first matrix
printf("\n");
}
printf("The Second Matrix Is:\n");
for(i=0;i< p;i++) // print the second matrix
{
for(j=0;j< q;j++)
printf(" %d ",b[i][j]);
printf("\n");
}
if(n!=p)
{
printf("Aborting!!!!!!/nMultiplication Of The Above Matrices Not Possible.");
exit(0);
}
else
{
for(i=0;i< m;i++)
{
for(j=0;j< q;j++)
{
c[i][j] = 0;
for(k=0;k< n;k++)
{
c[i][j] = c[i][j] + a[i][k] * b[k][j];
}
}
}
printf("\nMultiplication Of The Above Two Matrices Are:\n\n");
for(i=0;i< m;i++)
{
for(j=0;j< q;j++)
{
printf(" %d ",c[i][j]);
}
printf("\n");
}
}
getch();
}

Merge Sort

2007-07-05T10:35:00.000-07:00

Merging is the process of combining two or more sorted arrays into a third sorted array. We can use this technique to sort an array of n elements as follows.
Divide the array into ‘n’ sub arrays of size 1 and merge adjacent pairs of sub arrays. Then we can have approximately n/2 sorted sub arrays of size 2. Repeat this process until there is 1 array containing n elements.
Algorithm
1. Establish a sub array ‘a’ with n elements
2. Let size < - 1 3. Repeat steps 4 through 6 until size >= n
4. Subdivide the sub array into sub arrays of size ‘size’
5. Merge adjacent pairs of sub arrays
6. Double the size

/*** C Program For Implementation Of Merge Sort ***/

#define MAX 20

void mergesort(int *,int);
void main()
{
int x[MAX],n,j,i;
char ans;
clrscr();
{
printf("\nEnter The Length Of The Array\t: ");
scanf("%d",&n);
for(i=0;i< n;i++)
{
printf("Enter Element %d\t: ",i+1);
scanf("%d",&x[i]);
}
mergesort(x,n);
printf("\n\t│ Sorted Array :\t\t\t│\n\t│");
for(i=0;i< n;i++)
printf("%d\t",x[i]);
}
printf("│");
getch();
}

void mergesort(int x[],int n)
{
int sub[MAX];
int i,j,k,list1,list2,u1,u2,size=1;
while(size< n)
{
list1=0;
k=0;

while((list1+size)< n)
{
list2=list1+size;
u1=list2-1;
u2=((list2+size-1)< n)?(list2+size-1):(n-1);

for(i=list1,j=list2;i< =u1 &&amp;amp; j< =u2;k++)
if(x[i]< =x[j])
sub[k]=x[i++];
else
sub[k]=x[j++];

for(;i< =u1;k++)
sub[k]=x[i++];

for(;j< =u2;k++)
sub[k]=x[j++];

list1=u2+1;
}
for(i=list1;k< n;i++)
sub[k++] = x[i];
for(i=0;i< n;i++)
x[i] =sub[i];
size *= 2;
}
}
/********* OUTPUT **********

Enter The Length Of The Array : 5
Enter Element 1 : 12
Enter Element 2 : 69
Enter Element 3 : 78
Enter Element 4 : 2
Enter Element 5 : 5

│ Sorted Array : │
│2 5 12 69 78 │
*/

Circular Queue

2007-07-05T10:34:00.000-07:00

A circular queue is a Queue but a particular implementation of a queue. It is very efficient. It is also quite useful in low level code, because insertion and deletion are totally independant, which means that you don't have to worry about an interrupt handler trying to do an insertion at the same time as your main code is doing a deletion.

Algorithm for Insertion:-
Step-1: If "rear" of the queue is pointing to the last position then go to step-2 or else step-3
Step-2: make the "rear" value as 0
Step-3: increment the "rear" value by one
Step-4:

if the "front" points where "rear" is pointing and the queue holds a not NULL value for it, then its a "queue overflow" state, so quit; else go to step-4.2
insert the new value for the queue position pointed by the "rear"

Algorithm for deletion:-
Step-1: If the queue is empty then say "empty queue" and quit; else continue
Step-2: Delete the "front" element
Step-3: If the "front" is pointing to the last position of the queue then step-4 else step-5
Step-4: Make the "front" point to the first position in the queue and quit
Step-5: Increment the "front" position by one

/****** C Program For Impelmetation Of Circular Queue *******/
#define MAX 5

struct queue
{
int arr[MAX];
int rear,front;
};

int isempty(struct queue *p)
{
if(p->front ==p->rear)
return 1;
else
return 0;
}

void insertq(struct queue *p,int v)
{
int t;
t = (p->rear+1)%MAX;
if(t == p->front)
printf("\nQueue Overflow\n");
else
{
p->rear=t;
p->arr[p->rear]=v;
}
}
int removeq(struct queue *p)
{
if(isempty(p))
{
printf("\nQueue Underflow");
exit(0);
}
else
{
p->front=(p->front + 1)%MAX;
return(p->arr[p->front]);
}
}

void main()
{
struct queue q;
char ch;
int no;
clrscr();
q.rear=q.front =0;
insertq(&q,7);
insertq(&q,10);
insertq(&q,12);
insertq(&q,15);
insertq(&q,8);
printf("\n%d\n",removeq(&q));
printf("%d\n",removeq(&q));
printf("%d\n",removeq(&q));
printf("%d\n",removeq(&q));
removeq(&q);
getch();
}
/************** OUTPUT ****************

Queue Overflow

7
10
12
15

Queue Underflow */

Queue

2007-07-05T10:33:00.000-07:00

A queue is a buffer abstract data structure providing services in computer science, transport and operations research where various entities such as data, objects, persons, or events are stored and held to be processed later. The most well known operation of the queue is the First-In-First-Out (FIFO) queue process. In a FIFO queue, the first element in the queue will be the first one out; this is equivalent to the requirement that whenever an element is added, all elements that were added before have to be removed before the new element can be invoked. Unless otherwise specified, the remainder of the article will refer to FIFO queues. There are also non-FIFO queue data structures, like priority queues.

/******** C Program For Impelmetation Of Queue ***********/

#define MAXSIZE 10

struct st
{
int front,rear;
int queue[MAXSIZE];
};

struct st s;

int empty(void);
int full(void);
void add(void);
void delete(void);
void display(void);

void main()
{
char ans;
int ch;
s.front = 0;
s.rear = 0;

do
{
clrscr();
printf("********Queue Program**********\n");
printf("1. ADD\n");
printf("2. DELETE\n");
printf("3. DISPLAY\n");
printf("4. QUIT\n");
printf("Enter Your Choice : ");
scanf("%d",&ch);
switch(ch)
{
case 1:
add();
break;
case 2:
delete();
break;
case 3:
display();
break;
case 4:
exit(1);
break;

default:
printf("INVALID CHOICE!!!!!!!!!!!!!!!!\n");
break;
}
printf("\nWant To Go To The Main Menu[y/n]");
flushall();
ans = getch();
}
while(ans == 'y' ans == 'Y');
printf("\nPress Any Key To Continue\n");
getch();
}

int full(void)
{
if (s.rear == MAXSIZE)
return(1);
else
return(0);
}
int empty(void)
{
if (s.front == s.rear + 1)
return(1);
else
return(0);
}

void add(void)
{
char ch;
int x;
do
{
if(full() == 1)
{
printf("\n\nQueue Full\n");
break;
}
else
{
s.rear = s.rear + 1;
printf("\nEnter An Element to Be Added ");
scanf("%d",&x);
s.queue[s.rear] = x;
if(s.rear == 1) s.front ++;
}
printf("\nDo You Want to Add More Elements[y/n]:");
flushall();
ch = getch();
}
while(ch=='y' ch == 'Y');
}

void delete(void)
{
char ch;
do
{
if(empty() == 1)
{
printf("\n\nQueue Empty\n");
break;
}
else
{
printf("% d Has Been Deleted!",s.queue[s.front]);
s.front = s.front +1;
}
printf("\nWant to Delete More [y\n]");
flushall();
ch = getch();
}
while(ch=='y' ch == 'Y');
}

void display(void)
{
int i;
clrscr();
if(empty () == 1)
printf("\nQueue Empty!!");
else
{
printf("\nDisplaying Queue\n");
for(i = s.front;i printf("%d\n",s.queue[i]);
}
}
/************ OUTPUT ***************

**********Queue Program**********
1. ADD
2. DELETE
3. DISPLAY
4. QUIT
Enter Your Choice : 1

Enter An Element to Be Added 1
Do You Want to Add More Elements[y/n]:y
Enter An Element to Be Added 2
Do You Want to Add More Elements[y/n]:y
Enter An Element to Be Added 3
Do You Want to Add More Elements[y/n]:y
Enter An Element to Be Added 4
Do You Want to Add More Elements[y/n]:y
Enter An Element to Be Added 5
Do You Want to Add More Elements[y/n]:n
Want To Go To The Main Menu[y\n] y

**********Queue Program**********
1. ADD
2. DELETE
3. DISPLAY
4. QUIT
Enter Your Choice : 3

Displaying Queue
1
2
3
4
5
Want To Go To The Main Menu[y\n] y

**********Queue Program**********
1. ADD
2. DELETE
3. DISPLAY
4. QUIT
Enter Your Choice : 2
1 Has Been Deleted!!
Do You Want To Delete More?[y/n] n
Want to Go To Main Menue[y/n] y

**********Queue Program**********
1. ADD
2. DELETE
3. DISPLAY
4. QUIT
Enter Your Choice : 3

Displaying Queue
2
3
4
5
Want To Go To The Main Menu[y\n] y

**********Queue Program**********
1. ADD
2. DELETE
3. DISPLAY
4. QUIT
Enter Your Choice : 4 */

Stack

2007-07-05T09:16:00.001-07:00

One way to think about this implementation is to think of functions as being stacked on top of each other; the last one added to the stack is the first one taken off. In this way, the data structure itself enforces the proper order of calls. Conceptually, a stack is simple: a data structure that allows adding and removing elements in a particular order. Every time an element is added, it goes on the top of the stack; the only element that can be removed is the element that was at the top of the stack.

Consequently, a stack is said to have "first in last out" behavior (or "last in, first out"). The first item added to a stack will be the last item removed from a stack. So what's the big deal? Where do stacks come into play? As you've already seen, stacks are a useful way to organize our thoughts about how functions are called. In fact, the "call stack" is the term used for the list of functions either executing or watiing for other functions to return. In a sense, stacks are part of the fundamental language of computer science. When you want to express an idea of the "first in last out" variety, it just makes sense to talk about it using the common terminology. Moreover, such operations show up an awful lot, from theoretical computer science tools such as a push-down automaton to AI, including implementations of depth-first search.

Stacks have some useful terminology associated with them:

Push To add an element to the stack
Pop To remove an element from the stock
Peek To look at elements in the stack without removing them
LIFO Refers to the last in, first out behavior of the stack
FILO Equivalent to LIFO

General Algorithm

[Prologue] Save the parameters, Local Variables and return address.
[Body] If the base criterion has been reached, then perform the final computation and go to step 3; otherwise, perfprm the partial computation and go to step 1(initialize a recursive call)
[Epilogue] Restore the most recently saved parameters, local variables, and return address. Go to this return address.

/**************** C Program For Impelmetation Of Stack ********************/

#define MAXSIZE 10

struct st
{
int top;
int stack[MAXSIZE];
};

struct st s;

int empty(void);
int full(void);
void push(void);
void pop(void);
void display(void);

void main()
{
char ans;
int ch;
do
{
clrscr();
printf("********Stack Program**********\n");
printf("1.PUSH\n");
printf("2.POP\n");
printf("3.DISPLAY\n");
printf("4.QUIT\n");
printf("Enter Your Choice : ");
scanf("%d",&ch);
switch(ch)
{
case 1:
push();
break;
case 2:
pop();
break;
case 3:
display();
break;
case 4:
exit(1);
break;

default:
printf("INVALID CHOICE!!!!!!!!!!!!!!!!\n");
break;
}
printf("Want To Go To The Main Menu[y/n]");
flushall();
ans = getch();
}
while(ans == 'y' ans == 'Y');
printf("\nPress Any Key To Exit");
getch();
}

int full(void)
{
if (s.top == MAXSIZE)
return(1);
else
return(0);
}

int empty(void)
{
if (s.top == 0)
return(1);
else
return(0);
}
void push(void)
{
char ch;
int x;
do
{
if(full() == 1)
{
printf("\nStack Full\n");
break;
}
else
{
s.top = s.top + 1;
printf("\nEnter An Element To Be Pushed: ");
scanf("%d",&x);
s.stack[s.top] = x;
}
printf("\nDo You Want To Push More Elements[y/n]");
flushall();
ch = getch();
}
while(ch == 'y' ch == 'Y');
}

void pop(void)
{
char ch;
do
{
if(empty() == 1)
{
printf("\nStack Empty\n");
break;
}
else
{
printf("\n%d has been popped !",s.stack[s.top]);
s.top = s.top - 1;
}
printf("\nDo you Want To Pop Out More?[y/n]");
flushall();
ch = getch();
}
while(ch == 'Y' ch == 'y');
}

void display(void)
{
int i;
clrscr();
if(empty() == 1)
printf("\nStack Empty!!!");
else
{
printf("Displaying Stack............\n");
for(i = s.top; i>0;i--)
printf("%d",s.stack[i]);
}
}
/************** OUTPUT *************

********Stack Program**********
1. PUSH
2. POP
3. DISPLAY
4. QUIT
Enter Your Choice : 1

Enter An Element To Be Pushed : 1
Do YOu Want To Push More Elements [y\n] y
Enter An Element To Be Pushed : 2
Do YOu Want To Push More Elements [y\n] y
Enter An Element To Be Pushed : 3
Do YOu Want To Push More Elements [y\n] y
Enter An Element To Be Pushed : 4
Do YOu Want To Push More Elements [y\n] y
Enter An Element To Be Pushed : 5
Do YOu Want To Push More Elements [y\n] n
Want To Go Main Menu? [y\n] y

********Stack Program**********
1. PUSH
2. POP
3. DISPLAY
4. QUIT
Enter Your Choice : 3

Displaying Stack......
5
4
3
2
1
Want To Go Main Menu? [y\n] y

********Stack Program**********
1. PUSH
2. POP
3. DISPLAY
4. QUIT
Enter Your Choice : 2

5 Has Been Popped!
Do You Want To Pop More? [y\n] y
4 Has Been Popped!

Do You Want To Pop More? [y\n] n
Want To Go Main Menu? [y\n] y

********Stack Program**********
1. PUSH
2. POP
3. DISPLAY
4. QUIT
Enter Your Choice : 3

Displaying Stack.........
3
2
1
Want To Go Main Menu? [y\n] y

********Stack Program**********
1. PUSH
2. POP
3. DISPLAY
4. QUIT
Enter Your Choice : 4 */

File Handling - C Program

2007-07-05T09:14:00.000-07:00

This is a C program on file Handling

/************** File Handling *************/

void main()
{
FILE *file1;
char c;
int choice;
char op;
clrscr();
do
{
printf("\t\tMenu\n\t1. Enter The Information\n\t2. Display The Information\n");
scanf("%d",&choice);

switch(choice)
{
case 1:
printf("\n Information \n");
file1=fopen("Handlin.doc","w");

while((c=getchar())!=EOF)
{

putc(c,file1);
}
fclose(file1);
break;

case 2:
printf("Information\n");
printf("Result :");
file1=fopen("Malcolm .doc","r");
while((c=getc(file1))!=EOF)
printf("%c",c);
fclose(file1);
break;

default:
exit(1);
}
printf("Enter Y To Continue:");
flushall();
scanf("%c",&op);
}
while((op=='y')(op=='Y'));
getch();
}
/********************* OUTPUT **********************
Menu
1. Enter The Information
2. Display The Information
1

Information
Today Is Sunday
^Z
Enter Y To Continue:y
Menu
1. Enter The Information
2. Display The Information
2
Information
Result :
Today Is Sunday
Enter Y To Continue:n

*/

Structures

2007-07-05T09:06:00.000-07:00

/* Program To Display The Highest Salary Of A Employees */

int count;
struct employee
{
int idno,salary;
char name[10];
};

struct employee s[10];

void main()
{
int i,loc=0;
float top;
clrscr();
printf("Enter Number Of Employees : ");
scanf("%d",&count);
for(i=0;itop)
{
top=s[i].salary;
loc=i;
}

}
printf("\nThe Highest Salary Is : ");
printf("%s",s[loc].name);
getch();
}
/***************** OUTPUT ******************

Name : Lionel
ID no : 40
salary : 25000

Name : Cyril
ID no : 42
salary : 10000

Name : Bob
ID no : 46
salary : 15000

Name : Nigel
ID no : 45
salary : 12000
___________________________
Name ID no. Salary
---------------------------------------
Lionel 40 25000
Cyril 42 10000
Bob 46 15000
Nigel 45 12000
---------------------------------------
The Highest Salary Is : Lionel */