⌨️ Programming in 'C' (SEC101T)

UNIT 1 — Introduction to C Programming

1.1 History of C

C kyun seekhna chahiye (features/importance) — exam ke liye 6 points

1.2 Structure of a C Program

/* 1. Documentation section — comments (naam, kaam, date) */
#include <stdio.h>        /* 2. Link/Library section — header files */
#define PI 3.14159        /* 3. Definition section — symbolic constants */
int add(int a, int b);    /* 4. Global declaration — function prototype */
int main()                /* 5. main() function — yahin se program shuru */
{
    int r;                /* 6. variable declaration */
    r = 5;
    printf("Area = %f\n", PI * r * r);
    return 0;             /* 0 = program successful khatam hua */
}
int add(int a, int b) {   /* 7. Sub-programs / user-defined functions */
    return a + b;
}

Ek poora annotated program (exam me isi style me likho)

/* Program: circle ka area aur circumference
   Author : Ansh | Date: 2026 */
#include <stdio.h>
#define PI 3.14159

int main()
{
    float r = 7.5, area, circ;

    area = PI * r * r;          // area = πr²
    circ = 2 * PI * r;          // circumference = 2πr

    printf("Radius      = %.2f\n", r);
    printf("Area        = %.4f\n", area);
    printf("Circumference = %.4f\n", circ);
    return 0;
}
/* Output:
   Radius      = 7.50
   Area        = 176.7146      (3.14159 × 7.5 × 7.5)
   Circumference = 47.1239     (2 × 3.14159 × 7.5) */

1.3 Compilation & Execution of a C Program

Steps (yaad rakho — exam me ye exact sequence puchha jata hai):

    first.c (source code — aap likhte ho)
      │
      ▼ 1. PREPROCESSOR → #include/#define ko expand karta hai (.i file)
      ▼ 2. COMPILER     → C → assembly language (syntax errors yahin milti hain)
      ▼ 3. ASSEMBLER    → assembly → object code (first.obj / first.o)
      ▼ 4. LINKER       → object + library functions (printf etc.) jodta hai
    first.exe (executable)
      ▼ 5. LOADER       → RAM me load karke CPU ko chalane deta hai
    OUTPUT 🎉

Commands jo lab me kaam aayenge

Types of Errors (exam me alag-alag poochhte hain)

1.4 Data Types and Sizes

Modifiers (size/range badalte hain): short (chhota), long (bada), signed (negative + positive), unsigned (sirf positive — 0 se 2× tak range). Example: unsigned int = 0 to 65,535 (2 bytes me). Aur long long = 8 bytes — bade numbers (jaise 20 ka factorial) ke liye.

/* Program: har data type ka size aur value print karo */
#include <stdio.h>
int main()
{
    char  c  = 'A';
    int   i  = 45;
    float f  = 89.75;
    double d = 3.14159265;
    short s  = 100;
    long long big = 123456789012345;

    printf("char   : %c  | size = %d byte\n", c, sizeof(c));
    printf("int    : %d  | size = %d bytes\n", i, sizeof(i));
    printf("float  : %.2f | size = %d bytes\n", f, sizeof(f));
    printf("double : %.8f | size = %d bytes\n", d, sizeof(d));
    printf("short  : %d  | size = %d bytes\n", s, sizeof(s));
    printf("long long : %lld | size = %d bytes\n", big, sizeof(big));
    return 0;
}
/* Output (64-bit gcc par):
   char   : A  | size = 1 byte
   int    : 45  | size = 4 bytes
   float  : 89.75 | size = 4 bytes
   double : 3.14159265 | size = 8 bytes
   short  : 100  | size = 2 bytes
   long long : 123456789012345 | size = 8 bytes */

Format specifiers ki poori list (printf/scanf me kaam aati hai)

1.5 Declaration of Variables

// Declaration
int a;
// Declaration + initialization (definition)
int b = 10;
float pi = 3.14;
char grade = 'A';
int x = 5, y = 10;   // ek hi line me kai variables

// Galat tarike (exam me "identify the error" ke liye):
// int 1num = 5;        // digit se naam shuru nahi hota
// int total marks = 5; // space allowed nahi
// int int = 5;         // keyword naam nahi ban sakta

Rules for naming variables (identifiers)

• Naam sirf letters (A–Z, a–z), digits (0–9) aur underscore (_) se banega.
• Pehla character letter ya underscore ho — digit nahi. ❌ 1num ✔️ num1
• Naam me space ya special symbol nahi (@, #, $, -). ❌ total marks
• Keyword naam nahi ho sakta. ❌ int int;
• C case-sensitive hai: marks aur Marks alag hain.
• Naam meaningful rakho (marks, total, avg) — debugging easy.
• Maximum length compiler par depend karti hai, par 31 characters tak ka naam har jagah chal jaata hai.

/* Program: local vs global variable ka farak */
#include <stdio.h>
int total = 100;          // GLOBAL — poore program me zinda

void show()
{
    int local = 5;        // LOCAL — sirf is function ke andar
    printf("Inside show(): total = %d, local = %d\n", total, local);
}

int main()
{
    printf("Inside main(): total = %d\n", total);
    show();
    // printf("%d", local);  // ❌ error — local main me exist nahi karta
    return 0;
}
/* Output:
   Inside main(): total = 100
   Inside show(): total = 100, local = 5 */

1.6 Keywords & Identifiers

32 keywords (yaad karne ka trick — group me yaad karo 💡)

Data types : int char float double void
Modifiers  : short long signed unsigned
Storage    : auto static extern register
Control    : if else switch case default break continue goto
Loops      : for while do return
Logic/other: const sizeof typedef enum volatile union struct

1.7 Symbolic Constants

// 1. #define (macro) — text replace (preprocessor karta hai)
#define PI 3.14159
#define MAX 100
#define MSG "Welcome"
// (Dhyaan do: #define ke end me semicolon NAHI lagta)

// 2. const keyword — type-safe constant (memory me jagah leta hai)
const float GST = 0.18;
// GST = 0.20;  // ❌ error — const ko badal nahi sakte

// 3. enum — named integer constants
enum week { MON, TUE, WED };   // MON=0, TUE=1, WED=2
enum week today = TUE;         // today = 1

/* Program: teeno tarike ek saath */
#include <stdio.h>
#define MAX 100
const float GST = 0.18;
enum status { FAIL, PASS };

int main()
{
    int marks = 78;
    float price = 1000, total;

    total = price + (price * GST);
    printf("MAX allowed = %d\n", MAX);
    printf("Price with GST = %.2f\n", total);
    if (marks >= 33)
        printf("Status = %d (PASS)\n", PASS);
    else
        printf("Status = %d (FAIL)\n", FAIL);
    return 0;
}
/* Output:
   MAX allowed = 100
   Price with GST = 1180.00
   Status = 1 (PASS) */

1.8 Storage Classes High-yield syllabus topic

/* static ka jaadu — count hota rehta hai, reset NAHI hota */
#include <stdio.h>
void counter() {
    static int c = 0;      // sirf pehli baar 0 hota hai!
    c++;
    printf("Called %d times\n", c);
}
int main() {
    counter();             // Called 1 times
    counter();             // Called 2 times
    counter();             // Called 3 times
    return 0;
}

/* Default values ka demo — local garbage vs static/global zero */
#include <stdio.h>
int g;                     // global — default 0
void test() {
    int local;             // auto — garbage value (kuch bhi!)
    static int s;          // static — default 0
    printf("local=%d  static=%d  global=%d\n", local, s, g);
}
int main() { test(); return 0; }
/* Output (local garbage ho sakti hai, static/global pakka 0):
   local=32767  static=0  global=0 */

/* extern — doosri file me define hui value use karna (2 files)
   file1.c:  int total = 500;              // definition
   file2.c:  extern int total;             // declaration (yahan value nahi)
             printf("%d", total);          // 500 mil jaayega
   Compile:  gcc file1.c file2.c -o app   */

1.9 First C Program — samajho line by line

#include <stdio.h>          // printf/scanf ke liye
int main() {                // program ka entry point
    printf("Hello, BCA!\n");  // \n = new line
    return 0;               // 0 = success (OS ko bataya)
}
/* Output: Hello, BCA! */

printf aur scanf (I/O ka A-B-C)

int age; float marks;

printf("Enter age: ");
scanf("%d", &age);            // & = address of (kahan rakhna hai)

printf("Enter marks: ");
scanf("%f", &marks);

printf("Age = %d, Marks = %.2f\n", age, marks);   // %.2f = 2 decimal places

/* Do values ek saath leni ho to:
   scanf("%d %d", &a, &b);
   aur char ke liye: scanf(" %c", &ch);   // space zaroori (buffer issue) */

Chhote-chhote ready programs (lab aur exam ke liye)

/* P1 — Do numbers ka sum */
#include <stdio.h>
int main() {
    int a, b, sum;
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    sum = a + b;
    printf("Sum = %d\n", sum);
    return 0;
}
/* Input: 15 25  →  Output: Sum = 40 */

/* P2 — Celsius se Fahrenheit */
#include <stdio.h>
int main() {
    float c, f;
    printf("Enter temperature in Celsius: ");
    scanf("%f", &c);
    f = (c * 9 / 5) + 32;          // formula: F = 9C/5 + 32
    printf("%.2f C = %.2f F\n", c, f);
    return 0;
}
/* Input: 37  →  Output: 37.00 C = 98.60 F */

/* P3 — Do numbers swap karo (third variable ke bina) */
#include <stdio.h>
int main() {
    int a = 5, b = 9;
    a = a + b;      // a = 14
    b = a - b;      // b = 5  (purani a)
    a = a - b;      // a = 9  (purani b)
    printf("a = %d, b = %d\n", a, b);
    return 0;
}
/* Output: a = 9, b = 5 ✔ */

/* P4 — Character ka ASCII code */
#include <stdio.h>
int main() {
    char ch;
    printf("Enter a character: ");
    scanf("%c", &ch);
    printf("Character = %c, ASCII = %d\n", ch, ch);
    return 0;
}
/* Input: A  →  Output: Character = A, ASCII = 65 */

/* P5 — Simple interest (formula: SI = P×R×T/100) */
#include <stdio.h>
int main() {
    float p, r, t, si;
    printf("Enter P R T: ");
    scanf("%f %f %f", &p, &r, &t);
    si = (p * r * t) / 100;
    printf("Simple Interest = %.2f\n", si);
    return 0;
}
/* Input: 10000 8 2  →  Output: Simple Interest = 1600.00 */

UNIT 2 — C Operators & Expressions

2.1 What is an Operator & Expression?

Exam me "C ke operators ke types explain karo" (10 marks) isi table se shuru karo — 8 categories, har ek ki 2 line + example. Aur ye yaad rakho: C me operands ka type hi result ka type decide karta hai (int + int = int, int + float = float).

2.2 Arithmetic Operators

/* Program: saare arithmetic operators ka demo + int division ka jadoo */
#include <stdio.h>
int main() {
    int a = 10, b = 3;
    float c = 10.0;

    printf("a + b = %d\n", a + b);        // 13
    printf("a - b = %d\n", a - b);        // 7
    printf("a * b = %d\n", a * b);        // 30
    printf("a / b = %d\n", a / b);        // 3  (int division)
    printf("a %% b = %d\n", a % b);       // 1
    printf("10.0 / 3 = %.4f\n", c / 3);   // 3.3333
    printf("(float)a / b = %.4f\n", (float)a / b);  // 3.3333 (casting)
    return 0;
}
/* Note: printf me %% likhne se % print hota hai (kyunki % special hai) */

2.3 Relational Operators (comparison — True=1 / False=0)

/* Program: comparison ka result 1/0 me dikhta hai */
#include <stdio.h>
int main() {
    int a = 10, b = 3;
    printf("a > b  = %d\n", a > b);    // 1
    printf("a < b  = %d\n", a < b);    // 0
    printf("a == b = %d\n", a == b);   // 0
    printf("a != b = %d\n", a != b);   // 1
    printf("5 <= 5 = %d\n", 5 <= 5);  // 1 (barabar bhi chhota-ya-barabar me aata hai)
    return 0;
}

2.4 Logical Operators

/* Program: leap year check — && aur || ka classic use */
#include <stdio.h>
int main() {
    int y;
    printf("Enter year: ");
    scanf("%d", &y);

    /* Leap year: 4 se divisible AND (100 se nahi ya 400 se haan) */
    if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
        printf("%d is a Leap Year\n", y);
    else
        printf("%d is not a Leap Year\n", y);
    return 0;
}
/* 2024 → Leap ✔  2025 → Not ✔  1900 → Not (100 se divisible, 400 se nahi)  2000 → Leap ✔ */

Short-circuit evaluation (bonus concept — viva me poochhte hain): A && B me agar A false nikal gaya, to B check hi nahi hota. A || B me A true hua to B check nahi hota. Isse code fast banta hai aur crash bachta hai — jaise if (ptr != NULL && *ptr == 5): pehla false hua to doosra chala hi nahi, warna NULL pointer dereference se crash hota. Yahi trick real projects me roz kaam aati hai.

2.5 Assignment Operators

/* Program: compound assignment ka step-by-step tracking */
#include <stdio.h>
int main() {
    int a = 20;
    printf("Start: a = %d\n", a);   // 20
    a += 5;  printf("a += 5  → %d\n", a);   // 25
    a -= 3;  printf("a -= 3  → %d\n", a);   // 22
    a *= 2;  printf("a *= 2  → %d\n", a);   // 44
    a /= 4;  printf("a /= 4  → %d\n", a);   // 11
    a %= 4;  printf("a %%= 4  → %d\n", a);  // 3
    return 0;
}

2.6 Increment & Decrement Operators

/* Program: prefix vs postfix — exam ke favourite tricky questions */
#include <stdio.h>
int main() {
    int a = 5, b;
    b = a++;   printf("b = a++ → b=%d, a=%d\n", b, a);   // b=5, a=6
    b = ++a;   printf("b = ++a → b=%d, a=%d\n", b, a);   // b=7, a=7
    b = a--;   printf("b = a-- → b=%d, a=%d\n", b, a);   // b=7, a=6
    b = --a;   printf("b = --a → b=%d, a=%d\n", b, a);   // b=5, a=5

    /* Tricky exam questions — khud verify karo */
    int x = 5, y;
    y = x++ + ++x;      // 5 + 7 = 12, x = 7
    printf("x=%d, y=%d\n", x, y);

    int i = 1;
    printf("%d %d %d\n", i++, ++i, i);  // evaluation order compiler par depend karta hai!
    return 0;
}
/* Output (gcc): b=5,a=6 | b=7,a=7 | b=7,a=6 | b=5,a=5 | x=7,y=12 */

2.7 Bitwise Operators (bits par kaam — 0/1)

Bit-by-bit calculation (exam me aise likho):

    5 = 0 1 0 1
    3 = 0 0 1 1
    -------------- 
  5 & 3 = 0 0 0 1 = 1      (AND: dono 1 tabhi 1)
  5 | 3 = 0 1 1 1 = 7      (OR : koi ek 1 to 1)
  5 ^ 3 = 0 1 1 0 = 6      (XOR: alag ho to 1)
     ~5 = 1 0 1 0 → sign bit ke wajah se = −6
  5 << 1 = 1 0 1 0 = 10     (left shift = 5 × 2)
  5 >> 1 = 0 0 1 0 = 2      (right shift = 5 ÷ 2)

/* Program: bitwise operators ka demo + fast multiply/divide */
#include <stdio.h>
int main() {
    int a = 5, b = 3;
    printf("a & b  = %d\n", a & b);     // 1
    printf("a | b  = %d\n", a | b);     // 7
    printf("a ^ b  = %d\n", a ^ b);     // 6
    printf("~a     = %d\n", ~a);        // -6
    printf("a << 2 = %d\n", a << 2);    // 20 (5 × 4)
    printf("a >> 1 = %d\n", a >> 1);    // 2  (5 ÷ 2, integer)

    /* Even/Odd check — AND se (fastest) */
    if (a & 1) printf("%d is Odd\n", a);
    else       printf("%d is Even\n", a);
    return 0;
}

2.8 Conditional (Ternary) Operator

// Syntax
result = (condition) ? value_true : value_false;

// Example: dono me se bada number
int a = 10, b = 25, big;
big = (a > b) ? a : b;         // big = 25

// Nested ternary: teen me se bada
big = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);

