Computer Science student Projects science fair projects

AutoCad Mechanical Project

Air-conditioning and Air-conditioning System Design AutoCad Mechanical Project.
The goal of the Air-conditioning and Air-conditioning System Design AutoCad Mechanical Project is to design system of air-condition for building. The air conditioning system is designed to monitor the indoor environment such as temperature, relative humidity, air movement etc. in an economical method with Auto-CAD MEP.
Heating ventilating and air-conditioning HVAC is to make the mechanical services which are consist of fire protection, plumbing, and escalators. Air-conditioning is the method of heating, cooling, ventilation, or disinfection which changes the air condition. The aim of an HVAC system offers an environment with energy of qualities like cost effective, efficient, healthy and comfortable indoor environment with indoor air quality.
The conditioning system is based on two systems. They are central systems and decentralized systems. The difference among central and decentralized systems is critical based on architecture view.
Generally, the conditioning systems are classified into four methods. They are all-air system, all-water system, air-water system, and unitary refrigerant based system. The HVAC system acts like thermal zones with major components present out of the zone. The central air conditioning systems includes three major parts. They are an air system, water system, and central plant.
The decentralized system acts like a single thermal zone with components present inside the zone. It is divided into individual systems and unitary systems.
Click Here To Download Air-conditioning and Air-conditioning System Design AutoCad Mechanical Project

Binary search Tree C++

khan-8703 March

Binary search tree with all the three recursive and non recursive traversals

/*Binary search tree with all the Recursive and non Recursive 
traversals*/
/* By:- Aniket P. Kadu :- S.e computer :- M.E.S.C.O.E */

#include
#include
#include

class binarynode
{
 public:
   int data;
   binarynode *left;
   binarynode *right;
};

class binsrctree
{
 private:
   binarynode *root;
   void inorder_rec(binarynode *);
   void inorder_non_rec(binarynode *);
   void preorder_rec(binarynode *);
   void preorder_non_rec(binarynode *);
   void postorder_rec(binarynode *);
   void postorder_non_rec(binarynode *);
 public:
   binsrctree()
   {
    root=NULL;
   }
   void insert(int );
   void print_inorder_rec();
   void print_inorder_non_rec();
   void print_preorder_rec();
   void print_preorder_non_rec();
   void print_postorder_rec();
   void print_postorder_non_rec();
};

class stack
{
 int top;
 binarynode *stackel[20];
  public:
   stack()
   {
    top=-1;
   }
  void push(binarynode *);
  binarynode* pop();
  int empty()
  {
   if(top==-1)
   return(1);

   return(0);
  }
};

void stack::push(binarynode *node)
{
 stackel[++top]=node;
}

binarynode *stack::pop()
{
 return(stackel[top--]);
}

class stack_int
{
 int top;
 int stack_int[20];
  public:
   stack_int()
   {
    top=-1;
   }
  void push(int flag);
  int pop();
  int empty_int()
  {
   if(top==-1)
   return(1);

   return(0);
  }
};

void stack_int::push(int flag)
{
 stack_int[++top]=flag;
}

int stack_int::pop()
{
 return(stack_int[top--]);
}
/*---------------------------------------------------------------------*/
/* fUNCTION TO INSERT A NODE IN THE TREE */
/*---------------------------------------------------------------------*/
void binsrctree::insert(int val)
{
 binarynode *temp,*prev,*curr;
 temp=new binarynode;
 temp->data=val;
 temp->left=temp->right=NULL;

 if(root==NULL)
 {
  root=temp;
 }
 else
 {
   curr=root;
   while(curr!=NULL)
   {
    prev=curr;
    if(temp->datadata)
       curr=curr->left;
    else
       curr=curr->right;
   }
   if(temp->datadata)
      prev->left=temp;
   else
      prev->right=temp;
  }
}

/* ------------------------------------------------*/
/*INORDER RECURSIVE TRAVERSAL*/
/*-------------------------------------------------*/

