Master
C Programming with
Pavel Ibrahim

#include <stdio.h>
int main() {
    int n;
    printf("Enter a number: ");
    scanf("%d", &n);

    /* % is the modulo (remainder) operator
       10 % 2 = 0  (even), 7 % 2 = 1 (odd) */
    if(n % 2 == 0)
        printf("%d is Even\n", n);
    else
        printf("%d is Odd\n", n);
    return 0;
}

#include <stdio.h>
int main() {
    int n, i;
    printf("Enter N: "); scanf("%d",&n);

    /* Loop flowchart → for loop in C
       Init: i=1, Condition: i<=n, Update: i++
       Body: print i */
    for(i=1; i<=n; i++) {
        printf("%d ", i);  /* prints 1 2 3 ... N */
    }
    printf("\n");
    return 0;
}

START
  INPUT array A of n numbers
  FOR i = 0 to n-2
    FOR j = 0 to n-i-2
      IF A[j] > A[j+1] THEN
        SWAP A[j] and A[j+1]
      ENDIF
    ENDFOR
  ENDFOR
  OUTPUT sorted array A
END

#include <stdio.h>
int main() {
    int a[] = {64,34,25,12,22};  /* array to sort */
    int n = 5, i, j, temp;

    /* Outer loop: each pass moves the next largest to end
       We need n-1 passes for n elements */
    for(i=0; i<n-1; i++) {

        /* Inner loop: compare adjacent elements
           Already-sorted portion at end shrinks each pass */
        for(j=0; j<n-i-1; j++) {
            if(a[j] > a[j+1]) {
                /* Swap: use temp variable to hold one value */
                temp    = a[j];
                a[j]   = a[j+1];
                a[j+1] = temp;
            }
        }
    }
    /* Print sorted array */
    for(i=0; i<n; i++) printf("%d ", a[i]);
    return 0;
}

/* Languages directly influenced by C:
   
   C++     (1983) — Bjarne Stroustrup — adds OOP to C
   Java    (1995) — James Gosling     — "write once, run anywhere"
   C#      (2000) — Anders Hejlsberg — Microsoft .NET
   PHP     (1994) — Rasmus Lerdorf   — web scripting
   JavaScript(95) — Brendan Eich     — web browsers
   Go      (2009) — Google           — systems programming
   Rust    (2010) — Mozilla          — memory-safe systems lang
   Python  ——————— uses C-style syntax and concepts
   
   C is truly the "Mother of All Languages" !
   
   Even your OS kernel is written mostly in C:
   Linux kernel   → 97% C
   Windows kernel → C and C++
   macOS kernel   → C and Objective-C    */

/* ====== SECTION 1: Documentation ======
   Program  : Area Calculator
   Author   : Your Name
   Date     : 2024
   Purpose  : Calculate area of circle & rectangle
   ======================================= */

/* ====== SECTION 2: Preprocessor / Link ====== */
#include <stdio.h>    /* Standard I/O: printf, scanf */
#include <math.h>     /* Math functions: sqrt, pow, M_PI */

/* ====== SECTION 3: Macro Definitions ====== */
#define PI  3.14159f  /* Constant for pi value */
#define MAX 100      /* Maximum array size */

/* ====== SECTION 4: Global Declarations ====== */
int programCount = 0;  /* Global: accessible from ALL functions */

/* Function PROTOTYPE (declaration) — tells compiler
   this function will be defined later below main() */
float circleArea(float r);
float rectArea(float l, float w);

/* ====== SECTION 5: main() Function ====== */
int main() {
    float r, l, w;  /* LOCAL variables — only visible in main() */

    printf("Enter circle radius: ");
    scanf("%f", &r);
    printf("Circle Area = %.2f\n", circleArea(r));

    printf("Enter rect L W: ");
    scanf("%f %f", &l, &w);
    printf("Rect Area = %.2f\n", rectArea(l,w));

    return 0;  /* 0 = success, 1 = error */
}

/* ====== SECTION 6: Sub-programs ====== */
/* Formula: π × r² */
float circleArea(float r) {
    return PI * r * r;
}

/* Formula: length × width */
float rectArea(float l, float w) {
    return l * w;
}

# FULL compilation in one step (most common usage)
gcc program.c -o program

# Step-by-step compilation:
gcc -E program.c -o program.i   # Step 1: Preprocess only
gcc -S program.i -o program.s   # Step 2: Compile to Assembly
gcc -c program.s -o program.o   # Step 3: Assemble to object
gcc program.o   -o program      # Step 4: Link to executable

# Recommended beginner command (-Wall shows all warnings)
gcc -Wall -g program.c -o program

# With math library (needed for sqrt, pow, sin, etc.)
gcc program.c -o program -lm

# Using C11 standard
gcc -std=c11 -Wall program.c -o program

# Run the compiled program
./program      # Linux/macOS
program.exe    # Windows

/* SYNTAX ERROR — missing semicolon */
int main() {
    int x = 5   /* ← ERROR: missing ; here! */
    return 0;
}

/* RUNTIME ERROR — divide by zero */
int main() {
    int a = 10 / 0;  /* ← program CRASHES at runtime */
    return 0;
}

/* LOGICAL ERROR — wrong formula (compiles fine!) */
#define PI 3.14159
float area(float r) {
    return 2 * PI * r;  /* ← should be PI*r*r */
}

/* In this line: int sum = a + b;
   int   → keyword (token type 1)
   sum   → identifier (token type 2)
   =     → operator (token type 4)
   a     → identifier (token type 2)
   +     → operator (token type 4)
   b     → identifier (token type 2)
   ;     → punctuator (token type 5)
   Total: 7 tokens in one statement! */

int sum = a + b;

#include <stdio.h>

/* METHOD 1: #define MACRO — no memory allocated
   Preprocessor replaces PI with 3.14159 everywhere
   before compilation even begins */
#define PI       3.14159
#define MAX_SIZE 100
#define GREETING "Hello"

int main() {

    /* METHOD 2: const keyword — type-safe, has memory
       Compiler ENFORCES that you can't change the value */
    const float  gravity  = 9.81f;  /* m/s² */
    const int    days     = 7;
    const char   grade    = 'A';

    /* Different numeric constant notations */
    int decimal = 255;    /* normal base-10 integer */
    int octal   = 0377;   /* prefix 0 = octal: 0377 = 255 */
    int hex     = 0xFF;   /* prefix 0x = hex: 0xFF = 255 */
    int binary  = 0b11111111; /* C99: 0b = binary = 255 */

    printf("All equal: %d %d %d\n", decimal, octal, hex);

    /* Character constant — stored as ASCII integer value
       'A' = 65, 'a' = 97, '0' = 48 */
    printf("Grade: %c = ASCII %d\n", grade, grade);

    /* Float constant suffixes:
       3.14    = double by default
       3.14f   = float (less precision, less memory)
       3.14L   = long double (more precision) */
    printf("PI macro: %f\n", PI);     /* 3.141590 */
    printf("Gravity: %.2f\n", gravity); /* 9.81 */

    return 0;
}

#include <stdio.h>

/* GLOBAL variable — declared OUTSIDE all functions
   Lives for the entire program duration
   Initialized to 0 automatically by the compiler
   Accessible from any function in any file */
int globalCount = 0;
float globalRate = 5.5;

int main() {

    /* LOCAL variables — declared INSIDE function/block
       Only accessible within this { } block
       NOT automatically initialized — contain random garbage! */
    int    age    = 20;         /* integer */
    float  height = 5.9f;       /* single-precision float */
    double pi     = 3.14159265; /* double precision */
    char   grade  = 'A';         /* single character */
    char   name[] = "Alice";     /* string = char array */

    /* Declare multiple variables of same type at once */
    int x = 1, y = 2, z;  /* z has garbage value! */
    z = x + y;              /* now z has a valid value */

    printf("Age: %d\n",      age);
    printf("Height: %.1f\n", height);
    printf("Pi: %lf\n",     pi);
    printf("Name: %s\n",    name);
    printf("x+y = %d\n",   z);

    return 0;
}

#include <stdio.h>
int main() {
    /* sizeof() — built-in operator that returns
       the SIZE of a type or variable in bytes */
    printf("char:        %zu bytes\n", sizeof(char));
    printf("int:         %zu bytes\n", sizeof(int));
    printf("float:       %zu bytes\n", sizeof(float));
    printf("double:      %zu bytes\n", sizeof(double));
    printf("long long:   %zu bytes\n", sizeof(long long));
    printf("long double: %zu bytes\n", sizeof(long double));

    /* sizeof also works on variables */
    int arr[10];
    printf("arr[10] size: %zu bytes\n", sizeof(arr));  /* 40 */
    printf("elements: %zu\n", sizeof(arr)/sizeof(arr[0])); /* 10 */
    return 0;
}

#include <stdio.h>
int main() {

    /* IMPLICIT CASTING — automatic (int promoted to float) */
    int   i = 5;
    float f = i;   /* int 5 auto-converts to float 5.0 */
    printf("Implicit int→float: %f\n", f);  /* 5.000000 */

    /* PROBLEM: int / int = int (fractional part LOST!)
       7 / 2 = 3, NOT 3.5 */
    printf("Wrong:   %d\n", 7/2);            /* 3 !! */

    /* EXPLICIT CASTING: (float) forces conversion
       Now 7 becomes 7.0 before dividing */
    printf("Correct: %.2f\n", (float)7/2);   /* 3.50 */

    /* char to int — reveals ASCII value */
    char ch = 'A';
    printf("ASCII of 'A' = %d\n", (int)ch);   /* 65 */

    /* double → int truncates (does NOT round!) */
    double d = 9.999;
    printf("Truncated: %d\n", (int)d);         /* 9, not 10! */

    /* Promotion hierarchy (low → high = safe):
       char → short → int → long → float → double → long double */
    char  c = 10;
    short s = 200;
    int   result = c + s;  /* both promoted to int automatically */
    printf("Result: %d\n", result);  /* 210 */

    return 0;
}

