Interview Questions for Freshers

SQL Random Line

2010-02-26T10:57:00.001-08:00

Function SQLRandomLines(proc, params, fname, count)
Dim i, j, k, rid, rs, result, records, reccount, normalized

On Error Resume Next

PushError

SQLRandomLines = Null

Set rs = iOpen(proc, params)
If CheckPopError Then
Exit Function
End If

If rs.EOF Then
rs.Close
Set rs = Nothing
Exit Function
End If

records = rs.GetRows(adGetRowsRest)
If CheckPopError Then
Exit Function
End If

rid = -1
For i = 0 To rs.Fields.Count - 1
If (rs.Fields(i).Name = fname) Then
rid = i
End If
Next
If (rid < 0) Or (rid > rs.Fields.Count - 1) Then
rid = -1
End If
rs.Close
Set rs = Nothing

If (rid = -1) Then
Exit Function
End If
reccount = UBound(records, 2) - LBound(records, 2) + 1

If (reccount >= count) Then
normalized = RandomArray(count, LBound(records, 2), UBound(records, 2))
For i = LBound(normalized) To UBound(normalized)
normalized(i) = records(rid, normalized(i))
Next
Else
normalized = RandomArray(reccount, LBound(records, 2), UBound(records, 2))
For i = LBound(normalized) To UBound(normalized)
normalized(i) = records(rid, normalized(i))
Next
End If

ReDim result(UBound(records, 1), UBound(normalized))
For k = LBound(records, 2) To UBound(records, 2)
For i = LBound(normalized) To UBound(normalized)
If (CStr(records(rid, k)) = CStr(normalized(i))) Then
For j = LBound(records, 1) To UBound(records, 1)
If (TypeName(records(j, k)) = "String") Then
result(j, i) = VarTrimStr(records(j, k))
Else
result(j, i) = records(j, k)
End If
Next
End If
Next
Next
SQLRandomLines = result
End Function

SQL Random ID

2010-02-26T10:56:00.002-08:00

Function SQLRandomIDs(proc, params, fname, count)
Dim i, rs, records, reccount, normalized

On Error Resume Next

PushError

SQLRandomIDs = Null

Set rs = iOpen(proc, params)
If CheckPopError Then
Exit Function
End If

If rs.EOF Then
rs.Close
Set rs = Nothing
Exit Function
End If

records = rs.GetRows(adGetRowsRest, , fname)
If CheckPopError Then
Exit Function
End If
rs.Close
Set rs = Nothing

reccount = UBound(records, 2) - LBound(records, 2) + 1
If IsNull(count) Or IsEmpty(count) Then
count = reccount
ElseIf (count < 0) Then
count = reccount
End If

If (reccount >= count) Then
normalized = RandomArray(count, LBound(records, 2), UBound(records, 2))
For i = LBound(normalized) To UBound(normalized)
normalized(i) = records(0, normalized(i))
Next
Else
normalized = RandomArray(reccount, LBound(records, 2), UBound(records, 2))
For i = LBound(normalized) To UBound(normalized)
normalized(i) = records(0, normalized(i))
Next
End If
SQLRandomIDs = normalized
End Function

Remove Duplicate Records

2010-02-26T10:56:00.000-08:00

Remove duplicate database records

Database:	.mdb
Table Name:
Field Name:
Primary Key:

Import the SQL Server error log into a table

2010-02-26T10:55:00.000-08:00

CREATE PROC sp_import_errorlog
(
   @log_name sysname,
   @log_number Int = 0,
   @overwrite bit = 0
)
As

Purpose: To import the SQL Server Error Log into a table, so that it can be queried

Tested On: SQL Server 2000

Limitation: With Error messages spanning more than one line only the first line Is included In the table

Example 1: To import the current Error Log To table myerrorlog
   EXEC sp_import_errorlog 'myerrorlog'

Example 2: To import the current Error Log To table myerrorlog, And overwrite the table
   'myerrorlog' if it already exists
   EXEC sp_import_errorlog 'myerrorlog', @overwrite = 1

Example 3: To import the previous Error Log To table myerrorlog
   EXEC sp_import_errorlog 'myerrorlog', 1

Example 4: To import the Second previous Error Log To table myerrorlog
   EXEC sp_import_errorlog 'myerrorlog', 2

BEGIN
   Set NOCOUNT On

   Declare @sql varchar(500) --Holds To SQL needed To create columns from Error Log

   If (Select OBJECT_ID(@log_name,'U')) IS NOT NULL
   BEGIN
   If @overwrite = 0
   BEGIN
   RAISERROR('Table already exists. Specify another name or pass 1 to @overwrite parameter',18,1)
   RETURN -1
   End
   Else
   BEGIN
   EXEC('DROP TABLE ' + @log_name)
   End
   End


   --Temp table To hold the output of sp_readerrorlog
   CREATE TABLE #errlog
   (
   err varchar(1000),
   controw tinyint
   )

   --Populating the temp table using sp_readerrorlog
   INSERT #errlog
   EXEC sp_readerrorlog @log_number

   --This will remove the header from the errolog
   Set ROWCOUNT 4
   DELETE #errlog
   Set ROWCOUNT 0


   Set @sql = 'SELECT
   CONVERT(DATETIME,Left(err,23)) [Date],
   SUBSTRING(err,24,10) [spid],
   Right(err,Len(err) - 33) [Message],
   controw
   INTO ' + QUOTENAME(@log_name) +
   ' FROM #errlog ' +
   'WHERE controw = 0'

   --Creates the table With the columns Date, spid, message And controw
   EXEC (@sql)

   --Dropping the temporary table
   DROP TABLE #errlog

   Set NOCOUNT OFF
Print 'Error log successfully imported to table: ' + @log_name
End

Call an Oracle Stored Procedure

2010-02-26T10:50:00.000-08:00

Assume you have a procedure like this one below, And that it has been already created On the
Oracle database. This procedure doesn't return anything, but that doesn't change anything!
STEP #1:
/******STORED PROCEDURE On ORACLE DATABASE************/
create Or Replace procedure test_me
Is
w_count integer;
begin
insert into TEST values ('Surya was here');
--commit it
commit;
end;
/*****End OF STORED PROCEDURE****/

STEP # 2:
+++++++++
I assume you have tested it from sql*plus by running the
following statements:

/************TEST THE STORED PROCEDURE FROM SQL*PLUS******/
SQL> execute test_me

PL/SQL procedure successfully completed.

SQL>
/***************End OF TESTING THE STORED PROC************/

STEP# 3:
++++++++
/*****CALLING A STORED PROCEDURE FROM ASP******************/

1. USING THE CONNECTION OBJECT

You can execute stored procedures which perform Oracle Server side tasks And return you a recordset. You can only use this method If
your stored procedure doesn't return any OUTPUT values.

Note that -1 means no count of total number of records Is
required. If you want To Get the count, substitute count
With some Integer variable

Note that 4 means it Is a stored procedure. By using the
actual number -1 And 4, you don't need the server side
include ADOVBS.INC ;-)

The above would Do the job On the database And return
back To you without returning any recordsets.

Alternatively, you could:

W_count Is the number of records affected. If your stored
procedure were To return a query result, it Is returned
within your recordset (rs). This method Is useful With Stored procs
which return results of an SQL query

2. USING THE COMMAND OBJECT

STEP# 4
+++++++++
/************PASSING Input/OUTPUT PARAMETERS**************************/

Add New Record with ADO

2010-02-26T10:29:00.002-08:00

The form responder looks like this:

Here Is the include file that displays appropriate errors:

ADO Schemas to list tables & fields

2010-02-26T10:29:00.000-08:00

Here Is the contents of lib_fieldtypes.asp which Is included To make this example work:

Database Paging

2010-02-26T10:27:00.000-08:00

5K Race

Records: - of

Name

Age

City

State

Time

Pace

How to filter a recordset

2010-02-26T10:26:00.002-08:00

>Before Filter

>After Filter

Index Server Access via ADO

2010-02-26T10:26:00.000-08:00

The iskeywordrespond.asp looks like this:

It has To exclude many folders On my site And the following file excludes directories:

Insert TEXT blob using ADO

2010-02-26T10:25:00.001-08:00

Using a Stored Procedure with ADO

2010-02-26T10:19:00.001-08:00

Dim cn As New ADODB.Connection
cn.Open sConStr
Dim cmd As New ADODB.Command
cn.CursorLocation = adUseClient
Set cmd.ActiveConnection = cn
cmd.CommandText = "addNew_Service"
cmd.CommandType = adCmdStoredProc
cmd.Parameters.Refresh
cmd.Parameters.Item("@wsdlfilename") = CStr(services(serviceId).wsdlfilename)
cmd.Parameters.Item("@WSMLFileName") = CStr(services(serviceId).WSMLFileName)
cmd.Parameters.Item("@name") = CStr(services(serviceId).name)
cmd.Parameters.Item("@description") = CStr(services(serviceId).description)
cmd.Parameters.Item("@uuid") = CStr(sUUID)
cmd.Parameters.Item("@Service_ID") = 0
cmd.Execute
Debug.Print Err.description
newService_ID = cmd.Parameters("@Service_ID").Value

How to shutdown reboot logoff WIndows 9x NT Me 2000

2010-02-26T10:16:00.000-08:00

program shutdown;
{$APPTYPE CONSOLE}
uses
  SysUtils,
  Windows;

var
   logoff: boolean = false;
   reboot: boolean = false;
   warn: boolean = false;
   downQuick: boolean = false;
   cancelShutdown: boolean = false;
   powerOff: boolean = false;
   timeDelay: integer = 0;

function HasParam(Opt: Char): Boolean;
var
   x: integer;
begin
   result := false;
   for x := 1 to paramCount do
   if (paramstr(x) = '-'+opt) or (paramstr(x) = '/'+opt) then result := true;
end;

function GetErrorString: String;
var
   lz: Cardinal;
   err: array[0..512] of Char;
begin
   lz := GetLastError;
   FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nil, lz, 0, @err, 512, nil);
   result := string(err);
end;

procedure DoShutdown;
var
   rl,flgs: Cardinal;
   hToken: Cardinal;
   tkp: TOKEN_PRIVILEGES;
