C Language & Programs

                                             'C' LANGUAGE
                                       =============

COMPUTER / SYSTEM :- IT IS THE COMBINATION OF HARDWARE AND SOFTWARE.
HARDWARE :- PHYSICAL PARTS OF THE COMPUTER. WHICH ARE SEE AND TOUCHABLE.
Ex :- KEYBOARD, MOUSE, MONITOR etc.

SOFTWARE :- SET OF PROGRAMS. WHICH ARE INVISIBLE AND UNTOUCHABLE.

Ex :- MS-OFFICE, WINDOWS, ORACLE, PHOTOSHOP etc.

TYPES OF SOFTWARES
====================

1) OPERATING SYSTEMS

2) PACKAGES

3) LANGUAGES

OPERATING SYSTEM :- IT IS AN INTERFACE (WAY) BETWEEN USER AND COMPUTER. IT CONTROLS AND MANAGES THE TOTAL RESOURCES OF THE COMPUTER. THROUGH OPERATING SYSTEM ONLY WE CAN OPERATE THE SYSTEM. WITHOUT OPERATING SYSTEM WE CAN'T PERFORM EVEN SINGLE OPERATION.

Ex :- MS-DOS, WINDOWS, UNIX, LINUX, MACINTOSH etc

PACKAGE :- IT IS A PRE-DESIGNED SOFTWARE.

ADVANTAGE : TIME SAVE.

DISADVANTAGE : WE CAN'T MAKE ANY MODIFICATIONS IN IT.

Ex:- MS-OFFICE, PHOTOSHOP, TALLY, PAGE MAKER etc

LANGUAGE :- BY USING LANGUAGES WE CAN DEVELOP NEW SOFTWARES.

ADVANTAGE :- WE CAN DEVELOP SOFTWARES AS PER OUR REQUIREMENTS.

DISADVANTAGE :- TIME WASTE.

BY USING LANGUAGES WE CAN DEVELOP NEW SOFTWARES / PROJECTS / APPLICATIONS / PACKAGES.

Ex :- COBOL, PASCAL, C, C++, JAVA etc

DATA :- IT IS NOTHING BUT A KNOWN VALUE, WHICH IS FORMED WITH DIGITS, ALPHABETS AND SPECIAL CHARACTERS.

Ex :- 101, RAMA, 12/3/09

INFORMATION :- PROCESSED DATA.

6 + 3 : 9

IN THE ABOVE STATEMENT 6 + 3 IS CALLED DATA AND 9 IS CALLED INFORMATION.

INSTRUCTION / STATEMENT :- IT IS NOTHING BUT A REQUEST / COMMAND.

Ex :- A = 10

PROGRAM :- SET OF INSTRUCTIONS.

Ex :- A = 10
B = 20
C = A + B
PRINT C

WHY WRITE PROGRAMS? :- TO SOLVE PROBLEMS.

WHERE WRITE PROGRAMS ? :- IN LANGUAGES.

SOFTWARE :- SET OF PROGRAMS.

BY WRITING PROGRAMS IN LANGUAGES WE CAN DEVELOP NEW SOFTWARES.

LANGUAGE :- IT IS A WAY TO COMMUNICATE WITH OTHERS / SYSTEM.

COMPUTER LANGUAGE :- IT UNDERSTANDS ONLY MACHINE LANGUAGE, WHICH CONTAINS ONLY ZEROS (OFF) AND ONES (ON). SYSTEM CONVERTS ANYTHING INTO ONES AND ZEROS. FOR EXAMPLE 25 IS CONVERTED TO 11001. (DRAW FIGURE).

TYPES OF LANGUAGES
====================

1) LOW LEVEL LANGUAGES

2) HIGH LEVEL LANGUAGES

LOW LEVEL LANGUAGES :- THESE ARE SYSTEM FRIENDLY LANGUAGES.  IN THESE LANGUAGES READIBILITY (READING FACILITY) & DEBUGGING (RECTIFYING ERRORS) IS VERY DIFFICULT. THE MAIN ADVANTAGE OF THESE LANGUAGES IS, THESE LANGUAGES INSTRUCTIONS EXECUTES VERY FASTLY BY SYSTEM. THESE LANGUAGES ARE CLASSIFIED INTO TWO CATEGORIES.

1) MACHINE LANGUAGE

2) ASSEMBLY LANGUAGE

MACHINE LANGUAGE :- IT IS NOTHING BUT SYSTEM LANGUAGE.

ASSEMBLY LANGUAGE :- BY USING THIS LANGUAGE WE CAN WRITE PROGRAM STATEMENTS WITH THE HELP OF MNEMONICS (SMALL ENGLISH WORDS LIKE ADD, SUB, MUL, DIV etc).

HIGH LEVEL LANGUAGES :- THESE ARE USER  FRIENDLY LANGUAGES.  USING THESE LANGUAGES WE CAN WRITE PROGRAM STATEMENTS IN SIMPLE ENGLISH LANGUAGE. THESE LANGUAGES PROVIDES EXCELLENT READIBILITY (READING FACILITY) & DEBUGGING (RECTIFYING ERRORS) FACILITIES. WE CAN'T COMMUNICATE DIRECTLY WITH SYSTEM THROUGH HIGH LEVEL LANGUAGES. WE CAN COMMUNICATE WITH THE HELP OF TRANSLATORS. SO THESE LANGAUGE INSTRUCTIONS EXECUTES SLOWLY.

Ex :- C, C++, JAVA etc.

LANGUAGE TRANSLATORS
========================

THESE ARE USED TO TRANSLATE HIGH LEVEL LANGUAGE INSTRUCTIONS INTO MACHINE LANGUAGE AND MACHINE LANGUAGE INSTRUCTIONS INTO HIGH LEVEL LANGUAGE.

1) ASSEMBLER

2) INTERPRETER

3) COMPILER

ASSEMBLER :- IT IS USED TO TRANSLATE ASSEMBLY LANGUAGE INSTRUCTIONS INTO MACHINE LANGUAGE.

INTERPRETER :-  IT IS USED TO TRANSLATE HIGH LEVEL LANGUAGE INSTRUCTIONS INTO MACHINE LANGUAGE. (STATEMENT BY STATEMENT, TIME WASTE).

COMPILER :-  IT IS USED TO TRANSLATE HIGH LEVEL LANGUAGE INSTRUCTIONS INTO MACHINE LANGUAGE.
(TOTAL STATEMENTS AT A TIME, TIME SAVE).

'C' IS A HIGH LEVEL LANGUAGE. 'C' LANGUAGE HAS COMPILER.

HISTORY OF 'C' LANGUAGE
=========================

IN 1950's THERE ARE MAINLY AVAILABLE THREE HIGH LEVEL LANGUAGES.

1) PASCAL

2) FORTRAN

3) COBOL

PASCAL (SCIENTIST NAME) :- IT IS USED TO DESIGN ENGINEERING APPLICATIONS.

FORTRAN (FORMULA TRANSLATION) :-  IT IS USED TO DESIGN SCIENTIFIC APPLICATIONS.

COBOL (COMMON BUSINESS ORIENTED LANGUAGE) :-
 IT IS USED TO DESIGN COMMERCIAL / BUSINESS APPLICATIONS.

IT IS NOT POSSIBLE TO DESIGN SCIENTIFIC APPLICATION IN COBOL AND SO ON.  IF A PROGRAMMER WANTS TO DEVELOP THREE TYPES OF APPLICATIONS HE MUST LEARN ABOVE THREE LANGUAGES. IT IS VERY DIFFICULT. AT THIS STAGE, COMPUTER EDUCATED PEOPLE TAUGHT, WHY NOT USE A SINGLE LANGUAGE TO DEVELOP ALL TYPES OF APPLICATIONS. THEN THE COMPUTER EDUCATED PEOPLE FORMED AS A TEAM NAMED INTERNATIONAL COMMITE. THE AIM OF INTERNATIONAL COMMITE IS TO DEVELOP A NEW LANGUAGE, WHICH HAS ABILITY TO DEVELOP ALL TYPES OF APPLICATIONS.

================================================
NAME YEAR DEVELOPED BY
================================================

ALGOL-60                   1960 INTERNATIONAL COMMITE
(ALGORTHEMIC
LANGUAGE)

CPL 1963 CAMBRIDGE UNIVERSITY
(COMBINED
PROGRAMMING
LANGUAGE)

BCPL 1967 MARTIN RICHARDS
(BASIC CPL)

B 1970 KEN THOMPSON

C 1972 DENNIS RITCHIE

'C' WAS DEVELOPED BY DENNIS RITCHIE IN 1972 at AT & T (ADVANCED TELE COMMUNCATIONS & TECHONOLGY) BELL LABORATORIES. THE NAME 'C' HAS NO ABBREVATION. IT IS JUST THE NEXT ALPHABET OF B. IT MEANS 'C' IS THE ADVANCED VERSION OF 'B' LANGUAGE. 'C' IS A GENERAL PURPOSE HIGH LEVEL PROGRAMMING LANGUAGE.

FEATURES OF 'C' LANGUAGE
==========================

SPEED :- GENERALLY HIGH LEVEL LANGUAGE PROGRAMS RUNS SLOWLY. BECAUSE NEEDS TRANSLATION. BUT 'C' LANGUAGE PROGRAMS RUNS VERY FASTLY WHEN COMPARING WITH OTHER HIGH LEVEL LANGUAGES.

PORTABILITY :- GENERALLY A PROGRAM IS EXECUTED ONLY ONE TYPE OF PLATFORM (OPERATING SYSTEM). FOR EXAMPLE IF WE WRITE A PROGRAM IN WINDOWS, IT CAN'T BE EXECUTED ON UNIX OR OTHER OPERATING SYSTEMS. IF WE MAKE SOME MODIFICATIONS,  A 'C' PROGRAM EXECUTES ON ANY PLATFORM.

MIDDLE LEVEL LANGUAGE :- GENERALLY LOW LEVEL LANGUAGES ARE USED TO DEVELOP SYSTEM SOFTWARES AND HIGH LEVEL LANGUAGES ARE USED TO DEVELOP USER SOFTWARES. USING 'C' LANGUAGE WE CAN DEVELOP BOTH SYSTEM SOFTWARES AND USER SOFTWARES. BECAUSE 'C' LANGUAGE CONTAINS LOW LEVEL LANGUAGE FEATURES AND HIGH LEVEL LANGUAGE FEATURES. IT MEANS WE CAN USE 'C' LANGUAGE AS LOW LEVEL LANGUAGE AS WELL AS HIGH LEVEL LANGUAGE.

COMPACT :- 'C' LANGUAGE CONTAINS HUNDREDS OF PRE-DEFINED FUNCTIONS TO PERFORM VARIOUS TASKS. BY USING THESE FUNCTIONS WE CAN REDUCE THE PROGRAM LENGTH.

    A SAMPLE 'C' PROGRAM
    ======================

void main( )
{
printf("Welcome to C Language");
}

OUTPUT
========
Welcome to C Language

NOTE :- 'C' LANGUAGE PROGRAMS MUST BE WRITEN IN LOWER CASE ALPHABETS. EVERY STATEMENT MUST BE ENDS WITH SEMICOLON.

STEPS TO WRITE, SAVE, COMPILE & EXECUTE / RUN A 'C' PROGRAM
=================================================

1) FILE ====> NEW

2) WRITE PROGRAM

3) SAVE PROGRAM
     FILE ====> SAVE (NAME.C) (F2)

4) COMPILE PROGRAM
    COMPILE ====> COMPILE (ALT + F9)

5) EXECUTE / RUN PROGRAM
    RUN ====> RUN  (CTRL +F9)

6) VIEW OUTPUT
    WINDOW ====> USER SCREEN (ALT + F5)

7) CLOSING FILE
     WINDOW ====> CLOSE (ALT + F3)

8) EXIT 'C' LANGAUGE
     FILE ====> QUIT (ALT + X)

IDE :- IT STANDS FOR INTEGRATED DEVELOPMENT ENVIRONMENT. IT IS USED TO WRITE, SAVE, COMPILE & EXECUTE PROGRAMS. MANY COMPANYS PROVIDE IDE'S FOR 'C' LANGUAGE. THE STANDARD AND FAMOUS IDE FOR 'C' LANGUAGE IS "TURBO C++ IDE".

SEARCHING FOR 'C' LANGUAGE
=============================

START ====> SEARCH ====> FOR FILES OR FOLDERS

CLICK ON ALL FILES AND FOLDERS

TYPE TC.EXE AND CLICK ON SEARCH

OPEN RELATED FOLDER (C:\TC)

RIGHT CLICK ON TC.EXE ====> SEND TO ====> DESKTOP (CREATE SHORTCUT)

     (OR)

