Q1 EXPLAIN VARIOUS VARIABLES AND DATA TYPES USED IN C.

ANS VARIABLES

VARIABLES ARE NAMES GIVEN TO STORAGE LOCATIONS IN MEMORY. EACH VARIABLE IN C

HAS A SPECIFIC TYPE , WHICH DETERMINES WHAT KIND OF DATA IT CAN STORE .

DATA TYPES

DATA TYPES IN C ARE CATEGORIZED INTO SEVERAL TYPES. HERE’S A BRIEF OVERVIEW OF
EACH :

1. PRIMARY (BASIC) DATA TYPES:

 INT : USED TO STORE INTEGERS (WHOLE NUMBERS ). EXAMPLE: INT AGE = 25;

FLOAT :USED TO STORE FLOATING-POINT (DECIMAL) NUMBERS . EXAMPLE: FLOAT

SALARY = 35000.75;


 CHAR : USED TO STORE SINGLE CHARACTERS . EXAMPLE: CHAR GRADE = 'A';

DOUBLE : USED TO STORE DOUBLE-PRECISION FLOATING -POINT NUMBERS .

EXAMPLE: DOUBLE PI = 3.141592653589793;


2. DERIVED DATA TYPES:

ARRAYS: USED TO STORE MULTIPLE VALUES OF THE SAME TYPE. EXAMPLE: INT
NUMBERS [5] = {1, 2, 3, 4, 5};


POINTERS: USED TO STORE THE ADDRESS OF A VARIABLE. EXAMPLE: INT* PTR =

&AGE;


FUNCTION: FUNCTIONS ARE SEGMENTS OF CODE DESIGNED TO EXECUTE A

SPECIFIC TASK .


3. USER-DEFINED DATA TYPES:

 STRUCT : USED TO GROUP DIFFERENT DATA TYPES TOGETHER. EXAMPLE:

STRUCT STUDENT {

INT ID ;

CHAR NAME [50];

FLOAT MARKS ;

};

UNION :SIMILAR TO STRUCTURES BUT USED TO STORE DIFFERENT DATA TYPES IN

THE SAME MEMORY LOCATION . E XAMPLE :


UNION DATA {

INT I ;

FLOAT F;
 CHAR STR [20];

};

ENUM :USED TO DEFINE A VARIABLE THAT CAN BE ASSIGNED ONE OUT OF A SET
OF POSSIBLE VALUES . E XAMPLE :


Q2 WHAT ARE OPERATORS IN PROGRAMMING LANGUAGE? NAME AND EXPLAIN WITH

EXAMPLES

OPERATORS ARE SPECIAL SYMBOLS THAT PERFORM OPERATIONS ON VARIABLES AND

VALUES . T HEY ARE USED TO MANIPULATE DATA AND VARIABLES IN PROGRAMMING .
HERE'S AN OVERVIEW OF THE DIFFERENT TYPES OF OPERATORS WITH EXAMPLES:

1. ARITHMETIC OPERATORS
THESE OPERATORS ARE USED TO PERFORM BASIC ARITHMETIC OPERATIONS .



OPERATO EXAMPL
DESCRIPTION RESULT
R E
GIVES THE SUM OF A AND
+ ADDITION A +B
B
DIFFERENCE BETWEEN A
- SUBTRACTION A - B
AND B
MULTIPLICATI
* A *B PRODUCT OF A AND B
ON
QUOTIENT OF A DIVIDED
/ DIVISION A /B
BY B
REMAINDER OF A DIVIDED
% MODULUS A %B
BY B

2. RELATIONAL OPERATORS
THESE OPERATORS COMPARE TWO VALUES.



OPERATO EXAMPL
DESCRIPTION RESULT
R E
== EQUAL TO A == B TRUE IF A EQUALS B
!= NOT EQUAL TO A != B TRUE IF A IS NOT EQUAL TO B
> GREATER THAN A >B TRUE IF A IS GREATER THAN B
< LESS THAN A <B TRUE IF A IS LESS THAN B
GREATER THAN OR TRUE IF A IS GREATER THAN OR
>= A >= B
EQUAL TO EQUAL TO B
LESS THAN OR EQUAL TRUE IF A IS LESS THAN OR EQUAL
<= A <= B
TO TO B

3. LOGICAL OPERATORS
THESE OPERATORS ARE USED TO PERFORM LOGICAL OPERATIONS .