/* =============================================
   Program : Complete printf() Format Specifiers Guide
   Purpose : Demonstrate all major printf() formatting options
   Input   : None (uses hardcoded values)
   Output  : Various formatted outputs showing different specifiers
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() function */

int main() {  /* Program entry point */

    /* VARIABLE DECLARATIONS:
       Different data types to demonstrate various format specifiers */
    int   age  = 21;         /* Integer variable */
    float gpa  = 3.857f;     /* Float variable (f suffix for float literal) */
    char  init = 'J';        /* Single character */
    char  name[] = "Alice";  /* Character array (string) */

    /* BASIC FORMAT SPECIFIERS:
       %d = decimal integer, %f = float, %c = character, %s = string */

    printf("Integer:  %d\n",  age);    /* %d: prints integer as decimal */
    printf("Float:    %f\n",  gpa);    /* %f: prints float with 6 decimal places */
    printf("2 decimals: %.2f\n", gpa); /* %.2f: float with exactly 2 decimal places */
    printf("Char:     %c\n",  init);   /* %c: prints single character */
    printf("String:   %s\n",  name);   /* %s: prints null-terminated string */

    /* MULTIPLE VALUES IN ONE PRINTF:
       Arguments must match format specifiers in exact order */
    printf("%s is %d years old, GPA: %.2f\n", name, age, gpa);

    /* WIDTH AND ALIGNMENT FORMATTING:
       Field width controls minimum characters printed
       Default is right-aligned, - makes left-aligned */
    printf("|%10d|\n",  42);   /* %10d: right-align in 10-char field */
    printf("|%-10d|\n", 42);   /* %-10d: left-align in 10-char field */
    printf("|%010d|\n", 42);   /* %010d: pad with zeros on left */
    printf("|%+d|\n",   42);   /* %+d: always show + sign for positive */

    /* DIFFERENT NUMBER BASES:
       Same number displayed in different bases */
    printf("Decimal: %d\n", 255);   /* %d: base 10 (default) */
    printf("Octal:   %o\n", 255);   /* %o: base 8 (octal) */
    printf("Hex:     %x\n", 255);   /* %x: base 16 (hex lowercase) */
    printf("Hex-UP:  %X\n", 255);   /* %X: base 16 (hex uppercase) */

    /* SCIENTIFIC NOTATION:
       %e displays float in scientific notation */
    printf("Scientific: %e\n", 3456.789);  /* %e: exponential notation */

    /* Program completed successfully */
    return 0;
}

/* =============================================
   Program : Escape Sequences in C
   Purpose : Demonstrate special characters in strings
   Escape sequences start with backslash (\) followed by a character
   They represent characters that are difficult to type or have special meaning
   ============================================= */

/* ESCAPE SEQUENCES REFERENCE:
   \n = newline character (moves cursor to next line)
   \t = horizontal tab (moves cursor to next tab stop, usually 8 spaces)
   \r = carriage return (moves cursor to beginning of current line)
   \b = backspace (moves cursor back one character position)
   \\ = literal backslash character (since \ has special meaning)
   \' = literal single quote character (for char literals)
   \" = literal double quote character (for string literals)
   \0 = null character (terminates strings, ASCII value 0)
   \a = alert/bell character (produces audible beep)
   \f = form feed (new page in printers, newline in terminals)
   \v = vertical tab (moves down to next vertical tab stop)
   \xHH = character with hex value HH (e.g., \x41 = 'A')
   \OOO = character with octal value OOO (e.g., \101 = 'A') */

#include <stdio.h>  /* Standard I/O library for printf() */

int main() {  /* Program entry point */

    /* NEWLINE ESCAPE SEQUENCE:
       \n moves output to the next line */
    printf("Line1\nLine2\n");      /* Prints "Line1" then moves to next line, prints "Line2" */

    /* TAB ESCAPE SEQUENCE:
       \t creates horizontal spacing (typically 8 characters) */
    printf("Col1\tCol2\tCol3\n"); /* Creates table-like columns with tab spacing */

    /* QUOTE ESCAPE SEQUENCES:
       Since double quotes delimit strings, we need \" to include them inside */
    printf("He said \"Hello!\"\n"); /* Prints: He said "Hello!" */

    /* BACKSLASH ESCAPE SEQUENCE:
       Since backslash starts escape sequences, we need \\ for literal backslash */
    printf("Path: C:\\Users\\me\n");/* Prints: Path: C:\Users\me */

    /* ALERT/BELL ESCAPE SEQUENCE:
       \a produces an audible beep (if system supports it) */
    printf("\aBeep!\n");            /* Makes beep sound then prints "Beep!" */

    /* Program completed successfully */
    return 0;
}

/* =============================================
   Program : Complete C Operators Demonstration
   Purpose : Showcase all major operator categories in C
   Categories: Arithmetic, Relational, Logical, Assignment, Increment/Decrement
   Input   : None (uses hardcoded values)
   Output  : Results of various operator operations
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() function */

int main() {  /* Program entry point */

    /* VARIABLE DECLARATIONS:
       a, b, c: integer variables for operator demonstrations
       a=10, b=3 provide good examples for various operations */
    int a=10, b=3, c;

    /* ============================================
       ARITHMETIC OPERATORS (+, -, *, /, %)
       Perform mathematical calculations
       ============================================ */

    printf("a+b=%d\n", a+b);   /* 13 — addition operator */
    printf("a-b=%d\n", a-b);   /* 7  — subtraction operator */
    printf("a*b=%d\n", a*b);   /* 30 — multiplication operator */
    printf("a/b=%d\n", a/b);   /* 3  — integer division (truncates decimal part) */
    printf("a%%b=%d\n", a%b);  /* 1  — modulo operator (remainder after division) */

    /* ============================================
       RELATIONAL OPERATORS (>, <, ==, !=, >=, <=)
       Compare values and return boolean result (1=true, 0=false)
       ============================================ */

    printf("a>b:  %d\n", a>b);   /* 1 = true (10 > 3) */
    printf("a<b:  %d\n", a<b);   /* 0 = false (10 < 3) */
    printf("a==b: %d\n", a==b);  /* 0 — equal? No (10 != 3) */
    printf("a!=b: %d\n", a!=b);  /* 1 — not equal? Yes (10 != 3) */
    printf("a>=b: %d\n", a>=b);  /* 1 — greater or equal? Yes (10 >= 3) */
    printf("a<=b: %d\n", a<=b);  /* 0 — less or equal? No (10 <= 3) */

    /* ============================================
       LOGICAL OPERATORS (&&, ||, !)
       Combine or negate boolean conditions
       && (AND): true only if BOTH operands are true
       || (OR):  true if at least ONE operand is true
       ! (NOT): flips true to false and vice versa
       ============================================ */

    printf("a>5 && b<5: %d\n", a>5 && b<5);  /* 1 (true AND true = true) */
    printf("a<5 || b<5: %d\n", a<5 || b<5);  /* 1 (false OR true = true) */
    printf("!(a>5): %d\n",       !(a>5));        /* 0 (NOT true = false) */

    /* ============================================
       ASSIGNMENT OPERATORS (=, +=, -=, *=, /=, %=)
       Modify variable values using shorthand notation
       These are equivalent to: variable = variable op value
       ============================================ */

    c = 20;          /* Simple assignment: c becomes 20 */
    c += 5;  /* c = c + 5 = 25 (addition assignment) */
    c -= 3;  /* c = c - 3 = 22 (subtraction assignment) */
    c *= 2;  /* c = c * 2 = 44 (multiplication assignment) */
    c /= 4;  /* c = c / 4 = 11 (division assignment) */
    c %= 4;  /* c = c % 4 = 3  (modulo assignment) */
    printf("c after ops: %d\n", c);  /* 3 (final result after all operations) */

    /* ============================================
       INCREMENT/DECREMENT OPERATORS (++, --)
       Increase or decrease variable by 1
       Pre-increment (++x): increment first, then use value
       Post-increment (x++): use value first, then increment
       Same applies to decrement operators
       ============================================ */

    int x = 5;  /* New variable for increment/decrement demo */

    printf("x++: %d\n", x++);  /* Post-increment: prints 5, then x becomes 6 */
    printf("++x: %d\n", ++x);  /* Pre-increment: x becomes 7, then prints 7 */
    printf("x--: %d\n", x--);  /* Post-decrement: prints 7, then x becomes 6 */
    printf("--x: %d\n", --x);  /* Pre-decrement: x becomes 5, then prints 5 */

    /* Program completed successfully */
    return 0;
}