START ====> RUN (C:\TC\TC.EXE)

     FILE ====> OPEN (F3)

     ZOOM ====> F5

PROGRAM NO : 2
===============

void main( )
{
printf("Learning C Language is Good");
}

OUTPUT
========
Welcome to C LanguageLearning C Language is Good

PROGRAM NO : 3
===============

void main( )
{
clrscr( );
printf("Learning C Language is Good");
getch( );
}

OUTPUT
========
Learning C Language is Good

void main( ):- IT IS THE MOST IMPORTANT FUNCTION IN 'C' PROGRAM. GENRALLY PROGRAM CONTAINS SOME FUNCTIONS. 'C' PROGRAM EXECUTION STARTS FROM MAIN( ). ALL PROGRAM STATEMENTS OR OTHER FUNCTIONS MUST BE PLACED INSIDE THE MAIN( ).

{ } :- THESE ARE CALLED CURELY BRACES. BRACES INDICATES STARTING AND ENDING OF THE MAIN( ).

printf( ) :- IT IS THE OUTPUT FUNCTION. THIS FUNCTION IS USED TO DISPLAY INFORMATION ON THE SCREEN. THE INFORMATION MUST BE PLACED INSIDE THE DOUBLE QUOTES.

clrscr( ) :- THIS FUNCTION IS USED TO CLEAR THE SCREEN.

getch( ) :- THIS FUNCTION IS USED TO VIEW OUTPUT.

PROGRAM NO : 4
===============

void main( )
{
clrscr( );
printf("One");
printf("Two");
printf("Three");
getch( );
}

OUTPUT
========
OneTwoThree

\n (BACK SLASH n) :- IT IS USED TO GENERATE NEW LINE OR NEXT LINE.

PROGRAM NO : 5
===============

void main( )
{
clrscr( );
printf("One\n");
printf("Two\n");
printf("Three");
getch( );
}

OUTPUT
========
One
Two
Three

PROGRAM NO : 6
===============

void main( )
{
clrscr( );
printf("One");
printf("\nTwo");
printf("\nThree");
getch( );
}

OUTPUT
========
One
Two
Three

PROGRAM NO : 7
===============

void main( )
{
clrscr( );
printf("One");
printf("\nTwo\n");
printf("Three");
getch( );
}

OUTPUT
========
One
Two
Three

PROGRAM NO : 8
===============

void main( )
{
clrscr( );
printf("One\nTwo\nThree");
getch( );
}

OUTPUT
========
One
Two
Three

PROGRAM NO : 9
===============

void main( )
{
clrscr( );
printf("One\NTwo");
getch( );
}

OUTPUT
========
OneNTwo

PROGRAM NO : 10
================

void main( )
{
clrscr( );
printf("One\n");
printf("\nTwo");
getch( );
}

OUTPUT
========
One

Two

\t (BACK SLASH t) :- IT IS USED TO GENERATE FIVE / EIGHT SPACES.

PROGRAM NO : 11
================

void main( )
{
clrscr( );
printf("1\t");
printf("2");
getch( );
}

OUTPUT
========
1       2

PROGRAM NO : 12
================

void main( )
{
clrscr( );
printf("*\n");
printf("*\t*\n");
printf("*\t*\t*");
getch( );
}

OUTPUT
=======
*
* *
* * *

PROGRAM NO : 13
================

void main( )
{
clrscr( );
printf("*\n*\t*\n*\t*\t*");
getch( );
}

OUTPUT
=======
*
* *
* * *

PROGRAM NO : 14
================

void main( )
{
clrscr( );
printf("\t\t*\n\t*\t*\n*\t*\t*");
getch( );
}

OUTPUT
=======
*
* *
* * *

WORKING WITH DATA
=====================

DATA :- IT IS NOTHING BUT A KNOWN VALUE.

VARIABLE :- WHICH STORES DATA. BEFORE USING VARAIBLES WE MUST DECLARE / CREATE THEM AT THE STARTING OF THE PROGRAM.

DECLARING VARIABLES
======================

SYNTAX
=======

DATA_TYPE VARIABLE_NAME;

Ex :-
int hno;
float rate;
char gndr;
char name[10]; (STRING)


=======================================
SAMPLE DATA DATA TYPE SIGN
=======================================
10 int %d

12.45 float %f

'K' char %c

"Rama" string %s
=======================================

WORKING WITH INTEGERS
=========================

PROGRAM NO : 15
================

void main( )
{
int a; (VARIABLE DECLARATION)
clrscr( );
a = 10; (ASSIGNMENT / STORING)
printf("a\n");
printf("%d\n",a);
printf("A Value : %d\n",a);
printf("%d is A Value\n",a);
printf("Ravana Has %d Heads\n",a);
printf("A = %d",a);
getch( );
}

OUTPUT
=======
a
10
A Value : 10
10 is A Value
Ravana Has 10 Heads
A = 10

WORKING WITH REAL NUMBERS
==============================
/
PROGRAM NO : 16
================

void main( )
{
float rate;
clrscr( );
rate = 12.75;
printf("Item Cost : %f\n",rate);
printf("Item Cost : %.2f",rate);
getch( );
}

OUTPUT
=======
Item Cost : 12.750000
Item Cost : 12.75

NOTE :- BY DEFAULT FLOAT DISPLAYS 6 DECIMALS.

WORKING WITH CHARACTERS
============================

PROGRAM NO : 17
================

void main( )
{
char grd;
clrscr( );
grd = 'A';
printf("Grade : %c",grd);
getch( );
}

OUTPUT
=======
Grade : A

NOTE :- CHARACTER DATA MUST BE PLACED INSIDE THE SINGLE QUOTES.

WORKING WITH STRINGS
=======================

PROGRAM NO : 18
================

void main( )
{
char name[10] = "Rama";
clrscr( );
printf("Name : %s\n",name);
printf("My Name : %s\n",name);
printf("Your Name : %s\n",name);
printf("%s is husband of sita\n",name);
printf("%s killed Ravana\n",name);
printf("Ravana was killed by %s",name);
getch( );
}

OUTPUT
=======
Name : Rama
My Name : Rama
Your Name : Rama
Rama is husband of sita
Rama Killed Ravana
Ravana was killed by Rama

NOTE :- STRINGS  MUST BE PLACED INSIDE THE DOUBLE QUOTES.

SQUARE OF A NUMBER
=====================

PROGRAM NO : 19
================

void main( )
{
int num;
int sqr;
clrscr( );
num = 6;
sqr = num * num;
printf("Square : %d\n",sqr);
printf("%d square : %d\n",num,sqr);
printf("%d is the square of %d",sqr,num);
printf("%d * %d = %d",num,num,sqr);
getch( );
}

OUTPUT
=======
Square : 36
6 square : 36
36 is the square of 6
6 * 6 = 36

SUM OF TWO NUMBERS
=====================

PROGRAM NO : 20
================

void main( )
{
int a,b,c;
clrscr( );
a = 10;
b = 20;
c = a + b;
printf("Sum : %d\n",c);
printf("%d and %d sum is %d\n",a,b,c);
printf("%d is the sum of %d and %d\n",c,a,b);
printf("%d + %d = %d",a,b,c);
getch( );
}

OUTPUT
=======
Sum : 30
10 and 20 sum is 30
30 is the sum of 10 and 20
10 + 20 = 30

AREA OF CIRCLE
================

void main( )
{
int rds;
float area;
clrscr( );
rds = 6;
area = 3.14 * rds * rds;
printf("Area of Circle : %.2f",area);
getch( );
}

OUTPUT
=======
Area of Circle : 113.04

PERIMETER OF CIRCLE
=====================

void main( )
{
int rds;
float prmtr;
clrscr( );
rds = 6;
prmtr = 2 * 3.14 * rds;
printf("Perimeter of Circle : %.2f",prmtr);
getch( );
}

OUTPUT
=======
Perimeter of Circle : 37.68

AREA OF SQUARE
================

void main( )
{
int side,area;
clrscr( );
side = 6;
area = side * side;
printf("Area of Square : %d",area);
getch( );
}

OUTPUT
=======
Area of Square : 36

AREA OF RECTANGLE
====================

void main( )
{
int len,brdth,area;
clrscr( );
len = 6;
brdth = 3;
area = len * brdth;
printf("Area of Rectangle : %d",area);
getch( );
}

OUTPUT
=======
Area of Rectangle : 18

AREA OF TRIANGLE
==================

void main( )
{
int base,hgt;
float area;
clrscr( );
base = 7;
hgt = 3;
area = 0.5 * base * hgt;
printf("Area of Triangle : %.1f",area);
getch( );
}

OUTPUT
=======
Area of Triangle : 10.5

     SWAPPING / EXCHANGE / INTERCHANGE NUMBERS
    ==============================================

void main( )
{
int a,b,temp;
clrscr( );
a = 10;
b = 20;
printf("Before Swapping\n");
printf("A Value : %d\nB Value : %d\n",a,b);
temp = a;
a = b;
b = temp;
printf("After Swapping\n");
printf("A Value : %d\nB Value : %d",a,b);
getch( );
}

OUTPUT
=======
Before Swapping
A Value : 10
B Value : 20
After Swapping
A Value : 20
B Value : 10

SWAPPING NUMBERS WITHOUT USING TEMPORARY VARIABLE
===============================================

void main( )
{
int a,b;
clrscr( );
a = 10;
b = 20;
printf("Before Swapping\n");
printf("A Value : %d\nB Value : %d\n",a,b);
a = a + b;
b = a - b;
a = a - b;
printf("After Swapping\n");
printf("A Value : %d\nB Value : %d",a,b);
getch( );
}

OUTPUT
=======
Before Swapping
A Value : 10
B Value : 20
After Swapping
A Value : 20
B Value : 10

              CREATING DIRECTORY
              =====================

FILE ====> DOS SHELL

C:\TC> cd\
C:\> md xxx (ONLY FIRST TIME)
C:\> cd xxx
C:\XXX> exit

SQUARE OF A NUMBER
=====================

void main( )
{
int num;
int sqr;
clrscr( );
num = 6;
sqr = num * num;
printf("Square : %d",sqr);
getch( );
}

OUTPUT
=======
Square : 36

THE ABOVE PROGRAM IS USELESS. IT ALWAYS DISPLAYS SQUARE OF 6. BECAUSE 'N' VALUE IS FIXED TO 6.

SCANF( ) :- IT IS INPUT FUNCTION. THIS FUNCTION IS USED TO INPUT DATA AT RUNTIME. ALL VARIABLES IN THIS FUNCTION MUST BE PREFIXED WITH AMPERSAND (&). ADVNATAGE OF USING THIS FUNCTION IS, WE CAN PROVIDE DIFFERENT VALUES AT EACH RUNTIME. WE MUST DISPLAY A MEANINGFUL MESSAGE BEFORE USING THIS FUNCTION.

WRITE A PROGRAM TO INPUT (SCANF( ))A NUMBER FIND SQUARE ?

void main( )
{
int num,sqr;
clrscr( );
printf("Enter Number : ");
scanf("%d",&num);     // & ====> ADDRESS OPERATOR
sqr = num * num;            // & ====> AMPERSAND
printf("Square : %d",sqr);
getch( );
}

OUTPUT 1
=========
Enter Number : 6
Square : 36

OUTPUT 2
=========
Enter Number : 9
Square : 81

OUTPUT 3
=========
Enter Number : 12
Square : 144

DON'T USE \n IN SCANF( ).

WRITE A PROGRAM TO INPUT (SCANF( ) ) TWO NUMBERS FIND SUM ?

void main( )
{
int a,b,c;
clrscr( );
printf("Enter A Value : ");
scanf("%d",&a);
printf("Enter B Value : ");
scanf("%d",&b);
c = a + b;
printf("Sum : %d",c);
getch( );
}

OUTPUT
========
Enter A Value : 6
Enter B Value : 3
Sum : 9

void main( )
{
int a,b,c;
clrscr( );
printf("Enter A,B Values");
scanf("%d",&a);
scanf("%d",&b);
c = a + b;
printf("Sum : %d",c);
getch( );
}

OUTPUT  1
=========
Enter A,B Values
10
20
Sum : 30

OUTPUT  2
=========
Enter A,B Values
30 40
Sum : 70

void main( )
{
int a,b,c;
clrscr( );
printf("Enter Two Numbers");
scanf("%d %d",&a,&b);
c = a + b;
printf("Sum : %d",c);
getch( );
}

OUTPUT
=======
Enter Two Numbers
6
3
Sum : 9

WHEN WE ARE INPUT MULTIPLE VALUES IN SINGLE SCANF( ), WE MUST PROVIDE SINGLE SPACE BETWEEN SIGNS (%d %d).

WRITE A PROGRAM TO INPUT RADIUS FIND AREA OF CIRCLE?