OPERATO DESCRIPTIO EXAMPL
RESULT
R N E
LOGICAL TRUE IF BOTH A AND B
&& A && B
AND ARE TRUE
` B̀ TRUE IF EITHER A OR B
` ` LOGICAL OR
A IS TRUE
LOGICAL
! !A TRUE IF A IS FALSE
NOT

4. ASSIGNMENT OPERATORS
THESE OPERATORS ARE USED TO ASSIGN VALUES TO VARIABLES .



OPERATO EXAMPL
DESCRIPTION EXPLANATION
R E
= ASSIGNMENT A = 10 ASSIGNS VALUE 10 TO A
A +=
+= ADDITION ASSIGNMENT ADDS 10 TO A AND ASSIGNS THE RESULT TO A
10
SUBTRACTION SUBTRACTS 10 FROM A AND ASSIGNS THE
-= A -= 10
ASSIGNMENT RESULT TO A
MULTIPLICATION MULTIPLIES A BY 10 AND ASSIGNS THE RESULT
*= A *= 10
ASSIGNMENT TO A
DIVIDES A BY 10 AND ASSIGNS THE RESULT TO
/= DIVISION ASSIGNMENT A /= 10
A
A %= FINDS THE REMAINDER OF A DIVIDED BY 10
%= MODULUS ASSIGNMENT
10 AND ASSIGNS IT TO A

5. BITWISE OPERATORS
THESE OPERATORS ARE USED TO PERFORM BIT-LEVEL OPERATIONS .



OPERATO DESCRIPTI
EXAMPLE RESULT
R ON
BITWISE BITS THAT ARE 1 IN BOTH A
& A &B
AND AND B BECOME 1
BITWISE B̀ BITS THAT ARE 1 IN
` ` `A
OR EITHER A OR B BECOME 1
BITWISE BITS THAT ARE 1 IN A OR B,
^ A ^B
XOR BUT NOT BOTH , BECOME 1
BITWISE
~ ~A ALL BITS IN A ARE INVERTED
NOT
SHIFTS A'S BITS TO THE LEFT
<< LEFT SHIFT A << 2
BY 2 PLACES
RIGHT SHIFTS A'S BITS TO THE
>> A >> 2
SHIFT RIGHT BY 2 PLACES
  6. MISCELLANEOUS OPERATORS

OPERATO
DESCRIPTION EXAMPLE
R
RETURNS THE SIZE OF A
SIZEOF SIZEOF (A)
VARIABLE
& ADDRESS OF &A (RETURNS THE ADDRESS OF VARIABLE A)
* POINTER *PTR (POINTER TO A VARIABLE)
(A > B) ? A : B (RETURNS A IF THE CONDITION IS
?: TERNARY OPERATOR
TRUE , OTHERWISE RETURNS B)

LOOP CONTROL STATEMENTS AND BRANCH CONTROL STATEMENTS ARE BOTH

ESSENTIAL ELEMENTS IN PROGRAMMING , EACH SERVING DISTINCT PURPOSES .
HERE’S A COMPARISON TO HELP YOU UNDERSTAND THEIR DIFFERENCES AND
APPLICATIONS :
LOOP CONTROL STATEMENTS
LOOP CONTROL STATEMENTS ARE USED TO REPEATEDLY EXECUTE A BLOCK OF
CODE AS LONG AS A SPECIFIED CONDITION IS TRUE . T HERE ARE DIFFERENT
TYPES OF LOOPS , EACH WITH A SPECIFIC USE CASE :

Q1 COMPARE LOOP CONTROL STATEMENTS & BRANCH CONTROL STATEMENTS

ANS

TY
DESCRIPTION EXAMPLE
PE

REPEATS A BLOCK OF CODE