begin
   flgs := 0;
   if downQuick then flgs := flgs or EWX_FORCE;
   if not reboot then flgs := flgs or EWX_SHUTDOWN;
   if reboot then flgs := flgs or EWX_REBOOT;
   if poweroff and (not reboot) then flgs := flgs or EWX_POWEROFF;
   if logoff then flgs := (flgs and (not (EWX_REBOOT or EWX_SHUTDOWN or EWX_POWEROFF))) or EWX_LOGOFF;
   if Win32Platform = VER_PLATFORM_WIN32_NT then begin
   if not OpenProcessToken(GetCurrentProcess, TOKEN_ADJUST_PRIVILEGES or TOKEN_QUERY, hToken) then
   Writeln('Cannot open process token. ['+GetErrorString+']')
   else begin
   if LookupPrivilegeValue(nil, 'SeShutdownPrivilege', tkp.Privileges[0].Luid) then begin
   tkp.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED;
   tkp.PrivilegeCount := 1;
   AdjustTokenPrivileges(hToken, False, tkp, 0, nil, rl);
   if GetLastError <> ERROR_SUCCESS then
   Writeln('Error adjusting process privileges.');
   end else Writeln('Cannot find privilege value. ['+GetErrorString+']');
   end;
{ if CancelShutdown then
   if AbortSystemShutdown(nil) = False then
   Writeln(\'Cannot abort. [\'+GetErrorString+\']\')
   else
   Writeln(\'Cancelled.\')
   else begin
   if InitiateSystemShutdown(nil, nil, timeDelay, downQuick, Reboot) = False then
   Writeln(\'Cannot go down. [\'+GetErrorString+\']\')
   else
   Writeln(\'Shutting down!\');
   end;}
   end;
// else begin
   ExitWindowsEx(flgs, 0);
// end;
end;

begin
   Writeln('Shutdown v0.3 for Win32 (similar to the Linux version)');
   Writeln('X Software. All Rights Reserved.');
   if HasParam('?') or (ParamCount=0) then begin
   Writeln('Usage: shutdown [-akrhfnc] [-t secs]');
   Writeln(' -k: don''t really shutdown, only warn.');
   Writeln(' -r: reboot after shutdown.');
   Writeln(' -h: halt after shutdown.');
   Writeln(' -p: power off after shutdown');
   Writeln(' -l: log off only');
   Writeln(' -n: kill apps that don''t want to die.');
   Writeln(' -c: cancel a running shutdown.');
   end else begin
   if HasParam('k') then warn := true;
   if HasParam('r') then reboot := true;
   if HasParam('h') and reboot then begin
   Writeln('Error: Cannot specify -r and -h parameters together!');
   Exit;
   end;
   if HasParam('h') then reboot := false;
   if HasParam('n') then downQuick := true;
   if HasParam('c') then cancelShutdown := true;
   if HasParam('p') then powerOff := true;
   if HasParam('l') then logoff := true;
   DoShutdown;
   end;
end.

Volumes & Areas

2010-02-26T10:07:00.001-08:00

/PROGRAM TO CALCULATE AREA,VOLUME,PERIMETER OF A PARTICULAR
GEOMETRIC SHAPE/

#include
#include
#include
#define PI 3.14159
char ch;
main()
{

clrscr();

  textcolor(4);
  intro();
  getch();
  textcolor(7);
  clrscr();
  do
   {
   ch=menu();
switch(ch)
{
case 'a':
case 'A':
clrscr();
square();
getch();
break;
case 'b':
case 'B':
clrscr();
rect();
getch();
break;
case 'c':
case 'C':
clrscr();
circl();
getch();
break;
case 'd':
case 'D':
clrscr();
tri();
getch();
break;
case 'e':
case 'E':
clrscr();
rom();
getch();
break;
case 'f':
case 'F':
clrscr();
para();
getch();
break;

case 'g':
case 'G':
clrscr();
tra();
getch();
break;
case 'h':
case 'H':
clrscr();
qua();
getch();
break;
case 'i':
case 'I':
clrscr();
semicir();
getch();
break;
case 'j':
case 'J':
clrscr();
msector();
getch();
break;

case 'k':
case 'K':
   clrscr();
sphere();
getch();
break;
case 'l':
case 'L':
clrscr();
cone();
getch();
break;
case 'm':
case 'M':
clrscr();
cyll();
getch();
break;

case 'n':
case 'N':
clrscr();
cube();
getch();
break;
case 'o':
case 'O':
clrscr();
cuboid();
getch();
break;
case 'p':
case 'P':
clrscr();
hemisphe();
getch();
break;

case 'q':
case 'Q':
exit(1);
}
   } while(ch!='Q'||ch!='q');
   getch();
}
  intro()
   {
   int i;
   clrscr();
   printf("

");
   textcolor(2);

cprintf("#################################################################
###############");
   textcolor(4);
   printf("

PROGRAM TO CALCULATE AREAS , VOLUMES ,
CIRCUMFERENCES ");
   printf("

=====================================================
");
   printf("
   OF VARIOUS GEOMETRIC SHAPES");
   printf("
   ===========================

");
   textcolor(2);

cprintf("#################################################################
###############");
   getch();

   printf("

Program developed and designed
by...

");
   printf("WWW");

   }
  menu()
   {
   clrscr();
   textcolor(7);
   printf(" MENU
Two Dimensional Shapes.

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

A.SQUARE
B.RECTANGLE

C.CIRCLE
D.TRIANGLE

E.RHOMBUS
F.PARALLELOGRAM

G.TRAPEZIUM
H.QUADRILATERAL.

I.SEMICERCLE
J.SECTOR
");
   printf("
Three Dimensional Shapes.

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

K.SPHERE
L.CONE
M.CYLLINDER

N.CUBE
O.CUBOID
P.HEMISPHERE

Q.QUIT
Enter Your Choice :");
   scanf("%c",&ch);
   return(ch);
   }

/***** SUB FUNCTIONS *****/
/***** 2 D SHAPES *****/

square()
{
float s,a,p;int i,j;
printf("
Enter side of square:");
scanf("%f",&s);
a=s*s;
p=4*s;
printf("
Perimeter of square : %.3f units",p);
printf("
Area of square : %.3f sq.units",a);
printf("
Square is ...
");
for(i=1;i<=s;i++)
{
textcolor(10);
for(j=1;j<=s;j++)
cprintf("ÛÛ");
printf("
");
}
return(0);
}
rect()
{
float a,p,l,b; int i,j;
printf("
Enter length and breadth of rectangle:
Length:");
scanf("%f",&l);
printf("
Breadth:");
scanf("%f",&b);
a=l*b;
p=2*(l+b);
printf("
Perimeter of rectangle : %.3f units",p);
printf("
Area of rectangle : %.3f sq.units",a);
printf("
Rectangle is...
");
for(i=1;i<=b;i++)
{
textcolor(4);
for(j=1;j<=l;j++)
cprintf("ÛÛ");
printf("
");
}
return(0);
}
tri()
{
float area,p;
float a,b,c,s;
printf("
Enter three sides of triangle:");
scanf( "%f%f%f",&a,&b,&c);
p=a+b+c;
s=p/2;
area=sqrt(s*(s-a)*(s-b)*(s-c));
printf("
Perimeter of triangle : %.3f units",p);
printf("
Area of a triangle : %.3f sq.units",area);
}
rom()
{
float s,d1,d2,a,p;
printf("
Enter side and diagonals of a rhombus:
Side:");
scanf("%f",&s);
printf("
Diagonal :");scanf("%f",&d1);
printf("
Diagonal :");scanf("%f",&d2);
a=0.5*d1*d2;
p=4*s;
printf("
Perimeter of rhombus :%.3f units",p);
printf("
Area of rhombus :%.3f sq.units",a);
}
circl()
{
float r,a,p;
printf("Enter radius of circle:");
scanf("%f",&r);
a=PI * r * r;
p=2 * PI * r;
printf("
Circumference of circle : %.3f units",p);
printf("
Area of circle : %.3f sq.units",a);
}
para()
{
float a,p,base,h,l,b;
printf("Enter height,length,breadth of parallalogram :
" );
printf("
Height :"); scanf("%f",&h);
printf("
Base or Length :"); scanf("%f",&l);
printf("
Breadth :"); scanf("%f",&b);
base=l;
a=base*h;
p=2 * ( l + b );
printf("
Perimeter of parallalogram :%.3f units",p);
printf("
Area of parallogram :%.3f sq.units",a);

}

tra()
{
float a,b,d,are;
printf("Enter height and lengths of two parallel sides:
Height :");
scanf("%f",&d);
printf("Side:"); scanf("%f",&a);
printf("Side:"); scanf("%f",&b);
are=0.5 * d * (a+b);
printf("
Area of trapezium : %.3f sq.units",are);
}
qua()
{
float a,b,area,d;
printf("Enter diagonal and perpendicular distances from opposite
vertices:
");
printf("Diagonal :"); scanf("%f",&d);
printf("
Distance :"); scanf("%f",&a);
printf("
Distance :");scanf("%f",&b);
area= 0.5 * d * (a + b);
printf("
Area of quadrilateral : %.3f sq.units", area);
}
semicir()
{
float a,p,r;
printf("Enter radius of semicircle:");
scanf("%f",&r);
a=0.5* PI * r * r;
p= (PI * r ) + (2 * r);
printf("
Circumference of semicircle : %.3f units",p);
printf("
Area of semicircle : %.3f sq.units",a);
}

msector()
{
float x,r,temp,a,p;
printf("Enter radius and angle of sector:");
printf("
Radius :");
scanf("%f",&r);
printf("
Angle(in degrees) :");
scanf("%f",&x);
temp= x/360;
a= temp * (PI * r * r);
p= temp * (2 * PI * r);
printf("
Circumference of sector : %.3f units",p);
printf("
Area of sector : %.3f sq.units",a);
}

   /******** 3 DIMENSIONAL SHAPES *********/

sphere()
{
float lsa,tsa,v,r;
printf("Enter radius of sphere :");
scanf("%f",&r);
tsa=4*PI*r*r;
v=(4.0/3.0)*PI*r*r*r;
printf("
Total surface area of sphere :%.3f sq.units",tsa);
printf("
Volume of sphere :%.3f cu.units",v);
}
cone()
{
float h,r,s ,v,tsa,lsa;
printf("Enter base radius ,height, slant height of cone :");
printf("
Radius :"); scanf("%f",&r);
printf("
Height :"); scanf("%f",&h);
printf("
Slant height :"); scanf("%f",&s);
tsa=PI * r *(s+r);
lsa=PI * r * s;
v=(PI * r * r * h)/3;
printf("
Total surface area of cone :%.3f sq.units",tsa);
printf("
Lateral surface area of cone :%.3f sq.units",lsa);
printf("
Volume of cone :%.3f cu.units",v);
}
cyll()
{
float lsa,tsa,v,r,h;
printf("Enter height and radius of cyllinder");
printf("Height :"); scanf("%f",&h);
printf("Radius :"); scanf("%f",&r);
lsa=2*PI*r*h;
tsa=2*PI*r*(h+r);
v=PI*r*r*h;
printf("
Total surface area of cyllinder :%.3f sq.units",tsa);
printf("
Curved surface area of cyllinder :%.3f sq.units",lsa);
printf("
Volume of cyllinder :%.3f cu.units",v);
}
cube()
{
float lsa,tsa,v,s,d;
printf("Enter side of cube :");
scanf("%f",&s);
d=s*sqrt(3);
lsa=4 * s * s;
tsa=6 * s * s;
v= s * s * s;
printf("
Diagonal of cube :%.3f units",d);
printf("
Total surface area of cube :%.3f sq.units",tsa);
printf("
Lateral surface area of cube :%.3f sq.units",lsa);
printf("
Volume of cube :%.3f cu.units",v);
}
cuboid()
{
float lsa,tsa,v,l,b,d,h;
printf("Enter length,breadth,height of cuboid :");
printf("
Length :"); scanf("%f",&l);
printf("
Breadth :"); scanf("%f",&b);
printf("
Height :"); scanf("%f",&h);
d=sqrt(l*l + b*b + h*h );
lsa =2 * h *( l+b );
tsa = lsa + 2 * l * b;
v=l*b*h;
printf("
Diagonal of cuboid :%.3f units",d);
printf("
Total surface area of cuboid :%.3f sq.units",tsa);
printf("
Lateral surface area of cuboid :%.3f sq.units",lsa);
printf("
Volume of cuboid :%.3f cu.units",v);
}
hemisphe()
{
   float lsa,tsa,v,r;
printf("Enter radius of hemisphere :");
scanf("%f",&r);
tsa=3*PI*r*r;
lsa=2*PI*r*r;
v=(2.0/3.0)*PI*r*r*r;
printf("
Total surface area of hemisphere :%.3f sq.units",tsa);
printf("
Lateral surface area of hemisphere :%.3f sq.units",lsa);
printf("
Volume of hemisphere :%.3f cu.units",v);
}

Factorial series-e^x

2010-02-26T10:06:00.000-08:00

#include
#include
#include
long int factorial(int n);
void main()
{
int x,i;
float s,r;
char c;
clrscr();
printf("You have this series:-1+x/1! + x^2/2! + x^3/3! + x^4/4!
..x^x/x!");
printf("
To which term you want its sum? ");
scanf("%d",&x);
s=0;
for (i=1;i<=x;i++)
  { s=s+((float)pow(x,i)/(float)factorial(i)); }
printf("The sum of %d terms is %f",x,1+s);
fflush(stdin);
   getch();
}

long int factorial(int n)
{
  if (n<=1)
return(1);
  else
n=n*factorial(n-1);
return(n);
}

Square Root of a number by using simple calculations

2010-02-26T10:05:00.002-08:00

#include
#include
main()
{
  float a,b,e=0.00001,p,k;
  clrscr();
   textcolor(GREEN);
do {
   printf(" ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ
");
   printf(" xDB PROGRAM TO FIND SQUARE ROOT OF A NUMBERxDB
");
   printf(" ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ
");
   cprintf("
ENTER A NUMBER(-1 to Quit) :");
   scanf("%f",&k);

  a=k;p=a*a;
  while(p-k>=e)
   {
   b=(a+(k/a))/2;
   a=b;
   p=a*a;
   }
  printf("SQUARE ROOT IS = %f
",a);
  getch();
  clrscr();
}while(k!=-1);
  getch();
}

Program to find your Day of Birth given Date of Birth

2010-02-26T10:05:00.000-08:00

#include
#include
#include

main()
{
clrscr();
int d,m,y,year,month,day,i,n;
printf("Enter how many times you want to run this program : ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("

Enter the date : ");
scanf("%d%d%d",&d,&m,&y);
if( d>31 || m>12 || (y<1900 || y>=2000) )
  {
   printf("

INVALID INPUT
");
   getch();
   exit(0);
  }
year = y-1900;
year = year/4;
year = year+y-1900;
switch(m)
  {
   case 1:
   case 10:
month = 1;
break;
   case 2:
   case 3:
   case 11:
month = 4;
break;
   case 7:
   case 4:
month = 0;
break;
   case 5:
month = 2;
break;
   case 6:
month = 5;
break;
   case 8:
month = 3;
break;
   case 9:
   case 12:
month = 6;
break;
  }
year = year+month;
year = year+d;
day = year%7;
switch(day)
  {
   case 0:
printf("

Day is SATURDAY
");
break;
   case 1:
printf("

Day is SUNDAY
");
break;
   case 2:
printf("

Day is MONDAY
");
break;
   case 3:
printf("

Day is TUESDAY
");
break;
   case 4:
printf("

Day is WEDNESDAY
");
break;
   case 5:
printf("

Day is THURSDAY
");
break;
   case 6:
printf("

Day is FRIDAY
");
break;
  }
}
getch();
return 0;
}

Program to calculate Area of a Polygon

2010-02-26T10:04:00.000-08:00

/* Given the coordinates of the vertices of a convex polygon,
   calculate its area and perimeter. Subdivide it into triangles
   and calculate the area of each triangle with Heron's formula.
   Requires data file pvert.txt containing coordinates of each vertex.
   Example of data for a polygon with 5 vertices:

   3 7 6 4 3 -2 -6 1 -6 7
*/
#include
#include
#include
#define MAX_VERT 50
enum {x, y};
typedef struct triangle {
   double v1[2];
   double v2[2];
   double v3[2];
} triangle;
double area(triangle a);
double perimeter(double *vertices, int size);
double side(double *p1, double *p2);

int main(void)
{
  int n, idx;
  int triangles;
  int index;
  int xycount;
  double xy;
  double triangle_area;
  double polygon_area;
  double perim;
  double polygon_vertices[MAX_VERT] = {0.0};
  triangle a;
  FILE *data;

  xycount = 0;
  polygon_area = 0;
  if((data = fopen("pvert.txt", "r")) == NULL)
  {
   fprintf(stderr, "can't open data file
");
   exit(EXIT_FAILURE);
  }

  /* Read x-y coordinates of the vertices
   of the polygon from a file. */
  while(fscanf(data, "%lf", &xy) == 1)
   polygon_vertices[xycount++] = xy;
  fclose(data);
  idx = 0;
  /* triangles in polygon = vertices - 2 */
  triangles = (xycount / 2) - 2;
  putchar('
');

  for(index = 2, idx = 0; idx < triangles; index += 2, ++idx)
  {
  /* Load vertices of a triangle into struct.
   1st vertex of the polygon will be the 1st
   vertex of each triangle. index holds the
   starting index of each consecutive set of
   triangle vertices after the 1st. */
   a.v1[x] = polygon_vertices[0];
   a.v1[y] = polygon_vertices[1];
   a.v2[x] = polygon_vertices[index+0];
   a.v2[y] = polygon_vertices[index+1];
   a.v3[x] = polygon_vertices[index+2];
   a.v3[y] = polygon_vertices[index+3];

   /* calculate the area of the triangle */
   triangle_area = area(a);
   printf("area of triangle = %.2f
", triangle_area);

   /* add triangle area to polygon area */
   polygon_area += triangle_area;
  }
  printf("
area of polygon = %.2f
", polygon_area);

  /* calculate the perimeter of the polygon */
  perim = perimeter(polygon_vertices, xycount);
  printf("perimeter of polygon = %.2f
", perim);

  return 0;
}

/* calculate triangle area with Heron's formula */
double area(triangle a)
{
  double s1, s2, s3, S, area;

  s1 = side(a.v1, a.v2);
  s2 = side(a.v2, a.v3);
  s3 = side(a.v3, a.v1);
  S = (s1 + s2 + s3) / 2;
  area = sqrt(S*(S - s1)*(S - s2)*(S - s3));

  return area;
}

/* calculate polygon perimeter */
double perimeter(double *vertices, int size)
{
  int idx, jdx;
  double p1[2], p2[2], pfirst[2], plast[2];
  double perimeter;

  perimeter = 0.0;
  /* 1st vertex of the polygon */
  pfirst[x] = vertices[0];
  pfirst[y] = vertices[1];
  /* last vertex of polygon */
  plast[x] = vertices[size-2];
  plast[y] = vertices[size-1];
  /* calculate perimeter minus last side */
  for(idx = 0; idx <= size-3; idx += 2)
  {
   for(jdx = 0; jdx < 4; ++jdx)
   {
   p1[x] = vertices[idx];
   p1[y] = vertices[idx+1];
   p2[x] = vertices[idx+2];
   p2[y] = vertices[idx+3];
   }
   perimeter += side(p1, p2);
  }
  /* add last side */
  perimeter += side(plast, pfirst);

  return perimeter;
}

/* calculate length of side */
double side(double *p1, double *p2)
{
  double s1, s2, s3;

  s1 = (p1[x] - p2[x]);
  s2 = (p1[y] - p2[y]);
  s3 = (s1 * s1) + (s2 * s2);

  return sqrt(s3);
}

Program for Decimal to Roman Number conversion

2010-02-26T10:03:00.001-08:00

#include

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();
}

Progam that gives all details of a Triangle given the lengths of its sides

2010-02-26T10:02:00.001-08:00

#include
#include
#include
#include

main()
{
clrscr();
float a,b,c,S,D,A,B,C,Area,R;
printf("Enter the lengths of the three sides of the triangle :

");
scanf("%f%f%f",&a,&b,&c);

S = (a+b+c)/2.0; // S is the semiperimeter of the triangle
D = S*(S-a)*(S-b)*(S-c);//D is the square of the area of the triangle
if(D<=0)
{
  printf("
The triangle cannot be formed");
  getch();
  exit(0);
}

if((a==b || b==c || c==a) && !(a==b && b==c && c==a))
// this complex logic is to eliminate interpretting a triangle with all
three
// sides equal as both isosceles and equilateral.
   printf("
The triangle is ISOSCELES

");
if(a==b && b==c && c==a)
   printf("
The triangle is EQUILATERAL

");
if(a!=b && b!=c && c!=a)
  printf("
The triangle is SCALENE

");

Area = sqrt(D);
R = (a*b*c)/(4.0*Area);
printf("PERIMETER = %.2f units
",(2.0*S));
printf("AREA = %.2f sq.units
",Area);
printf("CIRCUM RADIUS = %.2f units
",R);
// using sine rule,we get...
A = (180.0/3.1415926)*asin(a/(2.0*R));// value of pi should be upto 7
B = (180.0/3.1415926)*asin(b/(2.0*R));// decimal places of accuracy and
also
C = (180.0/3.1415926)*asin(c/(2.0*R));// note that the 7th decimal place
is
// 6 and not 7 as it had to be if were
if(A==90.0 || B==90.0 || C==90.0) // approximated to 7 decimal
places
  printf("
The triangle is RIGHT ANGLED
");
if(A<90.0 && B<90.0 && C<90.0)
  printf("
The triangle is ACUTE ANGLED
");
if(A>90.0 || B>90.0 || C>90.0)
  printf("
The triangle is OBTUSE ANGLED
");

printf("
The angles are as follows :

");
printf("A = %.2f degrees
",A);
printf("B = %.2f degrees
",B);
printf("C = %.2f degrees
",C);
printf("
Where A,B,C stand for angles opposite to sides
%.2f,%.2f,%.2f",a,b,c);
printf(" respectively
");

getch();
return 0;
}

Circle Through Three Points

2010-02-26T10:01:00.001-08:00

#include
#include
#include

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;
}

Treesort [string array]

2010-02-25T09:29:00.001-08:00

#include

struct tnode {

char *str;

struct tnode *left;

struct tnode *right;

};

void insert(struct tnode **p, char *value);

void print(struct tnode *root);

int main(void) {

char line[1024];

struct tnode *root;

root = NULL;

while((fgets(line, 1024, stdin)) != NULL)

insert(&root, line);

print(root);

return 0;

}

/* call by reference .. ! */

void insert(struct tnode **p, char *value) {

if(!*p) {

p = (struct tnode )malloc(sizeof(struct tnode));

(p)->left = (p)->right = NULL;

(*p)->str = strdup(value);

return;

}

if(strcmp(value, (*p)->str) < 0)

insert(&(*p)->left, value);

else

insert(&(*p)->right, value);

}

/* inorder binary tree print ... */

void print(struct tnode *root) {

if(root != NULL) {

print(root->left);

printf("%s", root->str);

print(root->right);

}

Ssort, selection sort [array]

2010-02-25T09:28:00.003-08:00

#include

void selection_sort(int a[], int size);

int main(void) {
int arr[10] = {10, 2, 4, 1, 6, 5, 8, 7, 3, 9};
int i = 0;

printf("before:\n");
for(i = 0; i < 10; i++) printf("%d ", arr[i]);
printf("\n");

selection_sort(arr, 10);

printf("after:\n");
for(i = 0; i < 10; i++) printf("%d ", arr[i]);
printf("\n");

return 0;
}

void selection_sort(int a[], int size) {
int i = 0;
int j = 0;
int large = 0;
int index = 0;

for(i = size - 1; i > 0; i--) {
  large = a[0];
  index = 0;
  for(j = 1; j <= i; j++)
   if(a[j] > large) {
   large = a[j];
   index = j;
   }
   a[index] = a[i];
   a[i] = large;
}
}

Shsort, shell sort [array]

2010-02-25T09:28:00.001-08:00

#include

#define MAXARRAY 10

void shellsort(int a[], int total, int index);

int main(void) {
int array[MAXARRAY] = {0};
int i = 0;

/* load some random values into the array */
for(i = 0; i < MAXARRAY; i++)
  array[i] = rand() % 100;

/* print the original array */
printf("Before shellsort: ");
for(i = 0; i < MAXARRAY; i++) {
  printf(" %d ", array[i]);
}
printf("\n");

shellsort(array, MAXARRAY, 1);

/* print the `shellsorted' array */
printf("After shellsort: ");
for(i = 0; i < MAXARRAY; i++) {
  printf(" %d ", array[i]);
}
printf("\n");

return 0;
}

void shellsort(int a[], int total, int index) {
int i = 0;
int j = 0;
int k = 0;
int l = 0;

for(k = 0; k < index; k++) {
  for(i = k; i < total; i += index) {
   l = a[i];
   for(j = (i - index); j >= 0; j -= index) {
   if(a[j] > l)
   a[j + index] = a[j];
   else
   break;
   }
   a[j + index] = l;
  }
}

return;
}

Selection sort [linked list]

2010-02-25T09:27:00.003-08:00

#include
#include

#define MAX 10

struct lnode {
int data;
struct lnode *next;
} *head, *visit;

/* add a new entry to the linked list */
void llist_add(struct lnode **q, int num);
/* preform a selection sort on the linked list */
void llist_selection_sort(void);
/* print the entire linked list */
void llist_print(void);

int main(void) {
/* linked list */
struct lnode *newnode = NULL;
int i = 0; /* a general counter */

/* load some random values into the linked list */
for(i = 0; i < MAX; i++) {
  llist_add(&newnode, (rand() % 100));
}

head = newnode;
printf("Before selection sort:\n");
llist_print();
printf("After selection sort:\n");
llist_selection_sort();
llist_print();

return 0;
}

/* adds a node at the end of a linked list */
void llist_add(struct lnode **q, int num) {
struct lnode *temp;

temp = *q;

/* if the list is empty, create first node */
if(*q == NULL) {
  *q = malloc(sizeof(struct lnode));
   temp = *q;
} else {
  /* go to last node */
  while(temp->next != NULL)
   temp = temp->next;

   /* add node at the end */
   temp->next = malloc(sizeof(struct lnode));
   temp = temp->next;
}

/* assign data to the last node */
temp->data = num;
temp->next = NULL;
}

/* print the entire linked list */
void llist_print(void) {
visit = head;

/* traverse the entire linked list */
while(visit != NULL) {
  printf("%d ", visit->data);
  visit = visit->next;
}
printf("\n");
}

void llist_selection_sort(void) {
struct lnode *a = NULL;
struct lnode *b = NULL;
struct lnode *c = NULL;
struct lnode *d = NULL;
struct lnode *tmp = NULL;

a = c = head;
while(a->next != NULL) {
  d = b = a->next;
  while(b != NULL) {
   if(a->data > b->data) {
   /* neighboring linked list node */
   if(a->next == b) {
   if(a == head) {
   a->next = b->next;
   b->next = a;
   tmp = a;
   a = b;
   b = tmp;
   head = a;
   c = a;
   d = b;
   b = b->next;
   } else {
   a->next = b->next;
   b->next = a;
   c->next = b;
   tmp = a;
   a = b;
   b = tmp;
   d = b;
   b = b->next;
   }
   } else {
   if(a == head) {
   tmp = b->next;
   b->next = a->next;
   a->next = tmp;
   d->next = a;
   tmp = a;
   a = b;
   b = tmp;
   d = b;
   b = b->next;
   head = a;
   } else {
   tmp = b->next;
   b->next = a->next;
   a->next = tmp;
   c->next = b;
   d->next = a;
   tmp = a;
   a = b;
   b = tmp;
   d = b;
   b = b->next;
   }
   }
  } else {
   d = b;
   b = b->next;
  }
}
  c = a;
  a = a->next;
}
}

Qsort [string, dynamic pointer array]

2010-02-25T09:27:00.001-08:00

#include
#include
#include

void sortstrarr(void *array, unsigned n);
static int cmpr(const void *a, const void *b);

int main (void) {
char **strarray = NULL;
int i = 0, strcount = 0;
char line[1024];

while((fgets(line, 1024, stdin)) != NULL) {
  if(strlen(line) == 1)
   continue;

  strarray = (char **)realloc(strarray, (strcount + 1) * sizeof(char *));
  strarray[strcount++] = strdup(line);
}

printf("### Before ###\n");
for(i = 0; i < strcount; i++)
  printf("%2d: %s", i, strarray[i]);

sortstrarr(strarray, strcount);

printf("### After ###\n");
for(i = 0; i < strcount; i++)
  printf("%2d: %s", i, strarray[i]);

/* free mem... */
for(i = 0; i < strcount; i++)
  free(strarray[i]);

free(strarray);
return 0;
}

static int cmpr(const void *a, const void *b) {
return strcmp(*(char **)a, *(char **)b);
}

void sortstrarr(void *array, unsigned n) {
qsort(array, n, sizeof(char *), cmpr);
}

Qsort [string array]

2010-02-25T09:26:00.002-08:00

#include
#include
#include

void sortstrarr(void *array, unsigned n);
static int cmpr(const void *a, const void *b);

int main(void) {
char line[1024];
char *line_array[1024];
int i = 0;
int j = 0;

while((fgets(line, 1024, stdin)) != NULL)
  if(i < 1024)
   line_array[i++] = strdup(line);
  else
   break;

sortstrarr(line_array, i);

while(j < i)
  printf("%s", line_array[j++]);

return 0;
}

static int cmpr(const void *a, const void *b) {
return strcmp(*(char **)a, *(char **)b);
}

void sortstrarr(void *array, unsigned n) {
qsort(array, n, sizeof(char *), cmpr);
}

Qsort [array of pointers to structures]

2010-02-25T09:26:00.000-08:00

#include
#include
#include

struct node {
char *str;
};

/* compare function for qsort */
static int cmpr(const void *a, const void *b);

int main(void) {
struct node **strarray = NULL;
int i = 0, count = 0;
char line[1024];

while(fgets(line, 1024, stdin) != NULL) {
  /* add ONE element to the array */
  strarray = (struct node **)realloc(strarray, (count + 1) * sizeof(struct node *));

  /* allocate memory for ONE `struct node` */
  strarray[count] = (struct node *)malloc(sizeof(struct node));

  /* copy the data into the new element (structure) */
  strarray[count]->str = strdup(line);
  count++;
}

/* before sorting ... */
printf("Before:\n");
for(i = 0; i < count; i++) {
  printf("[%d]->str: %s", i, strarray[i]->str);
}

/* qsort array of structures */
qsort(strarray, count, sizeof(*strarray), cmpr);

/* after sorting ... */
printf("\n--\nAfter:\n");
for(i = 0; i < count; i++) {
  printf("[%d]->str: %s", i, strarray[i]->str);
}

/* free all strarray elements */
for(i = 0; i < count; i++) {
  free(strarray[i]->str);
  free(strarray[i]);
  i++;
}
free(strarray);

return 0;
}

/* compare function for qsort */
static int cmpr(const void *a, const void *b) {
struct node * const *one = a;
struct node * const *two = b;

return strcmp((*one)->str, (*two)->str);
}

Qcksort, quick sort [array]

2010-02-25T09:25:00.001-08:00

#include

#define MAXARRAY 10

void quicksort(int arr[], int low, int high);

int main(void) {
int array[MAXARRAY] = {0};
int i = 0;

/* load some random values into the array */
for(i = 0; i < MAXARRAY; i++)
  array[i] = rand() % 100;

/* print the original array */
printf("Before quicksort: ");
for(i = 0; i < MAXARRAY; i++) {
  printf(" %d ", array[i]);
}
printf("\n");

quicksort(array, 0, (MAXARRAY - 1));

/* print the `quicksorted' array */
printf("After quicksort: ");
for(i = 0; i < MAXARRAY; i++) {
  printf(" %d ", array[i]);
}
printf("\n");

return 0;
}

/* sort everything inbetween `low' <-> `high' */
void quicksort(int arr[], int low, int high) {
int i = low;
int j = high;
int y = 0;
/* compare value */
int z = arr[(low + high) / 2];

/* partition */
do {
  /* find member above ... */
  while(arr[i] < z) i++;

  /* find element below ... */
  while(arr[j] > z) j--;

  if(i <= j) {
   /* swap two elements */
   y = arr[i];
   arr[i] = arr[j];
   arr[j] = y;
   i++;
   j--;
  }
} while(i <= j);

/* recurse */
if(low < j)
  quicksort(arr, low, j);

if(i < high)
  quicksort(arr, i, high);
}

No sort, but reversing a [linked list]

2010-02-25T09:24:00.003-08:00

#include
#include

#define MAX 10 /* max of 10 elements */

struct lnode {
int number;
struct lnode *next;
};

/* add a lnode at the beginning of the list */
void llist_add_begin(struct lnode **n, int val);
/* reverse the whole list */
void llist_reverse(struct lnode **n);
/* display the whole linked list */
void llist_display(struct lnode *n);

int main(void) {
struct lnode *new = NULL;
int i = 0;

/* insert some numbers */
for(i = 0; i <= MAX; i++)
  llist_add_begin(&new, i);

printf("linked list before reversal:");
llist_display(new);
llist_reverse(&new);
printf("linked list after reversal:");
llist_display(new);

return 0;
}

/* add a lnode at the beginning of the list */
void llist_add_begin(struct lnode **n, int val) {
struct lnode *temp = NULL;

/* add new node */
temp = malloc(sizeof(struct lnode));
temp->number = val;
temp->next = *n;
*n = temp;
}

/* reverse the whole list */
void llist_reverse(struct lnode **n) {
struct lnode *a = NULL;
struct lnode *b = NULL;
struct lnode *c = NULL;
a = *n, b = NULL;

while(a != NULL) {
  c = b, b = a, a = a->next;
  b->next = c;
}

*n = b;
}

/* display the whole linked list */
void llist_display(struct lnode *n) {
while(n != NULL)
  printf(" %d", n->number), n = n->next;

printf("\n");
}

Msort, merge sort [array]

2010-02-25T09:24:00.001-08:00

#include
#include

#define MAXARRAY 10

void mergesort(int a[], int low, int high);

int main(void) {
int array[MAXARRAY];
int i = 0;

/* load some random values into the array */
for(i = 0; i < MAXARRAY; i++)
  array[i] = rand() % 100;

/* array before mergesort */
printf("Before :");
for(i = 0; i < MAXARRAY; i++)
  printf(" %d", array[i]);

printf("\n");

mergesort(array, 0, MAXARRAY - 1);

/* array after mergesort */
printf("Mergesort :");
for(i = 0; i < MAXARRAY; i++)
  printf(" %d", array[i]);

printf("\n");
return 0;
}

void mergesort(int a[], int low, int high) {
int i = 0;
int length = high - low + 1;
int pivot = 0;
int merge1 = 0;
int merge2 = 0;
int working[length];

if(low == high)
  return;

pivot = (low + high) / 2;

mergesort(a, low, pivot);
mergesort(a, pivot + 1, high);

for(i = 0; i < length; i++)
  working[i] = a[low + i];

merge1 = 0;
merge2 = pivot - low + 1;

for(i = 0; i < length; i++) {
  if(merge2 <= high - low)
   if(merge1 <= pivot - low)
   if(working[merge1] > working[merge2])
   a[i + low] = working[merge2++];
   else
   a[i + low] = working[merge1++];
   else
   a[i + low] = working[merge2++];
  else
   a[i + low] = working[merge1++];
}
}

Merge sort [linked list]

2010-02-25T09:23:00.000-08:00

#include

struct node {

int number;

struct node *next;

};

/* add a node to the linked list */

struct node *addnode(int number, struct node *next);

/* preform merge sort on the linked list */

struct node *mergesort(struct node *head);

/* merge the lists.. */

struct node *merge(struct node *head_one, struct node *head_two);

int main(void) {

struct node *head;

struct node *current;

struct node *next;

int test[] = {8, 3, 2, 6, 1, 5, 4, 7, 9, 0};

int i;

head = NULL;

/* insert some numbers into the linked list */

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

head = addnode(test[i], head);

/* sort the list */

head = mergesort(head);

/* print the list */

printf(" before after\n"), i = 0;

for(current = head; current != NULL; current = current->next)

printf("%4d\t%4d\n", test[i++], current->number);

/* free the list */

for(current = head; current != NULL; current = next)

next = current->next, free(current);

/* done... */

return 0;

}

/* add a node to the linked list */

struct node *addnode(int number, struct node *next) {

struct node *tnode;

tnode = (struct node*)malloc(sizeof(*tnode));

if(tnode != NULL) {

tnode->number = number;

tnode->next = next;

}

return tnode;

}

/* preform merge sort on the linked list */

struct node *mergesort(struct node *head) {

struct node *head_one;

struct node *head_two;

if((head == NULL) || (head->next == NULL))

return head;

head_one = head;

head_two = head->next;

while((head_two != NULL) && (head_two->next != NULL)) {

head = head->next;

head_two = head->next->next;

}

head_two = head->next;

head->next = NULL;

return merge(mergesort(head_one), mergesort(head_two));

}

/* merge the lists.. */

struct node *merge(struct node *head_one, struct node *head_two) {

struct node *head_three;

if(head_one == NULL)

return head_two;

if(head_two == NULL)

return head_one;

if(head_one->number < head_two->number) {

head_three = head_one;

head_three->next = merge(head_one->next, head_two);

} else {

head_three = head_two;

head_three->next = merge(head_one, head_two->next);

}

return head_three;

}

Isort, insertion sort [array]

2010-02-25T09:22:00.001-08:00

#include

void isort(float arr[], int n);
int fm(float arr[], int b, int n);

int main(void) {
float arr1[5] = {4.3, 6.7, 2.8, 8.9, 1.0};
float arr2[5] = {4.3, 6.7, 2.8, 8.9, 1.0};
int i = 0;

isort(arr2, 5);

printf("\nBefore\tAfter\n--------------\n");

for(i = 0; i < 5; i++)
  printf("%.2f\t%.2f\n", arr1[i], arr2[i]);

return 0;
}

int fm(float arr[], int b, int n) {
int f = b;
int c;

for(c = b + 1; c < n; c++)
  if(arr[c] < arr[f])
   f = c;

return f;
}

void isort(float arr[], int n) {
int s, w;
float sm;

for(s = 0; s < n - 1; s++) {
  w = fm(arr, s, n);
  sm = arr[w];
  arr[w] = arr[s];
  arr[s] = sm;
}
}

Insertion sort [linked list]

2010-02-25T09:21:00.002-08:00

#include
#include
#include

struct lnode {
char *str;
struct lnode *next;
};

struct lnode *insert(char *data, struct lnode *list);
void free_list(struct lnode *list);
void print_list(struct lnode *list);

int main(void) {
char line[1024];
struct lnode *list;

list = NULL;
while((fgets(line, 1024, stdin)) != NULL)
  list = insert(line, list);

print_list(list);
free_list(list);
return 0;
}

struct lnode *insert(char *data, struct lnode *list) {
struct lnode *p;
struct lnode *q;

/* create a new node */
p = (struct lnode *)malloc(sizeof(struct lnode));
/* save data into new node */
p->str = strdup(data);

/* first, we handle the case where `data' should be the first element */
if(list == NULL || strcmp(list->str, data) > 0) {
  /* apperently this !IS! the first element */
  /* now data should [be|becomes] the first element */
  p->next = list;
  return p;
} else {
  /* search the linked list for the right location */
  q = list;
  while(q->next != NULL && strcmp(q->next->str, data) < 0) {
   q = q->next;
  }
  p->next = q->next;
  q->next = p;
  return list;
}
}

void free_list(struct lnode *list) {
struct lnode *p;

while(list != NULL) {
  p = list->next;
  free(list);
  list = p;
}
}

void print_list(struct lnode *list) {
struct lnode *p;

for(p = list; p != NULL; p = p->next)
  printf("%s", p->str);
}

Hsort, heap sort [array]

2010-02-25T09:21:00.000-08:00

#include
#include

/* array of MAXARRAY length ... */
#define MAXARRAY 5

/* preform the heapsort */
void heapsort(int ar[], int len);
/* help heapsort() to bubble down starting at pos[ition] */
void heapbubble(int pos, int ar[], int len);

int main(void) {
int array[MAXARRAY];
int i = 0;

/* load some random values into the array */
for(i = 0; i < MAXARRAY; i++)
  array[i] = rand() % 100;

/* print the original array */
printf("Before heapsort: ");
for(i = 0; i < MAXARRAY; i++) {
  printf(" %d ", array[i]);
}
printf("\n");

heapsort(array, MAXARRAY);

/* print the `heapsorted' array */
printf("After heapsort: ");
for(i = 0; i < MAXARRAY; i++) {
  printf(" %d ", array[i]);
}
printf("\n");

return 0;
}

void heapbubble(int pos, int array[], int len) {
int z = 0;
int max = 0;
int tmp = 0;
int left = 0;
int right = 0;

z = pos;
for(;;) {
  left = 2 * z + 1;
  right = left + 1;

  if(left >= len)
   return;
  else if(right >= len)
   max = left;
  else if(array[left] > array[right])
   max = left;
  else
   max = right;

  if(array[z] > array[max])
   return;

  tmp = array[z];
  array[z] = array[max];
  array[max] = tmp;
  z = max;
}
}

void heapsort(int array[], int len) {
int i = 0;
int tmp = 0;

for(i = len / 2; i >= 0; --i)
  heapbubble(i, array, len);

for(i = len - 1; i > 0; i--) {
  tmp = array[0];
  array[0] = array[i];
  array[i] = tmp;
  heapbubble(0, array, i);
}
}

Bubble sort [string array]

2010-02-25T09:20:00.002-08:00

#include
#include
#include

#define MAX 50
#define N 2000

void sort_words(char *x[], int y);
void swap(char **, char **);

int main(void) {
char word[MAX];
char *x[N];
int n = 0;
int i = 0;

for(i = 0; scanf("%s", word) == 1; ++i) {
  if(i >= N)
   printf("Limit reached: %d\n", N), exit(1);

  x[i] = calloc(strlen(word)+1, sizeof(char));
  strcpy(x[i], word);
}

n = i;
sort_words(x, n);
  for(i = 0; i < n; ++i)
   printf("%s\n", x[i]);

  return(0);
}

void sort_words(char *x[], int y) {
int i = 0;
int j = 0;

for(i = 0; i < y; ++i)
  for(j = i + 1; j < y; ++j)
   if(strcmp(x[i], x[j]) > 0)
   swap(&x[i], &x[j]);
}

void swap(char **p, char **q) {
char *tmp;

tmp = *p;
*p = *q;
*q = tmp;
}

Bubble sort [linked list]

2010-02-25T09:20:00.000-08:00

#include
#include

#define MAX 10

struct lnode {
int data;
struct lnode *next;
} *head, *visit;

/* add a new entry to the linked list */
void llist_add(struct lnode **q, int num);
/* preform a bubble sort on the linked list */
void llist_bubble_sort(void);
/* print the entire linked list */
void llist_print(void);

int main(void) {
/* linked list */
struct lnode *newnode = NULL;
int i = 0; /* a general counter */

/* load some random values into the linked list */
for(i = 0; i < MAX; i++) {
  llist_add(&newnode, (rand() % 100));
}

head = newnode;
printf("Before bubble sort:\n");
llist_print();
printf("After bubble sort:\n");
llist_bubble_sort();
llist_print();

return 0;
}

/* adds a node at the end of a linked list */
void llist_add(struct lnode **q, int num) {
struct lnode *tmp;

tmp = *q;

/* if the list is empty, create first node */
if(*q == NULL) {
  *q = malloc(sizeof(struct lnode));
   tmp = *q;
} else {
  /* go to last node */
  while(tmp->next != NULL)
   tmp = tmp->next;

   /* add node at the end */
   tmp->next = malloc(sizeof(struct lnode));
   tmp = tmp->next;
}

/* assign data to the last node */
tmp->data = num;
tmp->next = NULL;
}

/* print the entire linked list */
void llist_print(void) {
visit = head;

while(visit != NULL) {
  printf("%d ", visit->data);
  visit = visit->next;
}
printf("\n");
}

/* preform a bubble sort on the linked list */
void llist_bubble_sort(void) {
struct lnode *a = NULL;
struct lnode *b = NULL;
struct lnode *c = NULL;
struct lnode *e = NULL;
struct lnode *tmp = NULL;

/*
// the `c' node precedes the `a' and `e' node
// pointing up the node to which the comparisons
// are being made.
*/
while(e != head->next) {
c = a = head;
b = a->next;
  while(a != e) {
   if(a->data > b->data) {
   if(a == head) {
   tmp = b -> next;
   b->next = a;
   a->next = tmp;
   head = b;
   c = b;
   } else {
   tmp = b->next;
   b->next = a;
   a->next = tmp;
   c->next = b;
   c = b;
   }
   } else {
   c = a;
   a = a->next;
   }
   b = a->next;
   if(b == e)
   e = a;
  }
}
}

sort, bubble sort [array]

2010-02-25T09:19:00.001-08:00

#include

void bubble_sort(int a[], int size);

int main(void) {
int arr[10] = {10, 2, 4, 1, 6, 5, 8, 7, 3, 9};
int i = 0;

printf("before:\n");
for(i = 0; i < 10; i++) printf("%d ", arr[i]);
printf("\n");

bubble_sort(arr, 10);

printf("after:\n");
for(i = 0; i < 10; i++) printf("%d ", arr[i]);
printf("\n");

return 0;
}

void bubble_sort(int a[], int size) {
int switched = 1;
int hold = 0;
int i = 0;
int j = 0;

size -= 1;

for(i = 0; i < size && switched; i++) {
  switched = 0;
  for(j = 0; j < size - i; j++)
   if(a[j] > a[j+1]) {
   switched = 1;
   hold = a[j];
   a[j] = a[j + 1];
   a[j + 1] = hold;
   }
}
}

Binary search [string pointer array]

2010-02-25T09:18:00.002-08:00

#include
#include

static int binsearch(char *str[], int max, char *value);

int main(void) {
/* note, array needs to be sorted for bsearch... */
char *strings[] = { "bill", "chris", "jason", "randy", "trish" };
int i, asize, result;

i = asize = result = 0;

asize = sizeof(strings) / sizeof(strings[0]);

for(i = 0; i < asize; i++)
  printf("%d: %s\n", i, strings[i]);

printf("\n");

if((result = binsearch(strings, asize, "randy")) != 0)
  printf("`randy' found at position: %d\n", result);
else
  printf("`randy' NOT found..\n");

if((result = binsearch(strings, asize, "nick")) != 0)
  printf("`nick' found at %d\n", result);
else
  printf("`nick' was NOT found..\n");

return 0;
}

static int binsearch(char *str[], int max, char *value) {
int position;
int begin = 0;
int end = max - 1;
int cond = 0;

while(begin <= end) {
  position = (begin + end) / 2;
  if((cond = strcmp(str[position], value)) == 0)
   return position;
  else if(cond < 0)
   begin = position + 1;
  else
   end = position - 1;
}

return 0;
}

Binary search [int array]

2010-02-25T09:18:00.000-08:00

#include

#define TRUE 0
#define FALSE 1

int main(void) {
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int left = 0;
int right = 10;
int middle = 0;
int number = 0;
int bsearch = FALSE;
int i = 0;

printf("ARRAY: ");
for(i = 1; i <= 10; i++)
  printf("[%d] ", i);

printf("\nSearch for Number: ");
scanf("%d", &number);

while(bsearch == FALSE && left <= right) {
  middle = (left + right) / 2;

  if(number == array[middle]) {
   bsearch = TRUE;
   printf("** Number Found **\n");
  } else {
   if(number < array[middle]) right = middle - 1;
   if(number > array[middle]) left = middle + 1;
  }
}

if(bsearch == FALSE)
  printf("-- Number Not found --\n");

return 0;
}

2d example insertion sort [linked list]

2010-02-25T09:16:00.000-08:00

#include
#include

struct node {
int number;
struct node *next;
};

struct node *head = NULL;

/* insert a node directly at the right place in the linked list */
void insert_node(int value);

int main(void) {
struct node *current = NULL;
struct node *next = NULL;
int test[] = {8, 3, 2, 6, 1, 5, 4, 7, 9, 0};
int i = 0;

/* insert some numbers into the linked list */
for(i = 0; i < 10; i++)
  insert_node(test[i]);

/* print the list */
printf(" before after\n"), i = 0;
while(head->next != NULL) {
  printf("%4d\t%4d\n", test[i++], head->number);
  head = head->next;
}

/* free the list */
for(current = head; current != NULL; current = next)
  next = current->next, free(current);

return 0;
}

void insert_node(int value) {
struct node *temp = NULL;
struct node *one = NULL;
struct node *two = NULL;

if(head == NULL) {
  head = (struct node *)malloc(sizeof(struct node *));
  head->next = NULL;
}

one = head;
two = head->next;

temp = (struct node *)malloc(sizeof(struct node *));
temp->number = value;

while(two != NULL && temp->number < two->number) {
  one = one->next;
  two = two->next;
}

one->next = temp;
temp->next = two;
}

XOR list example

2010-02-25T09:06:00.002-08:00

#include
#include
#include

struct xnode {
int data;
unsigned long direction;
};

struct xnode *add_data(int data, struct xnode* list);
void walk_list(struct xnode *list);

int main(void) {

struct xnode *l2 = add_data(2, NULL);
struct xnode *l1 = add_data(1, l2);
struct xnode *l3 = add_data(3, l2);
struct xnode *l4 = add_data(4, l3);

printf("front -> back....\n");
walk_list(l1);
printf("back -> front....\n");
walk_list(l4);

return 0;
}

struct xnode *add_data(int data, struct xnode *list) {
struct xnode *newxnode = malloc(sizeof(struct xnode));

assert(newxnode);
newxnode->direction = (unsigned long)list;
newxnode->data = data;

if(list != NULL)
  list->direction ^= (unsigned long)newxnode;

return newxnode;
}

void walk_list(struct xnode *list) {
unsigned long prev = 0;

while(list != NULL) {
  unsigned long next = prev ^ list->direction;
  printf("%d ", list->data);
  prev = (unsigned long)list;
  list = (struct xnode *)next;
}

printf("\n");
}

Program for demonstration of Tree Operations - INSERTION . INORDER

2010-02-25T09:06:00.000-08:00

# include
# include
# include

struct node
{
struct node *left;
int data;
struct node *right;
} ;

void main()
{
void insert(struct node **,int);
void inorder(struct node *);
void postorder(struct node *);
void preorder(struct node *);
struct node *ptr;
int will,i,num;
ptr = NULL;
ptr->data=NULL;
clrscr();

printf("
Enter the number of terms you want to add to the tree.
");
scanf("%d",&will);

/* Getting Input */
for(i=0;i
{
printf("
Enter the item");
scanf("%d",&num);
insert(&ptr,num);
}

getch();
printf("

INORDER TRAVERSAL

");
inorder(ptr);
getch();
printf("

PREORDER TRAVERSAL

");
preorder(ptr);
getch();
printf("

POSTORDER TRAVERSAL

");
postorder(ptr);
getch();
}

void insert(struct node **p,int num)
{

if((*p)==NULL)
{ printf("
Leaf node created.");
(*p)=malloc(sizeof(struct node));
(*p)->left = NULL;
(*p)->right = NULL;
(*p)->data = num;
return;
}
else
{ if(num==(*p)->data)
{
printf("

REPEATED ENTRY ERROR
VALUE REJECTED

");
return;
}
if(num<(*p)->data)
{
printf("
Directed to left link.");
insert(&((*p)->left),num);
}
else
{
printf("
Directed to right link.");
insert(&((*p)->right),num);
}
}
return;
}

void inorder(struct node *p)
{
if(p!=NULL)
{
inorder(p->left);
printf("
Data :%d",p->data);
inorder(p->right);
}
else
return;
}

void preorder(struct node *p)
{
if(p!=NULL)
{
printf("
Data :%d",p->data);
preorder(p->left);
preorder(p->right);
}
else
return;
}

void postorder(struct node *p)
{
if(p!=NULL)
{
postorder(p->left);
postorder(p->right);
printf("
Data :%d",p->data);
}
else
return;
}

To Sort Elements Of The Array Using Quick Sort Algorithm

2010-02-25T09:05:00.002-08:00

#include
#include
#define max 15
int beg,end,top,i,n,loc,left,right;
int array[max+1]; //contains the various elements.
int upper[max-1],lower[max-1];
//two stacks to store two ends of the list.

void main()
{

void enter(void);
void quick(void);
void prnt(void);
clrscr();
enter(); //entering elements in the array
top=i-1; //set top to stack
if (top==0)
{
printf("
UNDERFLOW CONDITION ");
getch();
exit();
}
top=0;
if(n>1)
{
top++;
lower[top]=1;upper[top]=n;
while ( top!=NULL )
{
beg=lower[top];
end=upper[top];
top--;
left=beg; right=end; loc=beg;
quick();
if ( beg
{
top++;
lower[top]=beg;
upper[top]=loc-1;
}
if(loc+1
{
top++;
lower[top]=loc+1;
upper[top]=end;
}
} //end of while
} //end of if statement
printf("
Sorted elements of the array are :");
prnt(); //to print the sorted array
getch();
} //end of main

  void enter(void)
   {
printf("
Enter the no of elements in the array:");
scanf("%d",&n);
printf("
Enter the elements of the array :");
for(i=1;i<=n;i++)
{
printf("
Enter the %d element :",i);
scanf("%d",&array[i]);
}
   }

   void prnt(void)
   {
for(i=1;i<=n;i++)
{
printf("
The %d element is : %d",i,array[i]);
}
   }

   void quick()
   {
int temp;
void tr_fr_right(void);
while( array[loc]<=array[right] && loc!=right)
{
right--;
}

if(loc==right)
return ;

if(array[loc]>array[right])
{
temp=array[loc];
array[loc]=array[right];
array[right]=temp;
loc=right;
tr_fr_right();
}
return ;
   }

   void tr_fr_right()
   {
int temp;
while( array[loc] > array[left] && loc!=left)
{
left++;
}

if(loc==left)
return ;

if(array[loc] < array[left])
{
temp=array[loc];
array[loc]=array[left];
array[left]=temp;
loc=left;
quick();
}
return ;
   }

Self-referential structure, example from K and R

2010-02-25T09:05:00.000-08:00

#include
#include
#include
#include
#include

#define MAXWORD 100
#define BUFSIZE 100

struct tnode { /* the tree node: */
char *word; /* points to the text */
int count; /* number of occurrences */
struct tnode *left; /* left child */
struct tnode *right; /* right child */
};

struct tnode *addtree(struct tnode *, char *);
struct tnode *talloc(void);
void treeprint(struct tnode *);
void ungetch(int);
int getword(char *, int);
int getch(void);

char buf[BUFSIZE]; /* buffer for ungetch */
int bufp = 0; /* next free position in buf */


int main(void) { /* word frequency count */
struct tnode *root;
char word[MAXWORD];

root = NULL;
while(getword(word, MAXWORD) != EOF)
  if(isalpha(word[0]))
   root = addtree(root, word);

treeprint(root);
exit(0);
}

   /* getword: get next word or character from input */
int getword(char *word, int lim) {
int c, getch(void);
void ungetch(int);
char *w = word;

while(isspace(c = getch()))
  ;
if(c != EOF)
  *w++ = c;
if(!isalpha(c)) {
  *w = '\0';
  return c;
}
for(; --lim > 0; w++)
  if(!isalnum(*w = getch())) {
   ungetch(*w);
   break;
  }
*w = '\0';
return word[0];
}

   /* addtree: add a node with w, at or below p */
struct tnode *addtree(struct tnode *p, char *w) {
int cond;

if(p == NULL) { /* a new word has arrived */
  p = talloc(); /* make a new node */
  p->word = strdup(w);
  p->count = 1;
  p->left = p->right = NULL;
} else if((cond = strcmp(w, p->word)) == 0)
  p->count++; /* repeated word */
else if(cond < 0) /* less than into left subtree */
  p->left = addtree(p->left, w);
else /* greater than into right subtree */
  p->right = addtree(p->right, w);

return p;
}

   /* talloc: make a tnode */
struct tnode *talloc(void) {
return(struct tnode *)malloc(sizeof(struct tnode));
}

   /* treeprint: in-order print of tree p */
void treeprint(struct tnode *p) {
if(p != NULL) {
  treeprint(p->left);
  printf("%4d %s\n", p->count, p->word);
  treeprint(p->right);
}
}

int getch(void) {
return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c) {
if(bufp >= BUFSIZE)
  printf("ungetch: too many characters\n");
else
  buf[bufp++] = c;
}

Search An Element in Linked List

2010-02-25T09:04:00.002-08:00

#include
#include
#include
struct linlst
{
  int info;
  struct link *next;
}
start, *node;

int search(int);
void main()
{
  int no,i,item,pos;
  clrscr();
  start.next=NULL;
  node=&start;
  printf("How many nodes, you want in linked list? ");
   scanf("%d",&no);
   printf("
");
   for(i=0;i
   {
   node->next=(struct linlst *)malloc(sizeof(struct linlst));
   printf("Enter element in node %d: ",i+1);
   scanf("%d",&node->info);
   node=node->next;
   }
   node->next=NULL;
   printf("
Linked list(only with info field) is:
");

   node=&start;
   while(node->next!=NULL)
   {
   printf("%d ",node->info);
   node=node->next;
   }
printf("

Enter item to be searched : ");
scanf("%d",&item);
pos=search(item);
if(pos<=no)
  printf("

Your item is at node %d",pos);
else
  printf("
Sorry! item is no in linked list.a");
getch();
}

int search(int item)
{
  int n=1;
  node=&start;
  while(node->next!=NULL)
   {
   if(node->info==item)
   break;
   else
   n++;
   node=node->next;
   }
return n;
}

Reversal of a singly linklist by recursion

2010-02-25T09:04:00.000-08:00

#include
#include
#include
struct node
   {
   int data;
   struct node*next;
   };
void insert(struct node**p,int num) /*Function for inserting an
element into a list */
{
   if(*p==NULL)
   {
   (*p)=(struct node*)malloc(sizeof(struct node));
   (*p)->next=NULL;
   (*p)->data=num;
   }
   else
   {
   insert(&((*p)->next),num);
   }
}
void display(struct node*p) /*Function for displaying the list*/
{
   while(p!=NULL)
   {
   printf("%d ",p->data);
   p=p->next;
   }
}
void reverse(struct node**p) /*Function for reversing the list by
recursion */
{
   struct node*q,*r,*x;
   int d;
   q=(*p); /*stores the address of the first element */
   x=q; /*also stores the element of the first element for
counter pourpose */
   d=q->data; /*stores the data of the first element*/
   r=q->next; /*stores the address of the second element in the list
*/
   free(q); /*deletes the first element of the list*/
   if(x==NULL)
   return ;
   else
   {
   reverse(&(r));/*Recursive call*/
   insert(p,d); /*This function is put in the stack so the first
   will be taken as last element for the new list */
   }
}
void main()
{
  clrscr();
  struct node*p=NULL;
  int n,d,i=0;
   printf("How many...? ");
   scanf("%d",&n);
   while(i++!=n)
   {
   scanf("%d",&d);
   insert(&p,d);
   }
  display(p);
  reverse(&p);
  printf("
The reversed list is...");
  display(p);
  getch();
}

Rat in a Maze Game implemented in C

2010-02-25T09:03:00.002-08:00

#include
#include
#define SIZE 15
#include
void main()
{
int maze[SIZE][SIZE],mark[SIZE][SIZE],stack[SIZE][3];
static int
move[8][2]={-1,0,-1,1,0,1,1,1,1,0,1,-1,0,-1,-1,-1};

int i,j,m,n,top,mov,g,h;
clrscr();
printf("enter size");
scanf("%d%d",&m,&n);
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{
scanf("%d",&maze[i][j]);
}
}
for(i=0;i<=n+1;i++)
maze[0][i]=1;
for(i=0;i<=n+1;i++)
maze[m+1][i]=1;
for(i=0;i<=m+1;i++)
maze[i][0]=1;
for(i=0;i<=m+1;i++)
maze[i][n+1]=1;
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{
mark[i][j]=0;
}
}
mark[1][1]=1;
stack[0][0]=1;
stack[0][1]=1;
stack[0][2]=2;
top=1;
while(top!=0)
{
i=stack[0][0];
j=stack[0][1];
mov=stack[0][2];
top=top-1;
while(mov<=7)
{
g=i+move[mov][0];
h=j+move[mov][1];

if(mark[g][h]==0&&maze[g][h]==0)
{
mark[g][h]=1;
top++;
stack[top][0]=i;
stack[top][1]=j;
mov=-1;
i=g;j=h;
}
mov=mov+1;
if(g==m&&h==n)
{
printf("
path made by the rat is");
for(i=1;i<=top;i++)
printf("
%d %d",stack[i][0],stack[i][1]);
printf("
%d %d",m,n);
getch();
exit(0);
}
}
}
}

Queue implementation using single linkedlist

2010-02-25T09:03:00.000-08:00

#include
#include
struct node
{
int n;
struct node* next;
};
typedef struct node sn;
sn *qit(sn *);
sn *rit(sn *);
sn *q =NULL;
static int k=1;
int main()
{
char i;
sn *qp;
do
{
printf("
Press 1 to put an element in queue
");
printf("Press 2 to remove an element from queue
");
printf("Press any other to exit
");
printf("
Enter choice:");
scanf("%d",&i);
switch(i)
{
case 1:
if(k==1)
{
k=0;
qp=malloc(sizeof(sn));
q=qp;
printf("Enter element:");
scanf("%d",&qp->n);
qp->next = NULL;
break;
}
else
{
q = qit(q);
break;
}
case 2:
if(k==1)
{
printf ("Queue list Empty
");
break;
}
else
{
q = rit(qp);
qp=q;
break;
}
default:
break;
}
}
while (i==1 || i==2);
return 0;
}

sn *qit(sn *p)
{
sn *t;
t=malloc(sizeof(sn*));
printf("Enter element:");
scanf("%d",&t->n);
p->next = t;
t->next = NULL;
return t;

}

sn *rit(sn *sq)
{
sn *st;
st=sq;
printf("
Removed element is: %d",sq->n);
if(sq->next == NULL)
{
printf("
Last element
");
k=1;
return NULL;
}
else
{
sq = sq->next;
free(st);
return sq;
}
}

Program to implement Stack as Linked List

2010-02-25T09:02:00.001-08:00

#include
#include
# include "malloc.h"
struct node
{
int data;
struct node *link;
} ;
struct node *top;

void main()
{
void push(int);
void display();
int wish, num,will,a;
wish = 1;
top = NULL;
clrscr();
printf("Program for Stack as Linked List demo..
");
while(wish == 1)
{
printf("
Main Menu
1.Enter data in stack
2.Delete from stack
");
scanf("%d",&will);
switch(will)
{
case 1:
printf("
Enter the data");
scanf("%d",&num);
push(num);
display();
break;
case 2:
a=pop();
printf("
Value returned from top of the stack is %d",a);
break;
default:
printf("
Invalid choice");
}
printf("
Do you want to continue, press 1");
scanf("%d",&wish);
}
}

void push(int y)
{
struct node *x;
x=malloc(sizeof(struct node));
printf("
Address of newly created node x is %d",x);
x->data = y;
x->link = top;
top = x;
}
void display()
{
int i =0;
struct node * temp;
temp = top;

while(temp!=NULL)
{
printf("
Item No. %d : Data %d Link %d ",i++,temp->data,temp->link);
temp=temp->link;
}
}

/// THIS FUNCTION REMOVES TOP NODE FROM THE STACK AND RETURNS ITS VALUE///

int pop()
{
  int a;
  if(top==NULL)
  {printf("
STACK EMPTY...

"); return 0;}
  else
  {
  a=top->data;
  printf("The value returned is %d ",a);
  free(top);
  top=top->link; return (a);
  }
}

Program to demonstrate linked list operations

2010-02-25T09:01:00.002-08:00

# include
# include
# include "malloc.h"
struct node
{
int data;
struct node *link;
};

void main()
{
int a=111,b=2,c=3,will,wish,num;
struct node *ptr,*ptr2,*result,*temp;
void add(struct node **,int );
struct node * search(struct node *);
void display(struct node *);
void invert(struct node *);
void del(struct node *,int);
struct node * concat(struct node *,struct node *);
ptr=NULL;
ptr2=NULL;
result=NULL; //result for storing the result of concatenation
clrscr();
will=1;

while(will==1)
{
printf("

Main Menu
1. Add element
2.Delete element
3.Search element
4Linked List concatenation
5.Invert linked list
6. Display elements
Please enter the choice");
scanf("%d",&wish);
switch(wish)
{
case 1:
printf("
Enter the element you want to add ");
scanf("%d",&num);
add(&ptr,num);
display(ptr);
break;
case 2:
printf("
Enter the element to delete ");
scanf("%d",&num);
del(ptr,num);
break;
case 3:
printf("
Now demonstrating search ");
temp = search(ptr);
printf("
Address of first occurence is %u ",temp);
break;
case 4:
/* Inputs given internally for demo only */
printf(" Now demonstrating linked list concatenation
Press any key to continue...");
add(&ptr2,2);
add(&ptr2,4);
add(&ptr2,6);
getch();
printf("

Displaying second Linked List

");
display(ptr2);
getch();
result = concat(ptr,ptr2);
clrscr();
printf("

Now Displaying the result of concatenation");
display(result);
getch();
break;
case 5:

printf("
Inverting the list ...
Press any key to continue...");
invert(ptr);
break;
case 6:
display(ptr);
break;
default:
printf("

Illegal choice

");
}
printf("
DO you want to continue ( press 1 for yes ");
scanf("%d",&will);
} //end of while
}

void add(struct node **q,int num)
{
struct node *temp;
temp = *q;
if(*q==NULL)
{
*q=malloc(sizeof(struct node));
temp = *q;
}
else
{
while((temp->link)!=NULL)
{
temp=temp->link;
}
temp->link = malloc(sizeof(struct node));
temp=temp->link;
}
temp->data = num;
temp->link = NULL;
}

void display(struct node *pt)
{

while(pt!=NULL)
{

printf("

Data : %d",pt->data);
printf("
Link : %d",pt->link);
pt=pt->link;
}
}

void invert(struct node *ptr)
{

struct node *p,*q,*r;
p=ptr;
q=NULL;

while(p!=NULL)
{
r=q;
q=p;
p=p->link;
q->link=r;
}
ptr = q;
display(ptr);
}

// CONCATENATION OF LINKED LISTS

struct node * concat(struct node *p,struct node *q)
{
struct node *x,*r;

if (p==NULL)
r=q;

if (q==NULL)
r=p;
else
{
   x=p;
   r=x;
   while(x->link!=NULL)
x=x->link;
   x->link=q;
}
   return(r);
}

// SEARCHING AN ELEMENT IN THE LINKED LIST
// THIS FUNCTION FINDS THE FIRST OCCURENCE OF
// A DATA AND RETURNS A POINTER TO ITS ADDRESS

struct node * search(struct node *p)
{
struct node *temp;
int num;
temp = p;
printf("
Enter the data that you want to search ");
scanf("%d",&num);
printf("
Link of temp %u", temp->link);
while(temp->link!=NULL)
{
printf("
In while ");
if(temp->data == num)
return(temp);
temp=temp->link;
}
return(NULL);
}

// DELETING DATA FROM THE LINKED LIST//

void del(struct node *p,int num)
{

struct node *temp,*x;
temp=p;
x= NULL;

while (temp->link !=NULL)
{
if(temp->data == num)
{
if (x==NULL)
{
p = temp->link;
free(temp);
return;
}
else
{
x->link = temp->link;
free(temp);
return;
}
} //end of outer if
x=temp;
temp=temp->link;
} //end of while
printf("

No such entry to delete ");
} //end of fn.

Program to add two polynomials

2010-02-25T09:01:00.000-08:00

#include

struct barbie

{

int coff;

int pow;

struct barbie *link;

}ptr,start1,node,start2,start3,ptr1,*ptr2;

typedef struct barbie bar;

int temp1,temp2;

void main()

{

void create(void);

void prnt(void);

void suml(void);

void sort(void);

clrscr();

printf("

Enrter the elements of the first poly :");

node = (bar *) malloc(sizeof (bar));

start1=node;

if (start1==NULL)

{

printf("

Unable to create memory.");

getch();

exit();

}

create();

printf("

Enrter the elements of the second poly :");

node = (bar *) malloc(sizeof (bar));

start2=node;

if (start2==NULL)

{

printf("

Unable to create memory.");

getch();

exit();

}

create();

clrscr();

//printing the elements of the lists

printf("

The elements of the poly first are :");

ptr=start1;

prnt();

printf("

The elements of the poly second are :");

ptr=start2;

prnt();

printf("

The first sorted list is :");

ptr=start1;

sort();

ptr=start1;

prnt();

printf("

The second sorted list is :");

ptr=start2;

sort();

ptr=start2;

prnt();

printf("

The sum of the two lists are :");

suml();

ptr=start3;

prnt();

getch();

}

/-----------------------------------------------------------------------------/

void create()

{

char ch;

while(1)

{

printf("

Enter the coff and pow :");

scanf("%d%d",&node->coff,&node->pow);

if (node->pow==0 )

{

ptr=node;

node=(bar *)malloc(sizeof(bar));

node=NULL;

ptr->link=node;

break;

}

printf("

Do u want enter more coff ?(y/n)");

fflush(stdin);

scanf("%c",&ch);

if (ch=='n' )

{

ptr=node;

node=(bar *)malloc(sizeof(bar));

node=NULL;

ptr->link=node;

break;

}

ptr=node;

node=(bar *)malloc(sizeof(bar));

ptr->link=node;

}

/-------------------------------------------------------------------------/

void prnt()

{ int i=1;

while(ptr!=NULL )

{

if(i!=1)

printf("+ ");

printf(" %dx^%d ",ptr->coff,ptr->pow);

ptr=ptr->link;

i++;

}

//printf(" %d^%d",ptr->coff,ptr->pow);

}

/---------------------------------------------------------------------------/

void sort()

{

for(;ptr->coff!=NULL;ptr=ptr->link)

for(ptr2=ptr->link;ptr2->coff!=NULL;ptr2=ptr2->link)

{

if(ptr->pow>ptr2->pow)

{

temp1=ptr->coff;

temp2=ptr->pow;

ptr->coff=ptr2->coff;

ptr->pow=ptr2->pow;

ptr2->coff=temp1;

ptr2->pow=temp2;

}

/---------------------------------------------------------------------------/

void suml()

{

node=(bar *)malloc (sizeof(bar));

start3=node;

ptr1=start1;

ptr2=start2;

while(ptr1!=NULL && ptr2!=NULL)

{

ptr=node;

if (ptr1->pow > ptr2->pow )

{

node->coff=ptr2->coff;

node->pow=ptr2->pow;

ptr2=ptr2->link; //update ptr list B

}

else if ( ptr1->pow < ptr2->pow )

{

node->coff=ptr1->coff;

node->pow=ptr1->pow;

ptr1=ptr1->link; //update ptr list A

}

else

{

node->coff=ptr2->coff+ptr1->coff;

node->pow=ptr2->pow;

ptr1=ptr1->link; //update ptr list A

ptr2=ptr2->link; //update ptr list B

}

node=(bar *)malloc (sizeof(bar));

ptr->link=node; //update ptr list C

}//end of while

if (ptr1==NULL) //end of list A

{

while(ptr2!=NULL)

{

node->coff=ptr2->coff;

node->pow=ptr2->pow;

ptr2=ptr2->link; //update ptr list B

ptr=node;

node=(bar *)malloc (sizeof(bar));

ptr->link=node; //update ptr list C

}

else if (ptr2==NULL) //end of list B

{

while(ptr1!=NULL)

{

node->coff=ptr1->coff;

node->pow=ptr1->pow;

ptr1=ptr1->link; //update ptr list B

ptr=node;

node=(bar *)malloc (sizeof(bar));

ptr->link=node; //update ptr list C

}

node=NULL;

ptr->link=node;

}

Program for Stack implementation through Array

2010-02-25T09:00:00.000-08:00

#include
#include
# define MAXSIZE 200

int stack[MAXSIZE];
int top; //index pointing to the top of stack
void main()
{
void push(int);
int pop();
int will=1,i,num;
clrscr();

while(will ==1)
{
printf("
MAIN MENU:
1.Add element to stack
2.Delete element from the stack
");
scanf("%d",&will);

switch(will)
{
case 1:
printf("
Enter the data... ");
scanf("%d",&num);
push(num);
break;
case 2: i=pop();
printf("
Value returned from pop function is %d ",i);
break;
default: printf("Invalid Choice . ");
}

printf("

Do you want to do more operations on Stack ( 1 for yes, any other key to exit) ");
scanf("%d" , &will);
} //end of outer while
} //end of main

void push(int y)
{

if(top>MAXSIZE)
   {
   printf("

STACK FULL

");
   return;
   }
else
{
top++;
stack[top]=y;
}
}

int pop()
{
int a;
if(top<=0)
{
printf("

STACK EMPTY

");
return 0;
}
else
{
a=stack[top];
top--;
}
return(a);

}

Program for Queue implementation through Linked List

2010-02-25T08:59:00.002-08:00

#include
#include
struct node
{
int data;
struct node *link;
} ;
struct node *front, *rear;
void main()
{

int wish,will,a,num;
void add(int);

wish=1;
clrscr();
front=rear=NULL;

printf("Program for Queue as Linked List demo..
");
while(wish == 1)
{
printf("
Main Menu
1.Enter data in queue
2.Delete from queue
");
scanf("%d",&will);
switch(will)
{
case 1:
printf("
Enter the data");
scanf("%d",&num);
add(num);
//display();
break;
case 2:
a=del();
printf("
Value returned from front of the queue is %d",a);
break;
default:
printf("
Invalid choice");
}
printf("
Do you want to continue, press 1");
scanf("%d",&wish);
}
getch();
}

void add(int y)
{
struct node *ptr;
ptr=malloc(sizeof(struct node));
ptr->data=y;
ptr->link=NULL;
if(front ==NULL)
{
front = rear= ptr;
}
else
{
rear->link=ptr;
rear=ptr;
}
}

int del()
{
int num;
if(front==NULL)
{
printf("

QUEUE EMPTY

");
return(0);
}
else
{
num=front->data;
front = front->link;
printf("
Value returned by delete function is %d
",num);
return(num);
}
}

Program for Queue implementation through Array

2010-02-25T08:59:00.000-08:00

#include
#include
# define MAXSIZE 200

int q[MAXSIZE];
int front, rear;
void main()
{
void add(int);
int del();
int will=1,i,num;
front =0;
rear = 0;

clrscr();

printf("
Program for queue demonstration through array

");

while(will ==1)
{
printf("
MAIN MENU:
1.Add element to queue
2.Delete element from the queue
");
scanf("%d",&will);

switch(will)
{
case 1:
printf("
Enter the data... ");
scanf("%d",&num);
add(num);
break;
case 2: i=del();
printf("
Value returned from delete function is %d ",i);
break;
default: printf("Invalid Choice ... ");
}

printf("

Do you want to do more operations on Queue ( 1 for yes, any other key to exit) ");
scanf("%d" , &will);
} //end of outer while
} //end of main

void add(int a)
{

if(rear>MAXSIZE)
{
printf("

QUEUE FULL

");
return;
}
else
{
q[rear]=a;
rear++;
printf("
Value of rear = %d and the value of front is %d",rear,front);
}
}

int del()
{
int a;
if(front == rear)
{
printf("

QUEUE EMPTY

");
return(0);
}
else
{
a=q[front];
front++;
}
return(a);
}

Program for finding the transpose of a martix in sparse form

2010-02-25T08:58:00.002-08:00

#include
#include
int a[100][100],b[100][100];

void main()
{
int i,m,n,p,q,col,t;
clrscr();
printf("Enter the no. of rows");
scanf("%d", &a[0][0]);
printf("
Enter the no. of cols");
scanf("%d", &a[0][1]);
printf("
Enter the number of non zero terms");
scanf("%d", &a[0][2]);

for(i=1;i<=a[0][2];i++)
{
printf("
Enter the value (that is non zero)");
scanf("%d",&a[i][2]);
printf("
Enter the row for %d : ",a[i][2]);
scanf("%d",&a[i][0]);
printf("
Enter the col for %d : ",a[i][2]);
scanf("%d",&a[i][1]);
}

/* Printing for testing the sparse input */
printf("
*****************************
The martix you entered is
************************

Row Col Value ");
for ( i = 0;i <= a[0][2];i++)
{
printf("
%d %d %d " , a[i][0],a[i][1],a[i][2]);
}

/* Calling function for evaluation of transpose */

m = a[0][0];
n = a[0][1];
t = a[0][2];

b[0][0] = n;
b[0][1] = m;
b[0][2] = t;

q=1;

for( col = 1; col <=n; col++)
{
for(p = 1; p<=t;p++)
{
if(a[p][1] == col)
{
b[q][0] = a[p][1];
b[q][1] =a[p][0];
b[q][2] = a[p][2];
q++;
}
}
} //end of outer for loop

/* Printing the transposed matrix */

getch();
printf("
The Transpose of the above matrix is ");
for ( i = 0;i <= a[0][2];i++)
{
printf("
%d %d %d " , b[i][0],b[i][1],b[i][2]);
}
getch();
}

Program for Circular Queue implementation through Array

2010-02-25T08:58:00.000-08:00

#include
#include
# define MAXSIZE 200

int cq[MAXSIZE];
int front,rear;

void main()
{
void add(int,int [],int,int,int);
int del(int [],int ,int ,int );
int will=1,i,num;
front = 1;
rear = 1;

clrscr();
printf("
Program for Circular Queue demonstration through array

");
while(will ==1)
{
printf("
MAIN MENU:
1.Add element to Circular Queue
2.Delete element from the Circular Queue
");
scanf("%d",&will);

switch(will)
{
case 1:
printf("
Enter the data... ");
scanf("%d",&num);
add(num,cq,MAXSIZE,front,rear);
break;
case 2: i=del(cq,MAXSIZE,front,rear);
printf("
Value returned from delete function is %d ",i);
break;
default: printf("

Invalid Choice . ");
}

printf("

Do you want to do more operations on Circular Queue ( 1 for yes, any other key to exit) ");
scanf("%d" , &will);
} //end of outer while
} //end of main

void add(int item,int q[],int MAX,int front,int rear)
{
rear++;
rear= (rear%MAX);
if(front ==rear)
{
printf("

CIRCULAR QUEUE FULL

");
return;
}
else
{
cq[rear]=item;
printf("
Rear = %d Front = %d ",rear,front);
}
}
int del(int q[],int MAX,int front,int rear)
{
int a;
if(front == rear)
{
printf("

CIRCULAR STACK EMPTY

");
return (0);
}
else
{
front++;
front = front%MAX;
a=cq[front];
return(a);
printf("
Rear = %d Front = %d ",rear,front);
}
}

Linked list stack example

2010-02-25T08:57:00.001-08:00

#include
#include
#include

typedef struct node {
char *str;
struct node *next;
} STACKNODE;

void push(char *key, STACKNODE **stack);
char *pop(STACKNODE **stack);
int isempty(STACKNODE *stack);
char top(STACKNODE *stack);

int main() {
char line[1024];
char *key;
STACKNODE *stack;

stack = NULL;
while((fgets(line, 1024, stdin)) != NULL)
key = line, push(key, &stack);

while(!isempty(stack))
printf("%s", pop(&stack));

return 0;
}

char top(STACKNODE *stack) {
return *stack->str;
}

void push(char *line, STACKNODE **stack) {
STACKNODE *newnode;

newnode = (STACKNODE *)malloc(sizeof(STACKNODE));
newnode->str = strdup(line);
newnode->next = (*stack);
(*stack) = newnode;
}

char *pop(STACKNODE **stack) {
STACKNODE *oldnode;
char *key;
char *retval;

oldnode = (*stack);
key = (*stack)->str;
(*stack) = (*stack)->next;
free(oldnode);

retval = calloc(strlen(key)+1, sizeof(char));
strcpy(retval, key);
return retval;
free(retval);
}

int isempty(STACKNODE *stack) {
return stack == NULL;
}

Linked list queue example

2010-02-25T08:56:00.002-08:00

# include
# include

struct qnode {
int data;
int prio;
struct qnode *next;
};

void quein(struct qnode **, struct qnode **, int , int);
int quedel(struct qnode **, struct qnode **, int *, int *);

int main(void) {
int tab[10] = {2, 8, 3, 5, 4, 9, 6, 7, 1, 0};
struct qnode *first = NULL;
struct qnode *last = NULL;
int val, prio, i;

for(i = 0; i < 10; i++) {
  val = tab[i], prio = i;
  printf("Inserting: value: %d with priority: %d\n", prio, val);
  quein(&first, &last, val, prio);
}

printf("=-=\n");

for(i = 0; i < 11; i++) {
  val = tab[i], prio = i;
  if(quedel(&first, &last, &val, &prio) != -1)
   printf("Deleting: value: %d with priority: %d\n", prio, val);
}

return 0;
}

int quedel(struct qnode **first, struct qnode **last, int *prio, int *val) {
struct qnode *tmp = NULL;

if((NULL == *last) && (*last == *first)) {
  fprintf(stderr, "Empty queue.....\n");
  return -1;
}

*val = (*first)->data, *prio = (*first)->prio;
tmp = *first, *first = (*first)->next;

if(*last == tmp)
  *last = (*last)->next;
free(tmp);

return 0;
}

void quein(struct qnode **first, struct qnode **last, int prio, int val) {
struct qnode *tmp = NULL;
struct qnode *tmp1 = NULL;

tmp = malloc(sizeof(struct qnode));

tmp->data = val;
tmp->prio = prio;
tmp->next = NULL;

if(*last == NULL) {
  *last = tmp;
  *first = *last;
  } else {
   if((*first)->prio < prio) {
   tmp->next = *first;
   *first = tmp;
   } else {
   if((*last)->prio > prio) {
   (*last)->next = tmp;
   *last = tmp;
   } else {
   tmp1 = *first;
   while((tmp1->next)->prio >= prio) {
   tmp1 = tmp1->next;
   }
   tmp->next = tmp1->next;
   tmp1->next = tmp;
   }
   }
  }

return;
}

Linked List implementation

2010-02-25T08:56:00.000-08:00

#include"m_list.h"

void main()
   {
   list *first=NULL,*second=NULL,*third=NULL;
   int choice,i;
   char ch='y';
   while(1)
   {
   clrscr();
   printf("
   case 1: Create list");
   printf("
   case 2: Add in the list");
   printf("
   case 3: Delete in the list");
   printf("
   case 4: Append two list");
   printf("
   case 5: show list");
   printf("
   case 6: Exit");
   printf("
   Enter your choice : ");
   scanf("%d",&choice);
   switch(choice)
   {
   case 1: //create list
   while(ch!='n')
   {
   printf("
Enter element : ");
   scanf("%d",&i);
   create(&first,i);
   printf("
Enter element (y/n) : ");
   fflush(stdin);
   scanf("%c",&ch);
   }
   break;
   case 2: //add in the list
   int c;
   clrscr();
   printf("
   case 1: Add in Beginning");
   printf("
   case 2: Add in End");
   printf("
   case 3: Add After a given element");
   printf("
   case 4: Return to main menu");
   printf("
   Enter your choice : ");
   scanf("%d",&c);
   switch(c)
   {
   case 1: add_at_beg(&first);
   break;
   case 2: add_at_end(&first);
   break;
   case 3: add_after_given_element(&first);
   break;
   case 4: break;
   }
   break;
   case 3:
   clrscr();
   printf("
   case 1: Delete in Beginning");
   printf("
   case 2: Delete in End");
   printf("
   case 3: Delete a specified element");
   printf("
   case 4: Return to main menu");
   printf("
   Enter your choice : ");
   scanf("%d",&c);
   switch(c)
   {
   case 1: del_at_beg(&first);
   break;
   case 2: del_at_end(&first);
   break;
   case 3: del_specified_element(&first);
   break;
   case 4: break;
   }
   break;
   case 4:
   char ch='y';
   printf("Enter element in second list : ");
   while(ch!='n')
   {
   printf("
Enter element : ");
   scanf("%d",&i);
   create(&second,i);
   printf("
Enter element (y/n) : ");
   fflush(stdin);
   scanf("%c",&ch);
   }
   append(&third,first,second);

   break;
   case 5: //show list
   clrscr();
   printf("
   case 1: List 1");
   printf("
   case 2: List 2");
   printf("
   case 3: List 3");
   printf("
   Enter choice : ");
   scanf("%d",&choice);
   switch(choice)
   {
   case 1: show(first);break;
   case 2: show(second);break;
   case 3: show(third);break;
   }
   break;
   case 6: exit(0);

   }

   }
   }

*********************************
#include
#include
#include
#include
typedef struct list
  {
   int info;
   struct list *next;
  };

//.................Function Declaration ...........

void create(struct list **p,int i)
   {
   struct list *temp,*q=*p;
   temp=(struct list*)malloc(sizeof(struct list));
   temp->info=i;
   temp->next=NULL;
   if(*p==NULL)
   *p=temp;
   else
   {
   while(q->next!=NULL)
   q=q->next;
   q->next=temp;
   }
   }
int append(struct list **t,struct list *f,struct list *s)
   {
   struct list *temp=*t;
   if(f==NULL && s==NULL)
   return 0;
   while(f)
   {
   create(t,f->info);
   f=f->next;
   }
   while(s)
   {
   create(t,s->info);
   s=s->next;
   }

   return 0;
   }
void show(struct list *p)
   {
   if(p==NULL)
   printf(" List is Empty");
   else
   while(p)
   {
   printf("%d ",p->info);
   p=p->next;
   }
   getch();
   }
void add_at_beg(struct list **l)
   {
   struct list *temp=(struct list *)malloc(sizeof(struct list));
   printf("
Enter element : ");
   scanf("%d",&temp->info);
   temp->next=NULL;
   if(*l==NULL)
   *l=temp;
   else
   {
   temp->next=*l;
   *l=temp;
   }
   }
void del_at_beg(struct list **l)
   {
   list *temp;
   if(*l==NULL)
   {
   printf("
List is empty");
   getch();
   }
   else
   {
   temp=*l;
   *l=(*l)->next;
   free(temp);
   }
   }
void add_at_end(struct list **l)
   {
   list *temp,*p;
   temp=(struct list *)malloc(sizeof(struct list));
   printf("
Enter element : ");
   scanf("%d",&temp->info);
   temp->next=NULL;
   if(*l==NULL)
   *l=temp;
   else
   {
   p=*l;
   while(p->next!=NULL)
   p=p->next;
   p->next=temp;
   }
   }

void del_at_end(struct list **l)
   {
   list *temp,*p;
   if(*l==NULL)
   {
   printf("
List is Empty");
   getch();
   }
   else if((*l)->next==NULL)
   {
   temp=*l;
   *l=NULL;
   free(temp);
   }
   else
   {
   p=*l;
   while(p->next->next!=NULL)
   p=p->next;
   temp=p->next->next;
   p->next=NULL;
   free(temp);
   }
   }
void add_after_given_element(list **l)
   {
   list *temp,*p;
   int m;
   temp=(struct list *)malloc(sizeof(struct list));
   printf("
Enter element : ");
   scanf("%d",&temp->info);
   printf("
Enter position after which element inserted : ");
   scanf("%d",&m);
   temp->next=NULL;
   if(*l==NULL)
   *l=temp;
   else
   {
   p=*l;
   while(p->next!=NULL)
   if(p->info==m)
   break;
   else
   p=p->next;

   temp->next=p->next;
   p->next=temp;

   }
   }
void del_specified_element(list **l)
   {
   list *temp,*p,*q;
   int m;
   printf("
Enter element which is deleted : ");
   scanf("%d",&m);
   if(*l==NULL)
   {
   printf("
List is Empty");
   getch();
   }
   else if((*l)->next!=NULL && (*l)->info==m)
   {
   temp=*l;
   *l=(*l)->next;
   free(temp);
   }
   else if((*l)->next==NULL && (*l)->info==m)
   {
   temp=*l;
   *l=NULL;
   free(temp);
   }
   else
   {
   p=*l;
   while(p!=NULL)
   if(p->info==m)
   break;
   else
   {
   q=p;
   p=p->next;
   }
   temp=p;
   q->next=p->next;
   free(temp);
   }
   }

Infix To Prefix Conversion

2010-02-25T08:55:00.001-08:00

#include
#include
#include
#define MAX 15
#define true 1
#define false 0

/*Structure Decvlaration*/
typedef struct
{
char data[MAX];
char top;
}STK;

/*Function Declarations*/
void input(char str[]);
void intopre(char str1[],char pre[]);
void intopost(char str1[],char post[]);
int isoperand(char sym);
int prcd(char sym);
void push(STK *s1,char elem);
int pop(STK *s1);
int empty(STK *s2);
int full(STK *s2);
void dis(char str[]);

void main()
{
STK s;
int cs,ans;
char str[MAX],pre[MAX],post[MAX];
clrscr();
do /*Using Do-while Loop*/
{
clrscr();
printf("
-----Program for Expressions-----");
printf("
Input The String:");
printf("
MENU:
");
printf("1.Infix to Prefix
");
printf("2.Infix to Postfix");
printf("
3.Exit");
cs=getche();

switch(cs) /*Using Switch Case*/
{
case 1:
intopre(str,pre);
break;
case 2:
intopost(str,post);
break;
case 3:
break;
default:
printf("
Enter a Valid Choise!"); /*Default Case*/
break;
}
printf("
Do you wish to Continue?(y/n)");
ans=getche();
}while(ans=='y'||ans=='Y'); /*Condition for Do-while loop*/

getch();
}

/*To Input String*/
void input(char str)
{
printf("Enter the Infix String:");
scanf("%s",str);
}

/*To Covert Infix To Prefix*/
void intopre(STK s1,char str1[],char pre[])
{
int len,flag;
len=strlen(str1);
int check=0,cnt=len-1,pos=0;
char elem;

while(cnt>=0) /*while condition*/
{
flag=0;
if(isoperand(str1[cnt])) /*Checking for Operand*/
{
printf("%c",str1[cnt]);
cnt--;
pos++;
}
else
{
check=prcd(str1[cnt]);
while(check==false)
{
pre[pos]=str1[cnt];
flag=1;
pos++;
cnt--;
}
if(flag==0)
{
elem=pop(&s1);
printf("%c",elem);
}
}

}
}

/*To Convert Infix To Postfix*/
void intopost(STK s1,char str1[],char post[])
{
int len;
len=strlen(str1);
int check=0,cnt=len-1,pos=0;

}

/*To Check For Operand*/
int isoperand(char sym)
{
if('A'<'Z'||'a'<'z')
return(true);
return(false);
}

/*To Check The Precedence*/
int prcd(char sym)
{

}

/*To Display String*/
void dis(char str[])
{

}

/*Push Function Definition*/
void push(STK *s1,char elem)
{
if(!full(s1))
{
s1->top++; /*Incrementing top*/
s1->data[s1->top]=elem; /*Storing element*/
}
else
printf("
Stack is Full!");
}

/*Full Function Definition*/
int full(STK *s2)
{
if(s2->top==MAX) /*Condition for Full*/
return(true);
return(false);
}

/*Pop Function Definition*/
int pop(STK *s1)
{
char elem;
if(!empty(s1))
{
elem=s1->data[s1->top]; /*Storing top stack element in elem*/
s1->top--; /*Decrementing top*/
return(elem);
}
return(false);
}

/*Empty Function Definition*/
int empty(STK *s2)
{
if(s2->top==-1) /*Condition For Empty*/
return(true);
return(false);
}

Hash, use shift-folding snip

2010-02-25T08:54:00.001-08:00

#include
#include
#include
#include

#define MAXLINE 128
#define HTABSIZE 101
#define NSHIFT 3

struct hnode {
int pos;
char *key;
struct hnode *next;
};

typedef struct hnode *hashtable[HTABSIZE];

int htab_key(char *key);
int htab_getval(hashtable h, char *key);
void htab_insert(hashtable h, char *key, int pos);
void htab_dump(hashtable htab);
void htab_free(hashtable htab);

int main(int argc, char *argv[]) {
char line[MAXLINE];
hashtable htab = {0};
int len = 0;
int i = 0;
int retv = 0;

if(argc != 2)
  error(1, 0, "querry < input.txt");

while(fgets(line, MAXLINE, stdin) != NULL) {
  /* strip newlines */
  len = strlen(line);
  if(line[len - 1] == '\n')
   line[--len] = '\0';

  if(len > 2)
   htab_insert(htab, line, i++);
}

if((retv = htab_getval(htab, argv[1])) == -1)
  printf("NOT found: `%s', `%d'\n", argv[1], retv);
else
  printf("FOUND: `%s' at `%d'\n", argv[1], retv);

/* htab_dump(htab); */
htab_free(htab);

return 0;
}

int htab_key(char *key) {
char *ptr = NULL;
int retv = 0;
int i = 0;
int x = 0;

for(ptr = key; *ptr; retv += x)
  for(i = 0, x = 0; i < NSHIFT && *ptr; i++, ptr++)
   x = x * 10 + *ptr;

retv %= HTABSIZE;
return retv;
}

void htab_insert(hashtable htab, char *key, int pos) {
struct hnode *ptr = (struct hnode *)malloc(sizeof(struct hnode));
int index = htab_key(key);

ptr->key = strdup(key);
ptr->pos = pos;
ptr->next = htab[index];

htab[index] = ptr;
return;
}

int htab_getval(hashtable htab, char *key) {
struct hnode *ptr = {0};

for(ptr = htab[htab_key(key)]; ptr && strcmp(ptr->key, key); ptr = ptr->next)
  ;

if(ptr)
  return ptr->pos;
else
  return -1;
}

void htab_dump(hashtable htab) {
struct hnode *ptr = {0};
int i = 0;

for(i = 0; i < HTABSIZE; i++) {
  printf("[%02d]: ", i);
  for(ptr = htab[i]; ptr; ptr = ptr->next) {
   printf("[%d] -> %s", ptr->pos, ptr->key);
  }
  printf("\n");
}

return;
}

void htab_free(hashtable htab) {
struct hnode *ptr = {0};
struct hnode *tmp = {0};
int i = 0;

for(i = 0; i < HTABSIZE; i++) {
  for(ptr = htab[i]; ptr; ptr = ptr->next) {
   if(ptr->next != NULL) {
   free(ptr->key), tmp = ptr->next;
   free(ptr), ptr = tmp;
   }
  }
}

return;
}

Dynamic string arrays

2010-02-25T08:53:00.001-08:00

#include
#include
#include

int main (void) {
char **strarray = NULL;
int i = 0, strcount = 0;
char line[1024];

while((fgets(line, 1024, stdin)) != NULL) {
  strarray = (char **)realloc(strarray, (strcount + 1) * sizeof(char *));
  strarray[strcount++] = strdup(line);
}

/* print the array of strings */
for(i = 0; i < strcount; i++)
  printf("strarray[%d] == %s", i, strarray[i]);

/*
// free the string array
// Note: You must delete each individual string
// before you delete the array of pointers
*/
for(i = 0; i < strcount; i++)
  free(strarray[i]);

free(strarray);
return 0;
}

Dynamic array of structures

2010-02-25T08:52:00.002-08:00

#include
#include
#include

struct node {
char *str;
int len;
};

int main(void) {
struct node **strarray = NULL;
int i = 0, count = 0;
char line[1024];

while(fgets(line, 1024, stdin) != NULL) {
  /* add ONE element to the array */
  strarray = (struct node **)realloc(strarray, (count + 1) * sizeof(struct node *));

  /* allocate memory for one `struct node` */
  strarray[count] = (struct node *)malloc(sizeof(struct node));

  /* copy the data into the new element (structure) */
  strarray[count]->str = strdup(line);
  strarray[count]->len = strlen(line);
  count++;
}

/* print the array */
for(i = 0; i < count; i++) {
  printf("--\n");
  printf("[%d]->str: %s", i, strarray[i]->str);
  printf("[%d]->len: %d\n", i, strarray[i]->len);
}

/* free all strarray elements */
for(i = 0; i < count; i++) {
  free(strarray[i]->str);
  free(strarray[i]);
  i++;
}
free(strarray);

return 0;
}

Interview Questions for Freshers

SQL Random Line

SQL Random ID

Remove Duplicate Records

Import the SQL Server error log into a table

Call an Oracle Stored Procedure

Add New Record with ADO

ADO Schemas to list tables & fields

Database Paging

5K Race

How to filter a recordset

Index Server Access via ADO

Insert TEXT blob using ADO

Using a Stored Procedure with ADO

How to shutdown reboot logoff WIndows 9x NT Me 2000

Volumes & Areas

Factorial series-e^x

Square Root of a number by using simple calculations

Program to find your Day of Birth given Date of Birth

Program to calculate Area of a Polygon

Program for Decimal to Roman Number conversion

Progam that gives all details of a Triangle given the lengths of its sides

Circle Through Three Points

Treesort [string array]

#include

#include

#include

struct tnode {

char *str;

struct tnode *left;

struct tnode *right;

};

void insert(struct tnode **p, char *value);

void print(struct tnode *root);

int main(void) {

char line[1024];

struct tnode *root;

root = NULL;

while((fgets(line, 1024, stdin)) != NULL)

insert(&root, line);

print(root);

return 0;

}

/* call by reference .. ! */

void insert(struct tnode **p, char *value) {

if(!*p) {

*p = (struct tnode *)malloc(sizeof(struct tnode));

(*p)->left = (*p)->right = NULL;

(*p)->str = strdup(value);

return;

}

if(strcmp(value, (*p)->str) < 0)

insert(&(*p)->left, value);

else

insert(&(*p)->right, value);

}

/* inorder binary tree print ... */

void print(struct tnode *root) {

if(root != NULL) {

print(root->left);

printf("%s", root->str);

print(root->right);

}

}

Ssort, selection sort [array]

Shsort, shell sort [array]

Selection sort [linked list]

Qsort [string, dynamic pointer array]

Qsort [string array]

Qsort [array of pointers to structures]

Qcksort, quick sort [array]

No sort, but reversing a [linked list]

Msort, merge sort [array]

Merge sort [linked list]

Isort, insertion sort [array]

Insertion sort [linked list]

Hsort, heap sort [array]

Bubble sort [string array]

Bubble sort [linked list]

sort, bubble sort [array]

p = (struct tnode )malloc(sizeof(struct tnode));

(p)->left = (p)->right = NULL;

}ptr,start1,node,start2,start3,ptr1,*ptr2;