WRITE A PROGRAM TO INPUT RADIUS FIND PERIMETER OF CIRCLE?

WRITE A PROGRAM TO INPUT BASE, HIEGHT FIND AREA OF TRIANGLE?

WRITE A PROGRAM TO INPUT LENGTH, BREADTH FIND AREA OF RECTANGLE?

WRITE A PROGRAM TO INPUT SIDE FIND AREA OF SQUARE?

WRITE A PROGRAM TO INPUT TWO NUMBERS AND SWAP THEM?

INPUT REAL NUMBERS AT RUNTIME
=================================

void main( )
{
float rate;
clrscr( );
printf("Enter Rate\n");
scanf("%f",&rate);
printf("Rate : %.2f",rate);
getch( );
}

OUTPUT
=======
Enter Rate
12.75
Rate : 12.75

DON'T WRITE %.2f IN SCANF( ).
==========================================================================================================
INPUT CHARACTERS AT RUNTIME
===============================

void main( )
{
char gndr;
clrscr( );
printf("Enter Gender[m/f]\n");
scanf("%c",&gndr);
printf("Gender : %c",gndr);
getch( );
}

OUTPUT
=======
Enter Gender[m/f]
m
Gender : m

INPUT STRINGS AT RUNTIME
==========================

void main( )
{
char city[20];
clrscr( );
printf("Enter City Name\n");
scanf("%s",&city);
printf("City Name : %s",city);
getch( );
}

OUTPUT
=======
Enter City Name
Tenali
City Name : Tenali


               PROBLEMS WHILE INPUT STRINGS
               ================================

void main( )
{
char name[20];
clrscr( );
printf("Enter Name\n");
scanf("%s",&name);
printf("Name : %s",name);
getch( );
}

OUTPUT 1
=========
Enter Name
Rama
Name : Rama

OUTPUT 2
=========
Enter Name
Rama Krishna
Name : Rama

NOTE :- THE MAIN DRAWBACK OF SCANF( ) IS IT CAN'T TAKE TWO WORDS AS INPUT. BECAUSE SCANF( ) STOPS TAKING INPUT WHEN A SPACE CHARACTER / ENTER IS ENCOUNTERED.

GETS( ) :- THIS FUNCTION TAKES MUTLIPLE WORDS UPTO ONE LINE AS INPUT. GETS( ) STOPS TAKING INPUT WHEN ENTER IS ENCOUNTERED.

void main( )
{
char name[20];
clrscr( );
printf("Enter Name\n");
gets(name);
printf("Name : %s",name);
getch( );
}

OUTPUT 1
=========
Enter Name
Rama
Name : Rama

OUTPUT 2
=========
Enter Name
Raja Ram Mohan Roy
Name : Raja Ram Mohan Roy

PUTS( ) :- THIS FUNCTION IS USED TO DISPLAY A STRING.

void main( )
{
clrscr( );
puts("Welcome");
getch( );
}

OUTPUT
=======
Welcome

PUTS( ) AUTOMATICALLY GENERATES NEW LINE.

void main( )
{
clrscr( );
puts("One");
puts("Two");
puts("Three");
getch( );
}

OUTPUT
=======
One
Two
Three

INPUT MIXED DATA TYPES AT A TIME
==================================

void main( )
{
int a;
float b;
char c;
char d[20];
clrscr( );
puts("Enter Integer, Float, Character, String");
scanf("%d %f %c %s",&a,&b,&c,&d);
printf("Integer : %d\nFloat : %.2f\n",a,b);
printf("Character : %c\nString : %s",c,d);
getch( );
}

OUTPUT
=======
Enter Integer, Float, Character, String
10 12.75 K Rama
Integer : 10
Float : 12.75
Character : K
String : Rama

         CONVERTING CENTIGRADE TO FOREIGN HEAT
         ===========================================

void main()
{
int c;
float f;
clrscr( );
printf("Enter Centigrade\n");
scanf("%d",&c);
f = (c + 32) * 1.8;
printf("Foreign Heat :%.2f",f);
getch();
}

OUTPUT
=======
Enter Centigrade
100
Foreign Heat : 237.60

         CONVERTING FOREIGN HEAT TO CENTIGRADE
         ===========================================

void main()
{
int f;
float c;
clrscr( );
printf("Enter Foreign Heat\n");
scanf("%d",&f);
c = (f - 32) / 1.8;
printf("Centigrade : %.2f",c);
getch();
}

OUTPUT
=======
Enter Foreign Heat
100
Centigrade : 37.78

HEADER FILES
=============

THE MAIN REASON FOR POPULARITY OF 'C' LANGUAGE IS IT'S BUILT-IN / PRE-DEFINED / STANDARD / LIBRARY FUNCTIONS. A FUNCTION PERFORMS SOME TASK. 'C' LANGUAGE CONTAINS MORE THAN 1500 FUNCTIONS TO PERFORM VARIOUS TASKS. IF THERE IS NO FUNCTION AVAILABLE FOR OUR REQUIREMENTS, THEN WE CAN CREATE NEW FUNCTIONS AS PER OUR REQUIREMENTS. THESE FUNCTIONS ARE CALLED USER-DEFINED FUNCTIONS. THE 1500 LIBRARY FUNCTIONS ARE CLASSIFIED INTO 18 CATEGORIES. EACH CATEGORY IS CALLED A HEADER FILE. HEADER FILES CONTAINS FUNCTIONS. SOME OF THE MOST COMMONLY USED HEADER FILES ARE LISTED BELOW.

1) STDIO.H 2) CONIO.H 3) MATH.H
4) STRING.H

STDIO.H :- IT STANDS FOR STANDARD INPUT OUTPUT HEADER FILE. THIS HEADER FILE CONTAINS ALL INPUT OUTPUT FUNCTIONS LIKE PRINTF( ), SCANF( ), GETS( ), PUTS( ) ETC.

CONIO.H :- IT STANDS FOR CONSOLE (SCREEN) INPUT OUTPUT HEADER FILE. THIS HEADER FILE CONTAINS ALL SCREEN RELATED FUNCTIONS LIKE CLRSCR( ), GETCH( ) ETC.

MATH.H :- IT STANDS FOR MATHEMATICAL HEADER FILE. THIS HEADER FILE CONTAINS ALL MATHEMATICAL FUNCTIONS LIKE SQRT( ), POW( ),
SIN( ) ETC.

STRING.H :- IT STANDS FOR STRING HEADER FILE. THIS HEADER FILE CONTAINS ALL STRING RELATED FUNCTIONS LIKE STRLEN( ), STRREV( ) ETC.

BEFORE USING ANY FUNCTION WE MUST INCLUDE RELATED HEADER FILE IN THE FOLLOWING MANNER.

SYNTAX
=======
# include <header_file_name>

Ex:-
# include <stdio.h>
# include <conio.h>
# include <math.h>

FINDING FUNCTION RELATED HEADER FILE
========================================

TYPE FUNCTION NAME AND PLACE CURSOR ON THE FUNCTION NAME. THEN PRESS CTRL + F1 (ESC).

# include <stdio.h>
# include <conio.h>
void main( )
{
clrscr( );
printf("Welcome to C Language");
getch( );
}

OUTPUT
========
Welcome to C Language

WRITE A PROGRAM TO INPUT EMPLOYEE NUMBER, NAME, MONTHLY SALARY FIND ANNUAL SALARY?

# include <stdio.h>
# include <conio.h>
void main( )
{
int eno,msal,asal;
char ename[20];
clrscr( );
puts("Enter Employee Number");
scanf("%d",&eno);
puts("Enter Employee Name");
scanf("%s",&ename);
puts("Enter Monthly Salary");
scanf("%d",&msal);
asal = msal * 12;
printf("Annual Salary : %d",asal);
getch( );
}

OUTPUT 1
=========
Enter Employee Number
101
Enter Employee Name
Rama
Enter Monthly Salary
2000
Annual Salary : 24000

OUTPUT 2
=========
Enter Employee Number
102
Enter Employee Name
JayaSree
Enter Monthly Salary
3000
Annual Salary : -29000

THE ABOVE PROGRAM CAN'T DISPLAY ANNUAL SALARY PROPERLY. BECAUSE AN INT CAN STORE MAXIMUM OF 32767. IF WE WANT TO WORK WITH LARGE NUMBERS WE CAN USE LONG INT INSTEAD OF INT. LONG INT CAN STORE UPTO NEARLY 214 CRORES AND IT'S SIGN IS %LD. AN INTEGER CONSTANT IS CONVERTED TO LONG INTEGER CONSTANT BY ADDING EITHER "l" OR "L". FOR EXAMPLE 25 IS TREATED AS INTEGER CONSTANT AND 25L IS TREATED AS LONG INTEGER CONSTANT BY THE COMPILER.

WE CAN PRODUCE THE PROGRAM OUTPUT ATTRACTIVELY. THE OUTPUT MAY BE USED FOR PRINTING PURPOSE.

# include <stdio.h>
# include <conio.h>
void main( )
{
int eno,msal;
long int asal;
char ename[20];
clrscr( );
puts("Enter Employee Number, Name, Monthly Salary");
scanf("%d %s %d",&eno,&ename,&msal);
asal = msal * 12L;
clrscr( );
printf("\t\tTata Group of Companies\n");
printf("\t\t====================\n\n");
printf("Employee Number : %d\n\n",eno);
printf("Employee Name     : %s\n\n",ename);
printf("Monthly Salary      : %d\n\n",msal);
printf("Annual Salary        : %ld\n\n",asal);
printf("\t\t\tAccountant");
getch( );
}

OUTPUT
========
Enter Employee Number, Name, Monthly Salary
101 Rama 3000

Tata Group of Companies
====================

Employee Number : 1000

Employee Name     : Rama

Monthly Salary      : 3000

Annual Salary       : 36000

Accountant

WRITE A PROGRAM TO INPUT EMPLOYEE NUMBER, NAME, MONTHLY SALARY FIND DAY SALARY?

# include <stdio.h>
# include <conio.h>
void main()
{
int eno,msal;
float dsal;
char ename[20];
clrscr();
puts("Enter Employee Number, Name, Monthly Salary");
scanf("%d %s %d",&eno,&ename,&msal);
dsal = msal / 30.0;
clrscr();
printf("\t\tTata Group of Companies\n");
printf("\t\t=======================\n\n");
printf("Employee Number : %d\n\n",eno);
printf("Employee Name   : %s\n\n",ename);
printf("Monthly Salary  : %d\n\n",msal);
printf("Day     Salary  : %.2f\n\n",dsal);
printf("\t\t\tAccountant");
getch();
}

OUTPUT
========
Enter Employee Number, Name, Monthly Salary
101 Rama 5000

Tata Group of Companies
====================

Employee Number : 1000

Employee Name     : Rama

Monthly Salary      : 5000

Annual Salary       : 166.66

Accountant

      STEPS TO WRITE PROGRAM
      =========================

1) PUT MEANINGFUL VARIABLE NAMES

2) IDENTIFIY DATA TYPES

3) DECLARE VARIABLES

4) INPUT DATA INTO VARIABLES

5) PROCESSING

6) OUTPUT

WRITE A PROGRAM TO INPUT STUDENT NUMBER, NAME, ENGLISH MARKS, TELUGU MARKS, HINDI MARKS, MATHS MARKS, SCIENCE MARKS, SOCIAL MARKS FIND TOTAL MARKS AND AVERAGE MARKS?

# include <stdio.h>
# include <conio.h>
void main( )
{
int sno,em,tm,hm,mm,scm,som,tot;
float avg;
char sname[20];
clrscr( );
puts("Enter Student Number, Name");
scanf("%d %s",&sno,&sname);
puts("Enter English, Telugu, Hindi Marks");
scanf("%d %d %d",&em,&tm,&hm);
puts("Enter Maths, Science, Social Marks");
scanf("%d %d %d",&mm,&scm,&som);
tot = em + tm + hm + mm + scm + som;
avg = tot / 6.0;
clrscr( );
printf("\t\t\tSridevi Convent\n");
printf("\t\t\t**************\n\n");
printf("Student Number : %d\n\n",sno);
printf("Student Name     : %s\n\n",sname);
printf("Total     Marks   : %d\n\n",tot);
printf("Average Marks   : %.2f\n\n",avg);
printf("\t\t\tPrincipal");
getch( );
}

OUTPUT
=======
Enter Student Number, Name
101 Rama
Enter English, Telugu, Hindi Marks
10 20 30
Enter Maths, Science, Social Marks
40 50 61

Sridevi Convent
**************

Student Number : 101

Student Name     : Rama

Total     Marks   : 211

Average Marks  : 35.16

Principal