#include <stdio.h>
int main() {
    int a=6, b=3;  /* a=0110, b=0011 in binary */

    /* Bitwise AND: both bits must be 1
       0110 & 0011 = 0010 = 2 */
    printf("AND: %d\n", a&b);   /* 2 */
    /* Bitwise OR: either bit = 1 → result bit = 1
       0110 | 0011 = 0111 = 7 */
    printf("OR:  %d\n", a|b);   /* 7 */
    /* Left shift = multiply by 2 per shift position */
    printf("SHL: %d\n", a<<1);  /* 12 (6×2) */
    /* Right shift = integer divide by 2 per position */
    printf("SHR: %d\n", a>>1);  /* 3  (6÷2) */

    /* TERNARY OPERATOR: condition ? value_if_true : value_if_false
       Most compact form of if-else
       (a > b) is true, so max = a */
    int max = (a>b) ? a : b;
    printf("Max: %d\n", max);  /* 6 */

    /* Nested ternary for grade (use sparingly — can be hard to read) */
    int marks = 75;
    char g = (marks>=90) ? 'A':
              (marks>=80) ? 'B':
              (marks>=70) ? 'C': 'F';
    printf("Grade: %c\n", g);   /* C */

    /* Practical bitwise: check if number is even/odd
       n & 1 → if last bit is 1 = odd, 0 = even */
    printf("6 is %s\n", (a&1)?"Odd":"Even");  /* Even */

    return 0;
}

/* =============================================
   Program : Complete Conditional Statements Guide
   Purpose : Demonstrate if, if-else, else-if, and nested if constructs
   Input   : None (uses hardcoded values)
   Output  : Results of various conditional executions
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() */

int main() {  /* Program entry point */

    /* VARIABLE DECLARATION:
       marks: student score (75 out of 100)
       age, hasID: variables for nested if demonstration */
    int marks = 75;
    int age=20, hasID=1;

    /* ============================================
       SIMPLE IF STATEMENT
       Syntax: if(condition) { statements; }
       Executes body ONLY if condition evaluates to true (non-zero)
       No else clause = does nothing if condition is false
       ============================================ */

    if(marks >= 50)
        printf("Passed!\n");  /* Executes because 75 >= 50 is true */

    /* ============================================
       IF-ELSE STATEMENT
       Syntax: if(condition) { true_statements; } else { false_statements; }
       Exactly ONE branch always executes - either if or else
       ============================================ */

    if(marks >= 50)
        printf("Pass\n");
    else
        printf("Fail\n");  /* This would execute if marks < 50 */

    /* ============================================
       ELSE-IF LADDER (MULTI-WAY BRANCHING)
       Syntax: if(cond1) {...} else if(cond2) {...} else if(cond3) {...} else {...}
       Tests conditions in sequence from top to bottom
       ONLY the FIRST true condition executes - rest are skipped
       Final else catches all remaining cases (optional)
       ============================================ */

    if     (marks >= 90) printf("Grade: A\n");
    else if(marks >= 80) printf("Grade: B\n");
    else if(marks >= 70) printf("Grade: C\n"); /* ← Executes (75 >= 70) */
    else if(marks >= 60) printf("Grade: D\n");
    else                 printf("Grade: F\n");

    /* ============================================
       NESTED IF STATEMENTS
       An if statement inside another if statement
       Both outer AND inner conditions must be true to reach deepest code
       Useful for multi-level decision making
       ============================================ */

    if(age >= 18) {         /* OUTER CONDITION: Check age eligibility */
        if(hasID == 1) {    /* INNER CONDITION: Check ID requirement */
            printf("Entry allowed\n");
        } else {
            printf("Bring ID card\n");
        }
    } else {
        printf("Too young\n");
    }

    /* Program completed successfully */
    return 0;
}

/* =============================================
   Program : Switch-Case Statement Demonstration
   Purpose : Show multi-way branching based on a single value
   Use when: Comparing the SAME variable against multiple constant values
   Works with: int, char (not float or string)
   Alternative to: Long if-else-if chains
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() */

int main() {  /* Program entry point */

    /* VARIABLE DECLARATIONS:
       day: integer representing day of week (1=Monday, 7=Sunday)
       op: character for calculator operation
       x, y: operands for calculator */
    int day = 3;
    char op='+'; int x=10, y=5;

    /* ============================================
       SWITCH STATEMENT SYNTAX AND FLOW
       switch(expression) {
           case constant1: statements; break;
           case constant2: statements; break;
           ...
           default: statements;  // optional
       }

       Flow: Expression evaluated once, then jumps to matching case
       Execution continues until break or end of switch
       ============================================ */

    /* SWITCH EXAMPLE 1: Day of week
       day=3, so execution jumps to case 3 */
    switch(day) {
        case 1: printf("Monday\n");    break; /* break exits switch immediately */
        case 2: printf("Tuesday\n");   break;
        case 3: printf("Wednesday\n"); break; /* ← This executes */
        case 4: printf("Thursday\n");  break;
        case 5: printf("Friday\n");    break;
        /* FALL-THROUGH: Multiple cases can share same code block */
        case 6:
        case 7: printf("Weekend!\n");  break;
        default: printf("Invalid!\n");  /* Runs if no case matches */
    }

    /* ============================================
       SWITCH EXAMPLE 2: Simple Calculator
       Demonstrates switch with char data type
       op='+', so case '+' executes: 10 + 5 = 15
       ============================================ */

    switch(op) {
        case '+': printf("%d\n",x+y); break;  /* Addition: 10 + 5 = 15 */
        case '-': printf("%d\n",x-y); break;  /* Subtraction: 10 - 5 = 5 */
        case '*': printf("%d\n",x*y); break;  /* Multiplication: 10 * 5 = 50 */
        case '/': printf("%d\n",x/y); break;  /* Division: 10 / 5 = 2 */
        default:  printf("Unknown\n");      /* Invalid operator */
    }

    /* Program completed successfully */
    return 0;
}

/* =============================================
   Program : Complete Loop Control Structures
   Purpose : Demonstrate for, while, and do-while loops
   Use when: Repeating code multiple times
   Key concepts: Initialization, condition, update, body
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() */

int main() {  /* Program entry point */

    /* ============================================
       FOR LOOP: Best when you know exact number of iterations
       Syntax: for(initialization; condition; update) { body; }
       Flow: 1. Initialize, 2. Check condition, 3. Execute body, 4. Update, repeat
       ============================================ */

    printf("for:      ");
    for(int i=1; i<=5; i++) {  /* i starts at 1, loops while i<=5, increments i */
        printf("%d ", i);       /* Body: print current value of i */
    } printf("\n");                   /* Output: 1 2 3 4 5 */

    /* ============================================
       WHILE LOOP: Best when number of iterations is unknown
       Syntax: while(condition) { body; update; }
       Flow: 1. Check condition, 2. If true execute body, 3. Repeat
       Condition checked BEFORE each iteration
       ============================================ */

    printf("while:    ");
    int j=1;                    /* Initialize outside loop */
    while(j<=5) {                /* Check condition first */
        printf("%d ", j);         /* Body: print current value */
        j++;                          /* Update: increment j */
    } printf("\n");                   /* Output: 1 2 3 4 5 */

    /* ============================================
       DO-WHILE LOOP: Executes body AT LEAST once
       Syntax: do { body; update; } while(condition);
       Flow: 1. Execute body, 2. Check condition, 3. If true repeat
       Condition checked AFTER each iteration
       ============================================ */

    printf("do-while: ");
    int k=1;                    /* Initialize */
    do {
        printf("%d ", k);         /* Body: always executes first */
        k++;                          /* Update */
    } while(k<=5);             /* Check condition after */
    printf("\n");                   /* Output: 1 2 3 4 5 */

    /* ============================================
       NESTED LOOPS: Loop inside another loop
       Outer loop controls rows, inner loop controls columns
       Total iterations = outer_iterations * inner_iterations
       ============================================ */

    printf("Multiplication Table (3×3):\n");
    for(int r=1; r<=3; r++) {     /* Outer loop: rows (1,2,3) */
        for(int c=1; c<=3; c++) {   /* Inner loop: columns (1,2,3) */
            printf("%3d", r*c);     /* Print product with 3-char field width */
        }
        printf("\n");                /* New line after each row */
    }

    /* Program completed successfully */
    return 0;
}

/* =============================================
   Program : Jump Statements in C
   Purpose : Demonstrate break, continue, goto, and return
   Use when: Need to alter normal control flow in loops/functions
   Key concepts: Loop control, function exit, unconditional jumps
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() */

int main() {  /* Program entry point */

    /* ============================================
       BREAK STATEMENT: Immediately exits the nearest loop or switch
       Execution resumes at the statement AFTER the loop/switch
       Useful for: Early exit from loops when condition is met
       ============================================ */

    printf("break:    ");
    for(int i=1; i<=10; i++) {  /* Loop from 1 to 10 */
        if(i==5) break;            /* Exit loop when i reaches 5 */
        printf("%d ", i);          /* Prints: 1 2 3 4 */
    } printf("\n");                       /* Loop exits here after break */

    /* ============================================
       CONTINUE STATEMENT: Skips the REST of current iteration
       Goes immediately to the loop's update/condition check
       Useful for: Skipping certain iterations based on conditions
       ============================================ */

    printf("continue: ");
    for(int i=1; i<=8; i++) {  /* Loop from 1 to 8 */
        if(i%2==0) continue;     /* Skip even numbers */
        printf("%d ", i);          /* Prints: 1 3 5 7 */
    } printf("\n");                       /* Even numbers are skipped */

    /* ============================================
       GOTO STATEMENT: Unconditionally jumps to a labeled statement
       AVOID in general code — makes logic hard to follow and debug
       One legitimate use: Error handling with cleanup code
       ============================================ */

    int n = -1;                          /* Negative input for demonstration */
    if(n < 0) goto error_label;      /* Jump to error handling */
    printf("This line is skipped\n");   /* Never executed */

    error_label:                           /* Label: identifier followed by colon */
        printf("Error: negative input!\n"); /* Error message */

    /* ============================================
       RETURN STATEMENT: Exits the current function immediately
       For main(): return 0 = success, non-zero = error code
       Can return a value that the caller receives
       ============================================ */

    return 0;  /* Exit main() with success code */
}