// Same cheez if-else me (kitna lamba hai, dekho 👇)
if (a > b) big = a; else big = b;

/* Program: ternary ke 3 classic uses */
#include <stdio.h>
int main() {
    int a = 15, b = 8, c = 30, marks = 40;

    /* 1. Bada number */
    printf("Bigger = %d\n", (a > b) ? a : b);          // 15

    /* 2. Pass/Fail — statement me bhi */
    printf("Result: %s\n", (marks >= 33) ? "PASS" : "FAIL");  // PASS

    /* 3. Even/Odd */
    printf("%d is %s\n", a, (a % 2 == 0) ? "Even" : "Odd");   // Odd

    /* 4. Teen me se bada (nested) */
    printf("Largest of three = %d\n", (a>b) ? ((a>c)?a:c) : ((b>c)?b:c));  // 30
    return 0;
}

2.9 Special Operators

/* Program: special operators in action */
#include <stdio.h>
int main() {
    int a = 10, b = 3;
    int x = (a = 7, a + 2);            // comma: x = 9
    printf("x = %d\n", x);

    int arr[] = {10, 20, 30, 40, 50};
    printf("sizeof(arr) = %d bytes\n", sizeof(arr));               // 20 (5 × 4)
    printf("Elements = %d\n", sizeof(arr) / sizeof(arr[0]));        // 5 (trick!)
    printf("Address of a = %p\n", &a);

    float avg = (float)(a + b) / 2;     // cast se decimal bacha
    printf("avg = %.2f\n", avg);        // 5.00
    printf("(int)3.9 = %d\n", (int)3.9);  // 3 (truncate, round nahi)
    return 0;
}

2.10 Operator Precedence & Associativity High-yield syllabus topic

Precedence table (upar se neeche — upar wale pehle chalte hain):

    Priority  Operator(s)                     Associativity
    --------  ----------------------------    -------------
      1       ()  []  .  ->                   L → R
      2       !  ~  ++ -- (unary)  + - (unary)  (type) sizeof
               & (address)  * (deref)         R → L
      3       *  /  %                         L → R
      4       +  -                            L → R
      5       <<  >>                          L → R
      6       <  <=  >  >=                    L → R
      7       ==  !=                           L → R
      8       &  (bitwise AND)                L → R
      9       ^                                L → R
     10       |                                L → R
     11       &&                               L → R
     12       ||                               L → R
     13       ?:                               R → L
     14       =  +=  -=  *=  /=  %=  etc.      R → L
     15       ,  (comma)                       L → R

Worked examples — step by step solve karo

/* Example 1 */  x = 10 + 2 * 3 - 4
   = 10 + 6 - 4        (* pehle)
   = 16 - 4  = 12      (+ - left to right)

/* Example 2 */  y = (10 + 2) * (7 - 4) / 2
   = 12 * 3 / 2        (brackets pehle)
   = 36 / 2   = 18

/* Example 3 */  z = 3 + 4 > 5 && 2 < 3
   = (7 > 5) && (2 < 3)   (arithmetic > relational)
   = 1 && 1 = 1 (true)

/* Example 4 */  p = 10 > 5 == 1
   = (10 > 5) == 1    (relational > equality)
   = 1 == 1 = 1

/* Example 5 */  q = 2 + 3 * 4 % 5
   = 2 + (12 % 5)     (* aur % same priority, L→R)
   = 2 + 2 = 4

/* Example 6 */  r = 5 * 2 / 4.0 + 3
   = 10 / 4.0 + 3     (* aur / same priority, L→R)
   = 2.5 + 3 = 5.5    (4.0 ke wajah se float division)

/* Example 7 — same cheez, alag likhi */
   n = 10 - 3 - 2     → (10-3)-2 = 5   (L→R — right se kiya to 9 aa jaata!)

/* Program: apne solve kiye answers verify karo */
#include <stdio.h>
int main() {
    printf("%d\n", 10 + 2 * 3 - 4);        // 12
    printf("%d\n", (10 + 2) * (7 - 4) / 2); // 18
    printf("%d\n", 3 + 4 > 5 && 2 < 3);      // 1
    printf("%d\n", 10 > 5 == 1);            // 1
    printf("%d\n", 2 + 3 * 4 % 5);          // 4
    printf("%.2f\n", 5 * 2 / 4.0 + 3);      // 5.50
    return 0;
}