WRITE A PROGRAM TO INPUT ITEM CODE, NAME, QUANTITY, RATE FIND AMOUNT?

# include <stdio.h>
# include <conio.h>
void main()
{
int icode,qty;
float rate,amt;
char iname[20];
clrscr();
puts("Enter Item Code, Name");
scanf("%d %s",&icode,&iname);
puts("Enter Quantity, Rate");
scanf("%d %f",&qty,&rate);
amt = qty * rate;
clrscr();
printf("\t\tRama Departmental Stores\n");
printf("\t\t^^^^^^^^^^^^^^^^^^^^^^^^\n\n");
printf("Item Code : %d\n\n",icode);
printf("Item Name : %s\n\n",iname);
printf("Quantity  : %d\n\n",qty);
printf("Rate      : %.2f\n\n",rate);
printf("Amount    : %.2f\n\n",amt);
printf("\t\t\tCashier");
getch();
}

OUTPUT
=======
Enter Item Code, Name
101
Tv
Enter Quantity, Rate
10
1.25

Rama Departmental Stores
^^^^^^^^^^^^^^^^^^^^

Item Code : 101

Item Name : Tv

Quantity     : 10

Rate            : 1.25

Amount      : 12.50

Cashier

WRITE A PROGRAM TO INPUT SERVICE NUMBER, CONSUMOR NAME, LAST MONTH READING, PRESENT MONTH READING, UNIT RATE FIND NUMBER OF UNITS CONSUMED, BILL?

# include <stdio.h>
# include <conio.h>
void main()
{
int sno,lmr,pmr,nuc;
float ur,bill;
char cname[20];
clrscr();
puts("Enter Service Number, Consumor Name");
scanf("%d %s",&sno,&cname);
puts("Enter Last Month Reading, Present Month Reading");
scanf("%d %d",&lmr,&pmr);
puts("Enter Unit Rate");
scanf("%f",&ur);
nuc = pmr - lmr;
bill = nuc * ur;
clrscr();
printf("\t\tA.P Power Distribution Company\n");
printf("\t\t******************************\n\n");
printf("Service Number           : %d\n\n",sno);
printf("Consumor Name            : %s\n\n",cname);
printf("Last Month Reading       : %d\n\n",lmr);
printf("Present Month Reading    : %d\n\n",pmr);
printf("Unit Rate                : %.2f\n\n",ur);
printf("Number of Units Consumed : %d\n\n",nuc);
printf("Bill                     : %.2f\n\n",bill);
printf("\t\t\t\tManager");
getch();
}

OUTPUT
========
Enter Service Number, Consumor Name
101
Rama
Enter Last Month Reading, Present Month Reading
200
350
Enter Unit Rate
1.25

            A.P Power Distribution Company
             *****************************

Service Number                   : 101

Consumor Name                  : Rama

Last Month Reading            : 200

Present Month Reading        : 350

Unit Rate           : 1.25

Number of Units Consumed : 150

Bill           : 187.50

Manager

WRITE A PROGRAM TO INPUT EMPLOYEE NUMBER, NAME, BASIC SALARY, HOUSE RENT ALLOWANCE, DEARNESS ALLOWANCE, TRAVELLING ALLOWANCE, INCOME TAX, PROVIDENT FUND FIND ALLOWANCES, GROSS SALARY, DEDUCTIONS AND NET SALARY?
     (EMPLOYEE PAYROLL SYSTEM)


WRITE A PROGRAM TO INPUT EMPLOYEE NUMBER, NAME, SALARY FIND COMMISSION(6% OF SALARY) AND NET SALARY?

# include <stdio.h>
# include <conio.h>
void main()
{
int eno,sal;
float comm,nsal;
char ename[20];
clrscr();
puts("Enter Employee Number, Name, Salary");
scanf("%d %s %d",&eno,&ename,&sal);
comm = sal * 6 / 100.0;  // comm = sal * 0.06;
nsal = sal + comm;   // comm = sal * 0.6; (60%)
clrscr();
printf("\t\tTata Group of Companies\n");
printf("\t\t=======================\n\n");
printf("Employee Number : %d\n\n",eno);
printf("Employee Name   : %s\n\n",ename);
printf("Salary          : %d\n\n",sal);
printf("Commission      : %.2f\n\n",comm);
printf("Net Salary      : %.2f\n\n",nsal);
printf("\t\t\tAccountant");
getch();
}

OUTPUT
=======
Enter Employee Number, Name, Salary
101
Rama
1234

Tata Group of Companies
=====================

Employee Number : 101

Employee Name     : Rama

Salary                     : 1234

Commission           : 74.04

Net Salary              : 1308.04

WRITE A PROGRAM TO INPUT ITEM CODE, NAME, QUANTITY, RATE, DISCOUNT IN PERCENTAGE FIND AMOUNT, DISCOUNT, BILL?

WRITE A PROGRAM TO INPUT EMPLOYEE NUMBER, NAME, BASIC SALARY FIND HOUSE RENT ALLOWANCE (25% OF BASIC SALARY), DEARNESS ALLOWANCE (12% OF BASIC SALARY), TRAVELLING ALLOWANCE (9% OF BASIC SALARY), INCOME TAX (4% OF BASIC SALARY), PROVIDENT FUND (30% OF BASIC SALARY), ALLOWANCES, GROSS SALARY, DEDUCTIONS AND NET SALARY?

     PROBLEMS WHILE INPUT CHARACTERS & STRINGS
     ===============================================

# include <stdio.h>
# include <conio.h>
void main()
{
char ch1,ch2;
clrscr();
puts("Enter First Character");
scanf("%c",&ch1);
puts("Enter Second Character");
scanf("%c",&ch2);
printf("First  Character: %c\n",ch1);
printf("Second Character: %c",ch2);
getch();
}

OUTPUT
=======
Enter First Character
k
Enter Second Character
First     Character : k
Second Character :

IN 'C' LANGUAGE WE CAN'T INPUT TWO CHARACTERS / STRINGS ONE BY ONE. BECAUSE ENTER KEY IS STORED IN SECOND CHARACTER VARIABLE. IN THIS SITUTATION FFLUSH( ) FUNCTION IS USEFUL.

fflush( ) :- THIS FUNCTION IS USED TO CLEAR KEYBOARD MEMORY. IT MEANS CLEARS ENTER KEY.

# include <stdio.h>
# include <conio.h>
void main()
{
char ch1,ch2;
clrscr();
puts("Enter First Character");
scanf("%c",&ch1);
fflush(stdin); // stdin : STANDARD INPUT : KEYBOARD
puts("Enter Second Character");
scanf("%c",&ch2);
printf("First  Character: %c\n",ch1);
printf("Second Character: %c",ch2);
getch();
}

OUTPUT
=======
Enter First Character
k
Enter Second Character
v
First     Character : k
Second Character : v

# include <stdio.h>
# include <conio.h>
void main()
{
int i;
char ch;
clrscr();
puts("Enter Character");
scanf("%c",&ch);
puts("Enter Integer");
scanf("%d",&i);
printf("Character : %c\n",ch);
printf("Integer  : %d",i);
getch();
}

OUTPUT
=======
Enter Character
k
Enter Integer
6
Character : k
Integer      : 6

# include <stdio.h>
# include <conio.h>
void main()
{
int i;
char ch;
clrscr();
puts("Enter Integer");
scanf("%d",&i);
puts("Enter Character");
scanf("%c",&ch);
printf("Integer   : %d\n",i);
printf("Character : %c",ch);
getch();
}

OUTPUT
=======
Enter Integer
6
Enter Character
Integer      : 6
Character :

# include <stdio.h>
# include <conio.h>
void main()
{
int i;
char ch;
clrscr();
puts("Enter Integer");
scanf("%d",&i);
fflush(stdin);
puts("Enter Character");
scanf("%c",&ch);
printf("Integer   : %d\n",i);
printf("Character : %c",ch);
getch();
}

OUTPUT
=======
Enter Integer
6
Enter Character
k
Integer      : 6
Character : k
================================================================================================================
PROBLEMS WITH GETS( ) FUNCTION
=================================

# include <stdio.h>
# include <conio.h>
void main()
{
char addr[200];
clrscr();
puts("Enter Address");
gets(addr);
printf("Address\n");
puts(addr);
getch();
}

OUTPUT
=======
Enter Address
Rama Rao
Address
Rama Rao

GETS( ) IS USED TO INPUT MULTIPLE WORDS UPTO ONE LINE ONLY. BECAUSE GETS( ) TERMINATES WITH ENTER KEY. GETS( ) IS UNABLE TO INPUT MULTIPLE LINES. TO INPUT MULTIPLE LINES WE CAN USE
SCANF( ) INSTEAD OF GETS( ).

# include <stdio.h>
# include <conio.h>
void main()
{
char addr[200];
clrscr();
puts("Enter Address, Ends with *");
scanf("%[^*]",&addr); // [] : list, ^ : until (carat)
printf("Address\n");
puts(addr);
getch();
}

OUTPUT
=======
Enter Address, Ends with *
Rama
S/o Dasaradha
Door Number : 123/456
Ayodhya*
Address
Rama
S/o Dasaradha
Door Number : 123/456
Ayodhya

NUMBER SYSTEMS
=================

1) BINARY NUMBER SYSTEM : BASE 2 NUMBER SYSTEM
    CHARACTER SET : 0 AND 1

2) OCTAL NUMBER SYSTEM : BASE 8 NUMBER SYSTEM
    CHARACTER SET : 0 - 7

3) DECIMAL NUMBER SYSTEM (DEFAULT) : BASE 10              NUMBER SYSTEM,    CHARACTER SET : 0 - 9

4) HEXA DECIMAL NUMBER SYSTEM : BASE 16                      NUMBER SYSTEM,    CHARACTER SET : 0 - 9, A - F


DECIMAL BASE     OCTAL BASE     HEXA DECIMAL BASE
==============     ===========     ====================
0 0 0
1 1 1
2 2 2
3 3 3
4 4 4
5 5 5
6 6 6
7 7 7
8 10 8
9 11 9
10 12 a
11 13 b
12 14 c
13 15 d
14 16 e
15 17 f
16 20 10
17 21 11
18 22 12
19 23 13
20 24 14
21 25 15
22 26 16
23 27 17
24 30 18
25 31 19
26 32 1a
27 33 1b
28 34 1c
29 35 1d
30 36 1e
31 37 1f
32 40 20

# include <stdio.h>
# include <conio.h>
void main()
{
int a = 30;
clrscr();
printf("A Value : %i\n",a);
printf("A Value in Decimal Base : %d\n",a);
printf("A Value in Octal   Base : %o\n",a);
printf("A Value in Hexa Decimal Base : %x\n",a);
getch();
}

OUTPUT
=======
A Value : 30
A Value in Decimal Base : 30
A Value in Octal   Base : 36
A Value in Hexa Decimal Base : 1e

# include <stdio.h>
# include <conio.h>
void main()
{
int a = 05;
clrscr();
printf("A Value : %d\n",a);
getch();
}

OUTPUT
=======
A Value : 5

# include <stdio.h>
# include <conio.h>
void main()
{
int a = 09;
clrscr();
printf("A Value : %d\n",a);
getch();
}

ERROR, BECAUSE 9 IS NOT AVAILABLE IN OCTAL NUMBER SYSTEM. IF A NUMBER STARTS WITH ZERO THEN COMPILER TREATS AS OCTAL BASE NUMBER.

# include <stdio.h>
# include <conio.h>
void main()
{
int a = 030;
clrscr();
printf("A Value in Decimal Base : %d\n",a);
printf("A Value in Octal   Base : %o\n",a);
printf("A Value in Hexa Decimal Base : %x\n",a);
getch();
}

OUTPUT
=======
A Value in Decimal Base : 24
A Value in Octal   Base : 30
A Value in Hexa Decimal Base : 18

IF A NUMBER STARTS WITH 0x (ZERO)THEN COMPILER TREATS AS HEXA DECIMAL BASE NUMBER.

# include <stdio.h>
# include <conio.h>
void main()
{
int a = 0x20;
clrscr();
printf("A Value in Decimal Base : %d\n",a);
printf("A Value in Octal   Base : %o\n",a);
printf("A Value in Hexa Decimal Base : %x\n",a);
getch();
}

OUTPUT
=======
A Value in Decimal Base : 32
A Value in Octal   Base : 40
A Value in Hexa Decimal Base : 20

