Showing posts with label c programs. Show all posts
Showing posts with label c programs. Show all posts

Sunday, June 17, 2012

68. PROGRAM TO READ AND WRITE INTEGER VALUES


//WAP TO READ AND WRITE INTEGER VALUES
#include<stdio.h>
#include<conio.h>
void main()
{
 FILE *f1,*f2,*f3;
 int number,i;
 clrscr();
 printf("\n\nENTER THE CONTENTS IN A FILE\n\n");
 f1=fopen("data","w");
 for(i=0;i<=9;i++)
 {
  scanf("%d",&number);
  if(number==-1)
  break;
  putw(number,f1);
 }
 fclose(f1);
 f1=fopen("data","r");
 f2=fopen("odd","w");
 f3=fopen("even","w");
 while((number=getw(f1))!=EOF)
 {
  if(number%2==0)
  putw(number,f3);
   else
    putw(number,f2);
 }
 fclose(f1);
 fclose(f2);
 fclose(f3);
 f2=fopen("odd","r");
 f3=fopen("even","r");
 printf("\n\nCONTENTS OF ODD FILE\n\n");
 while((number=getw(f2))!=EOF)
  {
   printf("%d",number);
   printf("\t");
  }
 printf("\n\nCONTENTS OF EVEN FILE\n\n");
 while((number=getw(f3))!=EOF)
  {
   printf("%d",number);
   printf("\t");
  }
 fclose(f2);
 fclose(f3);
 getch();
}
/**************************************************************************
      OUTPUT
 **************************************************************************


 ENTER THE CONTENTS IN A FILE

 1 2 3 4 5 6 7 8 9 0^Z


 CONTENTS OF ODD FILE

 1       3       5       7       9

 CONTENTS OF EVEN FILE

 2       4       6       8       0
 */

                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               

Saturday, June 16, 2012

66. PROGRAM TO COPY ONE STRING TO ANOTHER USING POINTERS


//WAP TO COPY ONE STRING TO ANOTHER USING POINTERS
 #include<conio.h>
 #include<stdio.h>
 void copystr(char*,char*);
 main()
 {
  char *str1="YOU ARE COPYING";
  char str2[20];
  clrscr();
  copystr(str2,str1);

  printf("\n%s",str2);
  getch();
  }
  void copystr(char *dest,char *src)
  {
   while(*src!='\0')
   {
    *dest++=*src++;
   }
   *dest='\0';
  return;
  }

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

 YOU ARE COPYING
 */
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               

65. PROGRAM TO DEFINE A STRING USING POINTER NOTATION & ARRAY NOTATION



//WAP TO DEFINE A STRING USING POINTER NOTATION & ARRAY NOTATION
 #include<conio.h>
 #include<stdio.h>

 void main()
 {
  char str1[]="Defined As An Array";
  char *str2="Defined As A Pointer";

  clrscr();
  printf("\n\n%s",str1);
  printf("\n\n%s",str2);
  printf("\n\n%s",str2+5);
  getch();
 }
/***************************************************************
  OUTPUT
 ***************************************************************

                                                                               
 Defined As An Array

 Defined As A Pointer

 ed As A Pointer
 */
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               


64. PROGRAM TO SORT LIST OF NO. WITHOUT CHANGING THE ORIGINAL ARRAY


/*WAP TO SORT LIST OF NO. WITHOUT CHANGING THE ORIGINAL ARRAY.
 **************not workng***************/
 #include<conio.h>
 #include<stdio.h>
 void main()
 {
 int a[20],i,*ptr,j,temp,n;
 ptr=a;

 clrscr();
 printf("\n\nENTER THE SIZE OF THE ARRAY=");
 scanf("%d",&n);
 printf("\n\nENTER THE ELEMENTS=\n");
 for(i=0;i<n;i++)
 {
 scanf("%d",&a[i]);
 ptr[i]=&a[i];
 }
 for(j=0;j<n-1;j++)
 {
 for(i=0;i<n-1;i++)
  {
   if(*ptr[i]>*ptr[i+1])
   {
    temp=ptr[i];
    ptr[i]=ptr[i+1];
    ptr[i+1]=temp;
   }
  }}
 printf("\n\nORIGINAL ARRAY IS=");
 for(i=0;i<n;i++)
 printf("\n%d",a[i]);
 printf("\n\nAFTER SORTING ARRAY IS=");
 for(i=0;i<n;i++)
 printf("%d",*ptr[i]);
 getch();
 }

63. PROGRAM TO DEMONSTRATE THAT ARRAY ELEMENTS ARE STORED IN CONTIGUOUS MEMORY LOCATION


/*WAP TO DEMONSTRATE THAT ARRAY ELEMENTS ARE STORED IN
  CONTIGUOUS MEMORY LOCATION*/
 #include<conio.h>
 #include<stdio.h>
 void main()
 {
  int x[5]={10,20,30,40,50};
  int i;
  int *ptr;
  ptr=x;
  clrscr();
  for(i=0;i<5;i++)
  printf("\n\nVALUE %d = %d IS STORED AT=%u",i,x[i],ptr+i);
  getch();
  }
/*************************************************************************
    OUTPUT
 *************************************************************************


 VALUE 0 = 10 IS STORED AT=65516

 VALUE 1 = 20 IS STORED AT=65518

 VALUE 2 = 30 IS STORED AT=65520

 VALUE 3 = 40 IS STORED AT=65522

 VALUE 4 = 50 IS STORED AT=65524
 */


                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               

61. PROGRAM TO DEMONSTRATE USE OF ADDRESS OF OPERATOR(&) AND INDIRECTION OPERATOR(*) FOR DIFF. PURPOSES