2.11 Evaluation of Arithmetic Expressions & Type Conversion

Implicit conversion ka rule (promotion chain):

     char → int → float → double → long double
     (chhota type hamesha bade type me khud badal jaata hai — data safe)

     Bade se chhote me (float → int) jaaney par:
        - decimal hissa KAT jata hai (truncation)
        - kuch cases me value wrap/overflow ho sakti hai

  Example (automatic):
     int i = 5; float f = 2.5, r;
     r = i + f;        // i khud float ban gaya → r = 7.5 ✔ (data safe)

  Example (cast — programmer ka adhikaar):
     int a = 10, b = 3;
     float r1 = a / b;             // 3.000000 ❌ (int division pehle hua)
     float r2 = (float) a / b;     // 3.333333 ✔
     int   r3 = (int) 3.99;        // 3 (truncate — round nahi!)

/* Program: implicit vs explicit conversion ka farak */
#include <stdio.h>
int main() {
    int i = 7, j = 2;
    float f = 2.5;

    /* Implicit — mixed types */
    printf("i + f = %.2f\n", i + f);        // 9.50 (i float ban gaya)

    /* Explicit — cast */
    printf("i / j        = %.2f\n", (float) i / j);   // 3.50
    printf("(float)i / j = %.2f\n", (float) i / j);   // same 3.50
    printf("(int) 3.99   = %d\n", (int) 3.99);        // 3
    printf("(char) 65    = %c\n", (char) 65);         // A

    /* Char aur int ka rishta — ASCII */
    char ch = 'A';
    printf("ch + 1 = %c (ASCII %d)\n", ch + 1, ch + 1);  // B (66)
    return 0;
}

UNIT 3 — Decision Making & Control Structures

3.1 Simple if

/* Syntax — simple if */
if (condition)
{
    statements;   // sirf jab condition TRUE ho
}
// condition false ho to ye block skip ho jata hai (aur program aage chalta hai)

/* Example */
int marks = 72;
if (marks >= 33)
{
    printf("Pass\n");
}
printf("Result declared\n");   // ye hamesha chalega (if ke bahar hai)

/* Program 1: ek number positive hai? */
#include <stdio.h>
int main() {
    int n;
    printf("Enter a number: ");
    scanf("%d", &n);
    if (n > 0)
        printf("%d is Positive\n", n);
    if (n == 0)
        printf("Number is Zero\n");
    if (n < 0)
        printf("%d is Negative\n", n);
    return 0;
}
/* Input: 42 → 42 is Positive | Input: -7 → -7 is Negative | Input: 0 → Number is Zero */

/* Program 2: even/odd */
#include <stdio.h>
int main() {
    int n;
    scanf("%d", &n);
    if (n % 2 == 0)                 // remainder 0 = even
        printf("%d is Even\n", n);
    if (n % 2 != 0)
        printf("%d is Odd\n", n);
    return 0;
}
/* Input: 7 → 7 is Odd    Input: 20 → 20 is Even */

/* Program 3: voting eligibility — real-life condition */
#include <stdio.h>
int main() {
    int age;
    printf("Enter age: ");
    scanf("%d", &age);
    if (age >= 18)
        printf("You can vote 🗳️\n");
    if (age < 18)
        printf("Not eligible — %d saal baaki\n", 18 - age);
    return 0;
}

3.2 if-else

if (condition)
{
    statements;      // TRUE par
}
else
{
    statements;      // FALSE par
}

/* Program 1: Largest of two numbers (lab ka pehla program) */
#include <stdio.h>
int main() {
    int a, b;
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    if (a > b)
        printf("%d is largest\n", a);
    else
        printf("%d is largest\n", b);
    /* Note: bada number 'equal' ho to else chalega — apne mann se
       else-if lagakar "both equal" bhi likh sakte ho */
    return 0;
}
/* Input: 15 42 → 42 is largest */

/* Program 2: Grade calculator (if-else) */
#include <stdio.h>
int main() {
    int m;
    printf("Enter marks (0-100): ");
    scanf("%d", &m);
    if (m >= 33)
        printf("PASS ✅\n");
    else
        printf("FAIL — better luck next time!\n");
    return 0;
}

/* Program 3: Leap year (condition ke andar && aur ||) */
#include <stdio.h>
int main() {
    int y;
    scanf("%d", &y);
    if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
        printf("Leap Year\n");
    else
        printf("Not a Leap Year\n");
    return 0;
}
/* 2024 → Leap  2023 → Not Leap  2000 → Leap  1900 → Not Leap */

3.3 Nested if-else

if (cond1) {
    if (cond2)  statement_A;      // dono true
    else        statement_B;      // cond1 true, cond2 false
}
else {
    // cond1 false — chahe cond2 kuch bhi ho
    statement_C;
}

/* Program 1: Largest of three — nested se */
#include <stdio.h>
int main() {
    int a, b, c;
    printf("Enter three numbers: ");
    scanf("%d %d %d", &a, &b, &c);
    if (a >= b) {
        if (a >= c)
            printf("%d is largest\n", a);
        else
            printf("%d is largest\n", c);
    } else {
        if (b >= c)
            printf("%d is largest\n", b);
        else
            printf("%d is largest\n", c);
    }
    return 0;
}
/* Input: 12 45 33 → 45 is largest */

/* Program 2: Driver licence eligibility — age + test */
#include <stdio.h>
int main() {
    int age, testPassed;
    printf("Age: ");              scanf("%d", &age);
    printf("Test passed (1/0): "); scanf("%d", &testPassed);
    if (age >= 18) {
        if (testPassed == 1)
            printf("Licence approved ✔\n");
        else
            printf("Test clear karo phir aao\n");
    } else {
        printf("Age %d — 18 se kam, licence nahi\n", age);
    }
    return 0;
}

/* Program 3: Nested → && me convert karo (same kaam, chhota code) */
int age = 20, citizen = 1;
if (age >= 18 && citizen == 1)   // nested if ki jagah &&
    printf("Vote de sakta hai\n");

3.4 else-if Ladder (multi-way decision)

if (cond1)       statement1;
else if (cond2)  statement2;
else if (cond3)  statement3;
else             default_statement;   // sab false ho to

/* Program: Grade calculator — 5-way ladder (NEP ke hisaab se) */
#include <stdio.h>
int main() {
    int m;
    printf("Enter marks (0-100): ");
    scanf("%d", &m);

    if (m >= 90)
        printf("Grade = O (Outstanding), 10 points\n");
    else if (m >= 75)
        printf("Grade = A, 9 points\n");
    else if (m >= 60)
        printf("Grade = B, 8 points\n");
    else if (m >= 50)
        printf("Grade = C, 7 points\n");
    else if (m >= 40)
        printf("Grade = D, 6 points\n");
    else
        printf("Grade = F (Fail) — improvement exam do\n");
    return 0;
}
/* 92 → O | 80 → A | 65 → B | 55 → C | 45 → D | 25 → F */

/* Program 2: Simple electricity bill — slab system ka real use */
#include <stdio.h>
int main() {
    float units, bill;
    printf("Units consumed: ");
    scanf("%f", &units);

    if (units <= 100)
        bill = units * 3.50;
    else if (units <= 300)
        bill = 100 * 3.50 + (units - 100) * 4.50;
    else if (units <= 500)
        bill = 100 * 3.50 + 200 * 4.50 + (units - 300) * 6.00;
    else
        bill = 100 * 3.50 + 200 * 4.50 + 200 * 6.00 + (units - 500) * 7.00;

    printf("Bill = ₹%.2f\n", bill);
    return 0;
}
/* Input: 250 → Bill = ₹1025.00  (350 + 150×4.50) */

3.5 Switch Statement

switch (expression)      // int ya char — float nahi!
{
    case value1:
        statements;
        break;           // case khatam
    case value2:
        statements;
        break;
    default:             // koi case match na ho to
        statements;
}

/* Program 1: Menu-driven calculator — switch ka perfect use */
#include <stdio.h>
int main() {
    int choice;
    float a, b;
    printf("1.Add 2.Sub 3.Mul 4.Div\nEnter choice: ");
    scanf("%d", &choice);
    printf("Enter two numbers: ");
    scanf("%f %f", &a, &b);

    switch (choice) {
        case 1: printf("Sum = %.2f\n", a + b);        break;
        case 2: printf("Diff = %.2f\n", a - b);       break;
        case 3: printf("Product = %.2f\n", a * b);    break;
        case 4:
            if (b != 0)
                printf("Quotient = %.2f\n", a / b);
            else
                printf("Cannot divide by zero!\n");
            break;
        default: printf("Invalid choice ❌\n");
    }
    return 0;
}
/* Input: 3 then 6 7 → Product = 42.00 */

/* Program 2: Day name — char se switch */
#include <stdio.h>
int main() {
    int day;
    printf("Enter day number (1-7): ");
    scanf("%d", &day);
    switch (day) {
        case 1: printf("Monday\n");    break;
        case 2: printf("Tuesday\n");   break;
        case 3: printf("Wednesday\n"); break;
        case 4: printf("Thursday\n");  break;
        case 5: printf("Friday\n");    break;
        case 6: printf("Saturday\n");  break;
        case 7: printf("Sunday\n");    break;
        default: printf("Only 1-7 allowed\n");
    }
    return 0;
}

/* Program 3: Vowel check — char switch ka famous example */
#include <stdio.h>
int main() {
    char ch;
    printf("Enter a letter: ");
    scanf(" %c", &ch);       // space zaroori! (buffer issue)
    switch (ch) {
        case 'a': case 'e': case 'i': case 'o': case 'u':
        case 'A': case 'E': case 'I': case 'O': case 'U':
            printf("Vowel\n");
            break;
        default: printf("Consonant\n");
    }
    return 0;
}
/* Note: kai cases ek saath — jab same kaam ho to fall-through ka FAIDA uthate hain */

switch ke rules (exam me list banana hota hai)