/* =============================================
   Program : Complete Function Guide in C
   Purpose : Demonstrate function declaration, definition, and calling
   Key concepts: Prototypes, parameters, return values, void functions
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() */

/* ============================================
   FUNCTION DECLARATIONS (Prototypes)
   Must appear BEFORE they are called
   Tells compiler: "this function exists — trust me"
   Syntax: return_type function_name(parameter_types);
   ============================================ */

int   add(int a, int b);              /* Returns int, takes two ints */
float average(int arr[], int n);        /* Returns float, takes array and size */
void  greet(char name[]);             /* Returns nothing (void), takes string */
int   square(int n);                  /* Returns int, takes one int */

int main() {  /* Program entry point */

    /* ============================================
       FUNCTION CALLS — values passed as arguments
       Arguments are COPIED to function parameters
       ============================================ */

    printf("5 + 3 = %d\n", add(5,3));         /* Calls add function, prints: 8 */
    printf("4^2 = %d\n",  square(4));        /* Calls square function, prints: 16 */
    greet("Alice");                             /* Calls greet function */

    int nums[] = {10,20,30,40};             /* Array of 4 integers */
    printf("Avg: %.1f\n", average(nums,4));     /* Calls average function, prints: 25.0 */

    return 0;  /* Exit main with success */
}

/* ============================================
   FUNCTION DEFINITIONS — actual implementation code
   Parameters 'a' and 'b' are LOCAL copies of arguments
   Changes to parameters here do NOT affect caller's variables
   ============================================ */

int add(int a, int b) {
    return a + b;  /* Return result to caller */
}

/* One-liner function — still valid C syntax */
int square(int n) { return n * n; }  /* Return n squared */

/* ============================================
   ARRAY PARAMETER: arr[] automatically becomes a pointer
   n is passed separately since arrays don't know their size
   ============================================ */

float average(int arr[], int n) {
    int sum = 0;                              /* Initialize sum to zero */
    for(int i=0; i<n; i++) sum += arr[i];   /* Add each element to sum */
    return (float)sum / n;                  /* Cast to float for decimal division */
}

/* ============================================
   VOID FUNCTION — performs work but returns nothing
   No return statement needed, or use bare "return;"
   ============================================ */

void greet(char name[]) {
    printf("Hello, %s!\n", name);         /* Print greeting message */
    /* No return statement needed for void functions */
}

/* =============================================
   Program : Recursion and Parameter Passing in C
   Purpose : Demonstrate recursive functions and call by value/reference
   Key concepts: Base cases, recursive calls, pointers, memory addresses
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() */

/* ============================================
   RECURSION: A function that calls itself
   Must have a BASE CASE to stop infinite recursion
   Each call progresses toward the base case
   Call stack builds up then unwinds with return values
   ============================================ */

/* FACTORIAL RECURSION: factorial(5) = 5 × 4 × 3 × 2 × 1 = 120
   Call stack: factorial(5) → factorial(4) → factorial(3) → factorial(2) → factorial(1) → factorial(0)
   Returns: 1 ← 1 ← 2 ← 6 ← 24 ← 120 */

int factorial(int n) {
    if(n <= 1) return 1;                     /* BASE CASE: factorial(0) = factorial(1) = 1 */
    return n * factorial(n-1);                /* RECURSIVE CALL: multiply by smaller factorial */
}

/* FIBONACCI RECURSION: fib(n) = fib(n-1) + fib(n-2)
   Sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...
   Base cases: fib(0) = 0, fib(1) = 1 */

int fib(int n) {
    if(n<=1) return n;                      /* BASE CASES: fib(0)=0, fib(1)=1 */
    return fib(n-1) + fib(n-2);          /* TWO recursive calls */
}

/* ============================================
   CALL BY VALUE — Default parameter passing in C
   Function receives a COPY of the argument
   Changes to parameter inside function do NOT affect original variable
   ============================================ */

void doubleVal(int x) {
    x *= 2;                                       /* Only modifies the LOCAL copy */
    printf("Inside doubleVal: %d\n", x);     /* Prints doubled value */
}

/* ============================================
   CALL BY REFERENCE — Using pointers
   Function receives the MEMORY ADDRESS of the argument
   Changes through pointer DIRECTLY affect the original variable
   Use & (address-of) operator when calling, * (dereference) inside function
   ============================================ */

void doubleRef(int *x) {
    *x *= 2;                                  /* *x dereferences pointer = changes original value */
    printf("Inside doubleRef: %d\n", *x);  /* Prints doubled original value */
}

int main() {  /* Program entry point */

    /* RECURSION DEMONSTRATION */
    printf("5! = %d\n", factorial(5));             /* 120 */
    printf("fib(8) = %d\n", fib(8));           /* 21 */

    /* CALL BY VALUE DEMONSTRATION */
    int a=10;                                      /* Original value: 10 */
    doubleVal(a);                                 /* Pass by value */
    printf("After doubleVal: %d\n", a);        /* Still 10! Original unchanged */

    /* CALL BY REFERENCE DEMONSTRATION */
    int b=10;                                      /* Original value: 10 */
    doubleRef(&b);                              /* Pass ADDRESS of b using & operator */
    printf("After doubleRef: %d\n", b);       /* Now 20! Original was modified */

    return 0;  /* Exit with success */
}

/* =============================================
   Program : Complete Arrays Guide in C
   Purpose : Demonstrate 1D and 2D arrays with operations
   Key concepts: Declaration, initialization, indexing, traversal
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() */

int main() {  /* Program entry point */

    /* ============================================
       1D ARRAY — Linear sequence of elements
       Declaration: type name[size] = {values};
       Index starts at 0, ends at size-1
       ============================================ */

    int marks[5] = {85,92,78,95,88};  /* Array of 5 integers */

    /* ACCESS ELEMENTS: Use index [0..n-1] */
    printf("First: %d\n", marks[0]);           /* 85 - first element */
    printf("Last:  %d\n", marks[4]);           /* 88 - last element */

    /* TRAVERSE WITH LOOP: Process all elements */
    int sum=0;                                      /* Initialize sum to zero */
    for(int i=0; i<5; i++) sum+=marks[i];       /* Add each element to sum */
    printf("Average: %.1f\n", (float)sum/5);   /* Cast to float for decimal division */

    /* FIND MAXIMUM VALUE: Linear search algorithm */
    int max=marks[0];                              /* Start with first element */
    for(int i=1; i<5; i++)                     /* Check remaining elements */
        if(marks[i]>max) max=marks[i];           /* Update max if larger found */
    printf("Max: %d\n", max);                   /* 95 */

    /* ============================================
       2D ARRAY — Table/matrix of elements
       Declaration: type name[rows][cols] = {{row0}, {row1}, ...};
       Stored in row-major order: matrix[row][col]
       ============================================ */

    int mat[3][3] = {                              /* 3x3 matrix */
        {1,2,3},                                  /* Row 0 */
        {4,5,6},                                  /* Row 1 */
        {7,8,9}                                   /* Row 2 */
    };

    /* PRINT 2D ARRAY: Nested loops for rows and columns */
    printf("Matrix:\n");
    for(int r=0; r<3; r++) {                     /* Outer loop: rows */
        for(int c=0; c<3; c++)                 /* Inner loop: columns */
            printf("%3d", mat[r][c]);                /* Print element with 3-char width */
        printf("\n");                                /* New line after each row */
    }

    /* MATRIX TRANSPOSE: Swap mat[i][j] with mat[j][i] */
    printf("Transpose:\n");
    for(int r=0; r<3; r++) {                     /* Outer loop: rows */
        for(int c=0; c<3; c++)                 /* Inner loop: columns */
            printf("%3d", mat[c][r]);            /* Note: c,r swapped for transpose */
        printf("\n");                                /* New line after each row */
    }

    return 0;  /* Exit with success */
}

/* =============================================
   Program : Arrays with Functions in C
   Purpose : Demonstrate passing arrays to functions and processing them
   Key concepts: Array parameters, pointer decay, in-place modifications
   ============================================= */

#include <stdio.h>  /* Standard I/O library for printf() */

/* ============================================
   ARRAY PARAMETERS: Arrays are passed as pointers automatically
   Syntax: return_type function_name(type arr[], int size)
   Changes to array elements WILL affect the caller's original array
   ============================================ */

/* FIND MAXIMUM VALUE: Linear search through array */
int findMax(int arr[], int n) {                    /* arr[] decays to int* pointer */
    int max=arr[0];                                  /* Start with first element */
    for(int i=1; i<n; i++)                         /* Check remaining elements */
        if(arr[i]>max) max=arr[i];               /* Update max if larger found */
    return max;                                       /* Return maximum value */
}

/* REVERSE ARRAY IN-PLACE: Two-pointer technique */
void reverse(int arr[], int n) {                   /* void = no return value */
    int lo=0, hi=n-1;                            /* Initialize pointers at ends */
    while(lo<hi) {                                 /* While pointers haven't crossed */
        int tmp=arr[lo]; arr[lo]=arr[hi]; arr[hi]=tmp; /* Swap elements */
        lo++; hi--;                                  /* Move pointers toward center */
    }
}

/* LINEAR SEARCH: Find index of target value */
int search(int arr[], int n, int target) {         /* Returns index or -1 if not found */
    for(int i=0; i<n; i++)                     /* Check each element */
        if(arr[i]==target) return i;                  /* Return index if found */
    return -1;                                          /* -1 = not found convention */
}

