Rotation and Revolution of Two Wheels following a 'D' Shaped Path - Computer Graphics Experiment

This is a computer graphics lab experiment. The question was to animate both rotation and revolution of two wheels in opposite direction. Both the wheels move in a path in a of shape 'D'. If one moves in clockwise direction, the other moves in counter clockwise direction. The output of the program is as follows:
The program is as follows:

Program to Display String with Odd Number of Letters in the shape of letter 'X' - Zoho Programming Test Question

One of the previous questions in the programming round of Zoho recruitment process was to write a C program to display any string with odd number of letters as follows, in the shape of letter 'X'.

Print the word with odd number of letters as

P         M
 R      A
   O  R
     G
  O    R
 R       A
P          M 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void main()
{
int n,i,j,k,l;
char str[20];
printf("Enter a string with odd number of letters.");
scanf("%s",str);
if((n=strlen(str))%2==0)
    {
    printf("\nNot odd");
    exit(0);
    }

for(i=0;i<n;i++)
    {
    printf("\n");
    for(j=0;j<n;j++)
        {
        if(i==j||j==n-1-i)
            printf("%c",str[j]);
        else
            printf(" ");
        }
    }
}

C Program to Simulate grep Command in Linux

This post contains C program to simulate grep command in Linux or Unix operating systems

Simulation of  grep command in Linux

#include<stdio.h>
#include<string.h>
void main()
{
char fn[10],pat[10],temp[200];
FILE *fp;
printf("Enter file name\n");
scanf("%s",fn);
printf("Enter pattern to be searched\n");
scanf("%s",pat);
fp=fopen(fn,"r");
while(!feof(fp))
{
fgets(temp,1000,fp);
if(strstr(temp,pat))
  printf("%s",temp);
}
fclose(fp);
}

Related Posts:

C Program to Simulate ls Command in Linux
C Program to Simulate Round Robin CPU Scheduling Algorithm
C Program to Simulate Priority CPU Scheduling Algorithm
C Program to Simulate Shortest Job First (SJF) CPU Scheduling Algorithm
C Program to Simulate First Come First Serve (FCFS) CPU Scheduling Algorithm
C Program to Simulate rmdir Command or Delete Directory
C Program to Open, Read and Write Files
C Program to Create Process and Display Process ID - OS Lab Program
How to Use Fork and Exec System Calls
How to Use Exit System Call
C Program to make Parent Process Wait for Child to Terminate
C Program to make Child Process an Orphan Process
C Program to Show Process ID in Linux
C Program for Inter Process Communication using Pipes or Named Pipes (Chat Program)
C Program to Create a Process Using Fork System Call

Using System calls in C Program to rename a Directory in Linux

C Program to rename a directory in Unix or Linux operating systems using system call rename().

#include<stdio.h>
main()
{

char s[10],d[10];
printf("Enter source Dir Name:\n");
scanf("%s",s);
printf("Enter New Dir Name:\n");
scanf("%s",d);
if(rename(s,d)==-1)
perror("Can't be changed\n");
else
printf("%s is changed to %s\n\n",s,d);
}

How to Create process and display Process ID (pid) of Both Parent and Child

This program shows how to create process and display Process ID (pid) of Both Parent and Child processes. The process is created using the fork system call in UNIX (Linux) operating systems.