WRITE A PROGRAM TO INPUT CITY NAME, THEATRE NAME, MOVIE NAME, SHOW DATE, SHOW DESCRIPTION, STARTING TICKET NUMBER IN 'A' CLASS, STARTING TICKET NUMBER IN 'B' CLASS, STARTING TICKET NUMBER IN 'C' CLASS, STARTING TICKET NUMBER IN 'D' CLASS, ENDING TICKET NUMBER IN 'A' CLASS, ENDING TICKET NUMBER IN 'B' CLASS, ENDING TICKET NUMBER IN 'C' CLASS, ENDING TICKET NUMBER IN 'D' CLASS, RATE OF 'A' CLASS, RATE OF 'B' CLASS, RATE OF 'C' CLASS, RATE OF 'D' CLASS FIND NUMBER OF TICKETS SOLD IN 'A' CLASS, NUMBER OF TICKETS SOLD IN 'B' CLASS, NUMBER OF TICKETS SOLD IN 'C' CLASS, NUMBER OF TICKETS SOLD IN 'D' CLASS, COLLECTION OF 'A' CLASS, COLLECTION OF 'B' CLASS, COLLECTION OF 'C' CLASS, COLLECTION OF 'D' CLASS, SHOW COLELCTION?

           TOKENS / BUZZ WARDS OF 'C' LANGUAGE
           ======================================

1) COMMENTS

2) WHITE SPACES

3) KEY WORDS / RESERVED WORDS

4) CHARACTER SET

5) CONSTANTS

6) VARIABLES

7) IDENTIFIERS

8) DATA TYPES

COMMENTS :- COMMENTS ARE USED TO WRITE AIM OF
THE PROGRAM. THESE ARE ALSO USED TO WRITE REFERENCES. THE MAIN ADVANTAGE OF COMMENTS IS READABILITY (UNDERSTANDABLE).  THESE ARE NOT EXECUTABLE STATEMENTS. A COMMENT STARTS WITH /* AND ENDS WITH */. A COMMENT MAY BE SINGLE LINE OR MULTIPLE LINES.

 /*
AIM : SUM OF TWO NUMBERS
AUTHOR : RAMA
DATE : 26/04/2010
 */
# include <stdio.h>
# include <conio.h>
void main()
{
int a,b,c; /* variable declaration */
clrscr();  /* clears the screen */
puts("Enter Two Numbers");
scanf("%d %d",&a,&b);   /* input */
c = a + b;      /* processing */
printf("Sum : %d",c); /* output */
getch();
}

OUTPUT
=======
Enter Two Numbers
10
20
Sum : 30

WHITE SPACES :- THESE ARE USED TO SEPERATE VARIABLE NAMES FROM KEY WORDS LIKE INT, CHAR ETC. A WHITE SPACE MAY BE A SPACE / TAB / ENTER.

KEYWORDS :- THESE ARE ALSO CALLED AS RESERVED WORDS. THESE WORDS HAS PRE-DEFINED MEANING IN 'C' LANGUAGE. WE CAN DEVELOP PROGRAMS WITH THE HELP OF KEY WORDS. WE CAN'T USE THESE KEYWORDS AS VARIABLE NAMES. 'C' LANGUAGE PROVIDES THE FOLLOWING 32 KEYWORDS.

AUTO(MATIC) BREAK CASE CONST(ANT) CHAR(ACTER) CONTINUE    DO DOUBLE DEFAULT DEFINE ELSE EXTERN(AL) ENUM(ERATED) FOR FLOAT GOTO INT(EGER) IF LONG REGISTER    RETURN SHORT SWITCH STATIC SIGNED STRUCT(URE) TYPEDEF(INITION)   UNION  UNSIGNED VOLATILE  VOID WHILE

CHARACTER SET :- EVERY LANGUAGE HAS IT'S OWN CHARACTER SET. WE CAN FORM / DEVELOP ANYTHING BASED ON THESE CHARACTER SET ON THAT LANGAUGE. 'C' LANGUAGE CHARACTER SET CONTAINS THE FOLLOWING CHARACTERS.

UPPER CASE ALPHABETS : A - Z
LOWER CASE ALPHABETS   : a -z
DIGITS : 0 - 9
~ : COMPLEMENT OPERATOR (TILDE)
! : NOT
# : PRE PROCESSOR DIRECTIVE (HASH)
% : MODULES OPERATOR (MOD)
^ : CARAT
& : ADDRESS OPERATOR (AMPERSAND)
* : ASTERSIK
( : OPENING PARANTHESIS
) : CLOSING PARANTHESIS
[ : OPENING SQUARE BRACKET
] : CLOSING SQUARE BRACKET
{ : OPENING CURELY BRACE
} : CLOSING CURELY BRACE
- : MINUS
_ : UNDER SCORE (WORD CONNECTOR)
+ : PLUS
= : ASSIGNMENT OPERATOR
| : OR OPERATOR (PIPE)
\ : BACKWARD SLASH
: : COLON
; : SEMI COLON
' : SINGLE QUOTE
" : DOUBLE QUOTE
< : LEFT ANGULAR BRACKET
> : RIGHT ANGULAR BRACKET
, : COMMA (SEPERATOR)
. : PERIOD / DOT OPERATOR
? : QUESTION MARK
/ : FORWARD SLASH

LITERALS / CONSTANTS :- THESE VARIABLES STORES ONLY ONE VALUE. WE CAN'T CHANGE THESE VALUE. GENERALLY KNOWN VALUES ARE DECLARED AS LITERALS. GENERALLY WE MUST INITIALIZE LITERALS. LITERALS ARE DECLARED BY USING "const" KEYWORD. GENERALLY LITERALS ARE WRITEN IN UPPER CASE ALPHABETS.

# include <stdio.h>
# include <conio.h>
void main()
{
float PIE = 3.14;
clrscr();
printf("Pie Value : %.2f",PIE);
PIE = 8; (error)
getch();
}

OUTPUT
========
Pie Value : 3.14

TYPES OF CONSTANTS
====================

    (DRAW FIGURE)

ESCAPE SEQUENCES :- THESE ARE ALSO CALLED NON-PRINTABLE CHARARACTERS. THESE CHARACTERS CAN'T PRINT ON SCREEN, WHICH PERFORMS SOME ACTION. THESE CHARACTERS STARTS WITH BACK SLASH AND FOLLOWED BY A LOWER CASE ALPHABET.

[ \n, \t, \v, \f, \a, \b, \r, \', \", \?, \\, \0 ]

\n : NEW LINE / NEXT LINE

\t : HORIZONTAL TAB

\v : VERTICAL TAB (ONLY IN ANSI C).

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
printf("1\v");
printf("2");
getch();
}

OUTPUT
=======
1


2

\f : FORM FEED (NEXT PAGE, ONLY AT PRINTING)

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
printf("1\f");
printf("2");
getch();
}

\a : ALERT (BEEP / SOUND)

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
printf("Hai,\a ");
printf("How R U");
getch();
}

OUTPUT
=======
Hai, Sound How R U

\b : BACK SPACE

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
printf("Jaya\b");
printf("Sree");
getch();
}

OUTPUT
=======
JaySree

\r : CARRAIGE RETURN

IT IS SIMILAR TO \n.

\n : NEXT LINE FIRST COLUMN

\r : SAME LINE FIRST COLUMN

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
printf("Jaya\r");
printf("Sree");
getch();
}

OUTPUT
=======
Sree

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
printf("This is Rama\'s Pen\n");
printf("This is \"Rama\" System\n");
printf("What is your name\?\n");
printf("C:\\Jasmine\\Lily\\Rose\\Lotus\n");
getch();
}

OUTPUT
=======
This is Rama's Pen
This is "Rama" System
What is your name?
C:\Jasmine\Lily\Rose\Lotus

\0 : NULL CHARACTER (STRING TERMINATOR)

VARIABLES :- VARIABLES REPRESENTS MEMORY LOCATIONS, WHICH ARE USED TO STORE DATA.

IDENTIFIERS :- IDENTIFIERS ARE NAMES OF THE VARIABLES.

          RULES FOR IDENTIFIERS
         =======================

1) MAXIMUM 30 CHARACTER ALLOWED. BUT RECOMMONDED IS 8 CHARACTERS.

2) SPACES ARE NOT ALLOWED. BUT WE CAN USE UNDER SCORE ( _ ) TO CONNECT TO WORDS. UNDER SCORE IS CALLED WORD CONNECTOR.

Ex :- float avg_marks;

3) GENERALLY IDENTIFIERS ARE WRITEN IN LOWER CASE ALPHABETS ONLY.

4) AN IDENTIFIER MAY CONTAIN ALPHABETS AND DIGITS. BUT AN IDENTIFIER MUST STARTS WITH ALPHABET.

Ex :- int kv6; ====> Valid
int 6kv; ====> Not Valid

5) RESERVED WORDS ARE NOT ALLOWED.

Ex:- int char; ====> Not Valid

DATA TYPES
===========

A DATA TYPE REPRESENTS, WHAT TYPE OF DATA TO BE STORED INTO A VARIABLE.

DATA TYPES
============

(DRAW FIGURE)

1) NUMERIC DATA TYPES : INTEGER, REAL

2) NON-NUMERIC DATA TYPES : VOID, CHARACTER, STRING

INTEGER FAMILY : INT, UNSIGNED INT, LONG INT

REAL FAMILY : FLOAT, DOUBLE / LONG FLOAT, LONG DOUBLE

===============================================
DATA TYPE   MEMORY  RANGE SIGN
===============================================
int       2 BYTES   -32768 to +32767 %d
===============================================
long int   4 BYTES   -2147483648 to +2147483647 %ld
===============================================
unsigned int 2 BYTES   0 to 65535 %u
===============================================
float 4 BYTES      -3.4e38 to +3.4e38 %f
===============================================
double 8 BYTES   -1.7e308 to +1.7e308 %lf
===============================================
long double 10 BYTES %Lf
===============================================
void (NOTHING)  0 BYTES
===============================================
char 1 BYTE %c
===============================================
string NO FIXED SIZE %s
===============================================

THE MAIN DIFFERENCE BETWEEN INT AND LONG INT IS RANGE. THE MAIN DIFFERENCE BETWEEN FLOAT AND DOUBLE IS ACCURACY. FLOAT CAN STORES ONLY UPTO 6 DECIMALS ACCURATELY, BUT DOUBLE CAN STORES ONLY UPTO 15 DECIMALS ACCURATELY. SO USE DOUBLES NOT FLOATS.

# include <stdio.h>
# include <conio.h>
void main()
{
int a;
long int b;
unsigned int c;
clrscr();
a = 50000;
b = 50000;
c = -10;
printf("A Value : %d\n",a);
printf("B Value : %ld\n",b);
printf("C Value : %u\n",c);
c = 50000;
printf("C Value : %u\n",c);
getch();
}

OUTPUT
=======
A Value : -123 (GARBAGE VALUE / UNKNOWN VALUE)
B Value : 50000
C Value : 6463(GARBAGE VALUE / UNKNOWN VALUE)
C Value : 50000

# include <stdio.h>
# include <conio.h>
void main()
{
float a;
double b;
clrscr();
a = 123456.123456;
b = 123456.123456;
printf("A Value : %f\n",a);
printf("B Value : %lf\n",b);
getch();
}

OUTPUT
=======
A Value : 123456.123000
B Value : 123456.123456

GARBAGE VALUE :- IT MEANS UNKNOWN VALUE / MEANING LESS VALUE. BY DEFAULT ALL VARIABLES HAS GARBAGE VALUE.

# include <stdio.h>
# include <conio.h>
void main()
{
int a;
clrscr();
printf("A Value : %d\n",a);
a = 10; (ASSIGNMENT)
printf("A Value : %d\n",a);
getch();
}

OUTPUT
=======
A Value : 866 (GARBAGE VALUE)
A Value : 10

INITIALIZATION :- IT IS THE PROCESS OF STORING SOME VALUE INITIALLY (FIRST) INTO A VARIABLE AT THE TIME OF IT'S DECLARATION. THE MAIN ADVANTAGE OF INITIALIZATION IS TO RESTRICT GARBAGE VALUES.
###################################################################################################################################################################
###################################################################################################################################################################
# include <stdio.h>
# include <conio.h>
void main()
{
int a = 10;
clrscr();
printf("A Value : %d\n",a);
getch();
}

OUTPUT
=======
A Value : 10

GENERALLY KNOWN VALUES ARE INITIALIZED.

# include <stdio.h>
# include <conio.h>
void main()
{
float pie = 3.14;
clrscr();
printf("Pie Value : %.2f\n",pie);
getch();
}

OUTPUT
=======
Pie Value : 3.14

FIELD WITH SPECIFIERS
======================

\t : IT IS USED TO MOVE CURSOR TO NEXT TAB ZONE. TAB ZONES ARE SETTED FOR EVERY 8 COLUMNS. TO FORMAT OUTPUT WE CAN USE FIELD WITH SPECIFIERS INSTEAD OF \t.