1. Expression integer ya character hona chahiye — float/double/string allowed nahi ❌.
2. case ki value constant honi chahiye (literal ya #define) — variable nahi.
3. Har case ke baad break lagao, warna aage ke cases bhi chal jaayenge (fall-through).
4. default optional hai par best practice hai (invalid input handle karta hai) — ise kahin bhi likh sakte ho.
5. Do cases ki value same nahi ho sakti (duplicate case = compile error).
6. case me range ya condition nahi likh sakte — case marks>50: ❌ galat. Range ke liye else-if ladder.
7. switch ke andar switch (nested switch) allowed hai.

3.6 goto Statement

/* Syntax */
goto label_name;
   ...  // ye statements SKIP ho jaati hain
label_name:
   statement;   // yahan se execution dobara shuru

/* Example 1: aage jump (forward goto) */
#include <stdio.h>
int main() {
    printf("Start\n");
    goto skip;
    printf("Ye line kabhi nahi chalegi 😅\n");
skip:
    printf("End\n");
    return 0;
}
/* Output: Start \n End */

/* Example 2: peeche jump se loop banao (backward goto) */
#include <stdio.h>
int main() {
    int i = 1;
again:                       // label
    printf("%d ", i);
    i++;
    if (i <= 5)
        goto again;          // wapas label par
    return 0;
}
/* Output: 1 2 3 4 5  (yahi kaam for/while aasani se karte hain) */

/* Example 3: nested loops se ek saath bahar nikalna — goto ka sahi use */
#include <stdio.h>
int main() {
    int i, j;
    for (i = 1; i <= 3; i++) {
        for (j = 1; j <= 3; j++) {
            if (i * j == 6)
                goto done;        // dono loops se ek jump me bahar!
            printf("i=%d j=%d\n", i, j);
        }
    }
done:
    printf("Found 6, loops khatam\n");
    return 0;
}
/* Output: i=1 j=1, i=1 j=2, i=1 j=3, i=2 j=1, i=2 j=2 → Found 6 */

3.7 break & continue

/* break vs continue — ek hi program me dono */
#include <stdio.h>
int main() {
    int i;
    printf("break demo (5 par ruk jayega): ");
    for (i = 1; i <= 10; i++) {
        if (i == 5)
            break;            // poora loop khatam
        printf("%d ", i);
    }
    printf("\n");

    printf("continue demo (5 skip hoga): ");
    for (i = 1; i <= 10; i++) {
        if (i == 5)
            continue;         // sirf ye round chhoda
        printf("%d ", i);
    }
    printf("\n");
    return 0;
}
/* Output:
   break demo (5 par ruk jayega): 1 2 3 4
   continue demo (5 skip hoga): 1 2 3 4 6 7 8 9 10 */

/* break ka real use: prime check — divisor mila to ruk jao */
#include <stdio.h>
int main() {
    int n, i, flag = 1;
    scanf("%d", &n);
    for (i = 2; i <= n / 2; i++) {
        if (n % i == 0) {
            flag = 0;
            break;        // ek divisor mil gaya, aage check ki zarurat nahi
        }
    }
    printf("%d is %s\n", n, (flag && n > 1) ? "Prime" : "Not Prime");
    return 0;
}
/* 17 → Prime (poora loop chala) | 21 → Not Prime (3 par break) */

/* continue ka real use: sirf positive numbers ka average */
#include <stdio.h>
int main() {
    int n, i, x, sum = 0, count = 0;
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        scanf("%d", &x);
        if (x <= 0)
            continue;        // negative/zero skip
        sum += x;
        count++;
    }
    printf("Average of positives = %.2f\n", (float)sum / count);
    return 0;
}

3.8 Looping Statements — Entry vs Exit Controlled High-yield syllabus topic

for loop

for (initialization ; condition ; update)
{
    body;
}
/* Step by step: 1) init ek baar  2) condition check  3) body
                 4) update  5) wapas condition... jab tak condition false */

/* for loop ki 4 shakalein (exam me trick questions isi par) */
for (i = 1; i <= 5; i++)        // normal — 1 2 3 4 5
for (i = 5; i >= 1; i--)        // ulta — 5 4 3 2 1
for (i = 0; i <= 10; i += 2)    // step 2 ka — 0 2 4 6 8 10
for ( ; ; )                     // infinite loop (teeno khaali) ⚠️

/* Ek hi line me kai variables (comma operator) */
for (i = 1, j = 10; i < j; i++, j--)
    printf("%d %d\n", i, j);    // 1 10 / 2 9 / 3 8 / 4 7 / 5 6

/* Program: sum aur average — classic for loop */
#include <stdio.h>
int main() {
    int n, i, x, sum = 0;
    float avg;
    printf("Kitne numbers? ");  scanf("%d", &n);

    for (i = 1; i <= n; i++) {
        printf("Number %d: ", i);
        scanf("%d", &x);
        sum += x;
    }
    avg = (float) sum / n;
    printf("Sum = %d, Average = %.2f\n", sum, avg);
    return 0;
}
/* n=4, inputs 10 20 30 40 → Sum = 100, Average = 25.00 */

/* Program: multiplication table (kitni baar pata hai — for best) */
#include <stdio.h>
int main() {
    int n, i;
    printf("Table of: ");  scanf("%d", &n);
    for (i = 1; i <= 10; i++)
        printf("%d x %d = %d\n", n, i, n * i);
    return 0;
}
/* n=7 → 7 x 1 = 7 ... 7 x 10 = 70 */

while loop (entry-controlled — 0 baar bhi chal sakta hai)

initialization;
while (condition)
{
    body;
    update;        // ⚠️ ise bhoolna = infinite loop!
}

/* Program: sum of digits — while ka classic (n % 10, n / 10 trick) */
#include <stdio.h>
int main() {
    int n, sum = 0, r;
    printf("Enter number: ");  scanf("%d", &n);
    while (n != 0) {
        r = n % 10;        // last digit nikalo
        sum = sum + r;
        n = n / 10;        // last digit hatao
    }
    printf("Sum of digits = %d\n", sum);
    return 0;
}
/* 4821 → 4+8+2+1 = 15  |  Jab tak number ke digits hain, loop chalta hai */

while ka trace (dry run — exam me likhna): n = 4821 → (r=1, sum=1, n=482) → (r=2, sum=3, n=48) → (r=8, sum=11, n=4) → (r=4, sum=15, n=0) → loop khatam. Aise table banake dikhana = examiner khush 😊

do-while loop (exit-controlled — kam se kam 1 baar)

do
{
    body;
    update;
} while (condition);      // ❗ semicolon lagana mat bhoolna!

/* Program 1: 1 se 5 print */
#include <stdio.h>
int main() {
    int i = 1;
    do {
        printf("%d ", i);
        i++;
    } while (i <= 5);      // 1 2 3 4 5
    return 0;
}

/* Program 2: menu — jab tak user exit na chune (asli use case) */
#include <stdio.h>
int main() {
    int choice;
    do {
        printf("\n1. Say Hello\n2. Say Bye\n3. Exit\nChoice: ");
        scanf("%d", &choice);
        if (choice == 1) printf("Hello BCA! 👋\n");
        else if (choice == 2) printf("Bye! 👋\n");
    } while (choice != 3);      // exit chune bina menu dikhta rahega
    printf("Program khatam\n");
    return 0;
}

Output-tracing exercise:

   int i = 10;
   while (i < 5)  { printf("A"); i++; }     // 0 baar — kuch print nahi
   do { printf("B"); i++; } while (i < 5);  // 1 baar — "B" print hua

   Isliye: do-while "pehle kaam, phir sawaal" 💡

Nested loops (loop ke andar loop) — pattern aur table ka raja

/* Program 1: Table 1-5 (outer loop × inner loop) */
for (i = 1; i <= 5; i++) {          // outer = kitni tables
    for (j = 1; j <= 10; j++) {     // inner = 1 se 10 tak
        printf("%d x %d = %d\n", i, j, i * j);
    }
    printf("\n");                    // har table ke baad khali line
}

/* Program 2: Star patterns (lab me sabse zyada poochha jaata hai) */
// (a) Right triangle            // (b) Ulta triangle
for (i = 1; i <= 4; i++) {        for (i = 4; i >= 1; i--) {
    for (j = 1; j <= i; j++)          for (j = 1; j <= i; j++)
        printf("* ");                     printf("* ");
    printf("\n");                      printf("\n");
}                                 }
/* Output (a):                     Output (b):
   *                                * * * *
   * *                              * * *
   * * *                            * *
   * * * *                          *            */

// (c) Pyramid (spaces + stars) — thoda advanced
for (i = 1; i <= 4; i++) {
    for (j = 1; j <= 4 - i; j++) printf(" ");    // spaces
    for (j = 1; j <= 2 * i - 1; j++) printf("*"); // stars (1,3,5,7)
    printf("\n");
}
/* Output (c):
      *
     ***
    *****
   *******  */

/* Program 3: Number pattern */
for (i = 1; i <= 4; i++) {
    for (j = 1; j <= i; j++)
        printf("%d ", j);      // 1 / 1 2 / 1 2 3 / 1 2 3 4
    printf("\n");
}

3.9 Complete Practice Programs (ye likh-mar do, exam me direct aate hain)

/* P1 — Largest of two numbers (if-else) */
#include <stdio.h>
int main() {
    int a, b;
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    if (a > b)
        printf("%d is largest\n", a);
    else
        printf("%d is largest\n", b);
    return 0;
}
/* Input: 15 42 → Output: 42 is largest */

/* P2 — Reverse of a number (while loop + % aur /) */
#include <stdio.h>
int main() {
    int n, rev = 0, r;
    printf("Enter number: ");
    scanf("%d", &n);
    while (n != 0) {
        r = n % 10;            // last digit nikala
        rev = rev * 10 + r;    // reverse me joda
        n = n / 10;            // last digit hata diya
    }
    printf("Reverse = %d\n", rev);
    return 0;
}
/* Trace: n=1234 → r=4 rev=4 n=123 → r=3 rev=43 n=12 → r=2 rev=432 n=1 → r=1 rev=4321 n=0
   Input: 1234 → Output: Reverse = 4321 */

/* P3 — Sum of first n natural numbers (formula bhi batao: n(n+1)/2) */
#include <stdio.h>
int main() {
    int n, i, sum = 0;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
        sum += i;
    printf("Sum = %d\n", sum);
    return 0;
}
/* Input: 10 → Sum = 55  (formula: 10 × 11 / 2 = 55 ✔) */

/* P4 — Factorial (bada number — long long use karo) */
#include <stdio.h>
int main() {
    int n, i; long long f = 1;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
        f = f * i;
    printf("Factorial = %lld\n", f);
    return 0;
}
/* 5 → 120 | 10 → 3628800 | 20 → 2432902008176640000 (2-byte int me overflow!) */