int main() {  /* Program entry point */

    int nums[]={3,7,1,9,4,6}, sz=6;           /* Array and its size */

    /* CALL FUNCTIONS WITH ARRAY */
    printf("Max: %d\n", findMax(nums,sz));              /* 9 - maximum value */

    int idx=search(nums,sz,9);                      /* Search for value 9 */
    printf("9 found at index: %d\n", idx);           /* 3 - index of 9 */

    reverse(nums,sz);                              /* Reverse array in-place */
    printf("Reversed: ");
    for(int i=0; i<sz; i++) printf("%d ",nums[i]); /* Print reversed array: 6 4 9 1 7 3 */

    return 0;  /* Exit with success */
}

/* =============================================
   Program : Complete String Functions Guide in C
   Purpose : Demonstrate string operations and functions from <string.h>
   Key concepts: Null-terminated arrays, string functions, character processing
   ============================================= */

#include <stdio.h>   /* Standard I/O library for printf(), fgets() */
#include <string.h>  /* String functions: strlen, strcpy, strcat, strcmp, etc. */
#include <ctype.h>   /* Character functions: toupper, tolower, isdigit, etc. */

int main() {  /* Program entry point */

    /* ============================================
       STRING DECLARATIONS: Arrays of characters ending with '\0'
       "Hello" stores: H e l l o \0 (6 bytes total)
       Always declare with enough space for the null terminator!
       ============================================ */

    char s1[20] = "Hello";         /* Fixed size, initialized */
    char s2[] = "World";           /* Size auto-calculated = 6 */
    char s3[50];                     /* Empty — holds user input */

    /* ============================================
       STRING INPUT METHODS
       scanf("%s") — reads until whitespace (single word only)
       fgets() — reads full line including spaces (safer, recommended)
       ============================================ */

    printf("Enter your name: ");
    fgets(s3, sizeof(s3), stdin);      /* Reads up to 49 chars + \n */

    /* ============================================
       STRING FUNCTIONS from <string.h>
       All functions work with null-terminated strings
       ============================================ */

    /* strlen — Count characters (NOT counting \0) */
    printf("Length of '%s': %zu\n", s1, strlen(s1));  /* 5 characters */

    /* strcpy — Copy source string INTO destination
       Destination must be large enough to hold source + \0 */
    char dest[20];                          /* Destination buffer */
    strcpy(dest, s1);                    /* dest now = "Hello" */

    /* strcat — Append source TO END of destination
       Destination must have enough space for combined strings */
    strcat(s1, " World");               /* s1 = "Hello World" */
    printf("%s\n", s1);                 /* Print concatenated result */

    /* strcmp — Compare two strings LEXICOGRAPHICALLY
       Returns: 0 if equal, <0 if s1<s2, >0 if s1>s2 */
    int r=strcmp("apple","apple");       /* Compare identical strings */
    printf("strcmp equal: %d\n", r);     /* 0 = equal */

    /* strchr — Find first occurrence of character in string
       Returns pointer to that position, or NULL if not found */
    char *p=strchr("Hello",'l');         /* Find first 'l' */
    printf("Found 'l' at: %s\n", p);    /* "llo" (pointer to 'l') */

    /* strstr — Find first occurrence of substring */
    char *q=strstr("Hello World","World"); /* Find "World" */
    printf("Substring: %s\n", q);      /* "World" */

    /* strtok — Split string by delimiters (tokenize)
       First call: pass the string. Subsequent calls: pass NULL */
    char csv[] = "Alice,Bob,Charlie";         /* Comma-separated values */
    char *tok=strtok(csv,",");               /* First token: "Alice" */
    while(tok!=NULL) {                      /* While tokens remain */
        printf("Token: %s\n", tok);       /* Print current token */
        tok=strtok(NULL,",");            /* Next token */
    }

    /* ============================================
       CHARACTER PROCESSING from <ctype.h>
       toupper/tolower — convert single char case
       To convert whole string, loop through each character
       ============================================ */

    char word[]="hello";                     /* String to convert */
    for(int i=0; word[i]; i++)             /* Loop until null terminator */
        word[i]=toupper(word[i]);           /* Convert each char to uppercase */
    printf("Uppercase: %s\n", word);    /* "HELLO" */

    return 0;  /* Exit with success */
}

#include <stdio.h>
int main() {

    int var = 10;          /* regular variable stored somewhere */
    int *ptr;              /* pointer: * means "pointer to int" */

    /* & = address-of operator: gives the ADDRESS of variable */
    ptr = &var;            /* ptr now HOLDS the address of var */

    printf("var   = %d\n",  var);   /* 10 (the value) */
    printf("&var  = %p\n",  &var);  /* 0x...  (address) */
    printf("ptr   = %p\n",  ptr);   /* same address as &var */

    /* * = dereference operator: "go to that address and get value" */
    printf("*ptr  = %d\n", *ptr);   /* 10 = value at address */

    /* Change value THROUGH the pointer */
    *ptr = 99;   /* This changes var! Both ptr and &var point there */
    printf("var after *ptr=99: %d\n", var);  /* 99 */

    /* POINTER ARITHMETIC — moving through memory
       ptr + 1 moves forward by sizeof(int) = 4 bytes */
    int arr[]={10,20,30,40};
    int *p=arr;   /* p points to arr[0] */

    printf("%d\n", *p);       /* 10 = arr[0] */
    printf("%d\n", *(p+1));  /* 20 = arr[1] (moved 4 bytes) */
    printf("%d\n", *(p+2));  /* 30 = arr[2] */
    p++;  /* now p points to arr[1] */
    printf("%d\n", *p);       /* 20 */

    /* DOUBLE POINTER — pointer to a pointer (**pp)
       pp → ptr → var
       pp holds address of ptr, ptr holds address of var */
    int x=42;
    int  *ptr1=&x;       /* ptr1 points to x */
    int **ptr2=&ptr1;    /* ptr2 points to ptr1 */
    printf("x via **ptr2: %d\n", **ptr2);  /* 42 */

    /* NULL pointer — pointer that points to nothing
       ALWAYS initialize pointers! Uninitialized = DANGER */
    int *np=NULL;
    if(np==NULL) printf("Null pointer is safe!\n");

    return 0;
}

#include <stdio.h>

/* Swap two integers using pointers — classic pointer function
   Without pointers, original values would NOT be swapped */
void swap(int *a, int *b) {
    int tmp=*a;  /* save value at a's address */
    *a=*b;       /* write b's value to a's address */
    *b=tmp;      /* write saved value to b's address */
}

/* Functions for function pointer example */
int add(int x, int y) { return x+y; }
int mul(int x, int y) { return x*y; }

int main() {

    /* Array name IS a pointer to first element
       arr, &arr[0], and p all hold same address */
    int arr[]={5,10,15};
    int *p=arr;
    /* These three are EQUIVALENT ways to access arr[1]: */
    printf("%d %d %d\n", arr[1], *(p+1), p[1]);  /* all print 10 */

    /* Using pointer to iterate over array */
    for(int *q=arr; q<arr+3; q++)
        printf("%d ", *q);  /* 5 10 15 */
    printf("\n");

    /* Swap using pointers */
    int x=100, y=200;
    swap(&x,&y);  /* pass ADDRESSES — & required */
    printf("After swap: x=%d y=%d\n", x, y);  /* x=200 y=100 */

    /* FUNCTION POINTER — stores address of a function
       Declaration: return_type (*fp_name)(param_types)
       Enables runtime selection of which function to call */
    int (*fp)(int,int);  /* fp can point to any int(int,int) func */

    fp=add;  /* point to add function */
    printf("add via fp: %d\n", fp(3,4));  /* 7 */

    fp=mul;  /* now point to mul function */
    printf("mul via fp: %d\n", fp(3,4));  /* 12 */

    /* Pointer to string */
    char *str="Hello";  /* str points to string literal */
    while(*str) printf("%c", *str++);  /* print char by char */
    printf("\n");

    return 0;
}

#include <stdio.h>
#include <string.h>

/* Define a structure blueprint for Student
   This does NOT allocate memory — just defines the template */
struct Student {
    char  name[50];   /* 50 bytes for name string */
    int   roll;        /* 4 bytes for roll number */
    float marks;       /* 4 bytes for marks */
    char  grade;       /* 1 byte for grade character */
};  /* semicolon required after struct definition! */

/* typedef creates an ALIAS — write "Student" instead of "struct Student" */
typedef struct Student Student;

int main() {
    /* Create struct variable and initialize at once */
    Student s1 = {"Alice", 101, 92.5f, 'A'};

    /* Access members using DOT operator ( . ) */
    printf("Name:  %s\n",  s1.name);
    printf("Roll:  %d\n",  s1.roll);
    printf("Marks: %.1f\n",s1.marks);
    printf("Grade: %c\n",  s1.grade);

    /* Modify struct members after creation */
    s1.marks = 95.0f;
    strcpy(s1.name, "Bob");  /* use strcpy for string members */

    /* ARRAY OF STRUCTS — store multiple records */
    Student cls[3] = {
        {"Alice",1,90,'A'},
        {"Bob",  2,75,'B'},
        {"Carol",3,60,'C'}
    };
    for(int i=0; i<3; i++)
        printf("%s: %.0f\n", cls[i].name, cls[i].marks);

    /* POINTER TO STRUCT — use ARROW operator ( -> )
       Instead of (*ptr).member, use ptr->member */
    Student *sp = &cls[0];
    printf("Via ptr: %s\n", sp->name);   /* -> is shorthand for (*sp).name */
    sp++;  /* move pointer to next struct in array */
    printf("Next:    %s\n", sp->name);

    /* NESTED STRUCTS — struct inside struct */
    struct Date { int day, month, year; };
    struct Employee {
        char       name[40];
        float      salary;
        struct Date doj;   /* Date of Joining nested inside */
    };
    struct Employee emp = {"Dave", 50000, {15,6,2020}};
    printf("Joined: %d/%d/%d\n", emp.doj.day, emp.doj.month, emp.doj.year);

    return 0;
}