#include<stdio.h>
#include<dirent.h>
main(int argc,char **argv)
{

int pid,i;
for(i=0;i<atoi(argv[1]);i++)
{
pid=fork();
if(pid==0)
{
printf("child process id %d Parent process
id %d\n",getpid(),getppid());
}}}

How to use exit() System call

C program to show how to use exit system call. The function exit() is used to exit from a process (or to terminate a process). This works both in Linux or UNIX and Windows operating systems.

#include<stdio.h>
main()
{

int pid;
pid=fork();
printf("%d\n",pid);
if(pid<0)
{
perror("Child can't be executed\n");
exit(-1);
}
else
{
printf("Child created\n");
exit(0);
}
}

How to make parent process wait till Completion of Child Process (Joining parent with child process)

How to make the parent process wait till the completion of execution of child process. The following C program makes the parent process to wait till the completion of its child process.

#include<stdio.h>
main()
{

int pid;
pid=fork();
printf("%d\n",pid);
if(pid==0)
{
printf("From child process \n");
}
else
{
wait(0);
printf("From parent process\n");
}
}

How to make Child process an Orphan Process

C program in Linux or Unix to make a child process orphan:

Making child as orphan

#include<stdio.h>
main()
{

int pid,pid1;
pid=fork();
if(pid>0)
{
printf("From parent process\n");
printf("Parent process %d \n",getpid());
}
else
{
sleep(1);
printf("From child process\n");
printf("child process %d \n",getpid());
}}

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

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.

Program to Check Armstrong Number

An Armstrong number is a positive integer for which the sum of 'n'th power of its digits is equal to the number itself where n is the number of digits in the number. This is a c program to check whether a given number is an Armstrong number or not. For example, 153 is a 3 digit Armstrong number because 1³+5³+3³=153.

# include <stdio.h>
# include <conio.h>
# include <math.h>
void main ()
{
int a,b=0,sum=0;
long int n;
printf("Enter the number to check\n ");
scanf("%i",&n);
if(n<1)
{
printf ("\nThe number should be greater than 0");
}
else
{
a=n;
//counting the digits
while (a>0)
  {
  a=a/10;
  b++;
  }
a=n;
//adding up bth power of digits
while(a>0)
  {
  sum=sum+pow(( a%10) ,b);
  a=a/10;
  }
if(sum==n)
  printf ("\nThe number is an ARMSTRONG number");
else
  printf ("\nThe number is NOT an ARMSTRONG number");
}
getch();
}

Program to Display All Armstrong Numbers upto 1000

This post is for C program to display all Armstrong numbers less than 1000. But before all, I should tell what an Armstrong number is. An Armstrong number is a number that is the sum of its own digits each raised to the power of the number of digits. Consider an example. 153 is an Armstrong number. Since it is a 3 digit number, to check whether it is an Armstrong number or not, we should add the 3rd power digits together. So, in the program, we should have a code to determine number of digits in number, then add the n^th powers (where n is the number of digits) of each digit in the number and check whether both the sum and original number are the same.

#include<stdio.h>
#include<math.h>
void main()
{
int n,sum,r,digits;
for(n=1;n<=1000;n++)
  {
  digits=0;
  r=n;
  sum=0;
  while(r!=0)  //Counting Digits
    {
    digits++;
    r/=10;
    }
  r=n;
  while(r!=0)  /*Adding Digits Raised To a Power That Is Equal To Number of Digits *
    {
    sum+=pow((r%10),digits);
    r=r/10;
    }
  if(sum==n)
    {
    printf("%5d",sum);
    }
      }
}

C Program to Sort a Matrix Column wise using Pointers

This is a c program to sort a mxn matrix column wise in ascending order using pointers. To sort column wise in descending order, just replace the '>' symbol in the comparing line of code into '<'. That part of the code is marked with a comment 'comparison'.

#include<stdio.h>
main()
{
int a[7][7],i,j,k,m,n,temp;

//reading
printf("enter number of rows of matrix\n");
scanf("%i",&m);
printf("enter number of columns of matrix\n");
scanf("%i",&n);
printf("enter the elements\n");
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
scanf("%d",&a[i][j]);
}
//displaying
printf("the matrix you entered:\n");
for(i=0;i<m;i++)
{
printf("\n");
for(j=0;j<n;j++)
{
printf("%4d",*(*(a+i)+j));
}
}


//sorting
for(i=0;i<n;i++)
{
for(k=0;k<m-1;k++)
{
for(j=0;j<m-k-1;j++)
{
//comparison
if( *(*(a+j)+i)> *(*(a+(j+1))+i)) 
{
temp=*(*(a+j)+i);
*(*(a+j)+i)=*(*(a+(j+1))+i);
*(*(a+(j+1))+i)=temp;
}
}
}
}
//displaying
printf("\nSorted Matrix:\n");
for(i=0;i<m;i++)
{
printf("\n");
for(j=0;j<n;j++)
{
printf("%4d",*(*(a+i)+j));
}
}
}

Program to Understand Bitwise Operators

This is a C program that shows working of bitwise operators. The program takes two values, a and b. And displays the different bitwise operations' results. The program performs bitwise AND, bitwise OR, bitwise XOR, bitwise inversion (NOT), right bit shift and left bit shift operations.

#include<stdio.h>
main ()
{
unsigned int a = 60; /* 60 = 0011 1100*/
unsigned int b = 13; /* 13 = 0000 1101 */
printf ("a=60 ( 0011 1100)\nb=13 ( 0000 1101)\n"); 
int c = 0;
c = a&b ; /* 12 = 0000 1100 */
printf ("a&b=%d\n",c );
c = a | b ; /* 61 = 0011 1101 */
printf ("a|b=%d\n",c );
c = a ^ b ; /* 49 = 0011 0001 */
printf ("a^b=%d\n", c );
c = ~ a; /*-61 = 1100 0011 */
printf ("~a=%d\n" , c );
c = a << 2 ; /* 240 = 1111 0000 */
printf ("a<<2=%d\n" , c );
c = a >> 2 ; /*15 = 0000 1111*/
printf ("a>>2=%d\n" , c );
}