void binsrctree::inorder_rec(binarynode *root)
{
  if(root!=NULL)
  {
   inorder_rec(root->left);
   cout<data<<"	";
   inorder_rec(root->right);
  }
}

/*--------------------------------------------------*/
/*INORDER NON RECURSIVE TRAVERSAL*/
/*--------------------------------------------------*/

void binsrctree::inorder_non_rec(binarynode *root)
{
 stack stk;
 binarynode *temp;
 if(root!=NULL)
 {
  temp=root;
  do
  {
   while(temp!=NULL)
   {
      stk.push(temp);
      temp=temp->left;
   }/*end while*/
   if(!stk.empty())
   {
      temp=stk.pop();
      cout<data<<"	";
      temp=temp->right;
   }/*end if*/
   else
    break;
  }while(1); /*end do while*/
 }/* end if */
 else
  cout<<"
Empty tree";

} /*end function */

/*--------------------------------------------------*/
/*PREORDER RECURSIVE TRAVERSAL */
/*---------------------------------------------------*/
void binsrctree::preorder_rec(binarynode *root)
{
 if(root!=NULL)
 {
   cout<data<<"	";
   preorder_rec(root->left);
   preorder_rec(root->right);
 }
}

/*--------------------------------------------------*/
/*PREORDER NON RECURSIVE TRAVERSAL */
/*---------------------------------------------------*/

void binsrctree::preorder_non_rec(binarynode *root)
{
 stack stk;
 binarynode *temp=root;

 stk.push(temp);

 while(!stk.empty())
 {
  temp=stk.pop();
  if(temp!=NULL)
  {
   cout<data<<"	";
   stk.push(temp->right);
   stk.push(temp->left);
  }
 }

}

/*--------------------------------------------------*/
/*POSTRDER RECURSIVE TRAVERSAL */
/*---------------------------------------------------*/

void binsrctree::postorder_rec(binarynode *root)
{
 if(root!=NULL)
 {
  postorder_rec(root->left);
  postorder_rec(root->right);
  cout<data<<"	";
 }
}

/*--------------------------------------------------*/
/*POSTORDER NON RECURSIVE TRAVERSAL */
/*---------------------------------------------------*/

void binsrctree::postorder_non_rec(binarynode *root)
{
 stack stk;
 stack_int stk1;
 int flag;
 binarynode *temp=root;

 do
 {
  if(temp!=NULL)
  {
   stk.push(temp);
   stk1.push(1);
   temp=temp->left;
  }
  else
  {
   if(stk.empty())
     break;
   temp=stk.pop();
   flag=stk1.pop();
     if(flag==2)
     {
      cout<data;
      temp=NULL;
     } /*end if */
     else
     {
      stk.push(temp);
      stk1.push(2);
      temp=temp->right;
     } /* end else */
  } /* end if */
 }while(1);/*end do while*/
}/*end function*/

/*--------------------------------------------------*/
/*FUNCTION TO PRINT INORDER RECURSIVE TRAVERSAL */
/*----------------------------------n_rec()
{
 cout<<"
";
 postorder_non_rec(root);
 cout<<"
";
}

/*--------------------------------------------------*/
/* MAIN FUNCTION */
/*---------------------------------------------------*/

void main()
{
 binsrctree BST;
 int ch,element;
 clrscr();

 do
 {
  cout<<"
1.Insert a node in binary tree";
  cout<<"
2.Recursive Inorder traversal";
  cout<<"
3.Non Recursive Inorder traversal";
  cout<<"
4.Recursive preorder traversal";
  cout<<"
5.Non recursive preorder traversal";
  cout<<"
6.Recursive postorder traversal";
  cout<<"
7.Non recursive postorder traversal";
  cout<<"
8.Exit";
  cout<<"
Enter your choice";
  cin>>ch;

  switch(ch)
  {
   case 1:
    cout<<"
Enter the element you wnat to insert";
    cin>>element;
    BST.insert(element);
    break;
   case 2:
    cout<<"
Recursive Inorder traversal
";
    BST.print_inorder_rec();
    break;
   case 3:
    cout<<"
NonRecursive Inorder traversal
";
    BST.print_inorder_non_rec();
    break;
   case 4:
    cout<<"
Recursive preorder traversal
";
    BST.print_preorder_rec();
    break;
   case 5:
    cout<<"
Non recursive preorder traversal
";
    BST.print_preorder_non_rec();
    break;
   case 6:
    cout<<"
Recursive postorder traversal";
    BST.print_postorder_rec();
    break;
   case 7:
    cout<<"
Non recursive postorder traversal
";
    BST.print_postorder_non_rec();
    break;
   case 8:
    exit(1);

  }
 }while(ch<8);
}