# include <stdio.h>
# include <conio.h>
void main()
{
int a;
int b;
float c;
double d;
char e[10] = "Rama";
clrscr();
a = 10;
b = 20;
c = 12.34;
d = 12.34567890;
printf("India\t%d\n",a);
printf("India\t\t%d\n",a);
printf("%d\t%d\n",a,b);
printf("%5d%d\n",a,b);
printf("%5d%5d\n",a,b);
printf("%-5d%d\n",a,b);
printf("%05d%5d\n",a,b);
printf("%10.2f\n",c);
printf("%-10.2f\n",c);
printf("%010.2f\n",c);
printf("%015.8lf\n",d);
printf("%10s\n",e);
printf("%-10s\n",e);
getch();
}

OUTPUT
=======
India   10
India       10
10 20
    1020
    10     20
10     20
00010  20
       12.34
12.34
0000012.34
000012.34567890
      Rama
Rama

ASCII VALUES
=============

ASCII STANDS FOR AMERICAN STANDARD CODE FOR INFORMATION INTERCHANGE. IN 'C' LANGUAGE EVERY CHARACTER HAS A SPECIAL VALUE CALLED ASCII VALUE. 'C' LANGUAGE PROVIDES TOTAL 256 ASCII VALUES FROM ZERO TO 255.
THE STANDARD ASCII VALUES ARE AS FOLLOWS.

A - Z : 65 - 90
a - z : 97 - 122
0 - 9 : 48 - 57

COMPATABILITY : ADJUSTABILITY. CONVERTING FACILITY. ONLY INT TO CHAR AND CHAR TO INT.

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
printf("%d\n",65);
printf("%c\n",65);
printf("%c\n",'a');
printf("%d\n",'a');
printf("%c\t%c\t%c\t%c\t%c",3,6,232,242,225);
getch();
}

OUTPUT
=======
65
A
a
97
SPECIAL CHARACTER

# include <stdio.h>
# include <conio.h>
void main()
{
int a;
clrscr();
puts("Enter Ascii Value");
scanf("%d",&a);
printf("Ascii Code : %c\n",a);
getch();
}

OUTPUT
=======
Enter Ascii Value
65
Ascii Code : A

# include <stdio.h>
# include <conio.h>
void main()
{
char a;
clrscr();
puts("Enter Ascii Code");
scanf("%c",&a);
printf("Ascii Value : %d\n",a);
getch();
}

OUTPUT
=======
Enter Ascii Code
A
Ascii Value : 65

   TYPE CONVERSION / CASTING
   ===========================

IT IS THE PROCESS OF CHANGING ONE DATA TYPE VARIABLES INTO ANOTHER DATA TYPE VARIABLES. THIS IS TWO TYPES.

1) AUTOMATIC CONVERSION / IMPLICIT CASTING

2) MANUAL CONVERSION / EXPLICIT CASTING

AUTOMATIC CONVERSION :- IT IS DONE BY THE SYSTEM BY USING ASSIGNMENT OPERATOR (=).

# include <stdio.h>
# include <conio.h>
void main()
{
float a;
int b;
clrscr();
a = 12.34;
b = a;
printf("A Value : %.2f\n",a);
printf("B Value : %d\n",b);
getch();
}

OUTPUT
=======
A Value : 12.34
B Value : 12

# include <stdio.h>
# include <conio.h>
void main()
{
int a;
float b;
clrscr();
a = 12;
b = a;
printf("A Value : %d\n",a);
printf("B Value : %.2f\n",b);
getch();
}

OUTPUT
=======
A Value : 12
B Value : 12.00

# include <stdio.h>
# include <conio.h>
void main()
{
int a;
clrscr();
a = 'K';
printf("A Value : %d\n",a);
getch();
}

OUTPUT
=======
A Value : 75

# include <stdio.h>
# include <conio.h>
void main()
{
char a;
clrscr();
a = 75;
printf("A Value : %c\n",a);
getch();
}

OUTPUT
=======
A Value : K

MANUAL CONVERSION :- IT IS DONE BY THE PROGRAMMER BY USING CAST OPERATOR. TYPE CASTING MEANS CHANGING FORCLY ONE DATA TYPE VARIABLE INTO ANOTHER DATA TYPE.

CAST OPERATOR : (DATA TYPE)

# include <stdio.h>
# include <conio.h>
void main()
{
int a,b;
float c;
clrscr();
a = 5;
b = 2;
c = a / b;
printf("Quotient : %.1f\n",c);
getch();
}

OUTPUT
=======
Quotient : 2.0

# include <stdio.h>
# include <conio.h>
void main()
{
int a,b;
float c;
clrscr();
a = 5;
b = 2;
c = a / (float)b; //  c = (float) a / b;
printf("Quotient : %.1f\n",c);
getch();
}

OUTPUT
=======
Quotient : 2.5

CONVERTING FEETS TO INCHES
=============================

# include <stdio.h>
# include <conio.h>
void main()
{
int fts,inchs;
clrscr();
puts("Enter Feets");
scanf("%d",&fts);
inchs = fts * 12;
printf("Inches : %d\n",inchs);
getch();
}

OUTPUT
=======
Enter Feets
3
Inches : 36

CONVERTING INCHES TO FEETS
=============================

# include <stdio.h>
# include <conio.h>
void main()
{
int inchs;
float fts;
clrscr();
puts("Enter Inches");
scanf("%d",&inchs);
fts = inchs / 12.0;
printf("Feets : %.1f\n",fts);
getch();
}

OUTPUT
=======
Enter Inches
30
Feets : 2.5

WRITE A PROGRAM TO INPUT METERS AND CONVERT INTO CENTIMETERS?

WRITE A PROGRAM TO INPUT CENTIMETERS AND CONVERT INTO METERS?

WORKING WITH COLORS [CONIO.H]
=================================

textcolor( ) :- THIS FUNCTION IS USED TO SET TEXT (INFORMATION) COLOR.

textbackground( ) :- THIS FUNCTION IS USED TO SET BACK GROUND COLOR.

cprintf( ) :- THIS FUNCTION IS USED TO PRINT INFORMATION IN SPECIFIED COLOR.

'C' LANGUAGE SUPPORTS THE FOLLOWING 16 COLORS.
COLOR NAME MUST BE WRITEN IN UPPERCASE ALPHABETS.

COLOR NAME COLOR CODE
============= ============

BLACK 0
BLUE 1
GREEN 2
CYAN (SKY BLUE) 3
RED 4
MAGENTA (PINK) 5
BROWN 6
LIGHTGRAY 7
DARKGRAY 8
LIGHTBLUE 9
LIGHTGREEN 10
LIGHTCYAN 11
LIGHTRED 12
LIGHTMAGENTA 13
YELLOW 14
WHITE 15

BLINK (EFFECT) 128

WRITE COLOR NAME INSTEAD OF WRITING COLOR CODE IS RECOMMONDED. ONLY FIRST EIGHT COLORS CAN BE USE AS BACKGROUND COLORS.

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
textcolor(YELLOW);
textbackground(RED);
cprintf("Jaya Sree");
getch();
}

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
textcolor(14);
textbackground(4);
cprintf("Jaya Sree");
getch();
}

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
textcolor(YELLOW + BLINK);
// textcolor(YELLOW + 128);
// textcolor(14 + BLINK);
// textcolor(14 + 128);
cprintf("Jaya Sree");
getch();
}

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
textcolor(YELLOW);
cprintf("Jaya Sree\n");
textcolor(RED);
cprintf("Poornima\n");
textcolor(MAGENTA);
cprintf("Sruthi\n");
textcolor(BROWN);
cprintf("Sravani\n");
textcolor(BLUE);
cprintf("Durga\n");
getch();
}

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
textcolor(YELLOW);
cprintf("Jaya Sree\n\r");
textcolor(RED);
cprintf("Poornima\n\r");
textcolor(MAGENTA);
cprintf("Sruthi\n\r");
textcolor(BROWN);
cprintf("Sravani\n\r");
textcolor(BLUE);
cprintf("Durga\n\r");
getch();
}

GOTOXY( ) :- THIS FUNCTION IS USED TO LOCATE CURSOR ON SCREEN AT THE REQUIRED POSITION.

[ DRAW FIGURE ]


# include <stdio.h>
# include <conio.h>
void main()
{
clrscr();
printf("Rama");
gotoxy(1,5);
printf("Tata");
gotoxy(15,3);
printf("King");
getch();
}

OUTPUT
=======
Rama

King

Tata

STRLEN( ) :- THIS FUNCTION IS USED TO FIND LENGTH OF THE STRING.

       USING STRLEN( ) FUNCTION
       =========================

# include <stdio.h>
# include <conio.h>
# include <string.h>
void main()
{
char str[20];
int len;
clrscr();
puts("Enter String");
gets(str);
len = strlen(str);
printf("String Length : %d\n",len);
getch();
}

OUTPUT
=======
Enter String
Rama Rao
String Length : 8

# include <stdio.h>
# include <conio.h>
# include <string.h>
void main()
{
int sno,em,tm,hm,mm,scm,som,tot,len;
float avg;
char sname[20];
clrscr();
len = strlen("Sridevi Convent");
gotoxy((40 - len / 2),1);
textcolor(YELLOW);
cprintf("Sridevi Convent");
len = strlen("===============");
gotoxy((40 - len / 2),2);
cprintf("===============");
gotoxy(5,4);
textcolor(BLUE);
cprintf("Student Number : ");
gotoxy(55,4);
cprintf("Student Name : ");
gotoxy(5,6);
cprintf("English Marks  : ");
gotoxy(55,6);
cprintf("Telugu Marks : ");
gotoxy(5,8);
cprintf("Hindi Marks    : ");
gotoxy(55,8);
cprintf("Maths Marks  : ");
gotoxy(5,10);
cprintf("Science Marks  : ");
gotoxy(55,10);
cprintf("Social Marks : ");
gotoxy(22,4);
scanf("%d",&sno);
gotoxy(70,4);
scanf("%s",&sname);
gotoxy(22,6);
scanf("%d",&em);
gotoxy(70,6);
scanf("%d",&tm);
gotoxy(22,8);
scanf("%d",&hm);
gotoxy(70,8);
scanf("%d",&mm);
gotoxy(22,10);
scanf("%d",&scm);
gotoxy(70,10);
scanf("%d",&som);
tot = em + tm + hm + mm + scm + som;
avg = tot / 6.0;
gotoxy(25,12);
textcolor(RED);
cprintf("Total   Marks : ");
textcolor(GREEN + BLINK);
cprintf("%d",tot);
gotoxy(25,14);
textcolor(RED);
cprintf("Average Marks : ");
textcolor(GREEN + BLINK);
cprintf("%.2f",avg);
getch();
}

  OPERATORS
  ===========

AN OPERATOR IS A SPECIAL SYMBOL WHICH PERFORMS SOME OPERATION. AN OPERATOR ACTS ON SOME VARIABLES OR CONSTANTS WHICH ARE CALLED OPERANDS. OPERATORS ARE CLASSIFIED INTO THREE CATEGORIES.

1) UNARY OPERATORS

2) BINARY OPERATORS

3) TERNARY / CONDITIONAL OPERATOR

UNARY OPERATORS :- WHICH WORKS ON SINGLE OPERAND.

[ ++, --, -, !, &, *, sizeof ]

++ ====> INCREMENT OPERATOR
--  ====> DECREMENT OPERATOR
-   ====> NEGATION OPERATOR
!  ====> NOT
& ====> ADDRESS OPERATOR
* ====> POINTER OPERATOR

'C' LANGAUGE PROVIDES THE FOLLOWING TWO SPECIAL OPERATORS WHICH ARE NOT AVAILABLE IN MATHEMATICS.

1) INCREMENT OPERATOR (++)
2) DECREMENT OPERATOR (--)

INCREMENT OPERATOR ADDS ONE TO THE OPERAND AND DECREMENT OPERATOR SUBTRACTS ONE FROM THE OPERAND. WE CAN USE INCREMENT AND DECREMENT OPERATORS IN THE FOLLOWING TWO NOTATIONS.

1) POSTFIX NOTATION

Ex :- A++, B--

2) PREFIX NOTATION

Ex :- ++A, --B

USING INCREMENT & DECREMENT OPERATORS IN POSTFIX NOTATION
==============================================

# include <stdio.h>
# include <conio.h>
void main( )
{
int a = 10;
clrscr( );
printf("A Value : %d\n",a);
a++;
printf("A Value : %d\n",a);
a--;
printf("A Value : %d",a);
getch( );
}

OUTPUT
=======
A Value : 10
A Value : 11
A Value : 10

USING INCREMENT & DECREMENT OPERATORS IN PREFIX NOTATION
==============================================

# include <stdio.h>
# include <conio.h>
void main( )
{
int a = 10;
clrscr( );
printf("A Value : %d\n",a);
++a;
printf("A Value : %d\n",a);
--a;
printf("A Value : %d",a);
getch( );
}