/* P5 — Fibonacci series (0 1 1 2 3 5 8 13 ...) */
#include <stdio.h>
int main() {
    int n, i, a = 0, b = 1, c;
    scanf("%d", &n);
    printf("%d %d ", a, b);
    for (i = 3; i <= n; i++) {
        c = a + b;         // agla number = pichle do ka sum
        printf("%d ", c);
        a = b; b = c;      // dono ko ek kadam aage khiskao
    }
    return 0;
}
/* n = 8 → 0 1 1 2 3 5 8 13 */

/* P6 — Armstrong number (153 = 1³ + 5³ + 3³) */
#include <stdio.h>
int main() {
    int n, temp, r, sum = 0;
    scanf("%d", &n);
    temp = n;
    while (temp != 0) {
        r = temp % 10;
        sum += r * r * r;
        temp /= 10;
    }
    if (sum == n) printf("Armstrong\n");
    else          printf("Not Armstrong\n");
    return 0;
}
/* 153 → Armstrong ✔ | 370 ✔ | 371 ✔ | 123 ✘ */

/* P7 — Prime check */
#include <stdio.h>
int main() {
    int n, i, flag = 1;
    scanf("%d", &n);
    for (i = 2; i <= n / 2; i++) {
        if (n % i == 0) { flag = 0; break; }
    }
    if (flag && n > 1) printf("Prime\n");
    else               printf("Not Prime\n");
    return 0;
}
/* 2 ✔ 13 ✔ 1 ✘ (1 prime nahi) 15 ✘ */

/* P8 — Palindrome number (121 ulta bhi 121) */
#include <stdio.h>
int main() {
    int n, temp, rev = 0, r;
    scanf("%d", &n);
    temp = n;
    while (temp != 0) {
        r = temp % 10;
        rev = rev * 10 + r;
        temp /= 10;
    }
    if (rev == n) printf("Palindrome\n");
    else          printf("Not Palindrome\n");
    return 0;
}
/* 121 → Palindrome | 1234 → Not Palindrome (reverse nikalo, phir compare!) */

/* P9 — Perfect number check (6 = 1+2+3) */
#include <stdio.h>
int main() {
    int n, i, sum = 0;
    scanf("%d", &n);
    for (i = 1; i < n; i++) {
        if (n % i == 0) sum += i;    // proper divisors ka sum
    }
    if (sum == n) printf("Perfect number\n");
    else          printf("Not Perfect\n");
    return 0;
}
/* 6 ✔ (1+2+3) | 28 ✔ (1+2+4+7+14) | 12 ✘ */

/* P10 — HCF aur LCM (bade number ke liye long long) */
#include <stdio.h>
int main() {
    int a, b, x, y, hcf, lcm;
    scanf("%d %d", &a, &b);
    x = a; y = b;
    while (x != y) {                 // GCD (HCF) — dono ko barabar karne wala loop
        if (x > y) x = x - y;
        else       y = y - x;
    }
    hcf = x;
    lcm = (a * b) / hcf;             // formula: LCM = (a × b) / HCF
    printf("HCF = %d, LCM = %d\n", hcf, lcm);
    return 0;
}
/* 12 18 → HCF = 6, LCM = 36 | 7 5 → HCF = 1, LCM = 35 (co-prime) */

/* P11 — Table aur pattern wale programs upar §3.8 me hain — unhe bhi likh lo */
/* P12 — Count digits (kitne aankde) */
#include <stdio.h>
int main() {
    long n; int count = 0;
    scanf("%ld", &n);
    do {
        count++;          // do-while ka perfect use (0 me bhi 1 digit)
        n = n / 10;
    } while (n != 0);
    printf("Digits = %d\n", count);
    return 0;
}
/* 4821 → 4 | 0 → 1 (isliye do-while, warna 0 ke liye 0 aata) */

UNIT 4 — Arrays and Strings

4.1 Array — Introduction

Array ki zarurat kyun padi? (motivation — exam me pehla point)

Array ki characteristics (5 points — ratt lo)

1. Same type: sab elements ka data type ek hi (int array me sirf ints, float me floats). Mix nahi kar sakte.
2. Contiguous memory: elements RAM me lagataar (ek ke baad ek) rakhte hain — isliye address formula kaam karta hai.
3. Fixed size: size declare karte waqt batana padta hai; program chalte waqt badha nahi sakte.
4. Index 0 se: pehla element index 0, last index = size − 1. Size 5 → valid indexes 0,1,2,3,4.
5. Ek naam, kai values: array ka naam base address ko represent karta hai (array ka naam hi pehle element ka pointer hai — Unit 5 me detail me).

Array ke advantages & disadvantages

Array ke types

4.2 One-Dimensional Array

/* 1) DECLARATION (kitne elements chahiye) */
int marks[60];          // 60 ints (index 0..59)
float price[5];
char grade[10];

/* 2) INITIALIZATION — 4 tarike */
int a[5] = {10, 20, 30, 40, 50};   // poora
int b[5] = {10, 20};               // baaki 3 automatically 0
int c[]  = {5, 10, 15};            // size compiler count karega (3)
int d[5] = {0};                    // saare 5 elements 0 (reset ka trick!)

/* 3) ACCESS (index 0 se shuru!) */
a[0] = 10;              // pehla element
a[4] = 50;              // 5th (aakhri) element
a[5] = 99;              // ❌ OUT OF BOUNDS — undefined behaviour (garbage/crash!)

/* 4) LOOP se input + output (classic pattern) */
for (i = 0; i < 5; i++)
    scanf("%d", &marks[i]);
for (i = 0; i < 5; i++)
    printf("%d ", marks[i]);

Memory Representation (exam me poochhte hain — address calculation)

int a[5] = {10, 20, 30, 40, 50};   (assume int = 4 bytes, base address 1000)

Index    :  a[0]   a[1]   a[2]   a[3]   a[4]
Value    :   10     20     30     40     50
Address  :  1000   1004   1008   1012   1016
             ↑ Base address (a == &a[0])

FORMULA:  Address of a[i] = Base_Address + (i × size_of_one_element)

Verification:
  a[0] → 1000 + (0 × 4) = 1000 ✔
  a[3] → 1000 + (3 × 4) = 1012 ✔
  a[4] → 1000 + (4 × 4) = 1016 ✔ (aakhri element)

Exam question: "int a[10]; base address 2000 hai, a[6] ka address kya hoga?"
Answer: 2000 + (6 × 4) = 2024.

Aur ye formula hi ARRAY KA SABSE BADA PLUS hai — O(1) random access:
1000th element bhi utni hi speed se milta hai jitni 1st (formula se seedha address).

1D array ke programs (lab me sabse zyada aate hain) — output ke saath

/* Program 1: Sum, average, largest, smallest — ek hi loop me sab */
#include <stdio.h>
int main() {
    int a[50], n, i, sum = 0, max, min;
    float avg;
    printf("Kitne elements? ");  scanf("%d", &n);
    for (i = 0; i < n; i++) {
        printf("a[%d] = ", i);
        scanf("%d", &a[i]);
    }
    max = min = a[0];             // pehle element se maan lo
    for (i = 0; i < n; i++) {
        sum += a[i];
        if (a[i] > max) max = a[i];
        if (a[i] < min) min = a[i];
    }
    avg = (float) sum / n;
    printf("Sum = %d\nAverage = %.2f\nLargest = %d\nSmallest = %d\n", sum, avg, max, min);
    return 0;
}
/* n=5, inputs 45 12 78 3 90 →
   Sum = 228 | Average = 45.60 | Largest = 90 | Smallest = 3 */

/* Program 2: Array ko reverse print karo (majbooti: loop ulta chalao) */
for (i = n - 1; i >= 0; i--)
    printf("%d ", a[i]);
/* 10 20 30 40 50 → 50 40 30 20 10 */

/* Program 3: Linear search — element dhundho, position batao */
#include <stdio.h>
int main() {
    int a[20] = {10, 25, 30, 45, 60}, n = 5, key, i, pos = -1;
    printf("Kya dhundhna hai? ");  scanf("%d", &key);
    for (i = 0; i < n; i++) {
        if (a[i] == key) { pos = i; break; }
    }
    if (pos == -1) printf("Not found ❌\n");
    else printf("%d index %d par mila ✔\n", key, pos);
    return 0;
}
/* key = 30 → 30 index 2 par mila | key = 99 → Not found */

/* Program 4: Count even/odd */
int e = 0, o = 0;
for (i = 0; i < n; i++)
    (a[i] % 2 == 0) ? e++ : o++;
printf("Even = %d, Odd = %d\n", e, o);

/* Program 5: Do arrays ko add karke teesre me daalo (c[i] = a[i] + b[i]) */
for (i = 0; i < n; i++)
    c[i] = a[i] + b[i];