//not include below line on program//

Data Structures Scripts and C++ Code

khan-8703 March

/* Adelson Velseky Landis Tree */

# include 
# include 
# include 

struct node
{
   int element;
   node *left;
   node *right;
   int height;
};

typedef struct node *nodeptr;

class bstree
{

   public:
	void insert(int,nodeptr &);
	void del(int, nodeptr &);
	int deletemin(nodeptr &);
	void find(int,nodeptr &);
	nodeptr findmin(nodeptr);
	nodeptr findmax(nodeptr);
	void copy(nodeptr &,nodeptr &);
	void makeempty(nodeptr &);
	nodeptr nodecopy(nodeptr &);
	void preorder(nodeptr);
	void inorder(nodeptr);
	void postorder(nodeptr);
	int bsheight(nodeptr);
	nodeptr srl(nodeptr &);
	nodeptr drl(nodeptr &);
	nodeptr srr(nodeptr &);
	nodeptr drr(nodeptr &);
	int max(int,int);
	int nonodes(nodeptr);
};

//		Inserting a node
void bstree::insert(int x,nodeptr &p)
{
   if (p == NULL)
   {
	p = new node;
	p->element = x;
	p->left=NULL;
	p->right = NULL;
	p->height=0;
	if (p==NULL)
		cout<<"Out of Space";
   }
   else
   {
	if (xelement)
	{
	   insert(x,p->left);
	   if ((bsheight(p->left) - bsheight(p->right))==2)
	   {
	      if (x < p->left->element)
		p=srl(p);
	      else
		p = drl(p);
	   }
	}
	else if (x>p->element)
	{
	      insert(x,p->right);
	      if ((bsheight(p->right) - bsheight(p->left))==2)
	      {
		if (x > p->right->element)
			p=srr(p);
		else
			p = drr(p);
	     }
	}
	else
		cout<<"Element Exists";
	}
	int m,n,d;
	m=bsheight(p->left);
	n=bsheight(p->right);
	d=max(m,n);
	p->height = d + 1;

}

//		Finding the Smallest
nodeptr bstree::findmin(nodeptr p)
{
	if (p==NULL)
	{
	    cout<<"
Empty Tree
";
	    return p;
	}
	else
	{
	   while(p->left !=NULL)
		p=p->left;
	   return p;
	}
}

//		Finding the Largest
nodeptr bstree::findmax(nodeptr p)
{
	if (p==NULL)
	{
	   cout<<"
Empty Tree
";
	   return p;
	}
	else
	{
	   while(p->right !=NULL)
	       p=p->right;
	   return p;
	}
}

//		Finding an element
void bstree::find(int x,nodeptr &p)
{
	if (p==NULL)
	   cout<<"
Element not found
";
	else
	if (x < p->element)
	   find(x,p->left);
	else
	if (x>p->element)
	   find(x,p->right);
	else
	   cout<<"
Element found !
";

}

//		Copy a tree
void bstree::copy(nodeptr &p,nodeptr &p1)
{
	makeempty(p1);
	p1 = nodecopy(p);
}

//		Make a tree empty
void bstree::makeempty(nodeptr &p)
{
	nodeptr d;
	if (p != NULL)
	{
	   makeempty(p->left);
	   makeempty(p->right);
	   d=p;
	   free(d);
	   p=NULL;
	}
}