OUTPUT
=======
A Value : 10
A Value : 11
A Value : 10

NOTE :- IN POSTFIX NOTATION ANY OTHER OPERATION IS DONE FIRST AND INCREMENT / DECREMENT IS DONE AT LAST. IN PREFIX NOTATION INCREMENT / DECREMENT IS DONE FIRST AND ANY OTHER OPERATION IS DONE AT LAST.

 DIFFERENCE BETWEEN POSTFIX & PREFIX NOTATIONS
 ==================================================

# include <stdio.h>
# include <conio.h>
void main( )
{
int a = 10;
int b;
clrscr( );
b = a++;
printf("A Value : %d\n",a);
printf("B Value : %d",b);
getch( );
}

OUTPUT
=======
A Value : 11
B Value : 10

# include <stdio.h>
# include <conio.h>
void main( )
{
int a = 10;
int b;
clrscr( );
b = ++a;
printf("A Value : %d\n",a);
printf("B Value : %d",b);
getch( );
}

OUTPUT
=======
A Value : 11
B Value : 11

NEGATION OPERATOR (-) :- THIS OPERATOR IS USED TO CHANGE THE SIGN OF THE VALUE.

# include <stdio.h>
# include <conio.h>
void main( )
{
int a;
int b;
clrscr( );
a = 10;
b = -a;
printf("A Value : %d\n",a);
printf("B Value : %d",b);
getch( );
}

OUTPUT
=======
A Value : 10
B Value : -10

SIZEOF :- THIS OPERATOR IS USED TO FIND SIZE OF  THE DATA TYPE / VARIABLE.

# include <stdio.h>
# include <conio.h>
void main( )
{
int oc;
float k;
clrscr( );
oc = sizeof(int);
printf("Integer Occupies %d Bytes\n",oc);
oc = sizeof(k);
printf("Float Occupies %d Bytes\n",oc);
getch( );
}

OUTPUT
=======
Integer Occupies 2 Bytes
Float Occupies 4 Bytes

BINARY OPERATORS :- WHICH WORKS ON TWO OPERANDS. THESE OPERATORS ARE CLASSIFIED INTO THE FOLLOWING CATEGORIES.

1) ARITHMETICAL OPERATORS

2) ASSIGNMENT OPERATOR
(SHORTHAND OPERATORS)

3) RELATIONAL OPERATORS

4) LOGICAL OPERATORS

5) BITWISE OPERATORS

ARITHMETICAL OPERATORS :- THESE OPERATORS ARE USED TO PERFORM ARITHMETICAL OPERATIONS LIKE ADDITION, SUBTRACTION ETC.

[ +, -, *, /, % ]

% :- MODULES OPERATOR [REMAINDER]

MODULES OPERATOR WORKS ONLY ON INT DATA TYPE.

EXPRESSION :- IF TWO OPERANDS OR CONSTANTS ARE CONNECTED WITH AN ARITHMETICAL OPERATOR THEN IT IS CALLED EXPRESSION.

Ex :- A + B, 10 - 5

# include <stdio.h>
# include <conio.h>
void main( )
{
int a;
clrscr( );
a = 17 / 3;
printf("Quotient : %d\n",a);
a = 17 % 3;
printf("Remainder : %d",a);
getch( );
}

OUTPUT
=======
Quotient : 5
Remainder : 2

WRITE A PROGRAM TO INPUT TOTAL MINUTES AND CONVERT TO NUMBER OF HOURS AND REMAINING MINUTES?

# include <stdio.h>
# include <conio.h>
void main( )
{
int tm,rm,h;
clrscr( );
printf("Enter Total Minutes\n");
scanf("%d",&tm);
h = tm / 60;
rm = tm % 60;
printf("%d Hours and %d Minutes",h,rm);
getch( );
}

OUTPUT
=======
Enter Total Minutes
195
3 Hours and 15 Minutes

WRITE A PROGRAM TO INPUT TOTAL DAYS AND CONVERT TO NUMBER OF MONTHS AND REMAINING DAYS?

 PRIORITY OF OPERATORS / OPERATORS PRECEDENCE
 =================================================

OPERATORS PRIORITY IS BASED ON PRDMAS PRINCIPLE.

P ==== > PARANTHESIS ====> FIRST GROUP
R ====> REMAINDER ====> SECOND GROUP
D ====> DIVISION ====> SECOND GROUP
M ====> MULTIPLICATION ====> SECOND GROUP
A ====> ADDITION ====> THIRD GROUP
S ====> SUBTRACTION ====> THIRD GROUP

NOTE :- ASSIGNMENT OPERATOR (=) HAS LEAST PRIORITY.

# include <stdio.h>
# include <conio.h>
void main( )
{
int a;
clrscr( );
a = 10 + 5 * 3;
printf("A Value : %d\n",a);
a = 10 * 5 / 4;
printf("A Value : %d\n",a);
a = (10 + 5) * 3;
printf("A Value : %d\n",a);
a = 10 * 5 + 3;
printf("A Value : %d\n",a);
a = 10 * (5 + 3);
printf("A Value : %d",a);
getch( );
}

OUTPUT
=======
A Value : 25
A Value : 12
A Value : 45
A Value : 53
A Value : 80

ASSIGNMENT OPERATOR (=) :- IT IS USED TO STORE VALUES / DATA / CONSTANTS / EXPRESSIONS INTO A VARIABLE. IT CONTAINS A SUB CATEGORY CALLED SHORTHAND OPERATORS.

[ += ,-=, *=, /=, %= ]

Ex :- A += 10; ====> A = A + 10;

A = A + 10; EXPANDED NOTATION

A += 10; COMPACT NOTATION

# include <stdio.h>
# include <conio.h>
void main( )
{
int a = 10;
clrscr( );
printf("A Value : %d\n",a);
a += 5;
printf("A Value : %d\n",a);
a -= 3;
printf("A Value : %d\n",a);
a *= 5;
printf("A Value : %d\n",a);
a /= 6;
printf("A Value : %d\n",a);
a %= 3;
printf("A Value : %d",a);
getch( );
}

OUTPUT
=======
A Value : 10
A Value : 15
A Value : 12
A Value : 60
A Value : 10
A Value : 1

RELATIONAL OPERATORS :- THESE OPERATORS ARE USED TO CHECK RELATION BETWEEN TWO OPERANDS.
THESE OPERATORS ALWAYS RETURN BOOLEAN VALUE (TRUE / FALSE).  IN 'C' LANGUAGE NON-ZERO (EVEN NEGATIVE ALSO) IS TREATED AS TRUE AND ZERO IS TREATED AS FALSE.

[ >, >=, <, <=, ==, != ]

== : EQUALS TO (COMPARISION OPERATOR)

!= : NOT EQUALS TO

CONDITION :- IF TWO OPERANDS OR CONSTANTS ARE CONNECTED WITH A RELATIONAL OPERATOR THEN IT IS CALLED CONDITION.

Ex :- A > B, 10 < 5

LOGICAL OPERATORS :- THESE OPERATORS ARE USED TO JOIN MULTIPLE CONDITIONS. THE PURPOSE OF THESE OPERATORS IS TO CHECK MORE THAN ONE CONDITION.

[ &&, ||, ! ]

&& ====> LOGICAL AND OPERATOR
||      ====> LOGICAL OR OPERATOR
(| ====> PIPE SYMBOL)
!      ====> LOGICAL NOT OPERATOR

BITWISE OPERATORS
====================

THESE OPERATORS ACTS UPON INDIVIDUAL BITS OF A NUMBER. THESE OPERATORS PERFORM OPERATIONS BIT BY BIT. ADVANTAGE OF USING THIS OPERATORS IS SPEED.

[ ~, &, |, ^, <<, >> ]

~ ====> BITWISE COMPLEMENT OPERATOR
(~ ====> TILDE SYMBOL)
& ====> BITWISE AND OPERATOR
|   ====> BITWISE OR OPERATOR
            ^ ====>BITWISE XOR (EXCLUSIVE OR)
<< ====> BITWISE LEFT SHIFT OPERATOR
>> ====> BITWISE RIGHT SHIFT OPERATOR

          TERNARY OPERATOR / CONDITIONAL OPERATOR
          =============================================

IT IS AN ALTERNATE METHOD TO IF ELSE STATEMENT. IT USED THREE EXPRESSIONS. IT HAS THE FOLLOWING SYNTAX.

(CONDITION) ? TRUE PART : FALSE PART;

# include <stdio.h>
# include <conio.h>
void main( )
{
int a;
clrscr( );
a = (10 > 5) ? 100 : 200;
printf("A Value : %d\n",a);
a = (10 > 50) ? 100 : 200;
printf("A Value : %d",a);
getch( );
}

OUTPUT
=======
A Value : 100
A Value : 200

BIG OF TWO NUMBERS
=====================

# include <stdio.h>
# include <conio.h>
void main( )
{
int a,b,big;
clrscr( );
printf("Enter Two Numbers\n");
scanf("%d %d",&a,&b);
big = (a > b) ? a : b;
printf("Big Number : %d",big);
getch( );
}

OUTPUT 1
=========
Enter Two Numbers
10
5
Big Number : 10

OUTPUT 2
=========
Enter Two Numbers
10
50
Big Number : 50

     EVEN NUMBER / ODD NUMBER
     ===========================

# include <stdio.h>
# include <conio.h>
void main( )
{
int n,r;
clrscr( );
printf("Enter Number\n");
scanf("%d",&n);
r = n % 2;
(r == 0) ? printf("It is Even Number") : printf("It is Odd Number");
getch( );
}

OUTPUT 1
=========
Enter Number
6
It is Even Number

OUTPUT 2
=========
Enter Number
3
It is Odd Number

     LEAP YEAR / NORMAL YEAR
     ==========================

# include <stdio.h>
# include <conio.h>
void main( )
{
int y;
clrscr( );
printf("Enter Year\n");
scanf("%d",&y);
(y % 4 == 0) ? printf("It is Leap Year") : printf("It is Normal Year");
getch( );
}

OUTPUT 1
=========
Enter Year
2012
It is Leap Year

OUTPUT 2
=========
Enter Year
2010
It is Normal Year

CONTROL FLOW STATEMENTS
============================

FLOW OF EXECUTION :- THE WAY THE PROGRAM IS EXECUTED. GENERALLY PROGRAMS ARE EXECUTED IN TWO TYPES OF FLOW OF EXECUTIONS.

1) SEQUENTIAL EXECUTION

2) RANDOM EXECUTION

SEQUENTIAL EXECUTION :- IN THIS MODEL, ALL STATEMENTS ARE EXECUTED ONE BY ONE (TIME WASTE).

RANDOM EXECUTION :- IN THIS MODEL, WE CAN DIRECTLY EXECUTE THE REQUIRED STATEMENT (TIME SAVE). TO APPLY RANDOM EXECUTION WE NEED CONTROL FLOW STATEMENTS.

CONTROL FLOW STATEMENTS :- THESE ARE THE STATEMENTS TO CHANGE FLOW OF EXECUTION. THESE STATEMENTS ARE USED TO TAKE DECISIONS AND TO ITERATE (LOOP) SET OF STATEMENTS. WITH THE HELP OF CONTROL FLOW STATEMENTS PROGRAMMER HAS BETTER CONTROL ON HIS PROGRAM.

(DRAW FIGURE)


BRANCHING STATEMENTS :- THESE STATEMENTS ARE USED TO TAKE DECISIONS.

ITERATING STATEMENTS :- THESE STATEMENTS ARE USED TO EXECUTE SET OF STATEMENTS REPEATEDLY.

JUMPING STATEMENTS :- THESE STATEMENTS ARE USED TO TRANSFER CONTROL TO REQUIRED STATEMENT.

IF STATEMENT
=============

THIS STATEMENT IS USED TO CHECK CONDITIONS AND TO COMPARE VALUES. THIS STATEMENT IS AGAIN CLASSIFIED INTO THE FOLLOWING FOUR CATEGORIES.

1) SIMPLE IF STATEMENT

2) IF ELSE STATEMENT

3) ELSE IF STATEMENT

4) NESTED IF STATEMENT

SIMPLE IF STATEMENT
=====================

BLOCK / COMPOUND STATEMENT :- SET OF STATEMENTS INSIDE THE BRACES. IF A BLOCK CONTAINS ONLY ONE STATEMENT THEN BRACES ARE OPTIONAL. BUT PLACING BRACES IS RECOMONDED.

THIS STATE MENT IS USED TO CHECK WHETHER A CONDITION IS TRUE OR FALSE.

SYNTAX
=======

IF(CONDITION)
{
STATEMENT 1;
STATEMENT 2;
STATEMENT 3;
}
STATEMENT X;

