Characteristics of Array and Program for Age Analysis

Characteristics of Array [2 marks]

An array is a collection of similar data type elements stored in contiguous memory locations. Its main characteristics are:

1. Homogeneous Elements: All elements in an array must be of the same data type (e.g., all int, all float).
2. Contiguous Memory Allocation: Array elements are stored in consecutive memory locations.
3. Index/Subscript Based Access: Each element is accessed using an index starting from 0 (lower bound = 0, upper bound = size - 1).
4. Fixed Size: The size of an array is fixed at the time of declaration and cannot be changed during execution.
5. Random Access: Any element can be directly accessed using its index in constant time.
6. Single Variable Name: Multiple values are stored under one variable name with different indices.

Program to Input Age of 500 Persons [8 marks]

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

void main()
{
    int age[500], i;
    int count = 0;          /* count of persons with age between 25 to 30 */
    float sum = 0, average;

    clrscr();

    /* Input age of 500 persons */
    for(i = 0; i < 500; i++)
    {
        printf("Enter age of person %d: ", i + 1);
        scanf("%d", &age[i]);
    }

    /* Calculate sum and count persons with age between 25 to 30 */
    for(i = 0; i < 500; i++)
    {
        sum = sum + age[i];

        if(age[i] >= 25 && age[i] <= 30)
        {
            count++;
        }
    }

    /* a) Calculate average age */
    average = sum / 500;

    printf("\n--- Results ---\n");

    /* Display average age */
    printf("\na) Average Age = %.2f", average);

    /* b) Display ages between 25 to 30 */
    printf("\n\nb) Ages between 25 to 30:\n");
    for(i = 0; i < 500; i++)
    {
        if(age[i] >= 25 && age[i] <= 30)
        {
            printf("Person %d : %d years\n", i + 1, age[i]);
        }
    }

    printf("\nTotal persons with age between 25 to 30: %d", count);

    getch();
}

Explanation of the Program

Sample Output

--- Results ---

a) Average Age = 35.46

b) Ages between 25 to 30:
Person 3  : 27 years
Person 7  : 25 years
Person 12 : 30 years
...

Total persons with age between 25 to 30: 85

Difference Between Library Function and User Defined Function + Swap Using Call by Reference

(a) Difference Between Library Function and User Defined Function

As per the course notes, C programs have two types of functions: Library Functions and User Defined Functions.

Examples:

• Library functions: printf(), scanf(), sqrt(), strlen()
• User defined functions: any function written by the programmer for a specific task

(b) Program to Swap Two Values Using Call by Reference

Concept: Call by Reference

In call by reference, instead of passing the actual values to the function, the addresses (pointers) of the variables are passed. This means any changes made inside the function directly affect the original variables in the calling function.

Program

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

/* Function prototype (declaration) */
void swap(int *a, int *b);

int main()
{
    int x, y;

    printf("Enter first value  : ");
    scanf("%d", &x);

    printf("Enter second value : ");
    scanf("%d", &y);

    printf("\nBefore Swap: x = %d, y = %d\n", x, y);

    /* Passing addresses of x and y - Call by Reference */
    swap(&x, &y);

    printf("After  Swap: x = %d, y = %d\n", x, y);

    getch();
    return 0;
}

/* Function definition */
void swap(int *a, int *b)
{
    int temp;

    temp = *a;   /* temp stores value at address a */
    *a   = *b;   /* value at address a = value at address b */
    *b   = temp; /* value at address b = temp */
}

Step-by-Step Explanation

Sample Output

Enter first value  : 10
Enter second value : 20

Before Swap: x = 10, y = 20
After  Swap: x = 20, y = 10

Key Point

In call by reference, the function works with the actual memory locations of the variables. Therefore, the swap is reflected back in main(), unlike call by value where only copies are passed and the original values remain unchanged.

Types of Operators in C

List of Operators [2 marks]

An operator is a symbol that specifies an operation to be performed on operands. C includes the following types of operators:

1. Arithmetic Operator
2. Assignment Operator
3. Increment and Decrement Operator
4. Relational Operator
5. Logical Operator
6. Conditional Operator
7. Comma Operator
8. Sizeof Operator
9. Bitwise Operator

Explanation of Any Four Operators [8 marks]

1. Arithmetic Operators

Arithmetic operators are used for numeric calculations. They are of two types:

i. Unary Arithmetic Operators - operate on a single operand.

ii. Binary Arithmetic Operators - operate on two operands.

Example:

int a = 10, b = 3;
printf("%d", a % b);   // Output: 1
printf("%d", a / b);   // Output: 3

2. Relational Operators

Relational operators are used to compare two values or expressions. The result of a relational operation is either true (1) or false (0).

Example:

int a = 5, b = 3;
if (a > b)
    printf("a is greater");   // Output: a is greater

3. Increment and Decrement Operators

These operators are used to increase or decrease the value of a variable by 1. They are of two types:

i. Prefix (operator written before operand)

• ++x : value is incremented first, then used in expression.
• --x : value is decremented first, then used in expression.

ii. Postfix (operator written after operand)

• x++ : value is used in expression first, then incremented.
• x-- : value is used in expression first, then decremented.

Example:

int x = 5, y;

y = ++x;   // x becomes 6 first, then y = 6
printf("%d %d", x, y);   // Output: 6 6