#include <stdio.h>

/* UNION — members SHARE same memory location
   sizeof(Data) = 8 (largest member: double)
   Useful to save memory when only one value needed at a time */
union Data {
    int    i;    /* 4 bytes */
    float  f;    /* 4 bytes */
    double d;    /* 8 bytes → determines union size */
};

/* ENUM — enumeration of named integer constants
   Makes code readable: use "Mon" instead of "0" */
enum Day {
    Mon=1, Tue, Wed, Thu, Fri,  /* Mon=1, Tue=2, ... Fri=5 */
    Sat=10, Sun                  /* Sat=10, Sun=11 */
};

/* ENUM for status codes — very common pattern */
enum Status { PENDING=0, APPROVED=1, REJECTED=2 };

/* TYPEDEF — create shorter/cleaner alias for types */
typedef unsigned long long ull;   /* ull instead of ull */
typedef int bool;                  /* simulate bool */
#define true  1
#define false 0

int main() {
    /* Using union */
    union Data d;
    d.i = 42;                         /* store int */
    printf("d.i = %d\n", d.i);        /* 42 */

    d.f = 3.14f;                      /* OVERWRITES int — they share memory */
    printf("d.f = %.2f\n", d.f);      /* 3.14 */
    printf("d.i now = %d\n", d.i);    /* GARBAGE — int was overwritten */

    /* Using enum */
    enum Day today = Wed;
    printf("Wednesday = %d\n", today); /* 3 */
    printf("Saturday  = %d\n", Sat);   /* 10 */

    if(today == Wed)
        printf("Midweek!\n");

    /* Enum in switch — very clean pattern */
    enum Status s = APPROVED;
    switch(s) {
        case PENDING:  printf("Waiting\n");  break;
        case APPROVED: printf("Approved!\n"); break;
        case REJECTED: printf("Rejected.\n"); break;
    }

    /* typedef usage */
    ull big = 9999999999ULL;
    printf("Big: %llu\n", big);

    bool flag = true;
    printf("Flag: %d\n", flag);  /* 1 */

    return 0;
}

#include <stdio.h>

int main() {
    /* FILE* is a pointer to the file structure
       fopen() returns NULL on failure — ALWAYS check! */
    FILE *fp;

    /* WRITE to text file */
    fp = fopen("data.txt", "w");
    if(fp == NULL) {
        printf("Error: cannot open file!\n");
        return 1;  /* exit with error code */
    }
    fprintf(fp, "Hello, File!\n");      /* like printf but to file */
    fprintf(fp, "Number: %d\n", 42);
    fprintf(fp, "Float:  %.2f\n", 3.14);
    fclose(fp);  /* ALWAYS close! Flushes buffer to disk */

    /* READ from text file — line by line using fgets */
    fp = fopen("data.txt", "r");
    if(fp == NULL) { printf("File not found!\n"); return 1; }

    char line[100];
    printf("File contents:\n");
    while(fgets(line, sizeof(line), fp) != NULL)
        printf("%s", line);  /* fgets includes \n already */
    fclose(fp);

    /* APPEND mode — adds to END without deleting existing */
    fp = fopen("data.txt", "a");
    fprintf(fp, "Appended line!\n");
    fclose(fp);

    /* READ character by character using fgetc */
    fp = fopen("data.txt", "r");
    int ch;
    while((ch = fgetc(fp)) != EOF) {  /* EOF = End Of File marker */
        putchar(ch);  /* print each character */
    }
    fclose(fp);

    /* fscanf — read formatted data from file */
    fp = fopen("data.txt", "r");
    char word[20]; int num;
    fscanf(fp, "%s %s %d", word, word, &num);  /* read word by word */
    fclose(fp);

    return 0;
}

#include <stdio.h>

struct Record {
    int   id;
    char  name[30];
    float salary;
};

int main() {
    struct Record emp = {1, "Alice", 50000.0f};
    FILE *fp;

    /* fwrite — write raw binary bytes to file
       Syntax: fwrite(data_ptr, size_of_one_item, count, file)
       Faster than fprintf, stores exact bytes */
    fp = fopen("records.bin", "wb");
    fwrite(&emp, sizeof(struct Record), 1, fp);
    fclose(fp);

    /* fread — read binary data back
       Syntax: fread(dest_ptr, size_of_one_item, count, file)
       Returns number of items actually read */
    struct Record r2;
    fp = fopen("records.bin", "rb");
    int items = fread(&r2, sizeof(struct Record), 1, fp);
    fclose(fp);

    if(items==1)
        printf("ID:%d Name:%s Sal:%.0f\n", r2.id, r2.name, r2.salary);

    /* fseek — move file position pointer
       SEEK_SET = from start, SEEK_CUR = from current, SEEK_END = from end */
    fp = fopen("records.bin", "rb");
    fseek(fp, 0, SEEK_END);     /* jump to end of file */
    long sz = ftell(fp);         /* current position = file size */
    printf("File size: %ld bytes\n", sz);
    rewind(fp);                    /* go back to beginning */
    fclose(fp);

    /* remove() — delete a file */
    if(remove("records.bin") == 0)
        printf("File deleted!\n");

    /* rename() — rename a file */
    rename("data.txt", "output.txt");

    return 0;
}

#include <stdio.h>
#include <stdlib.h>  /* malloc, calloc, realloc, free */

