Computer Programming Fifth semester previous year Question Paper for Civil

Free download  Computer Programming (CP) 2014 Previous Year Question Paper as pdf for B.Tech Civil engineering.

Course : BTech Engineering course (degree)
University: MG University (Mahatma Gandhi University)
Semester: Fifth Semester (5th) (s5)
Subject: CE 010 502- Computer programming (CP) (C programming)

Department or Branch : Civil Engineering (CE)

Click to view file online

Click to download

C Program Using 8086 Interrupts to Restrict Mouse Pointer Into a Circle of Given Center and Radius

C Program Using 8086 Interrupts to Restrict Mouse Pointer Into a Circle of Given Center and Radius. The mouse ponter will be restricted to a circle of user specified center and radius using the interrupt 33 of 8086 in c complier. I have tested this program in Turbo C compiler.

Mouse pointer restricted into a circle in Turbo C

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

void main()
 {
 int x,y,tx,ty,r;
 union REGS inreg, outreg;
 /* request auto detection */
 int gdriver = DETECT, gmode, errorcode;
 clrscr();
 /* initialize graphics and local variables */
 initgraph(&gdriver, &gmode,"C:\\TC\\BGI\\" );
 /* read result of initialization */
 errorcode = graphresult();
 if (errorcode != grOk)  /* an error occurred */
  {
  printf("Graphics error: %s\n", grapherrormsg(errorcode));
  printf("Press any key to halt:");
  getch();
  exit(1); /* terminate with an error code */
  }
 setcolor(getmaxcolor());
 printf("\nEnter the center of circle. x and y");
 scanf("%d%d",&x,&y);
 printf("\nEnter the radius of circle");
 scanf("%d",&r);
 clrscr();
 circle(x,y,r);
 inreg.x.ax=0x1;
 int86(0x33,&inreg,&outreg);
 inreg.x.ax=0x7;
 inreg.x.cx=x-r;
 inreg.x.dx=x+r;
 int86(0x33,&inreg,&outreg);
 inreg.x.ax=0x8;
 inreg.x.cx=y-r;
 inreg.x.dx=y+r;
 int86(0x33,&inreg,&outreg);
 do
 {
  inreg.x.ax=0x3;
  int86(0x33,&inreg,&outreg);
  tx=outreg.x.cx;
  ty=outreg.x.dx;
  if((tx-x)*(tx-x)+(ty-y)*(ty-y)>r*r)
   {
   if(tx<=x)
   {
   if(ty<y)
    do{tx++; ty++;}while((tx-x)*(tx-x)+(ty-y)*(ty-y)>=r*r);
   else
    do{tx++; ty--;}while((tx-x)*(tx-x)+(ty-y)*(ty-y)>=r*r);
   }
   else
   {
   if(ty<=y)
    do{tx--; ty++;}while((tx-x)*(tx-x)+(ty-y)*(ty-y)>=r*r);
   else
    do{tx--; ty--;}while((tx-x)*(tx-x)+(ty-y)*(ty-y)>=r*r);
   }
   inreg.x.ax=0x4;
   inreg.x.cx=tx;
   inreg.x.dx=ty;
   int86(0x33,&inreg,&outreg);
   }
 }while(1);
}

C Program to Display and Set System Time and Date Using 8086 Interrupts

This is a C Program to Display and Set System Time and Date Using 8086 Interrupts. Interrupt number 21 (in hexadecimal) is used to:

Output of c Program to get and set system time and date 

• Get System time
• Set System time
• Get System Date
• Set System Date

To Get system date:

- Call interrupt 0x21 (hexadecimal) 

- AH (higher byte of accumulator) should be made equal to 2A (hex) before calling interrupt

Output:

• day in DL
• Month in DH
• Year in CX

To set System Date:

- Call interrupt 0x21 (hexadecimal) 

- AH (higher byte of accumulator) should be made equal to 2B (hex) before calling interrupt

- Before Calling interrupt, store:

• Year in CX
• Month in DH
• Day in DL

To Get system time:

- Call interrupt 0x21 (hexadecimal) 

- AH (higher byte of accumulator) should be made equal to 2C (hex) before calling interrupt

Output:

• Hours in CH
• Minutes in CL
• Seconds in DH
• 1/100 th of a second in DL

To set System Time:







- Call interrupt 0x21 (hexadecimal) 

- AH (higher byte of accumulator) should be made equal to 2D (hex) before calling interrupt
- Before Calling interrupt, store:

Hour in CH 
Minutes in CL
Seconds in DH 
1/100 th of second in DL

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

void main()
 {
 int day,month,year,tflag=0,dflag=0,hr,min,sec;
 union REGS inreg,outreg;
DISDATE:printf("\nCurrent date:\n");
 inreg.h.ah=0x2a;
 int86(0x21,&inreg,&outreg);
 printf("%d-%d-%d ",outreg.h.dl,outreg.h.dh,outreg.x.cx);
 switch(outreg.h.al)
  {
  case 0:printf("Sunday");break;
  case 1:printf("Monday");break;
  case 2:printf("Tueday");break;
  case 3:printf("Wednesday");break;
  case 4:printf("Thursday");break;
  case 5:printf("Friday");break;
  case 6:printf("Sunday");break;
  }
 if(dflag==1)
  goto SETTIME;
DISTIME:printf("\nCurrent Time:\n");
 inreg.h.ah=0x2c;
 int86(0x21,&inreg,&outreg);
 printf("%d:%d:%d.%d ",outreg.h.ch,outreg.h.cl,outreg.h.dh,outreg.h.dl);
 if(tflag==1)
  goto END;
SETDATE:printf("\nSet Date.\nDay,Month and Year\n");
 scanf("%d%d%d",&day,&month,&year);
 inreg.h.ah=0x2b;
 inreg.x.cx=year;
 inreg.h.dh=month;
 inreg.h.dl=day;
 int86(0x21,&inreg,&outreg);
 if(outreg.h.al==0x00)
  {
  dflag=1;
  goto DISDATE;
  }
 else
  {
  printf("\nInvalid entry");
  getch();
  exit(0);
  }
SETTIME:printf("\nSet Time. Enter Time.\nHour,Minutes and Seconds\n");
 scanf("%d%d%d",&hr,&min,&sec);
 inreg.h.ah=0x2d;
 inreg.h.ch=hr;
 inreg.h.dh=sec;
 inreg.h.cl=min;
 inreg.h.dl=0;
 int86(0x21,&inreg,&outreg);
 if(outreg.h.al==0x00)
  {
  tflag=1;
  goto DISTIME;
  }
 else
  {
  printf("\nInvalid entry");
  getch();
  exit(0);
  }
END: getch();
 }

C Program To Implement Circular Linked List

C Program to implement circular linked list.

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

struct node
    {
    int info;
    struct node *link;
    }*last;
void create_list(int num);
void addatbeg(int num);
void addafter(int num,int pos);
void del(int num);
void display();
void main()
    {
    int choice,n,m,po,i;
    last=NULL;
    while(1)
        {
        printf("1.Create List\n");
        printf("2.Add at begining\n");
        printf("3.Add after \n");

printf("4.Delete\n");

        printf("5.Display\n");
        printf("6.Quit\n");
        printf("Enter your choice : ");
        scanf("%d",&choice);

switch(choice)
           {
           case 1: printf("How many nodes you want : ");
                   scanf("%d",&n);
                   for(i=0; i < n;i++)
                      {
                      printf("Enter the element : ");
                      scanf("%d",&m);
                      create_list(m);
                      }
                   break;
           case 2: printf("Enter the element : ");
                   scanf("%d",&m);
                   addatbeg(m);
                   break;
           case 3: printf("Enter the element : ");
                   scanf("%d",&m);
                   printf("nter the position after which this element is inserted: ");
                   scanf("%d",&po);
                   addafter(m,po);
                   break;
           case 4: if(last == NULL)
                        {
                        printf("List underflow\n");
                        continue;
                        }
                   printf("Enter the number for deletion : ");
                   scanf("%d",&m);
                   del(m);
         break;
           case 5: display();
     break;
           case 6: exit(0);
           default:printf("Wrong choice\n");
           }
       }
   }
void create_list(int num)
   {
   struct node *temp;
   temp=(node*)malloc(sizeof(struct node));
   temp->info = num;
   if(last == NULL)
       {
       last = temp;
       temp->link = last;
       }
   else
       {
       temp->link = last->link;
       last->link = temp;
       last = temp;
       }
   }

void addatbeg(int num)
    {
    struct node *temp;
    temp =(node*)malloc(sizeof(struct node));
    temp->info = num;
    temp->link = last->link;
    last->link = temp;
    }