//		Copy the nodes
nodeptr bstree::nodecopy(nodeptr &p)
{
	nodeptr temp;
	if (p==NULL)
	   return p;
	else
	{
	   temp = new node;
	   temp->element = p->element;
	   temp->left = nodecopy(p->left);
	   temp->right = nodecopy(p->right);
	   return temp;
	}
}

//		Deleting a node
void bstree::del(int x,nodeptr &p)
{
	nodeptr d;
	if (p==NULL)
	   cout<<"Element not found 
";
	else if ( x < p->element)
	   del(x,p->left);
	else if (x > p->element)
	   del(x,p->right);
	else if ((p->left == NULL) && (p->right == NULL))
	{
	   d=p;
	   free(d);
	   p=NULL;
	   cout<<"
 Element deleted !
";
	}
	else if (p->left == NULL)
	{
	  d=p;
	  free(d);
	  p=p->right;
	  cout<<"
 Element deleted !
";
	}
	else if (p->right == NULL)
	{
	  d=p;
	  p=p->left;
	  free(d);
	  cout<<"
 Element deleted !
";
	}
	else
	  p->element = deletemin(p->right);
}

int bstree::deletemin(nodeptr &p)
{
	int c;
	cout<<"inside deltemin 
";
	if (p->left == NULL)
	{
	  c=p->element;
	  p=p->right;
	  return c;
	}
	else
	{
	  c=deletemin(p->left);
	  return c;
	}
}

void bstree::preorder(nodeptr p)
{
	if (p!=NULL)
	{
	  cout<element<<"-->";
	  preorder(p->left);
	  preorder(p->right);
	}
}

//		Inorder Printing
void bstree::inorder(nodeptr p)
{
	if (p!=NULL)
	{
	   inorder(p->left);
	   cout<element<<"-->";
	   inorder(p->right);
        }
}

//		PostOrder Printing
void bstree::postorder(nodeptr p)
{
        if (p!=NULL)
        {
	   postorder(p->left);
	   postorder(p->right);
	   cout<element<<"-->";
	}
}

int bstree::max(int value1, int value2)
{
	return ((value1 > value2) ? value1 : value2);
}

int bstree::bsheight(nodeptr p)
{
	int t;
	if (p == NULL)
		return -1;
	else
	{
		t = p->height;
		return t;
	}
}

nodeptr bstree:: srl(nodeptr &p1)
{
	nodeptr p2;
	p2 = p1->left;
	p1->left = p2->right;
	p2->right = p1;
	p1->height = max(bsheight(p1->left),bsheight(p1->right)) + 1;
	p2->height = max(bsheight(p2->left),p1->height) + 1;
	return p2;
}

nodeptr bstree:: srr(nodeptr &p1)
{
	nodeptr p2;
	p2 = p1->right;
	p1->right = p2->left;
	p2->left = p1;
	p1->height = max(bsheight(p1->left),bsheight(p1->right)) + 1;
	p2->height = max(p1->height,bsheight(p2->right)) + 1;
	return p2;
}


nodeptr bstree:: drl(nodeptr &p1)
{
	p1->left=srr(p1->left);
	return srl(p1);
}

nodeptr bstree::drr(nodeptr &p1)
{
	p1->right = srl(p1->right);
	return srr(p1);
}

int bstree::nonodes(nodeptr p)
{
	int count=0;
	if (p!=NULL)
	{
		nonodes(p->left);
		nonodes(p->right);
		count++;
	}
	return count;

}