int main() {
    int n=5;

    /* malloc — allocate n integers on the HEAP
       Returns void* (generic pointer) — must cast to correct type
       Does NOT initialize memory (contains garbage!) */
    int *a = (int*) malloc(n * sizeof(int));

    /* ALWAYS check if allocation succeeded! */
    if(a == NULL) {
        printf("malloc failed — not enough memory!\n");
        return 1;
    }
    /* Use it like a regular array */
    for(int i=0; i<n; i++) a[i] = (i+1)*10;
    for(int i=0; i<n; i++) printf("%d ", a[i]); /* 10 20 30 40 50 */
    printf("\n");

    /* calloc — allocate AND zero-initialize
       calloc(count, size_each) — safer than malloc */
    int *b = (int*) calloc(n, sizeof(int));
    if(b==NULL) { free(a); return 1; }
    for(int i=0; i<n; i++) printf("%d ", b[i]); /* 0 0 0 0 0 */
    printf("\n");

    /* realloc — resize existing allocation
       If new size is larger, old data is preserved
       May return a DIFFERENT pointer — reassign always! */
    int *c = (int*) realloc(a, 8 * sizeof(int));  /* grow to 8 ints */
    if(c==NULL) { free(a); free(b); return 1; }
    a = c;  /* update pointer — old 'a' may be invalid now */
    a[5]=60; a[6]=70; a[7]=80;  /* fill new slots */

    /* free — MUST free heap memory when done
       Not freeing = MEMORY LEAK (memory wasted forever)
       Never access memory after freeing! */
    free(a);  /* free first allocation */
    free(b);  /* free second allocation */
    a = NULL; b = NULL;  /* set to NULL after freeing — good habit */

    /* Dynamic array of structs */
    int cnt=3;
    struct { char name[20]; int age; } *people;
    people = malloc(cnt * sizeof(*people));
    if(people) {
        for(int i=0; i<cnt; i++)
            printf("Person %d age slot ready\n", i);
        free(people);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

/* Memory zones in a C program:
   ┌─────────────────┐
   │   Code Segment  │ ← compiled instructions
   ├─────────────────┤
   │  Data Segment   │ ← global & static vars
   ├─────────────────┤
   │      Heap       │ ← malloc/calloc (grows ↑)
   │        ↑        │
   │        ↓        │
   │      Stack      │ ← local vars (grows ↓)
   └─────────────────┘ */

int globalVar = 100;  /* Data Segment */

int main() {
    int local = 10;         /* STACK — auto freed at } */
    int *heap = malloc(4); /* HEAP  — must free manually */

    printf("Stack addr: %p\n", &local);
    printf("Heap  addr: %p\n",  heap);

    /* MEMORY LEAK — bad! heap never freed */
    /* heap = malloc(100);  ← if you forget free(heap) below */

    /* DANGLING POINTER — bad! access after free */
    free(heap);
    heap = NULL;  /* good practice — prevents dangling ptr */
    /* *heap = 5;  ← CRASH! Never use after free */

    return 0;
}

/* PREPROCESSOR DIRECTIVES — lines starting with #
   Processed BEFORE compilation by the preprocessor */

/* #include — insert header file content */
#include <stdio.h>    /* system header — search system path */
#include "myfile.h"   /* user header — search current directory first */

/* #define — create constants and macros */
#define PI       3.14159          /* simple constant */
#define MAX      100
#define SQ(x)   ((x)*(x))         /* function-like macro */
#define MAX2(a,b) ((a)>(b)?(a):(b)) /* max macro */
#define STR     "Hello Macro"    /* string constant */

/* #undef — remove a previously defined macro */
#undef MAX
#define MAX 200   /* redefine with new value */

/* #ifdef / #ifndef — conditional compilation
   Include code only if macro IS or IS NOT defined */
#define DEBUG   /* define DEBUG flag */

#ifdef DEBUG
    #define LOG(msg) printf("[DBG] %s\n", msg)
#else
    #define LOG(msg)   /* empty — no logging in release */
#endif

/* #if / #elif / #else — numeric condition check */
#define VERSION 2
#if VERSION == 1
    #define FEATURE "Basic"
#elif VERSION == 2
    #define FEATURE "Advanced"
#else
    #define FEATURE "Unknown"
#endif

/* #pragma — compiler-specific instructions */
#pragma once       /* include guard — prevent double inclusion */
#pragma warning(disable:4996)  /* suppress specific warnings */

/* Predefined macros — always available */
/* __FILE__ = "filename.c"    (current file name) */
/* __LINE__ = 42              (current line number) */
/* __DATE__ = "Jan 01 2024"   (compilation date) */
/* __TIME__ = "12:00:00"      (compilation time) */
/* __STDC__ = 1               (standard C?) */

int main() {
    printf("SQ(5) = %d\n", SQ(5));         /* 25 */
    printf("MAX2(3,7) = %d\n", MAX2(3,7)); /* 7 */
    LOG("Program started");                 /* [DBG] Program started */
    printf("Feature: %s\n", FEATURE);       /* Advanced */
    printf("File: %s Line: %d\n", __FILE__, __LINE__);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>  /* for atoi() */

/* argc = number of arguments (including program name)
   argv = array of argument strings
   Run as: ./program 10 20 30 */
int main(int argc, char *argv[]) {

    printf("Number of arguments: %d\n", argc);
    printf("Program name: %s\n", argv[0]);  /* always program name */

    /* Print all arguments */
    for(int i=1; i<argc; i++)
        printf("argv[%d] = %s\n", i, argv[i]);

    /* Convert string arg to integer using atoi() */
    if(argc >= 3) {
        int a=atoi(argv[1]), b=atoi(argv[2]);
        printf("%d + %d = %d\n", a, b, a+b);
    } else {
        printf("Usage: %s num1 num2\n", argv[0]);
    }
    return 0;
}

#include <stdio.h>

/* EXTERN — global variable shared across files
   Define it here, declare it in other files with 'extern int g;' */
int g = 100;  /* global — implicitly extern */

void countCalls() {
    /* STATIC local — survives between function calls
       Initialized ONCE to 0, then keeps its value */
    static int count = 0;
    count++;
    printf("Called %d time(s)\n", count);
}

void regularLocal() {
    /* AUTO local — destroyed and recreated each call
       Always starts fresh at 0 */
    auto int x = 0;  /* auto is the default, keyword rarely needed */
    x++;
    printf("x = %d\n", x);  /* always prints 1 */
}

int main() {
    /* static function — counts calls */
    countCalls();  /* Called 1 time(s) */
    countCalls();  /* Called 2 time(s) */
    countCalls();  /* Called 3 time(s) */

    regularLocal();  /* x = 1 */
    regularLocal();  /* x = 1 (always!) */

    /* REGISTER — hint for CPU register storage
       Best for loop counters accessed very frequently */
    register int i;
    int sum=0;
    for(i=0; i<1000000; i++) sum+=i;  /* i in register = faster */
    printf("Sum: %d\n", sum);

    /* static global in one file:
       In another .c file: extern int g; — to USE it
       In header .h: extern int g; — to DECLARE it */
    printf("Global g: %d\n", g);

    return 0;
}

#include <stdio.h>
#include <errno.h>   /* errno — global error number */
#include <string.h>  /* strerror() */
#include <math.h>    /* sqrt, log etc. */

/* BIT FIELDS — specify exact number of bits for each member
   Saves memory when you only need a few bits per field
   Total size here: 1+3+4 = 8 bits = 1 byte (vs 12 bytes normally) */
struct Flags {
    unsigned int active   : 1;  /* 1 bit  — 0 or 1 only */
    unsigned int priority : 3;  /* 3 bits — 0 to 7 */
    unsigned int type     : 4;  /* 4 bits — 0 to 15 */
};

int main() {

    /* Using bit fields */
    struct Flags f;
    f.active   = 1;   /* set active flag */
    f.priority = 5;   /* priority level 5 (0-7) */
    f.type     = 3;   /* type code 3 (0-15) */

    printf("active=%d priority=%d type=%d\n",
           f.active, f.priority, f.type);
    printf("Size of Flags struct: %zu bytes\n", sizeof(f));

    /* ERROR HANDLING — errno and perror()
       errno is a global integer set by failed system calls
       perror() prints errno as a human-readable message */
    FILE *fp = fopen("nonexistent.txt", "r");
    if(fp == NULL) {
        printf("errno = %d\n", errno);            /* 2 = ENOENT */
        perror("fopen failed");                    /* human message */
        printf("Error: %s\n", strerror(errno));   /* get string */
    }

    /* Math errors — check errno after math functions */
    errno = 0;  /* reset before calling */
    double result = sqrt(-1.0);  /* invalid: sqrt of negative */
    if(errno != 0)
        perror("sqrt error");
    else
        printf("sqrt(-1) = %f\n", result);

    /* EXIT codes — return meaningful values from main() */
    /* EXIT_SUCCESS (0) = success, EXIT_FAILURE (1) = error */
    return EXIT_SUCCESS;  /* same as return 0; */
}

#include <stdio.h>
#define PI 3.14159

int main() {
    float radius, area;
    printf("Enter radius: ");
    scanf("%f", &radius);
    area = PI * radius * radius;
    printf("Area = %.2f\n", area);
    return 0;
}

#include <stdio.h>

int main() {
    float celsius, fahrenheit;
    printf("Enter temperature in Celsius: ");
    scanf("%f", &celsius);
    fahrenheit = (celsius * 9/5) + 32;
    printf("%.2f°C = %.2f°F\n", celsius, fahrenheit);
    return 0;
}

#include <stdio.h>

int main() {
    int a, b, temp;
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    printf("Before swap: a=%d, b=%d\n", a, b);
    temp = a;
    a = b;
    b = temp;
    printf("After swap: a=%d, b=%d\n", a, b);
    return 0;
}

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int n = 5, key, i, found = 0;
    
    printf("Enter number to search: ");
    scanf("%d", &key);
    
    for(i = 0; i < n; i++) {
        if(arr[i] == key) {
            printf("Found at position %d\n", i + 1);
            found = 1;
            break;
        }
    }
    if(!found) printf("Not found\n");
    return 0;
}

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int n = 5, key, low = 0, high = n - 1, mid;
    
    printf("Enter number to search: ");
    scanf("%d", &key);
    
    while(low <= high) {
        mid = (low + high) / 2;
        if(arr[mid] == key) {
            printf("Found at position %d\n", mid + 1);
            return 0;
        } else if(arr[mid] < key) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    printf("Not found\n");
    return 0;
}

#include <stdio.h>

int main() {
    int arr[] = {12, 45, 23, 67, 89, 34};
    int n = 6, i, max, min;
    
    max = min = arr[0];
    
    for(i = 1; i < n; i++) {
        if(arr[i] > max) max = arr[i];
        if(arr[i] < min) min = arr[i];
    }
    
    printf("Maximum: %d\nMinimum: %d\n", max, min);
    return 0;
}

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int n = 5, i, sum = 0;
    float average;
    
    for(i = 0; i < n; i++) {
        sum += arr[i];
    }
    
    average = (float)sum / n;
    printf("Sum: %d\nAverage: %.2f\n", sum, average);
    return 0;
}

#include <stdio.h>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = 5, i, temp;
    
    printf("Original: ");
    for(i = 0; i < n; i++) printf("%d ", arr[i]);
    
    for(i = 0; i < n/2; i++) {
        temp = arr[i];
        arr[i] = arr[n-i-1];
        arr[n-i-1] = temp;
    }
    
    printf("\nReversed: ");
    for(i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>

int main() {
    int arr[] = {64, 34, 25, 12, 22};
    int n = 5, i, j, temp;
    
    for(i = 0; i < n-1; i++) {
        for(j = 0; j < n-i-1; j++) {
            if(arr[j] > arr[j+1]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    
    printf("Sorted array: ");
    for(i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>

int main() {
    char str[100];
    int length = 0;
    
    printf("Enter a string: ");
    scanf("%s", str);
    
    while(str[length] != '\0') {
        length++;
    }
    
    printf("Length: %d\n", length);
    return 0;
}

#include <stdio.h>
#include <string.h>

int main() {
    char str[100], temp;
    int i, len;
    
    printf("Enter a string: ");
    scanf("%s", str);
    
    len = strlen(str);
    
    for(i = 0; i < len/2; i++) {
        temp = str[i];
        str[i] = str[len-i-1];
        str[len-i-1] = temp;
    }
    
    printf("Reversed: %s\n", str);
    return 0;
}

#include <stdio.h>
#include <string.h>

int main() {
    char str[100];
    int i, len, isPalindrome = 1;
    
    printf("Enter a string: ");
    scanf("%s", str);
    
    len = strlen(str);
    
    for(i = 0; i < len/2; i++) {
        if(str[i] != str[len-i-1]) {
            isPalindrome = 0;
            break;
        }
    }
    
    if(isPalindrome)
        printf("%s is a palindrome\n", str);
    else
        printf("%s is not a palindrome\n", str);
    
    return 0;
}

#include <stdio.h>

int main() {
    int n, i, isPrime = 1;
    
    printf("Enter a number: ");
    scanf("%d", &n);
    
    if(n <= 1) isPrime = 0;
    
    for(i = 2; i * i <= n; i++) {
        if(n % i == 0) {
            isPrime = 0;
            break;
        }
    }
    
    if(isPrime)
        printf("%d is prime\n", n);
    else
        printf("%d is not prime\n", n);
    
    return 0;
}

#include <stdio.h>

int main() {
    int a, b, x, y, gcd, lcm;
    
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    
    x = a;
    y = b;
    
    while(y != 0) {
        int temp = y;
        y = x % y;
        x = temp;
    }
    
    gcd = x;
    lcm = (a * b) / gcd;
    
    printf("GCD: %d\nLCM: %d\n", gcd, lcm);
    return 0;
}

#include <stdio.h>

long long factorial(int n) {
    if(n == 0 || n == 1)
        return 1;
    else
        return n * factorial(n - 1);
}

int main() {
    int n;
    printf("Enter n: ");
    scanf("%d", &n);
    printf("%d! = %lld\n", n, factorial(n));
    return 0;
}

#include <stdio.h>

int main() {
    int n, i, j;
    printf("Enter n: ");
    scanf("%d", &n);
    
    for(i = 1; i <= n; i++) {
        for(j = 1; j <= n - i; j++) printf(" ");
        for(j = 1; j <= 2 * i - 1; j++) printf("*");
        printf("\n");
    }
    return 0;
}

#include <stdio.h>

int main() {
    int n, i, j;
    printf("Enter n: ");
    scanf("%d", &n);
    
    for(i = 1; i <= n; i++) {
        for(j = 1; j <= i; j++) {
            printf("%d ", j);
        }
        printf("\n");
    }
    return 0;
}

#include <stdio.h>

int main() {
    int n, i, j;
    printf("Enter n: ");
    scanf("%d", &n);
    
    // Upper half
    for(i = 1; i <= n; i++) {
        for(j = 1; j <= n - i; j++) printf(" ");
        for(j = 1; j <= 2 * i - 1; j++) printf("*");
        printf("\n");
    }
    
    // Lower half
    for(i = n - 1; i >= 1; i--) {
        for(j = 1; j <= n - i; j++) printf(" ");
        for(j = 1; j <= 2 * i - 1; j++) printf("*");
        printf("\n");
    }
    return 0;
}

#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;
    
    for(i = 0; i < 2; i++) {
        for(j = 0; j < 2; j++) {
            c[i][j] = a[i][j] + b[i][j];
        }
    }
    
    printf("Result:\n");
    for(i = 0; i < 2; i++) {
        for(j = 0; j < 2; j++) {
            printf("%d ", c[i][j]);
        }
        printf("\n");
    }
    return 0;
}

#include <stdio.h>

int main() {
    int a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    int t[3][3], i, j;
    
    for(i = 0; i < 3; i++) {
        for(j = 0; j < 3; j++) {
            t[j][i] = a[i][j];
        }
    }
    
    printf("Transpose:\n");
    for(i = 0; i < 3; i++) {
        for(j = 0; j < 3; j++) {
            printf("%d ", t[i][j]);
        }
        printf("\n");
    }
    return 0;
}

#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] = {0}, i, j, k;
    
    for(i = 0; i < 2; i++) {
        for(j = 0; j < 2; j++) {
            for(k = 0; k < 2; k++) {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    
    printf("Product:\n");
    for(i = 0; i < 2; i++) {
        for(j = 0; j < 2; j++) {
            printf("%d ", c[i][j]);
        }
        printf("\n");
    }
    return 0;
}

#include <stdio.h>

int main() {
    FILE *fp;
    char text[100];
    
    fp = fopen("sample.txt", "w");
    if(fp == NULL) {
        printf("Error opening file\n");
        return 1;
    }
    
    printf("Enter text to write: ");
    fgets(text, 100, stdin);
    fprintf(fp, "%s", text);
    
    fclose(fp);
    printf("Text written to file\n");
    return 0;
}

#include <stdio.h>

int main() {
    FILE *fp;
    char ch;
    
    fp = fopen("sample.txt", "r");
    if(fp == NULL) {
        printf("File not found\n");
        return 1;
    }
    
    printf("File contents:\n");
    while((ch = fgetc(fp)) != EOF) {
        printf("%c", ch);
    }
    
    fclose(fp);
    return 0;
}

#include <stdio.h>
#include <ctype.h>

int main() {
    FILE *fp;
    char ch;
    int words = 0, lines = 0, chars = 0, inWord = 0;
    
    fp = fopen("sample.txt", "r");
    if(fp == NULL) {
        printf("File not found\n");
        return 1;
    }
    
    while((ch = fgetc(fp)) != EOF) {
        chars++;
        if(ch == '\n') lines++;
        if(isspace(ch)) {
            inWord = 0;
        } else if(inWord == 0) {
            inWord = 1;
            words++;
        }
    }
    
    printf("Characters: %d\nWords: %d\nLines: %d\n", chars, words, lines);
    fclose(fp);
    return 0;
}

#include <stdio.h>
#include <string.h>

struct Student {
    char name[50];
    int roll;
    float marks;
};

int main() {
    struct Student s[3];
    int i;
    
    for(i = 0; i < 3; i++) {
        printf("Enter name, roll, marks for student %d: ", i+1);
        scanf("%s %d %f", s[i].name, &s[i].roll, &s[i].marks);
    }
    
    printf("\nStudent Records:\n");
    for(i = 0; i < 3; i++) {
        printf("Name: %s, Roll: %d, Marks: %.2f\n", 
               s[i].name, s[i].roll, s[i].marks);
    }
    return 0;
}

#include <stdio.h>
#include <string.h>

typedef struct {
    char name[50];
    int id;
    float salary;
    char department[20];
} Employee;

int main() {
    Employee emp;
    
    printf("Enter employee details:\n");
    printf("Name: ");
    scanf("%s", emp.name);
    printf("ID: ");
    scanf("%d", &emp.id);
    printf("Salary: ");
    scanf("%f", &emp.salary);
    printf("Department: ");
    scanf("%s", emp.department);
    
    printf("\nEmployee Information:\n");
    printf("Name: %s\nID: %d\nSalary: %.2f\nDepartment: %s\n",
           emp.name, emp.id, emp.salary, emp.department);
    
    return 0;
}

#include <stdio.h>
#include <string.h>

typedef struct {
    char title[100];
    char author[50];
    int year;
    float price;
} Book;

int main() {
    Book books[2] = {
        {"C Programming", "Dennis Ritchie", 1978, 29.99},
        {"Data Structures", "Robert Kruse", 1987, 39.99}
    };
    
    int i;
    printf("Library Books:\n");
    for(i = 0; i < 2; i++) {
        printf("Title: %s\nAuthor: %s\nYear: %d\nPrice: $%.2f\n\n",
               books[i].title, books[i].author, 
               books[i].year, books[i].price);
    }
    return 0;
}

#include <stdio.h>

int fibonacci(int n) {
    if(n == 0) return 0;
    if(n == 1) return 1;
    return fibonacci(n-1) + fibonacci(n-2);
}

int main() {
    int n, i;
    printf("Enter n: ");
    scanf("%d", &n);
    
    printf("Fibonacci series: ");
    for(i = 0; i < n; i++) {
        printf("%d ", fibonacci(i));
    }
    printf("\n");
    return 0;
}

#include <stdio.h>

int sumDigits(int n) {
    if(n == 0) return 0;
    return (n % 10) + sumDigits(n / 10);
}

int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
    printf("Sum of digits: %d\n", sumDigits(num));
    return 0;
}

#include <stdio.h>

void towerOfHanoi(int n, char from, char to, char aux) {
    if(n == 1) {
        printf("Move disk 1 from %c to %c\n", from, to);
        return;
    }
    towerOfHanoi(n-1, from, aux, to);
    printf("Move disk %d from %c to %c\n", n, from, to);
    towerOfHanoi(n-1, aux, to, from);
}

int main() {
    int n;
    printf("Enter number of disks: ");
    scanf("%d", &n);
    printf("Solution:\n");
    towerOfHanoi(n, 'A', 'C', 'B');
    return 0;
}

#include <stdio.h>

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int n = 5, i, j, min_idx, temp;
    
    for(i = 0; i < n-1; i++) {
        min_idx = i;
        for(j = i+1; j < n; j++) {
            if(arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
    
    printf("Sorted array: ");
    for(i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>

int main() {
    int decimal, binary[32], i = 0;
    
    printf("Enter decimal number: ");
    scanf("%d", &decimal);
    
    if(decimal == 0) {
        printf("Binary: 0\n");
        return 0;
    }
    
    while(decimal > 0) {
        binary[i] = decimal % 2;
        decimal = decimal / 2;
        i++;
    }
    
    printf("Binary: ");
    for(i = i-1; i >= 0; i--) {
        printf("%d", binary[i]);
    }
    printf("\n");
    return 0;
}

#include <stdio.h>

int main() {
    int arr1[] = {1, 3, 5, 7};
    int arr2[] = {2, 4, 6, 8};
    int n1 = 4, n2 = 4, merged[8];
    int i = 0, j = 0, k = 0;
    
    while(i < n1 && j < n2) {
        if(arr1[i] < arr2[j]) {
            merged[k++] = arr1[i++];
        } else {
            merged[k++] = arr2[j++];
        }
    }
    
    while(i < n1) merged[k++] = arr1[i++];
    while(j < n2) merged[k++] = arr2[j++];
    
    printf("Merged array: ");
    for(i = 0; i < n1+n2; i++) printf("%d ", merged[i]);
    printf("\n");
    return 0;
}