FOR C FOR (INT I = 0; I <
A SPECIFIC NUMBER OF
LOOP 10; I++) { // CODE }
TIMES

REPEATS A BLOCK OF CODE C WHILE

WHILE
WHILE A CONDITION IS (CONDITION) { //
LOOP
TRUE CODE }

DO- SIMILAR TO WHILE , BUT

C DO { // CODE }
WHILE THE BLOCK IS EXECUTED AT
WHILE ( CONDITION );
LOOP LEAST ONCE

BRANCH CONTROL STATEMENTS

BRANCH CONTROL STATEMENTS, ALSO KNOWN AS DECISION-MAKING
STATEMENTS , ARE USED TO EXECUTE A BLOCK OF CODE BASED ON CERTAIN
CONDITIONS . T HEY HELP IN MAKING DECISIONS AND CONTROLLING THE FLOW
OF EXECUTION .

TYPE DESCRIPTION EXAMPLE

IF EXECUTES A BLOCK OF C IF (CONDITION) { //

TYPE DESCRIPTION EXAMPLE

CODE IF A CONDITION IS
CODE }
TRUE

EXECUTES ONE BLOCK OF

IF - CODE IF A CONDITION IS C IF(CONDITION) { //
ELSE TRUE AND ANOTHER IF CODE } ELSE { // CODE }
FALSE

ADDS MULTIPLE C IF (CONDITION1) { //

ELSE -
CONDITIONS TO AN IF - CODE } ELSE IF
IF
ELSE STATEMENT (CONDITION2) { // CODE }

EXECUTES DIFFERENT C SWITCH (VARIABLE)

SWITC BLOCKS OF CODE BASED { CASE VALUE1: // CODE
H ON THE VALUE OF A BREAK ; DEFAULT : // CODE
VARIABLE }

Q2 ILLUSTRATE DIFFERENT BRANCH CONTROL STATEMENTS WITH EXAMPLE.

ANS 1. IF STATEMENT
THE IF STATEMENT IS USED TO EXECUTE A BLOCK OF CODE ONLY IF A
SPECIFIED CONDITION IS TRUE .
C
#INCLUDE <STDIO.H>

INT MAIN () {
INT NUM = 10;

IF (NUM > 5) {
PRINTF ("T HE NUMBER IS GREATER THAN 5\ N");
}

RETURN 0;
}
OUTPUT:
THE NUMBER IS GREATER THAN 5
2. IF-ELSE STATEMENT
THE IF-ELSE STATEMENT IS USED TO EXECUTE A BLOCK OF CODE IF A
CONDITION IS TRUE , AND ANOTHER BLOCK OF CODE IF THE CONDITION IS
FALSE .
C
#INCLUDE <STDIO.H>

INT MAIN () {
INT NUM = 3;
 IF (NUM > 5) {
PRINTF ("T HE NUMBER IS GREATER THAN 5\ N");
} ELSE {
PRINTF ("T HE NUMBER IS NOT GREATER THAN 5\ N");
}

RETURN 0;
}
OUTPUT:
THE NUMBER IS NOT GREATER THAN 5
3. ELSE-IF LADDER
THE ELSE-IF LADDER IS USED TO CHECK MULTIPLE CONDITIONS ONE AFTER
ANOTHER .
C
#INCLUDE <STDIO.H>

INT MAIN () {
INT NUM = 7;

(NUM > 10) {

IF
PRINTF ("T HE NUMBER IS GREATER THAN 10\ N");
} ELSE IF (NUM > 5) {
PRINTF ("T HE NUMBER IS GREATER THAN 5 BUT LESS THAN OR EQUAL TO
10\N");
} ELSE {
PRINTF ("T HE NUMBER IS LESS THAN OR EQUAL TO 5\ N");
}

UNIT 3
Q1 EXPLAIN DECLARATION AND INITIALIZATION OF ONE-DIMENSIONAL ARRAY WITH
EXAMPLE

ANS DECLARATION OF A ONE-DIMENSIONAL ARRAY

AN ARRAY IS DECLARED BY SPECIFYING THE TYPE OF ITS ELEMENTS AND THE
NUMBER OF ELEMENTS REQUIRED .
C
TYPE ARRAY N AME[ARRAY S IZE ];
TYPE IS THE DATA TYPE OF THE ELEMENTS IN THE ARRAY (LIKE INT, CHAR, FLOAT,
ETC.).


ARRAY N AME IS THE NAME OF THE ARRAY .

ARRAY S IZE IS THE NUMBER OF ELEMENTS THE ARRAY CAN HOLD .


EXAMPLE:


C
INT NUMBERS [5];// T HIS DECLARES AN ARRAY NAMED NUMBERS CAPABLE OF
HOLDING 5 INTEGERS .
 INITIALIZATION OF A ONE-DIMENSIONAL ARRAY
INITIALIZATION ASSIGNS VALUES TO AN ARRAY AT THE TIME OF DECLARATION .
METHOD 1: SPECIFY VALUES AT DECLARATION
YOU CAN INITIALIZE AN ARRAY BY LISTING THE VALUES IN CURLY BRACES {} RIGHT
AFTER THE ARRAY DECLARATION .
EXAMPLE:
C
INT NUMBERS [5] = {1, 2, 3,

Q2 EXPLAIN SEARCHING AND SORTING WITH EXAMPLE.

ANS SEARCHING
SEARCHING REFERS TO THE PROCESS OF LOCATING A SPECIFIC ELEMENT WITHIN A
COLLECTION OF ELEMENTS ( LIKE AN ARRAY OR LIST ).
1. LINEAR SEARCH
LINEAR SEARCH CHECKS EACH ELEMENT IN THE ARRAY ONE BY ONE UNTIL THE
DESIRED ELEMENT IS FOUND OR THE END OF THE ARRAY IS REACHED .
EXAMPLE:
C
#INCLUDE <STDIO.H>

INT LINEAR S EARCH (INT ARR [], INT SIZE , INT KEY) {
FOR (INT I = 0; I < SIZE; I++) {
IF (ARR[I] == KEY) {
RETURN I ; // R ETURN THE INDEX WHERE THE ELEMENT IS FOUND
}
}
RETURN -1; // E LEMENT NOT FOUND
}

INT MAIN () {
INT NUMBERS [] = {4, 2, 7, 1, 9};
INT KEY = 7;

INT INDEX = LINEARSEARCH(NUMBERS , 5, KEY);

IF ( INDEX != -1) {
PRINTF ("E LEMENT FOUND AT INDEX : % D\ N", INDEX );
} ELSE {
PRINTF ("E LEMENT NOT FOUND \ N");
}

RETURN 0;
}
OUTPUT:
ELEMENT FOUND AT INDEX: 2
2. BINARY SEARCH
BINARY SEARCH IS MORE EFFICIENT THAN LINEAR SEARCH BUT REQUIRES THE
ARRAY TO BE SORTED . I T WORKS BY REPEATEDLY DIVIDING THE SEARCH INTERVAL
IN HALF.
EXAMPLE:
C
#INCLUDE <STDIO.H>

INT BINARY S EARCH (INT ARR [], INT SIZE , INT KEY) {
INT LOW = 0, HIGH = SIZE - 1;

WHILE (LOW <= HIGH) {

INT MID = ( LOW + HIGH ) / 2;

IF (ARR[MID] == KEY) {
RETURN MID ; // E LEMENT FOUND
} ELSE IF (ARR[MID] < KEY) {
LOW = MID + 1; // S EARCH IN THE RIGHT HALF
} ELSE {
HIGH = MID - 1; // S EARCH IN THE LEFT HALF
}
}
RETURN -1; // E LEMENT NOT FOUND
}

INT MAIN () {
INT NUMBERS [] = {1, 2, 4, 7, 9}; // S ORTED ARRAY
INT KEY = 7;

INT INDEX = BINARYSEARCH(NUMBERS , 5, KEY);

IF ( INDEX != -1) {
PRINTF ("E LEMENT FOUND AT INDEX : % D\ N", INDEX );
} ELSE {
PRINTF ("E LEMENT NOT FOUND \ N");
}

RETURN 0;
}
OUTPUT:
ELEMENT FOUND AT INDEX: 3
SORTING
SORTING REFERS TO ARRANGING THE ELEMENTS IN A SPECIFIC ORDER, OFTEN
ASCENDING OR DESCENDING .
1. BUBBLE SORT
BUBBLE SORT REPEATEDLY STEPS THROUGH THE LIST, COMPARES ADJACENT
ELEMENTS , AND SWAPS THEM IF THEY ARE IN THE WRONG ORDER .
EXAMPLE:
C
#INCLUDE <STDIO.H>

VOID BUBBLE S ORT (INT ARR [], INT SIZE ) {

FOR (INT I = 0; I < SIZE - 1; I++) {
FOR ( INT J = 0; J < SIZE - 1 - I ; J++) {
IF ( ARR [J] > ARR [J + 1]) {
INT TEMP = ARR [J];
ARR [J] = ARR [J + 1];
ARR [J + 1] = TEMP ;
}
}
}
}

INT MAIN () {
INT NUMBERS [] = {4, 2, 7, 1, 9};

BUBBLE S ORT (NUMBERS , 5);

PRINTF ("S ORTED ARRAY : ");

FOR ( INT I = 0; I < 5; I ++) {
PRINTF ("%D ", NUMBERS [I ]);
}
PRINTF ("\ N");

RETURN 0;
}
OUTPUT:
SORTED ARRAY: 1 2 4 7 9
2. INSERTION SORT
INSERTION SORT BUILDS THE FINAL SORTED ARRAY ONE ITEM AT A TIME. IT’S MUCH
LESS EFFICIENT ON LARGE LISTS COMPARED TO MORE ADVANCED ALGORITHMS LIKE
QUICKSORT , HEAPSORT , OR MERGE SORT .
EXAMPLE:
C
#INCLUDE <STDIO.H>

VOID INSERTION S ORT (INT ARR [], INT SIZE ) {

FOR (INT I = 1; I < SIZE; I++) {
INT KEY = ARR [I ];
INT J = I - 1;

WHILE (J >= 0 && ARR[J] > KEY) {

ARR [J + 1] = ARR [J];
J--;
 }
ARR [J + 1] = KEY;
}
}

INT MAIN () {
INT NUMBERS [] = {4, 2, 7, 1, 9};

INSERTION S ORT (NUMBERS , 5);

PRINTF ("S ORTED ARRAY : ");

FOR ( INT I = 0; I < 5; I ++) {
PRINTF ("%D ", NUMBERS [I ]);
}
PRINTF ("\ N");

RETURN 0;
}
OUTPUT:
SORTED ARRAY: 1 2 4 7 9

UNIT 4
Q1 WRITE A PROGRAM TO CHECK WHETHER A STRING IS PALINDROME (REVERSED) OR NOT
WITHOUT USING STRING FUNCTION .
#INCLUDE <STDIO.H>

INT ISPALINDROME (CHAR STR []) {

INT START= 0;
INT END = 0;

// F IND THE LENGTH OF THE STRING

WHILE ( STR [END] != '\0') {
END++;
}
END--; // S ETS END TO THE LAST INDEX OF THE STRING

WHILE (START < END) {

IF (STR[START] != STR[END]) {
RETURN 0; // N OT A PALINDROME
}
START ++;
END--;
}
RETURN 1; // P ALINDROME
}
 INT MAIN (){
CHAR STR [100];

PRINTF ("E NTER A STRING : ");

SCANF ("%S ", STR );

IF (ISPALINDROME(STR)) {
PRINTF ("T HE STRING IS A PALINDROME .\N");
} ELSE {
PRINTF ("T HE STRING IS NOT A PALINDROME .\N");
}

RETURN 0;
}
Q2 EXPLAIN STRING MANIPULATION LIBRARY FUNCTIONS WITH THEIR SYNTAXES.

ANS 1. STRCPY()
COPIES ONE STRING TO ANOTHER.
SYNTAX:
C
CHAR STR 1[100], STR 2[100] = "H ELLO";
STRCPY (STR 1, STR 2); // STR1 NOW CONTAINS "HELLO"

2. STRCAT()
CONCATENATES (APPENDS) ONE STRING TO THE END OF ANOTHER.
SYNTAX:
C
CHAR STR 1[100] = "H ELLO, ", STR2[] = "WORLD!";
STRCAT (STR 1, STR 2); // STR 1 NOW CONTAINS "H ELLO , W ORLD!"

3. STRLEN()
RETURNS THE LENGTH OF A STRING.
SYNTAX:
C
CHAR STR [] = "HELLO";
SIZE _T LEN = STRLEN (STR ); // LEN IS 5

4. STRCMP()
COMPARES TWO STRINGS LEXICOGRAPHICALLY .
SYNTAX:
C
CHAR STR 1[] = "H ELLO", STR2[] = "WORLD";
INT RESULT = STRCMP(STR1, STR2); // RESULT IS NEGATIVE SINCE "HELLO" <
"WORLD"
5. STRNCPY()
COPIES A SPECIFIED NUMBER OF CHARACTERS FROM ONE STRING TO ANOTHER.
 SYNTAX:
C
CHAR STR 1[100], STR 2[100] = "H ELLO";
STRNCPY (STR 1, STR 2, 3); // STR 1 NOW CONTAINS "H EL"

6. STRNCAT()
APPENDS A SPECIFIED NUMBER OF CHARACTERS FROM ONE STRING TO ANOTHER.
SYNTAX:
C
CHAR STR 1[100] = "H ELLO", STR2[] = "WORLD";
STRNCAT (STR 1, STR 2, 3); // STR 1 NOW CONTAINS "H ELWOR "

7. STRNCMP()
COMPARES A SPECIFIED NUMBER OF CHARACTERS FROM TWO STRINGS .
SYNTAX:
C
C
CHAR STR 1[] = "H ELLO", STR2[] = "H ELLY";
INT RESULT = STRNCMP(STR1, STR2, 4); // RESULT IS ZERO SINCE FIRST 4
CHARACTERS ARE THE SAME
8. STRTOK()
SPLITS A STRING INTO TOKENS BASED ON A DELIMITER.
SYNTAX:
C
C
CHAR STR []= "HELLO,WORLD,HERE";
CHAR * TOKEN = STRTOK (STR , ",");
// TOKEN NOW CONTAINS "HELLO". SUBSEQUENT CALLS SPLIT THE REST.
9. STRCHR()
SEARCHES FOR THE FIRST OCCURRENCE OF A CHARACTER IN A STRING.
SYNTAX:
C
C
CHAR STR []= "HELLO";
CHAR * PTR = STRCHR (STR , ' E'); // PTR POINTS TO " ELLO "
10. STRRCHR()
SEARCHES FOR THE LAST OCCURRENCE OF A CHARACTER IN A STRING.
SYNTAX:

C
CHAR STR []= "HELLO WORLD";
CHAR * PTR = STRRCHR (STR , ' O'); // PTR POINTS TO " ORLD"

UNIT 5
Q1 EXPLAIN IN BRIEF 1) CALL BY VALUE 2) CALL BY REFERENCE
 ANS CALL BY VALUE
DEFINITION: IN CALL BY VALUE, A COPY OF THE ACTUAL PARAMETER'S VALUE IS
PASSED TO THE FUNCTION . T HE FUNCTION OPERATES ON THIS COPY, SO ANY
CHANGES MADE TO THE PARAMETER INSIDE THE FUNCTION DO NOT AFFECT THE
ORIGINAL VALUE .
EXAMPLE:
C
#INCLUDE <STDIO.H>

VOID MODIFY VALUE (INT NUM) {

NUM = 20; // T HIS CHANGE WON'T AFFECT THE ORIGINAL VARIABLE
}

INT MAIN () {
INT X = 10;
MODIFY VALUE (X);
PRINTF ("X = % D\ N", X); // O UTPUT : X = 10 ( REMAINS UNCHANGED )
RETURN 0;
}
CALL BY REFERENCE
DEFINITION: IN CALL BY REFERENCE, A REFERENCE (OR POINTER) TO THE ACTUAL
PARAMETER IS PASSED TO THE FUNCTION . T HE FUNCTION OPERATES ON THE
ADDRESS OF THE PARAMETER , SO ANY CHANGES MADE TO THE PARAMETER INSIDE
THE FUNCTION DIRECTLY AFFECT THE ORIGINAL VALUE .
EXAMPLE:
C
#INCLUDE <STDIO.H>

VOID MODIFY VALUE (INT * NUM) {

*NUM = 20; // T HIS CHANGE WILL AFFECT THE ORIGINAL VARIABLE
}

INT MAIN () {
INT X = 10;
MODIFY VALUE (&X);
PRINTF ("X = % D\ N", X); // O UTPUT : X = 20 ( VALUE IS CHANGED )

Q2 WRITE/BUILD A C PROGRAM TO DISPLAY THE SUM OF TWO NUMBERS USING USER

DEFINED FUNCTION
ANS #INCLUDE <STDIO.H>

// USER-DEFINED FUNCTION TO ADD TWO NUMBERS

INT ADD N UMBERS (INT A, INT B) {
RETURN A + B;
}
 INT MAIN ()
{
INT NUM1, NUM2, SUM ;

// A SKING FOR USER INPUT

PRINTF ("E NTER TWO NUMBERS : ");
SCANF ("%D % D", & NUM1, & NUM2);

// C ALLING THE USER-DEFINED FUNCTION

SUM = ADD N UMBERS (NUM1, NUM2);

// D ISPLAYING THE RESULT

PRINTF ("S UM: % D\ N", SUM );

RETURN 0;
}