void addafter(int num,int pos)
    {
    struct node
    *temp,*q;
    int i;
    q = last->link;
    for(i=0;i<pos-1;i++)
       {
       q = q->link;
       if(q==last->link)
           {
    printf("There are less than %d elements\n",pos);
           return;
    }
       }
    temp =(node*)malloc(sizeof(struct node) );
    temp->link = q->link;
    temp->info = num;
    q->link = temp;
    if(q==last)  //Element inserted at the end
        last=temp;
    }//End of addafter()

void del(int num)
    {
    struct node *temp,*q;
    if( last->link == last && last->info == num)  //Only one element
        {
        temp=last;
        last = NULL;
        free(temp);
        return;
 }
    q = last->link;
    if(q->info == num)
        {
 temp = q;
        last->link = q->link;
        free(temp);
        return;
 }
    while(q->link !=last)
        {
        if(q->link->info==num) //Element deleted in between
           {
           temp = q->link;
           q->link = temp->link;
           free(temp);
           printf("%d deleted\n",num);
           return;
           }
       q = q->link;
       }
   if(q->link->info==num) //Last element deleted q->link=last
       {
       temp = q->link;
       q->link = last->link;
       free(temp);
       last = q;
       return;
       }
   printf("Element %d not found\n",num);
   }

void display()
   {
   struct node *q;
   if(last == NULL)
      {
      printf("List is empty\n");
      return;
      }
   q = last->link;
   printf("List is :\n");
   while(q != last)
      {
      printf("%d ", q->info);
      q = q->link;
      }
   printf("%d\n",last->info);
   }

C Program For Insertion And Deletion In Heap

C program code for Insertion and Deletion in a Heap.

#include <stdio.h>
#include<stdlib.h>
int arr[100],n;
void display();
void insert(int num,int loc);
void del(int num);

void main()
 {
 int choice,num;
 n=0; //number of nodes in the heap
 while(1) //loop for menu
  {
  printf("1.Insert\n");
  printf("2.Delete\n");
  printf("3.Display\n");
  printf("4.Quit\n");
  printf("Enter your choice : ");
  scanf("%d",&choice);
  switch(choice)
   {
    case 1:
    printf("Enter the number to be inserted : ");
    scanf("%d",&num);
    insert(num,n);
    n=n+1;
    break;
    case 2:
    printf("Enter the number to be deleted : ");
    scanf("%d",&num);
    del(num);
    break;
    case 3:                                                 
    display();
    break;
    case 4:
    exit(0);
   default: printf("Wrong choice\n");
   }
  }
 }

void display()
 {
 int i;
 if(n==0)
  {
  printf("Heap is empty\n");
  return;
  }
 for(i=0;i<n;i++)
  printf("%d ",arr[i]);
 printf("\n");
 }

void insert(int num,int loc)
 {
 int par;
 while(loc>0)
  {
  par=(loc-1)/2;
  if(num<=arr[par])
   {
   arr[loc]=num;
   return;
   }
  arr[loc]=arr[par];
  loc=par;
  }
 arr[0]=num; //assign num to the root node
 }

void del(int num)
 {
 int left,right,i,temp,par;
 for(i=0;i<n;i++)
  {
  if(num==arr[i])
   break;
  }
 if(num!=arr[i])
  {
  printf("%d not found in heap\n",num);
  return;
  }
 arr[i]=arr[n-1];
 n=n-1;
 par=(i-1)/2; //find parent of node i
 if(arr[i] > arr[par])
  {
  insert( arr[i],i);
  return;
  }
 left=2*i+1;  //left child of i
 right=2*i+2; // right child of i
 while(right < n)
  {
  if(arr[i]>=arr[left] && arr[i]>=arr[right])
   return;
  if(arr[right]<=arr[left])
   {
   temp=arr[i];
   arr[i]=arr[left];
   arr[left]=temp;
   i=left;
   }
  else
   {
   temp=arr[i];
   arr[i]=arr[right];
   arr[right]=temp;
   i=right;
   }
  left=2*i+1;
  right=2*i+2;
  }
 if( left==n-1 && arr[i]<arr[left] ) /* right==n */
  {
  temp=arr[i];
  arr[i]=arr[left];
  arr[left]=temp;
  }
 }

C Program To Represent Directed or Undirected Graph Using Adjacency Matrix

C program to represent directed or undirected graph using Adjacency matrix.