int main()
{
	clrscr();
	nodeptr root,root1,min,max;//,flag;
	int a,choice,findele,delele,leftele,rightele,flag;
	char ch='y';
	bstree bst;
	//system("clear");
	root = NULL;
	root1=NULL;
	cout<<"
		AVL Tree
";
	cout<<"		========
";
	do
	{
		cout<<"
		1.Insertion
		2.FindMin
		";
		cout<<"3.FindMax
		4.Find
		5.Copy
		";
		cout<<"6.Delete
		7.Preorder
		8.Inorder
";
		cout<<"		9.Postorder
		10.height
";
		cout<<"
Enter the choice:
";
		cin>>choice;
		switch(choice)
		{
		case 1:
			cout<<"
New node's value ?
";
			cin>>a;
			bst.insert(a,root);
			break;
		case 2:
			if (root !=NULL)
			{
			min=bst.findmin(root);
			cout<<"
Min element :	"<element;
			}
			break;
		 case 3:
                        if (root !=NULL)
                        {
			max=bst.findmax(root);
			cout<<"
Max element :	"<element;
			}
			break;
		case 4:
			cout<<"
Search node : 
";
			cin>>findele;
			if (root != NULL)
				bst.find(findele,root);
			break;
		case 5:
			bst.copy(root,root1);
			bst.inorder(root1);
			break;
		case 6:
			cout<<"Delete Node ?
";
			cin>>delele;
			bst.del(delele,root);
			bst.inorder(root);
			break;

		case 7:
			cout<<"
 Preorder Printing... :
";
			bst.preorder(root);
			break;

		case 8:
                       cout<<"
 Inorder Printing.... :
";
                        bst.inorder(root);
                        break;

		case 9:
                        cout<<"
 Postorder Printing... :
";
                        bst.postorder(root);
                        break;
		case 10:
			cout<<"
 Height and Depth is 
";
			cout<>ch;
	}while(ch=='y');


	return 0;
}
/////// Not include below line on program///////

Student Projects Presentation Assignments

khan-8725 January

Project Download Last Year, Previous Year, Final Year Semester project files for MCA (Master of Computer Application), BCA (Bachelor of Computer Application), BSc. (Bachelor of Science), BE (Bachelor of Engineer), BTech (Bachelor of Technologies), BSC-CS (Bachelor of Computer Science), BSC-IT (Bachelor of Science in Information Technology), DIT (Diploma In Information Technology), BCom IS (Bachelor of Commerce in Information System), PGDCA (Post Graduate Diploma in Computer Application), MSc. CS (Master of Science in Computer Science), MCom IS (Master of Commerce in Information System), MBA IT ( Master of Business Administration Information Technology), BIT, ADIT, ME, MTech, MBA IT/System, Diploma, Polytechnic Engineering , Computer Science...

A Study of Tea Plantation Operational Aspects in Relation to Operational Workforce .

The following is a dissertation by Niranjan Wickremasinghe which he submitted in January 2008 as a project report in partial fulfillment of the requirements for his Master of Business Administration degree from Sikkim Manipal University in India. Niranjan had a brief tea planting career from 1993 to 1998 and is now the Managing Director of Medicheks Colombo (Pvt) Ltd, which provides medical investigations
for HACCP, ISO and other quality certificate purposes. We are indeed indebted to
Niranjan for submitting this work for the benefit of our readers. Click Here to Download File

Multiple Questions for CA ii

Multiple Questions for CA ii Click Here to Download File

Presentation on Service tax
HISTORICAL BACKGROUND

APPLICABILITY

WHO MUST OBTAIN REGISTRATION & TIME LIMIT

GENERAL EXEMPTION FROM SERVICE TAX (SEC.93)

TAX IS CALCULATED ON THE VALUE

WHO IS LIABLE FOR SERVICE TAX?

OTHER PROVISIONS RELATING TO SERVICE TAX

Provisional Payment of Service tax

Due dates for payment of service tax

DEFAULT & EXCESS PAYMENT OF SERVICE TAX

When will return be filed?

Other provisions relating to return

Some important forms

Penalty for late filing of return

Click Here to Download File

Electronic Commerce and the Internet
Electronic Commerce and the Internet
Click Here to Download File

Accounting for the Growth of MNC-based Trade using a Structural Model of U.S. MNCs

U.S. foreign trade has grown much more rapidly than GDP in recent decades. But there is no consensus as to why. More than half of U.S. foreign trade consists of arms-length and intrafirm
trade activity by multinational corporations (MNCs). Thus, in order to better understand the growth of trade, it is important to understand the reasons for the rapid growth in MNC-based trade.This paper uses confidential BEA data on the activities of U.S. MNCs to shed light on this issue. Specifically, we estimate a simple structural model of the production and trade decisions of U.S. MNCs with affiliates in Canada, the largest trading partner of the U.S., using data from 1983-96. We then use the model as a framework to decompose the growth in intrafirm and arms-length trade flows into components due to tariff reductions, changes in technology, changes in wages, and other factors. We find that tariff reductions can account for a substantial part of the increase in armslength MNC-based trade. But our model attributes most of the growth of intra-firm trade to technical change, with tariff reductions playing only a secondary role. Simple descriptive statistics provide face validity for this result, since arms-length tradegrew much more rapidly in industries with the largest tariff reductions, while intra-firm trade grew rapidly even in industries where tariffs were negligible to begin with.

Our work makes a number of other contributions: Our descriptive analysis of the BEA firm level data, which has rarely been made available for research, suggests that few MNCs fit into the neat vertical vs. horizontal dichotomy of the theoretical literature. Also, we find that MNC decisions to engage in intra-firm and arms-length trade are unrelated to tariff levels. The growth in MNC-based trade due to tariff reductions has been almost entirely on the intensive margin, among the subset of firms already engaged in such activities.
Finally, the estimation of our model requires the development of a number of new econometric procedures. We present new recursive importance sampling algorithms that are the continuous and discrete/continuous analogues of the GHK method.

Click Here to Download File

AIRTEL advertisements and their impact.

To find out effectiveness AIRTEL advertisements & their impact on the viewers

Mobile penetration is currently exploding in India and Bharti Airtel has been riding the crest of the huge mobile industry wave that has been formed. Vast market opportunities have now opened up the playing field in Indian telecom market and also has made it much more competitive. In this type of competitive environment it will be interesting to find out how AIRTEL advertisements have helped it to retain its number 1 position. The objective of the study is to find out how the different advertisements of AIRTEL are impacting the viewers to use AIRTEL and what type of changes AIRTEL needs to make in near future to make its advertisements more efficient and effective.

Acknowledgment……………………………………………………………….2
Executive Summary………………………………………….………………...5
Introduction…………………………………………………………………….6
Literature Review………………………………………………………………8
Airtel products……………...………………………………………………....9
Objective of Study…………………………………………………………….14
Research Methodology………………………………………………………..15
Data Analysis…………………………………………………………………16
Findings……………..………………………………………………………...27
Recommendations…………………………………………………………….28
Limitations of Study…………………………………………………………..29
Bibliography…………………………………………………………………..31
Questionnaire…………………………………………………………………32

Click Here to Download File

Research Proposal on Consumer Decision Analysis for Purchase of Fruit Drinks.

This project aims to find out the various factors influencing the consumer decision while making a purchase of a fruit drink in the age group of 19-30 in the city of Pune. Background talks about various factors that have led us to undertake this study and how and to whom this report will benefit. Objectives talks of types of data the research project will generate and how these data is relevant. A statement of value of information is also included in this section. Research approach gives a non technical description of the data collection method, measurement instrument, sample and analytical techniques.
The beverage market in India is worth 2074.67 Million INR. Though the major portion of the market is still dominated by the carbonated soft drinks there is major shift towards the Juice segment. There was a growth of 31.52% in the Juice segment from 2007 to 2008. As a result of this phenomenal growth, a lot of competition has entered the market. A number of new brands have flooded the market. The competition from Indian beverages such as Sugarcane Juice, Buttermilk, and Fresh Juices etc has also captured a sizeable share of the market.
Due to these changes in the beverage market there is a need to identify and evaluate the reasons for the shift in the consumer purchasing pattern. This study aims to determine the factors influencing the consumer decision while buying fruit drinks in the age group 19-30 in the city of Pune.
I also need to study the factors that are now driving the consumer’s purchasing decision. Also, due to the increase in the competition there is a need to determine the awareness levels for the various brands amongst the consumers. With the availability of a number of channels of distribution for the beverages in India, I will also try to identify the most preferred shopping channel of beverages for a consumer.

Click Here to Download File