/* Program 6: char array me vowels count (string ka pehla jhalak) */
char s[50]; int v = 0;
scanf("%s", s);                  // & nahi lagta (array khud address hai)
for (i = 0; s[i] != '\0'; i++)
    if (s[i]=='a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=='u') v++;
printf("Vowels = %d\n", v);

size nikalne ka trick: int n = sizeof(a) / sizeof(a[0]); — poore array ka size ÷ ek element ka size = elements ki count. Ye tab kaam aata hai jab array initialized ho aur size na likhi ho (jaise function me bhejne par). Exam me bhi poochhte hain: sizeof(a)/sizeof(a[0]) ka matlab.

4.3 Two-Dimensional Array (matrix / table)

/* Declaration aur initialization ke 3 tarike */
int a[3][4];                                  // khaali (garbage/0)
int m[2][3] = { {1, 2, 3},                    // nested braces (clear)
                {4, 5, 6} };
int m2[2][3] = {1, 2, 3, 4, 5, 6};            // flat — same cheez (row-by-row)
int m3[2][3] = { {1, 2}, {4} };               // baaki cells 0 ho jaati hain

/* Access: m[row][column] — dono index 0 se */
m[0][0] = 1;      // pehli row, pehla column
m[1][2] = 6;      // doosri row, teesra column (aakhri element)

/* Input / Output — nested loops (billing loops zaroori!) */
for (i = 0; i < rows; i++) {          // outer = row
    for (j = 0; j < cols; j++) {      // inner = column
        scanf("%d", &m[i][j]);
    }
}
for (i = 0; i < rows; i++) {
    for (j = 0; j < cols; j++) {
        printf("%4d", m[i][j]);       // row me print — %4d se alignment
    }
    printf("\n");                      // har row ke baad newline
}

2D array ki memory representation (Row-Major Order) — important practice topic

int m[2][3] = { {1,2,3}, {4,5,6} };   (int = 4 bytes, base = 2000)

C memory me 2D array ko LINEAR (ek seedhi line me) rakhta hai — ROW by ROW:

  [1]   [2]   [3]   [4]   [5]   [6]
  2000  2004  2008  2012  2016  2020
  ←── row 0 ──→     ←── row 1 ──→

ADDRESS FORMULA:  addr(m[i][j]) = Base + ( (i × number_of_columns) + j ) × size

Verification:
  m[0][2] → 2000 + ((0×3) + 2) × 4 = 2000 + 8  = 2008 ✔ (row 0 ka teesra)
  m[1][0] → 2000 + ((1×3) + 0) × 4 = 2000 + 12 = 2012 ✔ (row 1 ka pehla)
  m[1][2] → 2000 + ((1×3) + 2) × 4 = 2000 + 20 = 2020 ✔ (aakhri element)

⚠️ C me ROW-MAJOR order hota hai (pehle row bhar jati hai).
   COLUMN-MAJOR order (FORTRAN) me pehle column bhar jata hai — MCQ me aata hai!

2D array ke common programs

/* Program 1: Matrix ka addition — C[i][j] = A[i][j] + B[i][j] */
#include <stdio.h>
int main() {
    int A[2][2], B[2][2], C[2][2], i, j;
    printf("Matrix A ke 4 elements: ");
    for (i = 0; i < 2; i++) for (j = 0; j < 2; j++) scanf("%d", &A[i][j]);
    printf("Matrix B ke 4 elements: ");
    for (i = 0; i < 2; i++) for (j = 0; j < 2; j++) scanf("%d", &B[i][j]);

    for (i = 0; i < 2; i++)
        for (j = 0; j < 2; j++)
            C[i][j] = A[i][j] + B[i][j];

    printf("Sum matrix:\n");
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) printf("%4d", C[i][j]);
        printf("\n");
    }
    return 0;
}
/* A = [1 2; 3 4], B = [5 6; 7 8] → Sum = [ 6  8; 10 12] */

/* Program 2: Matrix MULTIPLICATION (Lab #7) — 3 nested loops, yaad kar lo */
#include <stdio.h>
int main() {
    int A[2][2] = { {1, 2}, {3, 4} };
    int B[2][2] = { {5, 6}, {7, 8} };
    int C[2][2], i, j, k;

    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) {
            C[i][j] = 0;                       // accumulator reset
            for (k = 0; k < 2; k++) {
                C[i][j] += A[i][k] * B[k][j];  // row × column ka dot product
            }
        }
    }
    printf("Product:\n");
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 2; j++) printf("%4d", C[i][j]);
        printf("\n");
    }
    return 0;
}
/* Output: [19 22; 43 50]
   C[0][0] = 1×5 + 2×7 = 19     C[0][1] = 1×6 + 2×8 = 22
   C[1][0] = 3×5 + 4×7 = 43     C[1][1] = 3×6 + 4×8 = 50
   RULE: A (m×n) × B (n×p) = C (m×p) — beech wala n match hona zaroori!
   A[2][3] × B[3][2] = C[2][2] ✔   A[2][3] × B[2][2] = ❌ invalid */

/* Program 3: Transpose — rows ↔ columns (trans[j][i] = A[i][j]) */
for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
        trans[j][i] = A[i][j];
/* [1 2 3; 4 5 6] ka transpose = [1 4; 2 5; 3 6] */

/* Program 4: Diagonal sum (square matrix) + largest element */
int dsum = 0, big = A[0][0];
for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
        if (i == j) dsum += A[i][j];     // main diagonal
        if (A[i][j] > big) big = A[i][j];
    }
printf("Diagonal sum = %d, Largest = %d\n", dsum, big);

4.4 Strings in C

/* Declaration & initialization ke 3 tarike */
char name[20] = "Ansh";                     // compiler '\0' khud lagata hai
char city[5] = {'H','a','l','d','w'};      // bina '\0' — risky!
char s[] = "BCA";                           // size = 4 (3 chars + '\0')

/* Memory me aise dikhta hai: */
Index  :  s[0]   s[1]   s[2]   s[3]
Value  :  'B'    'C'    'A'    '\0'
ASCII  :   66     67     65      0
                                ↑ string ka "full stop" 🛑

/* Input / Output */
scanf("%s", name);          // & ki zarurat NAHI (array khud address hai)
                             // ⚠️ %s space par RUK jata hai — "Ansh Kumar" me sirf "Ansh"
printf("%s\n", name);
fgets(name, 20, stdin);     // poora line (spaces ke saath) — SAFE
gets(name);                 // poora line par INSECURE — aaj use mat karo
puts(name);                 // print + automatic newline

/* Program: string ki length khud nikaalo (strlen ke bina) — concept clear karega */
#include <stdio.h>
int main() {
    char s[50];
    int i, len = 0;
    printf("Enter a word: ");
    scanf("%s", s);                 // & nahi!
    for (i = 0; s[i] != '\0'; i++)  // '\0' milte hi ruk jao
        len++;
    printf("Length = %d\n", len);
    return 0;
}
/* Input: Programming → Length = 11 */

/* Program: string ko character-by-character print + uppercase (tolower/toupper se) */
for (i = 0; s[i] != '\0'; i++)
    printf("%c-", s[i]);            // B-C-A-

/* Program: string me spaces ke saath input */
#include <stdio.h>
int main() {
    char line[100];
    printf("Enter your full name: ");
    fgets(line, 100, stdin);        // "Ansh Kumar" poora aayega
    printf("Hello, %s", line);
    return 0;
}

4.5 String Handling Functions (string.h) Lab #13

/* Lab #13 — string.h ke saare functions ka demo (output ke saath) */
#include <stdio.h>
#include <string.h>
int main() {
    char a[30] = "BCA";
    char b[30] = "Students";
    char c[30];
    char d[30] = "apple", e[30] = "banana";

    printf("1. strlen(a) = %zu\n", strlen(a));        // 3
    printf("2. strlen(\"Hello\") = %zu\n", strlen("Hello")); // 5

    strcpy(c, a);
    printf("3. After strcpy, c = %s\n", c);          // BCA

    strcat(a, " ");
    strcat(a, b);
    printf("4. After strcat, a = %s\n", a);          // BCA Students

    printf("5. strcmp(d, e) = %d (negative → d chhota)\n", strcmp(d, e));
    printf("6. strcmp(\"abc\", \"abc\") = %d\n", strcmp("abc", "abc"));  // 0

    if (strcmp("abc", "abc") == 0)
        printf("7. Strings equal ✔\n");
    return 0;
}
/* Output:
   1. strlen(a) = 3
   2. strlen("Hello") = 5
   3. After strcpy, c = BCA
   4. After strcat, a = BCA Students
   5. strcmp(d, e) = -1 (negative → d chhota)
   6. strcmp("abc", "abc") = 0
   7. Strings equal ✔ */

/* Program: palindrome check — strrev se (Turbo C) / manual reverse se (standard) */
#include <stdio.h>
#include <string.h>
int main() {
    char s[50], t[50];
    int i, len, ok = 1;

    printf("Enter a word: ");
    scanf("%s", s);

    len = strlen(s);
    for (i = 0; i < len; i++)              // manual reverse copy
        t[i] = s[len - 1 - i];
    t[len] = '\0';                          // terminator lagana mat bhoolo!

    if (strcmp(s, t) == 0)
        printf("%s is a Palindrome ✔\n", s);
    else
        printf("%s is not a Palindrome\n", s);
    return 0;
}
/* madam → Palindrome | level → Palindrome | BCA → Not Palindrome */

/* Program: do strings jodo — strcat ke bina (logic clear hoga) */
int i = 0, j = 0;
while (s1[i] != '\0') i++;               // s1 ke end par jao
while (s2[j] != '\0') { s1[i] = s2[j]; i++; j++; }
s1[i] = '\0';                            // naya end
printf("Joined: %s\n", s1);

4.6 Character Handling Functions (ctype.h)

/* Program: ek string ka poora analysis — letters, digits, spaces, special */
#include <stdio.h>
#include <ctype.h>
#include <string.h>
int main() {
    char s[100];
    int i, alpha = 0, digit = 0, space = 0, special = 0;

    printf("Enter a line: ");
    fgets(s, 100, stdin);

    for (i = 0; i < strlen(s); i++) {
        if (isalpha(s[i]))       alpha++;
        else if (isdigit(s[i]))  digit++;
        else if (isspace(s[i]))  space++;
        else                     special++;
    }
    printf("Letters = %d\nDigits = %d\nSpaces = %d\nSpecial = %d\n",
           alpha, digit, space, special);
    return 0;
}
/* Input: "BCA 2026 !" → Letters = 3, Digits = 4, Spaces = 2, Special = 2 */

/* Program: case toggle — capital ko small, small ko capital (XOR trick ke saath) */
for (i = 0; s[i] != '\0'; i++) {
    if (isupper(s[i]))      s[i] = tolower(s[i]);
    else if (islower(s[i])) s[i] = toupper(s[i]);
}
printf("Toggled: %s\n", s);
/* "Bca Notes" → "bCA nOTES" */

/* Program: sirf digits wala validation (form ka mobile number check) */
int valid = 1;
for (i = 0; s[i] != '\0'; i++)
    if (!isdigit(s[i])) { valid = 0; break; }
printf(valid ? "Valid number ✔\n" : "Invalid ❌\n");