#include<stdio.h>
#include<conio.h>
#define max 20
int adj[max][max]; //Adjacency matrix
int n;  //Denotes number of nodes in the graph
void main()
 {

  int max_edges,i,j,origin,destin;
  char graph_type;
  printf("Enter number of nodes : ");
  scanf("%d",&n);
  printf("Enter type of graph, directed or undirected.\n");
   printf("Enter d for directed and u for undirected:\n ");
  fflush(stdin);
   scanf("%c",&graph_type);
   if(graph_type=='u')
    max_edges=n*(n-1)/2;
  else
    max_edges=n*(n-1);
  for(i=1;i<=max_edges;i++)
    {
    printf("Enter edge %d( 0 0 to quit ) : ",i);
    scanf("%d %d",&origin,&destin);
    if( (origin==0) && (destin==0) )
     break;
    if( origin > n || destin > n || origin<=0 || destin<=0)
     {
     printf("Invalid edge!\n");
     i--;
     }
    else
     {
     adj[origin][destin]=1;
     if( graph_type=='u')
      adj[destin][origin]=1;
     }
    }

  printf("The adjacency matrix is :\n");
  for(i=1;i<=n;i++)
    {
    for(j=1;j<=n;j++)
     printf("%4d",adj[i][j]);
    printf("\n");
    }
   getch();
  }

C Program to Display SCAN and ASCII Codes of Keys on Keyboard Using 8086 Interrupt

Output (ASCII and SCAN code) when a is pressed

This program displays SCAN code and ASCII code of any key pressed on the keyboard. We use inregs is made zero in the program. Then interrupt 16h is called using int86() function in dos.h. The arguments are interrupt number (in hexadecimal ; in C 0x16) pointer to input register and pointer to output register.
The interrupt stores scan code in higher byte of accumulator and ASCII code in lower byte of accumulator.

8086 interrupt number 16h (hexadecimal) to read a keystroke from keyboard. The condition for this interrupt is that the higher byte of accumulator (AH) should be 00h.

#include<stdio.h>
#include<dos.h>
#include<conio.h>
void main()
 {
 union REGS inregs,outregs; //declaring 2 register files
 clrscr();
 inregs.h.ah=0x0; //pre-requisite for desired operation of interrupt 16h
 int86(0x16,&inregs,&outregs); //calling interrupt 16h
 printf("\nScan Code :%d\nASCII code:%d\n",outregs.h.ah,outregs.h.al);
 getch();
 }

C and C++ Compiler For Android Smartphones

In this post i'm listing some C Program compilers for Android phones or tabs. It will be very handy if you have one in your phone if you are a programming student. You don't need to have a laptop or a Personal computer with you.

C4Droid

It is a powerful offline C/C++ IDE + C/C++ compiler for Android operating System. I have been using it for 1 year. You do not need to root your phone to use this app. Its features are as listed below:

• Syntax highlighting
• Multiple tabs
• code complete
• Auto formating
• Options to export the program as apk or other Executables
• Full ANSI C and ISO C99 support with TCC (Tiny C Compiler) + uClibc
• Customizable Graphical User Interface with themes
• C++ support with GCC+
• Debugger with breakpoints and watches

C4Droid screen shot

Playstore link to the Application

CppDroid - C/C++ IDE

This is another offline compiler but it is freeware app. Rooting is not required. You don't have to pay for it. It is designed for educational purposes as the developer says, "CppDroid is simple C/C++ IDE focused on learning programming languages and libraries".


Features:

• real-time diagnostics (warnings and errors) and fixes
• syntax highlighting
• portrait or landscape UI
• C/C++ code examples and guides
• GUI customisation with themes

Find CppDroid in Playstore

C Compiler

A very simple and basic C compiler for Android phones. Not many features.

Find it in Google playstore

Storage Classes for Variables in C Programming Language

Every variable in C programming language has two properties; type and storage class. 'Type' refers to the data type of the variable such as integer, character, floating point values etc. It also deals with the size of the variable ( in bytes). 'Storage class' determines the part of memory where storage is allocated for the variable and how long the storage allocation continues to exist. It also determines the scope which specifies the part of the program over which a variable name is visible, i.e. the variable is accessible by name. The scope restriction can be overrode by making use of pointers. Whatever, in short, storage class is the property that determines the part of memory where storage is allocated, the lifetime of variable and the scope of the variable.

There are for storage classes in C programming:

• Automatic
• Register
• External
• Static

Automatic variables:

'Aromatic' or 'auto' is the storage class which is default for all local variables, i.e. variables declared inside a function or a block is automatic by default. They are normally declared s at the start of the block. Memory is allocated automatically upon entry to a block and freed automatically upon exit from the block. The scope of automatic variables is local to the block in which they are declared, including any blocks nested within the block. For these reasons, automatic variables are often referred to as 'local variables'. Since any variable declared inside a block or a function is 'local' by default, the keyword 'auto' which is used to declare automatic variables, are rarely used.