/*WAP TO DEMONSTRATE USE OF ADDRESS OF OPERATOR(&)
  AND INDIRECTION OPERATOR(*) FOR DIFF. PURPOSES*/

   #include<conio.h>
   #include<stdio.h>
   void main()
   {
    int i=5,j=2,*ptr;
    ptr=&i;
    clrscr();
    printf("\n\nADDRESS OF i=%u",&i);
    printf("\n\nVALUE STORED IN ptr=%u",ptr);
    printf("\n\nVALUE POINTED BY ptr=%d",*ptr);
    *ptr=10;
    printf("\n\nVALUE OF i=%d",i);
    j=*ptr;
    printf("\n\nVALUE OF j=%d",j);
    getch();
    }
/**************************************************************************
     OUTPUT
 **************************************************************************


 ADDRESS OF i=65524

 VALUE STORED IN ptr=65524

 VALUE POINTED BY ptr=5

 VALUE OF i=10

 VALUE OF j=10
 */
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               

57. PROGRAM TO CHECK WHETHER THE ENTERED STRING IS PALLINDROME OR NOT


//WAP TO CHECK WHETHER THE ENTERED STRING IS PALLINDROME OR NOT.
#include<conio.h>
#include<stdio.h>
#include<string.h>
void main()
{
 char a[20];
 char b[20];
 char temp[20];
 char temp1[20];
 char ch='y';
 int i;
 clrscr();

 do
 {
  fflush(stdin);
  puts("\n\nENTER THE STRING:");
  gets(a);
  printf("\n\nENTERED STRING IS:");
  puts(a);
  strcpy(temp1,a);
  strrev(a);
  strcpy(temp,a);
  for(i=0;a[i]!='\0';i++)
  if(temp1[i]==temp[i])
  {
   printf("\n\nENTERED STRING IS A PALLINDROME");
   break;
  }
   else
   {
    printf("\n\nENTERED STRING IS NOT A PALLINDROME");
    break;
   }
 puts("\n\nDO YOU WANT TO CONTINUE?");
 scanf("%s",&ch);
 }while(ch=='y'||ch=='Y');
 puts("\n\nBYE!!BYE!!\n\nPROGRAMMER:ABHISHEK WADHWA");
 getch();
}
/*-----------------------------------------------------------
      OUTPUT
  ------------------------------------------------------------


ENTER THE STRING:
NAMAN


ENTERED STRING IS:NAMAN


ENTERED STRING IS A PALLINDROME

DO YOU WANT TO CONTINUE?
Y


ENTER THE STRING:
ABHISHEK


ENTERED STRING IS:ABHISHEK


ENTERED STRING IS NOT A PALLINDROME

DO YOU WANT TO CONTINUE?
N


BYE!!BYE!!

PROGRAMMER:ABHISHEK WADHWA
*/


                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               

53. PROGRAM TO PRINT OUT THE NAMES OF THE DAYS OF THE WEEK


//WAP TO PRINT OUT THE NAMES OF THE DAYS OF THE WEEK.
 #include<conio.h>
 #include<stdio.h>
 void main()
 {
  char day[7][10]={"SUNDAY","MONDAY","TUESDAY","WEDNESDAY","THURSDAY","FRIDAY","SATURDAY"};
  int i;
  clrscr();
  for(i=0;i<7;i++)
  {
   printf("%s\n\n",day[i]);
  }
  getch();
 }

/*--------------------------------------------------------------
     OUTPUT
 ----------------------------------------------------------------
 SUNDAY
                                                                             
MONDAY                                                                        
                                                                             
TUESDAY                                                                      
                                                                             
WEDNESDAY                                                                    
                                                                             
THURSDAY                                                                      

FRIDAY

SATURDAY
*/
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             

52. PROGRAM TO PRINT ABCDE BCDEA CDEAB DEABC EABCD


/*WAP TO PRINT   abcde
bcdea
cdeab
deabc
eabcd*/

 #include<conio.h>
 #include<stdio.h>
 void main()
 {
 char a[20],temp;
 char i,j,n;
 clrscr();
 printf("\n\nENTER THE STRING:");
 gets(a);
 puts("\n\n");
 n=strlen(a);
 puts(a);
 for(i=0;i<n-1;i++)
 {
  temp=a[0];
  for(j=0;j<n-1;j++)
  {
   a[j]=a[j+1];
  }
  a[n-1]=temp;
  puts("\n\n");
  puts(a);
  }
 getch();
 }
 /*---------------------------------------------------------------
OUTPUT
  -----------------------------------------------------------------


ENTER THE STRING:ABCDE



ABCDE



BCDEA



CDEAB



DEABC



EABCD

*/

                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             

PROGRAM TO SORT THE CHARACTERS ALPHABATICALLY

//WAP TO SORT THE CHARACTERS ALPHABATICALLY.
#include<conio.h>
#include<stdio.h>
void main()
{
char a[20];
int m,j,k,temp;
clrscr();
printf("\nENTER THE STRING:");
gets(a);
k=strlen(a);
for(j=1;j<=k-1;j++)
for(m=0;m<k-j;m++)
{
 if(a[m]>a[m+1])
 {
  temp=a[m];
  a[m]=a[m+1];
  a[m+1]=temp;
 }
}
printf("\n\nAFTER SORTING STRING IS:\n\n");
puts(a);
getch();
}
/*-------------------------------------------------------------------
  OUTPUT
  -------------------------------------------------------------------

ENTER THE STRING:BADCFEHGJILK


AFTER SORTING STRING IS:

ABCDEFGHIJKL
*/




                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             


Programming the Whole World!