4.7 Ek Poora String Program (lab #14 se related)

/* Program: vowels, consonants, words count + uppercase conversion — sab ek saath */
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int main() {
    char str[200];
    int i, vowels = 0, cons = 0, words = 1, len;

    printf("Enter a sentence: ");
    fgets(str, 200, stdin);
    len = strlen(str);

    for (i = 0; i < len; i++) {
        char ch = tolower(str[i]);          // compare easy ho jayega

        if (isalpha(ch)) {
            if (ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')
                vowels++;
            else
                cons++;
        }
        if (isspace(str[i]) && isalpha(str[i+1]))
            words++;                        // space ke baad letter = naya word
    }
    printf("Length = %d\nVowels = %d\nConsonants = %d\nWords = %d\n",
           len, vowels, cons, words);
    return 0;
}
/* Input: "Hello BCA Students" →
   Length = 19 (newline ke saath), Vowels = 6, Consonants = 9, Words = 3 */

/* Program: naam ka pehla letter capital karo (Title Case — naam formatting) */
int newWord = 1;
for (i = 0; str[i] != '\0'; i++) {
    if (isspace(str[i])) newWord = 1;
    else if (newWord) { str[i] = toupper(str[i]); newWord = 0; }
    else str[i] = tolower(str[i]);
}
printf("Formatted: %s", str);      // "ansh kumar gupta" → "Ansh Kumar Gupta"

/* Program: do strings compare karo — strcmp ke bina (ASCII difference se) */
int i = 0, diff = 0;
while (s1[i] != '\0' && s2[i] != '\0' && s1[i] == s2[i])
    i++;
diff = s1[i] - s2[i];             // 0 = equal, +ve/−ve = bada/chhota
printf(diff == 0 ? "Equal\n" : "Not equal\n");

UNIT 5 — Functions and Pointers in C

5.1 Functions — Introduction

Function ka anatomy (5 hisse — exam me diagram ke saath likhna)

   return_type  function_name ( parameter_list )
   ┌──────────┐ ┌─────────────┐ ┌────────────────┐
        int      calculateArea   (float radius)
   {
       float area = 3.14 * radius * radius;   // body (kaam)
       return area;                            // result wapas
   }
                    ↑
             function ko "call" karte waqt:
             area = calculateArea(7.5);   // 7.5 = argument

Benefits of functions (6 points — 5-mark question)

• Reusability: Ek baar likho, baar-baar use karo (code duplication khatam).
• Modularity: Bada program chhote-chhote tasks me bat jata hai — samajhna aasan.
• Easy debugging: Problem wale function ko alag test kar sakte ho, poori file nahi.
• Readability: calculateInterest() dekh kar hi samajh aa jata hai kya ho raha hai (comment ki zarurat kam).
• Maintainability: Badlav ek jagah — 50 jagah nahi (bug fix ek hi baar).
• Teamwork: Alag-alag log alag-alag functions par kaam kar sakte hain.

5.2 Types of Functions: Built-in vs User-defined

/* Useful library functions ki list (lab me kaam aayegi) */
stdio.h  → printf, scanf, gets, puts, fgets, fopen, fclose   // input-output, file
math.h   → sqrt, pow, fabs, ceil, floor, sin, cos, log       // maths
string.h → strlen, strcpy, strcat, strcmp, strstr, strchr   // strings
ctype.h  → isalpha, isdigit, isspace, toupper, tolower       // characters
stdlib.h → malloc, free, abs, atoi, rand, exit              // memory, conversion, random
time.h   → time, clock                                       // date/time

/* Program: math.h ke functions ka demo */
#include <stdio.h>
#include <math.h>
int main() {
    printf("sqrt(144) = %.1f\n", sqrt(144));     // 12.0
    printf("pow(2,10) = %.0f\n", pow(2, 10));    // 1024
    printf("fabs(-7.5) = %.1f\n", fabs(-7.5));   // 7.5
    printf("ceil(4.1) = %.1f\n", ceil(4.1));     // 5.0
    printf("floor(4.9) = %.1f\n", floor(4.9));   // 4.0
    return 0;
}
/* Compile karte waqt kuch compilers me '-lm' lagana padta hai: gcc prog.c -o prog -lm */

5.3 Function Declaration, Definition aur Call (3 steps)

/* Teeno steps ek program me — LAB #9 type ka program */
#include <stdio.h>

/* 1. DECLARATION (prototype) — semicolon ke saath */
int add(int a, int b);
float areaCircle(float r);
void greet();                       // void = kuch return nahi karega

int main() {
    int s;
    /* 3. CALL — naam + arguments (actual parameters) */
    s = add(5, 3);
    printf("Sum = %d\n", s);                    // Sum = 8
    printf("Area = %.2f\n", areaCircle(7));     // Area = 153.94
    greet();                                    // Hello! (koi value nahi milti)
    return 0;
}

/* 2. DEFINITION — yahan actual kaam (formal parameters) */
int add(int a, int b) {          // a, b = formal parameters
    return a + b;                // result wapas
}
float areaCircle(float r) {
    return 3.14159 * r * r;
}
void greet() {
    printf("Hello! 👋\n");
    // return;  — void me return value ke bina bhi likh sakte ho
}

/* Program: function se table aur factorial — do chhote functions */
#include <stdio.h>
void table(int n);            // prototype (void — kuch return nahi)
int factorial(int n);         // prototype (int return karega)

int main() {
    table(5);
    printf("5! = %d\n", factorial(5));
    return 0;
}
void table(int n) {
    int i;
    for (i = 1; i <= 10; i++)
        printf("%d x %d = %d\n", n, i, n * i);
}
int factorial(int n) {
    int i, f = 1;
    for (i = 1; i <= n; i++)
        f *= i;
    return f;
}
/* Output: 5 x 1 = 5 ... 5 x 10 = 50, phir 5! = 120 */

/* Program: isPrime() function — function se code kitna saaf lagta hai! */
int isPrime(int n) {
    int i;
    if (n < 2) return 0;                 // 0 aur 1 prime nahi
    for (i = 2; i <= n / 2; i++)
        if (n % i == 0) return 0;        // divisor mila → prime nahi
    return 1;                            // koi divisor nahi mila → prime
}
/* main me: if (isPrime(17)) printf("Prime"); — English jaisa code! */

/* Program: 1 se 50 tak ke prime numbers print (function ka fayda) */
int main() {
    int i;
    for (i = 2; i <= 50; i++)
        if (isPrime(i))
            printf("%d ", i);            // 2 3 5 7 11 ... 47
    return 0;
}

5.4 Parameter Passing: Call by Value vs Call by Reference High-yield syllabus topic

MEMORY PICTURE (call by value) — sirf copy jaati hai:

  main() me:  a = 10, b = 20           swapVal(x, y) me:
                                        x = 10, y = 20   ← ALAG copies
  Function khatam → copies gayab →  a = 10, b = 20 (unchanged!)

MEMORY PICTURE (call by reference) — address jaata hai:

  main() me:        a = 10   (address 1000)
                    b = 20   (address 1004)
                              ↑        swapRef(&a, &b) me:
                              └──────  x = 1000, y = 1004 (addresses)
  *x = 20 karne se  → a (jo 1000 par hai) ki value badal gayi!
  Function khatam → a = 20, b = 10 ✔ (original badla)

/* LAB #10 — Call by value vs Call by reference (swap example) — poora program */
#include <stdio.h>

/* ---- CALL BY VALUE: original nahi badlega ---- */
void swapVal(int x, int y) {
    int t = x; x = y; y = t;        // sirf copies badli
}

/* ---- CALL BY REFERENCE: original BADLEGA ---- */
void swapRef(int *x, int *y) {
    int t = *x;                      // * = us address ki value
    *x = *y;
    *y = t;                          // original memory badli
}

int main() {
    int a = 10, b = 20;
    swapVal(a, b);
    printf("After call by value: a=%d b=%d\n", a, b);      // a=10 b=20
    swapRef(&a, &b);
    printf("After call by reference: a=%d b=%d\n", a, b);   // a=20 b=10 ✔
    return 0;
}
/* Output:
   After call by value: a=10 b=20      ← kuch nahi badla!
   After call by reference: a=20 b=10  ← original badal gaya ✔ */

5.5 Recursion

/* Factorial — recursion se (lab: GCD bhi isi tarah) */
#include <stdio.h>
long factorial(int n) {
    if (n == 0 || n == 1)
        return 1;                  // BASE CASE (ruko!)
    else
        return n * factorial(n - 1);   // khud ko chhote input se call
}
int main() {
    printf("5! = %ld\n", factorial(5));   // 120
    return 0;
}
/* Andar kya hua (recursion ka tree):
   factorial(5) = 5 * factorial(4)
                = 5 * 4 * factorial(3)
                = 5 * 4 * 3 * factorial(2)
                = 5 * 4 * 3 * 2 * factorial(1)
                = 5 * 4 * 3 * 2 * 1
                = 120 ✔ (base case par ruk kar sab multiply hua) */

/* Program: Fibonacci ka n-th term by recursion (2 calls — recursion tree) */
int fib(int n) {
    if (n == 0) return 0;          // base
    if (n == 1) return 1;          // base
    return fib(n - 1) + fib(n - 2);  // do recursive calls!
}
/* fib(6) = fib(5) + fib(4) = 5 + 3 = 8
   Note: yahan calls ki ginti exponential hoti hai — fib(40) dheere chalega.
   Isliye iteration wala version fast hota hai (recursion vs iteration ka point!) */

/* LAB #8 — GCD by iteration AND recursion */
int gcdIter(int a, int b) {          // loop wala
    while (b != 0) {
        int t = b;
        b = a % b;
        a = t;
    }
    return a;
}
int gcdRec(int a, int b) {            // recursion wala (Euclid)
    if (b == 0) return a;             // base case
    return gcdRec(b, a % b);          // chhote problem par pass
}
/* gcdRec(48, 18) → gcdRec(18, 12) → gcdRec(12, 6) → gcdRec(6, 0) → 6 ✔ */

/* Program: sum of digits by recursion (n%10 nikalo, n/10 par call) */
int digitSum(int n) {
    if (n == 0) return 0;
    return (n % 10) + digitSum(n / 10);
}
/* digitSum(4821) = 1 + digitSum(482) = 1 + 2 + digitSum(48) = 1+2+8+digitSum(4) = 1+2+8+4 = 15 ✔ */

/* Program: x^n by recursion (power) */
int power(int x, int n) {
    if (n == 0) return 1;              // kuch bhi ^ 0 = 1
    return x * power(x, n - 1);
}
/* power(2, 5) = 2 × 2 × 2 × 2 × 2 = 32 ✔ */

Tower of Hanoi (recursion ka sabse famous example)

/* 3 disk, 3 rods (Source → Auxiliary → Destination) */
#include <stdio.h>
void hanoi(int n, char from, char to, char via) {
    if (n == 1) {                          // base case: 1 disk seedha le jao
        printf("Disk 1: %c → %c\n", from, to);
        return;
    }
    hanoi(n - 1, from, via, to);           // upar wale disks hatao
    printf("Disk %d: %c → %c\n", n, from, to);  // sabse badi disk le jao
    hanoi(n - 1, via, to, from);           // hatai hui disks wapas rakho
}
int main() {
    hanoi(3, 'A', 'C', 'B');               // 7 moves → 2³ − 1
    return 0;
}
/* Moves ka formula = 2ⁿ − 1  →  3 disk = 7, 4 disk = 15, 64 disk = 1.8 × 10¹⁹ (baah!) */

/* Program: factorial(5) ka recursion tree visual (exam me ise likhna)
   factorial(5)
   └── 5 * factorial(4)
           └── 4 * factorial(3)
                   └── 3 * factorial(2)
                           └── 2 * factorial(1)
                                   └── 1  ← BASE CASE (wapsi shuru)
   Wapas: 1 → 2 → 6 → 24 → 120  */

5.6 Understanding Pointers

/* Pointer declaration, initialization & use — poora program */
#include <stdio.h>
int main() {
    int a = 10;                // ek normal variable
    int *p;                    // pointer declaration (int ka pointer)

    p = &a;                    // p me a ka ADDRESS daala (& = address-of)

    printf("Value of a     = %d\n", a);      // 10
    printf("Address of a   = %p\n", &a);     // e.g. 0061FF1C
    printf("p me kya hai   = %p\n", p);      // wahi address!
    printf("a ki value via p = %d\n", *p);   // 10 (* = dereference)

    *p = 50;                   // pointer se a ki value badal di
    printf("Ab a = %d\n", a);                // 50 ✔
    return 0;
}
/* Yaad rakho: p = address rakhta hai, *p = us address par padi VALUE
   a  aur  *p  ek hi jagah hain — ek ko badla, doosra bhi badla! */

/* Type ka matlab: int* → 4 byte skip, char* → 1 byte skip (pointer arithmetic) */
int  a = 10;   int  *p = &a;     // p++ se 4 byte aage (int ka size)
char c = 'A';  char *q = &c;     // q++ se 1 byte aage (char ka size)

/* Program: pointer ka size aur address */
#include <stdio.h>
int main() {
    int a = 5; char c = 'x'; float f = 1.5;
    int *p1 = &a; char *p2 = &c; float *p3 = &f;
    printf("sizeof(p1)=%d sizeof(p2)=%d sizeof(p3)=%d\n",
            sizeof(p1), sizeof(p2), sizeof(p3));   // sab 8 (64-bit machine par)
    printf("a via p1 = %d, c via p2 = %c, f via p3 = %.1f\n", *p1, *p2, *p3);
    return 0;
}

5.7 Pointers and Arrays (dono bhai-bhai hain)

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;              // arr khud pehle element ka address hai!

/* Ye chaaro lines SAME cheez tak le jaati hain: */
arr[2]  ==  *(arr + 2)  ==  *(p + 2)  ==  p[2]     // sab = 30 ✔
 &arr[0] ==  arr  ==  p                            // base address
 &arr[2] ==  (arr + 2) == (p + 2)                  // teesre element ka address

/* Loop with pointer (array ka alternative tarika) */
for (i = 0; i < 5; i++)
    printf("%d ", *(p + i));         // 10 20 30 40 50

/* Array parameter pointer me adjust hota hai; pointer value is passed by value. */
#include <stdio.h>
void doubleAll(int a[], int n) {      // a[] as good as int *a
    int i;
    for (i = 0; i < n; i++)
        a[i] = a[i] * 2;              // ORIGINAL array hi badla
}
int main() {
    int x[4] = {1, 2, 3, 4}, i;
    doubleAll(x, 4);
    for (i = 0; i < 4; i++) printf("%d ", x[i]);   // 2 4 6 8 ✔
    return 0;
}

5.8 Pointer Arithmetic

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;                  // maan lo address = 1000

p++;      // agle ELEMENT par — address 1000 → 1004 (+4, int ke size jitna) → *p = 20
p--;      // pichle element par → 1004 → 1000 → *p = 10
p = p + 2;  // do element aage → 1008 → *p = 30
p = p - 1;  // ek peeche → 1004 → *p = 20

int *q = &arr[4];   // address 1016
q - p;              // do pointers ka difference = kitne ELEMENTS ka gap (bytes ka nahi!)
                    // 1016 - 1004 = 12 bytes ÷ 4 = 3 elements

/* char pointer me farak dekho */
char s[] = "BCA";
char *c = s;        // address 2000
c++;                // 2001 (+1 byte, char ke size jitna) → *c = 'C'

/* Comparison allowed hai */
if (p < q) printf("p pehle wale element par hai\n");   // addresses ki comparison

/* Program: pointer arithmetic se array traverse (dono loop style) */
#include <stdio.h>
int main() {
    int a[5] = {10, 20, 30, 40, 50};
    int *p = a, sum = 0;

    while (p < a + 5) {        // jab tak aakhri element tak na pahuncho
        sum += *p;
        p++;
    }
    printf("Sum = %d\n", sum);   // Sum = 150

    p = a;                        // reset
    for (int i = 0; i < 5; i++)
        printf("%d ", *(p + i));  // 10 20 30 40 50
    return 0;
}

5.9 Advantages & Disadvantages of Pointers

/* Dynamic memory ka ek chhota demo (pointers ka sabse bada fayda) */
#include <stdio.h>
#include <stdlib.h>         // malloc/free ke liye
int main() {
    int n = 5, i;
    int *arr = (int *) malloc(n * sizeof(int));   // runtime par jagah mili

    if (arr == NULL) { printf("Memory nahi mili!\n"); return 1; }

    for (i = 0; i < n; i++) arr[i] = (i + 1) * 10;
    for (i = 0; i < n; i++) printf("%d ", arr[i]);   // 10 20 30 40 50

    free(arr);              // ⚠️ wapas kar dena zaroori (memory leak se bacho)
    arr = NULL;             // dangling pointer se bacho
    return 0;
}
/* Yaad rakho: malloc = "memory a lot", free = "wapas de do". Ye pair hi
   C me dynamic arrays, linked lists, strings — sab ka base hai (Unit 4 ke
   arrays ka "runtime size" wala nuksaan yahin theek hota hai) */

5.10 Pointer + Function = Reference-style Modification (syllabus phrase: call by reference)

/* Program: function jo ek array ke min AUR max dono return kare (pointers se) */
#include <stdio.h>
void minMax(int arr[], int n, int *mn, int *mx) {
    int i;
    *mn = *mx = arr[0];              // pehle element se start
    for (i = 1; i < n; i++) {
        if (arr[i] < *mn) *mn = arr[i];
        if (arr[i] > *mx) *mx = arr[i];
    }
}
int main() {
    int a[6] = {45, 12, 78, 3, 90, 56};
    int small, big;
    minMax(a, 6, &small, &big);      // addresses bheje
    printf("Smallest = %d, Largest = %d\n", small, big);
    // Output: Smallest = 3, Largest = 90 ✔
    return 0;
}

/* Program: sum aur average dono ek hi function se */
void stats(int a[], int n, int *sum, float *avg) {
    int i;
    *sum = 0;
    for (i = 0; i < n; i++) *sum += a[i];
    *avg = (float) *sum / n;
}
/* main me: stats(a, n, &s, &avg);
   printf("Sum = %d, Average = %.2f", s, avg); */

/* Program: pointer se string ki length (strlen ka apna version) */
int myStrlen(char *s) {
    int count = 0;
    while (*s != '\0') {      // jab tak null na mile
        count++;
        s++;                  // agle character par
    }
    return count;
}
/* myStrlen("Programming") → 11 (string functions andar aise hi kaam karte hain!) */

/* Program: do numbers ka swap by reference — function ke saath (LAB #10 recap) */
void swap(int *x, int *y) { int t = *x; *x = *y; *y = t; }
/* main: swap(&a, &b);  →  original values badal jaati hain */

⚡ Rapid-fire 2-mark Q&A — poore syllabus ka nichod (viva + short answers ke liye)

/* Ek final program — jo sab units ko jodta hai (array + function + pointer + string) */
#include <stdio.h>
#include <string.h>

void bestStudent(char names[][20], int marks[], int n, char topName[], int *topMarks) {
    int i, best = 0;
    for (i = 1; i < n; i++)
        if (marks[i] > marks[best]) best = i;
    strcpy(topName, names[best]);     // string copy (Unit 4)
    *topMarks = marks[best];          // pointer se value wapas (Unit 5)
}

int main() {
    char names[3][20] = {"Ansh", "Priya", "Rahul"};
    int marks[3] = {78, 91, 85}, m;
    char top[20];

    bestStudent(names, marks, 3, top, &m);   // function call (Unit 5)

    printf("Topper: %s with %d marks\n", top, m);
    return 0;
}

🧪 Lab practical bank (SEC101P) — 16 programs ka checklist + viva Q&A

Neeche SEC101P lab ke 16 programs ka checklist hai — kaunsa program kis unit ka concept test karta hai aur kya dhyaan rakhna hai. Poora code + output file 07_Lab_Practicals.html (SEC101P section) me hai; yahan revision ke liye logic aur viva ke answers hain.

📝 Exam program bank — 15 programs jo baar-baar aate hain (ek line ka logic yaad rakho)

/* Bonus: in 5 programs ka COMPLETE code ek jagah (lab file ke liye ready) */
/* A. Even-Odd (ternary) */
int n; scanf("%d", &n);
printf("%d is %s\n", n, (n % 2 == 0) ? "Even" : "Odd");

/* B. Table of any number */
int n, i; scanf("%d", &n);
for (i = 1; i <= 10; i++) printf("%d x %d = %d\n", n, i, n*i);

/* C. Sum of digits */
int n, s = 0; scanf("%d", &n);
while (n != 0) { s += n % 10; n /= 10; }
printf("Sum = %d\n", s);

/* D. Largest in array */
int a[5] = {45, 12, 78, 3, 90}, i, max = a[0];
for (i = 1; i < 5; i++) if (a[i] > max) max = a[i];
printf("Max = %d\n", max);        // 90

/* E. Reverse a string (manual) */
char s[50], t[50]; int i, len;
scanf("%s", s);
for (len = 0; s[len] != '\0'; len++);
for (i = 0; i < len; i++) t[i] = s[len-1-i];
t[len] = '\0';
printf("Reverse = %s\n", t);

✅ Mixed MCQ bank (30 questions — answers neeche)

🎓 Model answers — 5 sabse important 10-mark questions

🧪 Sample question paper — SEC101T (Programming in C) • 70-mark practice total • suggested timing only; official duration/pattern not stated in the supplied PDF

📖 C glossary — important terms ek jagah