IF THE CONDITION IS TRUE THEN THE BLOCK (FROM STATEMENT 1 TO STATEMENT 3) IS EXECUTED. OTHERWISE THE BLOCK IS NOT EXECUTED. STATEMENT X IS COMMON STATEMENT. IT CAN'T BE EFFECTED BY IF STATEMENT. IT IS EXECUTED IF THE CONDITION IS EITHER TRUE OR FALSE.

GENERALLY SIMPLE IF STATEMENT IS USED TO SELECT ONE OPTION.

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr( );
if(10 > 5)
{
printf("Hai");
}
getch( );
}

OUTPUT
=======
Hai

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr( );
if(10 > 50)
{
printf("Hai");
}
getch( );
}

OUTPUT
=======
BLANK

# include <stdio.h>
# include <conio.h>
void main( )
{
clrscr();
if(10 > 5)
{
printf("Hai,");
printf("How r u? ");
printf("Bye");
}
getch( );
}

OUTPUT
=======
Hai,How r u? Bye

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr( );
if(10 > 50)
{
printf("Hai,");
printf("How r u? ");
printf("Bye");
}
getch( );
}

OUTPUT
=======
BLANK

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr( );
if(10 > 5)
{
printf("Hai");
}
printf("Bye");
getch( );
}

OUTPUT
=======
HaiBye

# include <stdio.h>
# include <conio.h>
void main()
{
clrscr( );
if(10 > 50)
{
printf("Hai");
}
printf("Bye");
getch( );
}

OUTPUT
=======
Bye

# include <stdio.h>
# include <conio.h>
void main()
{
int m;
clrscr( );
puts("Enter Marks");
scanf("%d",&m);
if(m >= 35)
{
printf("Result : Pass");
}
getch( );
}

OUTPUT 1
=========
Enter Marks
98
Result : Pass

OUTPUT 2
=========
Enter Marks
32
BLANK

# include <stdio.h>
# include <conio.h>
# include <math.h>
void main()
{
int n,s;
clrscr( );
puts("Enter Number");
scanf("%d",&n);
if(n > 0)
{
s = sqrt(n);
printf("Square Root : %d\n",s);
}
getch( );
}

OUTPUT 1
=========
Enter Number
64
Square Root : 8

OUTPUT 2
=========
Enter Number
-64
BLANK

IF ELSE STATEMENT
==================

IF ELSE STATEMENT IS EXTENSION TO SIMPLE IF STATEMENT. IF ELSE STATEMENT IS USED TO SELECT ONE OPTION FROM TWO OPTIONS.

SYNTAX
=======

IF(CONDITION)
{
STATEMENT 1;
STATEMENT 2;
STATEMENT 3;
}
ELSE
{
STATEMENT 4;
STATEMENT 5;
STATEMENT 6;
}
STATEMENT X;

IF THE CONDITION IS TRUE THEN IF BLOCK (FROM STATEMENT 1 TO STATEMENT 3) IS EXECUTED. OTHERWISE ELSE BLOCK (FROM STATEMENT 4 TO STATEMENT 6) IS EXECUTED. STATEMENT X IS COMMON STATEMENT. IT CAN'T BE EFFECTED BY IF STATEMENT. IT IS EXECUTED IF THE CONDITION IS EITHER TRUE OR FALSE.

# include <stdio.h>
# include <conio.h>
void main()
{
int m;
clrscr( );
puts("Enter Marks");
scanf("%d",&m);
if(m >= 35)
{
printf("Result : Pass\n");
}
else
{
printf("Result : Fail\n");
}
printf("Prepared By S.S.C Board\n");
getch( );
}

OUTPUT 1
=========
Enter Marks
98
Result : Pass
Prepared By S.S.C Board

OUTPUT 2
=========
Enter Marks
32
Result : Fail
Prepared By S.S.C Board

WRITE A PROGRAM TO INPUT NUMBER FIND IT IS POSITIVE NUMBER OR NEGATIVE NUMBER?

# include <stdio.h>
# include <conio.h>
void main()
{
int n;
clrscr( );
puts("Enter Number");
scanf("%d",&n);
if(n > 0)
{
printf("It is Positive Number\n");
}
else
{
printf("It is Negative Number\n");
}
getch( );
}

OUTPUT 1
=========
Enter Number
63
It is Positive Number

OUTPUT 2
=========
Enter Number
-5
It is Negative Number

# include <stdio.h>
# include <conio.h>
void main()
{
int n;
clrscr( );
puts("Enter Number");
scanf("%d",&n);
if(n < 0)
{
printf("It is Negative Number\n");
}
else
{
printf("It is Positive Number\n");
}
getch( );
}

OUTPUT 1
=========
Enter Number
63
It is Positive Number

OUTPUT 2
=========
Enter Number
-5
It is Negative Number

WRITE A PROGRAM TO INPUT TWO NUMBERS FIND IT BIG NUMBER?

# include <stdio.h>
# include <conio.h>
void main()
{
int a,b;
clrscr( );
puts("Enter Two Numbers");
scanf("%d %d",&a,&b);
if(a > b)
{
printf("A is Big Number\n");
}
else
{
printf("B is Big Number\n");
}
getch( );
}

OUTPUT 1
=========
Enter Two Numbers
10
5
A is Big Number

OUTPUT 2
=========
Enter Two Numbers
10
50
B is Big Number

(H.W) : WRITE A PROGRAM TO INPUT TWO NUMBERS FIND SMALL NUMBER?

WRITE A PROGRAM TO INPUT NUMBER FIND IT IS EVEN NUMBER OR ODD NUMBER?

# include <stdio.h>
# include <conio.h>
void main()
{
int n;
clrscr( );
puts("Enter Number");
scanf("%d",&n);
if(n % 2 == 0)
{
printf("It is Even Number\n");
}
else
{
printf("It is Odd Number\n");
}
getch( );
}

OUTPUT 1
=========
Enter Number
6
It is Even Number

OUTPUT 2
=========
Enter Number
3
It is Odd Number

(H.W) : WRITE A PROGRAM TO INPUT YEAR FIND LEAP YEAR OR NORMAL YEAR?

WRITE A PROGRAM TO INPUT AGE FIND IT IS ELIGIBLE TO VOTE OR NOT ELIGIBLE TO VOTE?

# include <stdio.h>
# include <conio.h>
void main()
{
int age;
clrscr( );
puts("Enter Age");
scanf("%d",&age);
if(age >= 18)
{
printf("Eligible to Vote\n");
}
else
{
printf("Not Eligible to Vote\n");
}
getch( );
}

OUTPUT 1
=========
Enter Age
32
Eligible to Vote

OUTPUT 2
=========
Enter Age
17
Not Eligible to Vote

WRITE A PROGRAM TO INPUT AGE FIND IT IS TEENAGE OR NOT?

# include <stdio.h>
# include <conio.h>
void main()
{
int age;
clrscr( );
puts("Enter Age");
scanf("%d",&age);
if(age >= 13 && age <= 19) (&& ====> AND)
{
printf("It is Teenage\n");
}
else
{
printf("It is Not Teenage\n");
}
getch( );
}

OUTPUT 1
=========
Enter Age
16
It is Teenage

OUTPUT 2
=========
Enter Age
32
It is Not Teenage

WRITE A PROGRAM TO INPUT CHARACTER FIND IT VOWEL OR CONSONANT?
tolower( ) :- THIS FUNCTION IS USED TO CONVERT A CHARACTER INTO LOWER CASE. THIS FUNCTION IS AVAILABLE IN CTYPE.H.

# include <stdio.h>
# include <conio.h>
# include <ctype.h>
void main()
{
char ch;
clrscr( );
puts("Enter Character");
scanf("%c",&ch);
ch = tolower(ch);
if(ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
{ ( || ====> OR, PIPE SYMBOL)
printf("It is Vowel\n");
}
else
{
printf("It is Consonant\n");
}
getch( );
}

OUTPUT 1
=========
Enter Character
e
It is Vowel

OUTPUT 2
=========
Enter Character
E
It is Vowel

OUTPUT 3
=========
Enter Character
K
It is Consonant

strcpy( ) :- WE CAN'T ASSIGN STRINGS. WE CAN STORE STRINGS BY USING STRCPY( ) FUNCTION. THIS FUNCTION IS USED TO COPY / ASSIGN / STORE STRINGS. THIS FUNCTION IS AVAILABLE IN STRING.H

# include <stdio.h>
# include <conio.h>
# include <string.h>
void main()
{
char st[10];
clrscr( );
strcpy(st,"Jaya Sree");  ( st = "Jaya Sree"; )
printf("String : %s\n",st);
getch( );
}

OUPTUT
=======
String : Jaya Sree

# include <stdio.h>
# include <conio.h>
# include <string.h>
void main()
{
int sno,em,tm,hm,mm,scm,som,tot;
float avg;
char sname[20],res[10];
clrscr( );
puts("Enter Student Number, Name");
scanf("%d %s",&sno,&sname);
puts("Enter English, Telugu, Hindi Marks");
scanf("%d %d %d",&em,&tm,&hm);
puts("Enter Maths, Science, Social Marks");
scanf("%d %d %d",&mm,&scm,&som);
tot = em + tm + hm + mm + scm + som;
avg = tot / 6.0;
if(em >= 35 && tm >= 35 && hm >= 35 && mm >= 35
&& scm >= 35 && som >= 35)
{
strcpy(res,"Pass");
}
else
{
strcpy(res,"Fail");
}
clrscr();
printf("\t\t\tSridevi Convent\n");
printf("\t\t\t***************\n\n");
printf("Student Number : %d\n\n",sno);
printf("Student Name   : %s\n\n",sname);
printf("Total   Marks  : %d\n\n",tot);
printf("Average Marks  : %.2f\n\n",avg);
printf("Result         : %s\n\n",res);
printf("\t\t\tPrincipal");
getch( );
}

if(em < 35 || tm < 35 || hm < 35 || mm < 35
|| scm < 35 || som < 35)
{
strcpy(res,"Fail");
}
else
{
strcpy(res,"Pass");
}

OUTPUT 1
=========
Enter Student Number, Name
101
Eeswar
Enter English, Telugu, Hindi Marks
40
40
40
Enter Maths, Science, Social Marks
40
40
40
Sridevi Convent
**************

Student Number : 101

Student Name     : Eeswar

Total Marks        : 240

Average Marks   : 40.00

Result                  : Pass

Principal

 
OUTPUT 2
=========
Enter Student Number, Name
102
Jaya
Enter English, Telugu, Hindi Marks
100
100
100
Enter Maths, Science, Social Marks
100
100
34
Sridevi Convent
**************

Student Number : 101

Student Name     : Eeswar

Total Marks        : 534

Average Marks   : 89.00

Result                  : Fail

Principal


ELSE IF STATEMENT
==================

ELSE IF STATEMENT IS EXTENSION TO IF ELSESTATEMENT. ELSE IF STATEMENT IS USED TO SELECT ONE OPTION FROM MULTIPLE (MORE THAN TWO) OPTIONS.

SYNTAX
=======

IF(CONDITION 1)
{
STATEMENT 1;
STATEMENT 2;
STATEMENT 3;
}
ELSE
IF(CONDITION 2)
{
STATEMENT 4;
STATEMENT 5;
STATEMENT 6;
}
ELSE
IF(CONDITION 3)
{
STATEMENT 7;
STATEMENT 8;
STATEMENT 9;
}
ELSE
{
STATEMENT 10;
STATEMENT 11;
STATEMENT 12;
}
STATEMENT X;

# include <stdio.h>
# include <conio.h>
void main()
{
int n;
clrscr( );
puts("Enter Number");
scanf("%d",&n);
if(n > 0)
{
printf("It is Positive Number\n");
}
else
if(n < 0)
{
printf("It is Negative Number\n");
}
else
{
printf("It is Zero\n");
}
getch( );
}

OUTPUT 1
=========
Enter Number
6
It is Positive Number

OUTPUT 2
=========
Enter Number
-3
It is Negative Number

OUTPUT 3
=========
Enter Number
0
It is Zero

(H.W) WRITE A PROGRAM TO INPUT TWO NUMBERS FIND BIG NUMBER?

(H.W) WRITE A PROGRAM TO INPUT AGE FIND IT IS TEENAGE OR BELOW TEENAGE OR CROSSED TEENAGE?

(H.W) WRITE A PROGRAM TO INPUT STUDENT DETAILS FIND TOTAL MARKS, AVERAGE MARKS AND GRADE?

GRADE : DISTINCTION, FIRST CLASS, SECOND CLASS, THIRD CLASS, ORDINARY PASS, FAIL.

NUMBER OF SUBJECTS

EXIT(0)