x = 5;
y = x++;   // y = 5 first, then x becomes 6
printf("%d %d", x, y);   // Output: 6 5

4. Logical Operators

Logical operators are used to combine two or more relational expressions and return a true (1) or false (0) result. They are commonly used in decision-making.

Truth Table for AND (&&):

Example:

int a = 5, b = 3, c = 0;
if (a > b && b > c)
    printf("Both conditions true");   // Output: Both conditions true
if (!c)
    printf("c is zero");              // Output: c is zero

Summary: Operators are fundamental building blocks in C programming. Arithmetic operators perform calculations, relational operators compare values, increment/decrement operators modify values by 1, and logical operators combine conditions for decision-making.

Program to Display First 50 Prime Numbers

Given Data

• Required output: first 50 prime numbers
• Marks: 5

Concept

A prime number is an integer greater than 1 whose only positive divisors are 1 and itself. To generate the first 50 primes, we test successive integers starting from 2, counting each prime until 50 are found.

Program (C)

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

void main()
{
    int num, i, count, primeCount;

    clrscr();

    primeCount = 0;   /* number of primes found so far */
    num = 2;          /* start from smallest prime */

    printf("First 50 Prime Numbers are:\n");

    while(primeCount < 50)
    {
        count = 0;    /* 0 = prime, 1 = not prime */

        for(i = 2; i <= num/2; i++)   /* check divisors up to num/2 */
        {
            if(num % i == 0)
            {
                count = 1;
                break;
            }
        }

        if(count == 0)                /* num is prime */
        {
            printf("%d\t", num);
            primeCount++;
        }

        num++;
    }

    getch();
}

Note: an inner loop written as i < num is logically correct, it simply checks more divisors than necessary. Using i <= num/2 (or i*i <= num) is more efficient, and both give the same correct output.

Sample Output

First 50 Prime Numbers are:
2       3       5       7       11      13      17      19      23      29
31      37      41      43      47      53      59      61      67      71
73      79      83      89      97      101     103     107     109     113
127     131     137     139     149     151     157     163     167     173
179     181     191     193     197     199     211     223     227     229

Verification of Output

Counting the listed primes: 5 rows of 10 = 50 primes. The 50th prime is $229$, which is correct.

Explanation

Program to Display Series Up to 25 Terms (Skipping the 7th Term)

STEP 1 - Given Data

• Series: $2\times3,; 3\times5,; 4\times7,; 5\times9,\ldots$
• Number of terms: 25
• Condition: Do not print the 7th term

STEP 2 - Solve

Pattern Analysis

• First factor $a = i + 1$
• Second factor $b = 2i + 1$

Verification for $i=4$: $a=5$, $b=9$ → $5\times9$. Correct.

C Program

#include <stdio.h>

int main()
{
    int i, a, b;

    printf("Series: 2x3, 3x5, 4x7, 5x9 ... up to 25 terms\n");
    printf("(7th term is skipped)\n\n");

    for(i = 1; i <= 25; i++)
    {
        if(i == 7)          /* Skip the 7th term */
            continue;

        a = i + 1;          /* First factor  */
        b = 2 * i + 1;      /* Second factor */

        printf("Term %d: %d x %d = %d\n", i, a, b, a * b);
    }

    return 0;
}

Sample Output

Series: 2x3, 3x5, 4x7, 5x9 ... up to 25 terms
(7th term is skipped)

Term 1:  2 x 3  = 6
Term 2:  3 x 5  = 15
Term 3:  4 x 7  = 28
Term 4:  5 x 9  = 45
Term 5:  6 x 11 = 66
Term 6:  7 x 13 = 91
Term 8:  9 x 17 = 153
Term 9:  10 x 19 = 190
...
Term 25: 26 x 51 = 1326

Verification of Skipped Term

7th term would be: $a = 8,; b = 15 \Rightarrow 8\times15 = 120$ - this is skipped by the continue statement.

Key Points

• A for loop iterates $i = 1$ to $25$ (25 terms).
• if(i == 7) continue; skips only the 7th term.
• Formulas: $a = i+1$, $b = 2i+1$.

The program above uses standard C in place of the non-standard Turbo C constructs (void main(), conio.h, clrscr() and getch()); the logic, formulas and output are identical.

Program to Draw Two Shapes Using Graphics Functions

Answer

The two shapes chosen are a Circle and a Rectangle, both drawn using standard graphics functions from graphics.h.

Program

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

void main()
{
    int gd = DETECT, gm;

    /* Initialize the graphics mode */
    initgraph(&gd, &gm, "c:\\tc\\bgi");

    /* Shape 1: Draw a Circle
       center at (200, 150) with radius 80 */
    setcolor(WHITE);
    circle(200, 150, 80);

    /* Shape 2: Draw a Rectangle
       top-left corner at (350, 100)
       bottom-right corner at (550, 250) */
    setcolor(WHITE);
    rectangle(350, 100, 550, 250);

    getch();

    /* Close the graphics mode */
    closegraph();
}

Explanation of Each Step

Output

+------------------------------------------+
|                                          |
|      ( Circle )      [ Rectangle ]       |
|       drawn at        drawn at           |
|      (200,150)       (350,100) to        |
|      r = 80          (550,250)           |
|                                          |
+------------------------------------------+

Note: The pixel origin (0, 0) is at the top-left corner of the screen. All coordinates are measured in pixels from this origin.