int fact(int n)
{
  auto int result; /* automatic variable declaration*/
  if(n==0)
   result =1;
  else
   result =n*fact (n-1);
  return (result);
}

In above example, an automatic integer variable 'result' is declared within the function 'fact'. The variable is local to the function as it's declared as automatic. But, it is not necessary to use the keyword 'auto' because even if auto is avoided, the variable will be auto by default.

Register Variables:

A Register variable is a special case of automatic variable. Register variables are identical to automatic variables in the case of scope, i.e, they are local to the function or block in which they are declared. The only difference is in the part of memory in which the storage is allocated. An automatic variable is always stored in RAM whereas, as the name indicates, register variables are stored in registers. When we consider a program in which a certain variable is frequently used, the performance of the program can be improved if it is stored in a register instead of RAM since registers are very much faster memory components than RAM. Variables used in enormously repeated loops of large programs, variables used as parameters for frequently called functions etc. can be declared as register variables in order to increase the performance of the program considerably.

To declare a register variable, the keyword 'register' should be prefixed to the data type as shown:

register int a;

When the compiler encounters a register variable declaration, it tries to store the variable in microprocessor's register rather than RAM. Value stored in registers are much faster than those in RAM. Since the number of registers are limited, if it couldn't be stored in register it will store it in RAM. Even the availability of resisters doesn't guarantee faster execution of program. For example, if too many register variables are declared and there are not enough registers to store all of them, values in some of the registers would have to be moved to temporary storage in memory in order to clear those registers for other variables. Thus much time may be wasted in shipping the data in and out of the registers. In addition, careless use of register variables may interfere with other uses of registers by the compiler, such as storage of temporary values in expression evaluation. In short, the keyword 'register' should be used carefully and lavish usage may result in slower execution of program.

External variables:

In some applications it may be helpful to have data which is accessible from within any block and/or which remains in existence for the entire execution of program. Such variables are called global variables, and the C language provides storage classes which can meet these requirements; namely, the external storage class.
External variables may be declared outside any function block in a source code file the same way any other variable is declared; by specifying its type and name. No storage class specifier is used -- the position of the declaration within the file indicates external storage class. Memory fit such variables is allocated when the program begins execution, and remains allocated until the program terminates. For most C implementations, every byte of memory allocated for an external variable is initialised to zero. The scope of the external variable is global,i.e. the entire source code in the file following the declarations. All functions following the declaration may access the external variable by using its name. However, if a local variable having the same name is declared within a function, references to the name access the local variable cell.

#include<stdio.h>
int m=0; /* External variable */
main ()
   {
   int m=1; /* auto variable */
   printf("m=%d",m);
   }

The output of this code is:

m=1

Static variable

The difference between static and automatic storage class is that the lifetime of a static variable is more than that of the automatic variable. The difference between them is that static variable do not disappear when the function is no longer active. There value persist. If control comes back to the same function again , the static variables have the same values they had last time around. The difference can be easily understood by comparing two programs with same variable with different storage classes. Let us compare two programs and their outputs.

    
   
#include<stdio.h>

void findsum(int a)

   {

   auto int sum=0; /*automatic*/

   sum+=a;

   printf("\nsum=%d",sum);

   }

void main()

   {

   int p;

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

     {

     findsum(p);

     }

   }
#include<stdio.h>

void findsum(int a)

   {

   static int sum=0; /*static*/

   sum+=a;

   printf("\nsum=%d",sum);

   }

void main()

   {

   int p;

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

     {

     findsum(p);

     }

   }
  
   
   
  

Output: sum=1 sum=2 sum=3

Output: sum=1 sum=3 sum=6

In the first example, the variable sum in findsum() is declared as an automatic variable while it is static in second example. In first example, at the first call of function findsum() (when p=1), the variable sum in the function is initialized as with zero. After the completion of execution of the function findsum(), the life of variable sum ends. In the next call, again sum is allocated and initialised. So, each time the number is going to be added, the initial value of sum will be 0.

In second example, once the function gets executed, the variable sum is allocated and initialised with zero. Since it is declared as a static variable, the line static int sum=0; will not be executed in the next executions of the function. i.e. the declaration statement (along with initialisation if any) will not be executed each time the function is called. Moreover, if one execution of the function is over, the static variable will not be deallocated. If control comes back to the same function again , the static variables have the same values they had last time around. There for the variable sum will give cumulative values in second example.