1
2
3
4
5
6

#include <stdio.h>

int main(void) {
    printf("Hello, World!\n");
    return 0;
}

1
2

$ gcc hello.c -o hello
$ ./hello

1
2

hello.c  ->  preprocess(.i)  ->  compile(.s)  ->  assemble(.o)  ->  link(executable)
           expand #include   generate assembly   generate machine code    merge library functions

1
2
3
4

$ gcc -E hello.c -o hello.i    // preprocess only
$ gcc -S hello.c -o hello.s    // compile only, generate assembly
$ gcc -c hello.c -o hello.o    // assemble only, generate object file
$ gcc hello.o -o hello         // link to produce executable

1
2
3
4

-Wall        // enable all warnings (recommended)
-g           // generate debug info (for use with gdb)
-O2          // optimization level 2
-std=c99     // specify the C standard

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdio.h>

int main(void) {
    int age = 25;           // integer
    char grade = 'A';       // single character
    float pi = 3.14f;       // single-precision float
    double e = 2.71828;     // double-precision float

    printf("age=%d, grade=%c, pi=%.2f, e=%.5f\n",
           age, grade, pi, e);
    return 0;
}

1
2
3
4
5
6

int    -> 4 bytes  (-2^31 ~ 2^31-1)
char   -> 1 byte   (-128 ~ 127)
float  -> 4 bytes  (~6-7 significant digits)
double -> 8 bytes  (~15-16 significant digits)
long   -> 8 bytes
short  -> 2 bytes

1
2
3

printf("int: %zu bytes\n", sizeof(int));
printf("char: %zu bytes\n", sizeof(char));
printf("double: %zu bytes\n", sizeof(double));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <stdio.h>
int main(void) {
    int n = 42;
    double f = 3.14159;
    char c = 'X';
    char *s = "hack";

    printf("int:   %d\n", n);      // 42
    printf("float: %.2f\n", f);    // 3.14 (2 decimal places)
    printf("char:  %c\n", c);      // X
    printf("str:   %s\n", s);      // hack
    printf("hex:   %x\n", n);      // 2a (hexadecimal)
    printf("oct:   %o\n", n);      // 52 (octal)
    printf("pad:   %05d\n", n);    // 00042 (zero-padded)
    printf("left:  %-5d|\n", n);   // 42   | (left-aligned)
    return 0;
}

1
2
3
4
5
6

%[flags][width][.precision]type

flags:    - (left-align), 0 (zero-pad), + (show plus sign)
width:    minimum field width
precision: number of decimals (float) or max characters (string)
type:     d(integer) f(float) c(char) s(string) x(hex) %(percent sign itself)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <stdio.h>
int main(void) {
    int age;
    double score;
    char name[20];

    printf("Enter age: ");
    scanf("%d", &age);

    printf("Enter score: ");
    scanf("%lf", &score);

    printf("Enter name: ");
    scanf("%s", name);  // an array name is already an address, no & needed

    printf("Hello %s, %d years old, score %.1f\n", name, age, score);
    return 0;
}

1
2
3
4
5

int n = scanf("%d %d", &a, &b);
// n == 2 means two values were read successfully
// n == 1 means only one was read
// n == 0 means input did not match
// n == EOF means end of input (Ctrl+D)

1
2
3
4
5
6
7
8

int a = 17, b = 5;
printf("%d\n", a + b);   // 22  plus
printf("%d\n", a - b);   // 12  minus
printf("%d\n", a * b);   // 85  times
printf("%d\n", a / b);   // 3   integer division (truncates the fraction)
printf("%d\n", a % b);   // 2   remainder
printf("%d\n", a++);     // 17  postfix ++ (return first, then increment)
printf("%d\n", ++a);     // 19  prefix ++ (increment first, then return)

1
2
3
4
5
6
7

int x = 5;
x > 3 && x < 10   // true -> 1
x < 3 || x > 10   // false -> 0
!x                // false -> 0 (x is nonzero)

// In C: 0 means false, nonzero means true
// Result of relational ops: 1(true) or 0(false)

1
2
3
4
5
6
7
8
9
10

high -> low:
()  []  ->  .           // parentheses / member access
!  ~  ++  --  (type)    // unary
*  /  %                 // multiply/divide/modulus
+  -                    // add/subtract
<  <=  >  >=           // relational
==  !=                  // equality
&&                      // logical AND
||                      // logical OR
=  +=  -=  *=  /=      // assignment

1
2
3
4
5
6
7
8
9
10
11

int i = 10;
double d = 3.14;

// int + double -> automatically promoted to double
double result = i + d;
printf("%.2f\n", result);  // 13.14

// int / int -> integer division (loses the fraction)
int a = 7, b = 2;
double bad = a / b;       // 3.0 instead of 3.5!
printf("%.1f\n", bad);    // 3.0

1
2
3
4
5
6
7
8
9
10
11
12
13

int a = 7, b = 2;

// cast first, then divide
double good = (double)a / b;
printf("%.2f\n", good);  // 3.50

// equivalent form
double good2 = a / (double)b;
printf("%.2f\n", good2); // 3.50

// cast only a, b is promoted automatically
double good3 = 1.0 * a / b;
printf("%.2f\n", good3); // 3.50

1
2
3
4
5
6
7
8

char -> short -> int -> long -> float -> double

// during arithmetic, lower precision is automatically promoted to higher
// no precision is lost

// high -> low (requires an explicit cast, may lose data):
double pi = 3.14159;
int truncated = (int)pi;  // 3, the fractional part is discarded

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// single-line comment — introduced in C99

/*
 * multi-line comment
 * good for large explanations
 */

int main(void) {
    // TODO: implement the encryption feature
    int key = 42; // secret key value
    /* old code backup
    int old_key = 0;
    */
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

// ✅ good naming
int student_count;
int maxRetries;
double cpu_temperature;

// ❌ bad naming
int x, y, z;       // unclear meaning
int a1, a2, a3;    // meaningless
int data;          // which data?

// C naming style: snake_case (lowercase + underscores)
// constants may be all caps: MAX_BUFFER_SIZE
// type names capitalized first letter: typedef struct Student Student;

1
2
3
4
5
6
7

// always add these when compiling with gcc:
$ gcc -Wall -Wextra -std=c99 -g hello.c -o hello

// -Wall   : common warnings
// -Wextra : extra warnings
// -std=c99: use the C99 standard
// -g      : debug info

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <stdio.h>
int main(void) {
    char c = 'A';
    printf("char: %c\n", c);    // A
    printf("ASCII: %d\n", c);    // 65

    // char is essentially a small integer
    char next = c + 1;
    printf("next: %c (%d)\n", next, next);  // B (66)

    // case conversion
    char lower = c + 32;  // 'a' - 'A' = 32
    printf("lower: %c\n", lower);  // a
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11

'0' = 48    '9' = 57
'A' = 65    'Z' = 90
'a' = 97    'z' = 122
'\n' = 10   '\t' = 9
'\0' = 0    ' ' = 32

// check digit: c >= '0' && c <= '9'
// check uppercase: c >= 'A' && c <= 'Z'
// check lowercase: c >= 'a' && c <= 'z'
// uppercase to lowercase: c + ('a' - 'A')  i.e. c + 32
// lowercase to uppercase: c - ('a' - 'A')  i.e. c - 32

1
2
3
4
5

\n   newline       \t   tab
\0   null char     \\   backslash
\'   single quote  \"   double quote
\r   carriage return \b backspace
\x41 hex A        \101 octal A

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <stdio.h>
int main(void) {
    double a, b;
    char op;

    printf("Enter an expression (e.g. 3 + 5): ");
    scanf("%lf %c %lf", &a, &op, &b);

    double result;
    switch(op) {
        case '+': result = a + b; break;
        case '-': result = a - b; break;
        case '*': result = a * b; break;
        case '/':
            if (b == 0) {
                printf("Error: the divisor cannot be 0\n");
                return 1;
            }
            result = a / b;
            break;
        default:
            printf("Unsupported operator: %c\n", op);
            return 1;
    }
    printf("= %.2f\n", result);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

    if (score >= 90) {
        printf("Excellent!\n");
    } else if (score >= 60) {
        printf("Pass\n");
    } else {
        printf("Fail\n");
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// comparison operators: == != < > <= >=
// logical operators: &&(AND) ||(OR) !(NOT)

int age = 20;
char gender = 'M';

if (age >= 18 && gender == 'M') {
    printf("adult male\n");
}

// short-circuit evaluation
if (age > 0 && 100 / age > 5) {
    // if age <= 0, 100/age is not executed
    // avoiding: division by zero
    printf("ok\n");
}

1
2
3
4
5
6
7
8

int a = 10, b = 20;
int max = (a > b) ? a : b;
printf("max = %d\n", max);  // 20

// equivalent to:
int max2;
if (a > b) max2 = a;
else max2 = b;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <stdio.h>
int main(void) {
    int day;
    printf("Enter weekday (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:
        case 7: printf("Weekend!\n"); break;  // merges cases
        default: printf("Invalid input\n");
    }
    return 0;
}

1
2
3
4
5
6
7
8
9

int x = 2;
switch(x) {
    case 1: printf("one\n");
    case 2: printf("two\n");  // matched here
    case 3: printf("three\n");  // no break, keeps running!
    case 4: printf("four\n");  // keeps running!
    default: printf("default\n");
}
// output: two three four default

1
2
3
4
5
6

// switch can only compare equality (==)
// switch only works with integral and char types
// if-else can use any condition

// multiple equality checks -> switch is clearer
// range checks (score >= 90) -> use if-else

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
int main(void) {
    int i = 1;
    while (i <= 5) {
        printf("%d ", i);
        i++;  // don't forget to update the condition variable!
    }
    printf("\n");
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// countdown
int n = 5;
while (n > 0) {
    printf("%d... ", n);
    n--;
}
printf("Launch!\n");
// output: 5... 4... 3... 2... 1... Launch!

// sum from 1 to 100
int sum = 0, k = 1;
while (k <= 100) {
    sum += k;
    k++;
}
printf("sum = %d\n", sum);  // 5050

1
2
3
4
5
6
7
8
9
10

// classic infinite loop (terminate with Ctrl+C)
while (1) {
    printf("forever...\n");
}

// equivalent form
while (1) {  // always true
    // must break out from inside
    if (someCondition) break;
}

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
int main(void) {
    // for (init; condition; update)
    for (int i = 0; i < 5; i++) {
        printf("%d ", i);
    }
    printf("\n");
    // output: 0 1 2 3 4
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// omit the init
int i = 0;
for (; i < 5; i++) { ... }

// omit the condition -> infinite loop
for (int i = 0;; i++) {
    if (i >= 5) break;
}

// omit the update
for (int i = 0; i < 5;) {
    printf("%d ", i);
    i += 2;  // manual update
}
// output: 0 2 4

// omit everything = infinite loop
for (;;) { ... }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// reverse order
for (int i = 10; i > 0; i--) {
    printf("%d ", i);
}
// 10 9 8 7 6 5 4 3 2 1

// step size
for (int i = 0; i <= 20; i += 5) {
    printf("%d ", i);
}
// 0 5 10 15 20

// nested loops
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        printf("%d%d ", i, j);
    }
    printf("\n");
}

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main(void) {
    int n;
    do {
        printf("Enter a positive number: ");
        scanf("%d", &n);
    } while (n <= 0);  // the semicolon cannot be omitted!

    printf("You entered: %d\n", n);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

// while: check before executing (may not run at all)
int i = 10;
while (i < 5) {
    printf("%d ", i);  // never executes
    i++;
}

// do-while: execute then check (runs at least once)
int j = 10;
do {
    printf("%d ", j);  // prints 10
    j++;
} while (j < 5);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int choice;
do {
    printf("\n=== Menu ===\n");
    printf("1. Start game\n");
    printf("2. Settings\n");
    printf("3. Exit\n");
    printf("Choose: ");
    scanf("%d", &choice);

    switch(choice) {
        case 1: printf("Game started!\n"); break;
        case 2: printf("Settings...\n"); break;
        case 3: printf("Goodbye!\n"); break;
        default: printf("Invalid choice\n");
    }
} while (choice != 3);

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdio.h>
int main(void) {
    // find the first number divisible by 7
    for (int i = 1; i <= 100; i++) {
        if (i % 7 == 0) {
            printf("Found: %d\n", i);
            break;  // immediately break out of the for loop
        }
    }
    // output: Found: 7
    return 0;
}

1
2
3
4
5
6
7
8
9

// print the odd numbers from 1-10
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;  // skip even numbers
    }
    printf("%d ", i);
}
printf("\n");
// output: 1 3 5 7 9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 1) break;  // only breaks the inner for
        printf("%d%d ", i, j);
    }
}
// output: 00 10 20
// break only affects the inner loop, the outer continues

// want to break out of multiple levels? use goto or a flag variable
int found = 0;
for (int i = 0; i < 3 && !found; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) { found = 1; break; }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
int main(void) {
    int i = 0;

loop:  // label
    printf("%d ", i);
    i++;
    if (i < 5) goto loop;

    printf("\n");
    return 0;
}
// output: 0 1 2 3 4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

int process_file(const char *path) {
    FILE *f = fopen(path, "r");
    if (!f) goto err_open;

    char *buf = malloc(1024);
    if (!buf) goto err_malloc;

    if (fread(buf, 1, 1024, f) < 0) goto err_read;

    // ... process data ...

    free(buf);
    fclose(f);
    return 0;  // success

err_read:
    free(buf);
err_malloc:
    fclose(f);
err_open:
    return -1; // failure
}

1
2
3
4
5
6
7
8
9
10
11

for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
        for (int k = 0; k < 100; k++) {
            if (found_target(i, j, k)) {
                goto done;  // break out of three levels at once
            }
        }
    }
}
done:
printf("Target found!\n");

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
int main(void) {
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            printf("%dx%d=%-2d  ", j, i, i * j);
        }
        printf("\n");
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// right triangle
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= i; j++) {
        printf("* ");
    }
    printf("\n");
}
// *
// * *
// * * *
// * * * *
// * * * * *

// pyramid
int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 0; j < n - i; j++) printf(" ");
    for (int j = 0; j < 2*i - 1; j++) printf("*");
    printf("\n");
}

1
2
3
4
5
6
7
8
9
10
11
12

// print the prime numbers within 100
for (int n = 2; n <= 100; n++) {
    int is_prime = 1;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            is_prime = 0;
            break;
        }
    }
    if (is_prime) printf("%d ", n);
}
// 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdio.h>
#include <stdlib.h>  // rand(), srand()
#include <time.h>    // time()

int main(void) {
    srand(time(NULL));  // use time as the seed
    int target = rand() % 100 + 1;  // random number 1~100

    int guess, tries = 0;
    do {
        printf("Guess a number from 1-100: ");
        scanf("%d", &guess);
        tries++;

        if (guess > target)
            printf("Too high!\n");
        else if (guess < target)
            printf("Too low!\n");
        else
            printf("Congratulations! Guessed it in %d tries!\n", tries);
    } while (guess != target);

    return 0;
}

1
2
3
4
5
6
7
8
9
10

// rand() returns 0 ~ RAND_MAX (usually 2147483647)
// no seed -> same result every run
srand(42);  // fixed seed -> reproducible
srand(time(NULL));  // time seed -> different each run

// generate in the [1, 100] range:
int n = rand() % 100 + 1;

// generate in the [min, max] range:
int n = rand() % (max - min + 1) + min;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// ===== conditionals =====
if (condition) { ... }
else if (condition) { ... }
else { ... }
switch(val) { case N: ...; break; default: ...; }
result = condition ? valueA : valueB;

// ===== loops =====
while (condition) { ... }       // check first, then execute
for (init; cond; update) { ... }  // counting loop
do { ... } while (condition);    // execute first, then check

// ===== flow control =====
break;       // break out of loop/switch
continue;    // skip this iteration
goto label;  // jump (use with care)
return val;  // exit the function

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// when to use what?

// when you know the number of iterations -> for
for (int i = 0; i < n; i++) { ... }

// unknown count, possibly 0 -> while
while (data readable) { process(data); }

// runs at least once -> do-while
do { get input } while (input invalid);

// many equality comparisons -> switch
switch(op) { case '+': ...; break; }

// range checks -> if-else
if (score >= 90) { ... }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>

// function definition: return type name(parameter list) { ... }
int add(int a, int b) {
    int sum = a + b;
    return sum;  // return the result
}

int main(void) {
    int result = add(3, 5);  // call the function
    printf("3 + 5 = %d\n", result);
    printf("10 + 20 = %d\n", add(10, 20));
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// no return value: void
void greet(const char *name) {
    printf("Hello, %s!\n", name);
    // no return is needed, you may also write return;
}

// no parameters: void
int get_answer(void) {
    return 42;
}

int main(void) {
    greet("hacker");
    printf("answer = %d\n", get_answer());
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <stdio.h>

void try_swap(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
    printf("inside function: a=%d, b=%d\n", a, b);
}

int main(void) {
    int x = 10, y = 20;
    try_swap(x, y);
    printf("outside function: x=%d, y=%d\n", x, y);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int main(void) {
    int x = 10, y = 20;
    swap(&x, &y);  // pass addresses
    printf("x=%d, y=%d\n", x, y);  // x=20, y=10
    return 0;
}

1
2
3
4
5
6
7

// these two forms are fully equivalent
void print_arr(int arr[], int n) { ... }
void print_arr(int *arr, int n) { ... }

// an array passed to a function decays into a pointer
// sizeof(arr) inside the function is the pointer size (8), not the array size!
// so you must additionally pass the length parameter n

1
2
3
4
5
6
7
8
9
10
11
12
13

// return immediately ends the function and returns a value
int max(int a, int b) {
    if (a > b) return a;
    return b;
    // the code below never executes
    printf("this line will never print\n");
}

// a void function uses return to exit early
void print_if_positive(int n) {
    if (n <= 0) return;  // early return
    printf("%d\n", n);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <stdio.h>

// return quotient and remainder at the same time
void divmod(int a, int b, int *quotient, int *remainder) {
    *quotient = a / b;
    *remainder = a % b;
}

int main(void) {
    int q, r;
    divmod(17, 5, &q, &r);
    printf("17 / 5 = %d remainder %d\n", q, r);
    // 17 / 5 = 3 remainder 2
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

typedef struct {
    int quotient;
    int remainder;
} DivResult;

DivResult divmod(int a, int b) {
    DivResult r;
    r.quotient = a / b;
    r.remainder = a % b;
    return r;
}

// usage:
DivResult r = divmod(17, 5);
printf("%d remainder %d\n", r.quotient, r.remainder);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.h>

// option 1: define before the call
int add(int a, int b) {
    return a + b;
}
int main(void) {
    printf("%d\n", add(3, 5));  // OK
    return 0;
}

// option 2: declare the prototype first, define it later
int add(int a, int b);  // function prototype (declaration)
int main(void) {
    printf("%d\n", add(3, 5));
    return 0;
}
int add(int a, int b) {  // definition
    return a + b;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// math_utils.h
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);
int max(int a, int b);
double average(int arr[], int n);

#endif

// math_utils.c
#include "math_utils.h"
int add(int a, int b) { return a + b; }
int max(int a, int b) { return a > b ? a : b; }
double average(int arr[], int n) { ... }

// main.c
#include "math_utils.h"  // include the declarations
int main(void) {
    printf("%d\n", add(3, 5));
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11

// ❌ dangerous: calling an undeclared function
int main(void) {
    printf("%d\n", my_func(3));  // the compiler assumes it returns int
    return 0;
}
// if my_func actually returns double or has different parameter types
// -> undefined behavior!

// ✅ correct: declare it first or include the header
// implicit declarations were removed in C99, this now errors
// always compile with gcc -Wall, it warns about undeclared functions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <stdio.h>

int global_var = 100;  // global variable: visible to the whole file

void func(int param) {  // param: function scope
    int local = 10;      // local variable: visible within the function
    printf("global=%d, param=%d, local=%d\n",
           global_var, param, local);
}

int main(void) {
    int local = 20;  // main's local variable
    func(5);
    // printf("%d", param);  // error! param not visible
    // printf("%d", local);  // this is main's local=20
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int main(void) {
    int x = 1;
    {
        int x = 2;  // inner x shadows outer x
        printf("%d\n", x);  // 2
        {
            int x = 3;
            printf("%d\n", x);  // 3
        }
        printf("%d\n", x);  // 2
    }
    printf("%d\n", x);  // 1
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// global variable: defined outside all functions
int counter = 0;  // global

void increment(void) {
    counter++;  // access the global variable directly
}

// ⚠ dangers of global variables:
// 1. any function can modify them, hard to track
// 2. not thread-safe
// 3. breaks modularity
// 4. naming conflicts

// ✅ better: pass by parameter
void increment(int *counter) {
    (*counter)++;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>

// factorial: n! = n * (n-1)!
// base case: 0! = 1
long factorial(int n) {
    if (n <= 1) return 1;     // base case
    return n * factorial(n-1); // recursive call
}

int main(void) {
    for (int i = 0; i <= 10; i++)
        printf("%d! = %ld\n", i, factorial(i));
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// fibonacci: F(n) = F(n-1) + F(n-2)
// F(0)=0, F(1)=1
int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2);
}
// call tree of fib(5):
//         fib(5)
//        /      \
//     fib(4)    fib(3)
//    /    \    /    \
// fib(3) fib(2) fib(2) fib(1)
//   ...
// exponential complexity! O(2^n)
// fib(40) is already very slow

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 1. base case: when to stop recursing
// 2. recursive step: move toward the base case
// 3. combine results: how to use the sub-problem solutions

// ❌ forgot the base case -> infinite recursion -> stack overflow
void bad(int n) {
    bad(n);  // this never stops!
}

// ❌ not moving toward the base case -> also stack overflow
void bad2(int n) {
    if (n == 0) return;
    bad2(n);  // n never changes, so never equals 0
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>

int counter(void) {
    static int count = 0;  // initialized only once!
    count++;
    return count;
}

int main(void) {
    printf("%d\n", counter());  // 1
    printf("%d\n", counter());  // 2
    printf("%d\n", counter());  // 3
    return 0;
}

1
2
3
4
5
6
7
8
9
10

// file1.c
static int internal_data = 42;  // visible only in file1.c!
static void helper(void) { ... }  // visible only in file1.c!

// file2.c
extern int internal_data;  // ❌ link error! static limits visibility
// internal_data is not accessible in file2.c

// static global variables/functions = private to the file
// similar to private in other languages

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// file1.c
int shared_var = 100;  // global variable definition

// file2.c
extern int shared_var;  // declaration: references the variable in file1.c
// no memory is allocated, just tells the compiler "it is defined elsewhere"

void use_it(void) {
    printf("%d\n", shared_var);  // 100
}

// better: declare it in a header
// shared.h: extern int shared_var;
// file1.c: #include "shared.h"; int shared_var = 100;
// file2.c: #include "shared.h";

1
2
3
4
5
6
7
8
9
10

myproject/
├── main.c          // main program
├── math_utils.h    // header (declarations)
├── math_utils.c    // implementation
├── string_utils.h
├── string_utils.c
└── Makefile

// compile:
$ gcc -Wall main.c math_utils.c string_utils.c -o myapp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// math_utils.h
#ifndef MATH_UTILS_H    // if not defined
#define MATH_UTILS_H    // then define it

int add(int a, int b);
int max(int a, int b);

#endif  // MATH_UTILS_H

// prevent duplicate inclusion:
// if two files both #include "math_utils.h"
// without the guard -> duplicate definition error
// with the guard -> the second #ifndef is false, it is skipped

// C23 adds #pragma once (more concise)
#pragma once
int add(int a, int b);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// ✅ what header files should contain:
// - function declarations (prototypes)
// - macro definitions (#define)
// - type definitions (typedef, struct)
// - extern variable declarations
// - inline functions

// ❌ what header files should not contain:
// - function definitions (implementations)  <- put in .c files
// - variable definitions        <- put in .c files
// - static variables/functions  <- meaningless

// exception: inline functions may go in headers
static inline int square(int x) {
    return x * x;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>

// function-like macro: textual substitution
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS(x) ((x) < 0 ? -(x) : (x))

int main(void) {
    printf("%d\n", SQUARE(5));   // 25
    printf("%d\n", MAX(3, 7));   // 7
    printf("%d\n", ABS(-42));    // 42
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// ❌ forgot the parentheses
#define BAD_SQUARE(x) x * x
int result = BAD_SQUARE(3 + 2);
// expands to: 3 + 2 * 3 + 2 = 3 + 6 + 2 = 11 (not 25!)

// ✅ correct: wrap each parameter and the whole thing in parentheses
#define GOOD_SQUARE(x) ((x) * (x))
// expands to: ((3 + 2) * (3 + 2)) = 25

// ❌ side-effect problem
#define BAD_MAX(a, b) ((a) > (b) ? (a) : (b))
int x = 5, y = 3;
int z = BAD_MAX(x++, y);
// x may be incremented twice!

1
2
3
4
5
6
7
8
9
10
11
12

// inline: suggests the compiler inline-expand it
// safer than a macro (has type checking), faster than a normal function (no call overhead)
static inline int square(int x) {
    return x * x;
}

int main(void) {
    int a = 5;
    printf("%d\n", square(a + 1));  // 36, safe!
    // square(a++) also has no side-effect problem
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <stdio.h>
#define ROWS 5
#define COLS 5

// 0=path, 1=wall
int maze[ROWS][COLS] = {
    {0,1,0,0,0},
    {0,1,0,1,0},
    {0,0,0,1,0},
    {1,1,1,1,0},
    {0,0,0,0,0}
};
int visited[ROWS][COLS] = {0};

// returns 1 if an exit is found
int solve(int r, int c) {
    // out of bounds / wall / already visited
    if (r<0||r>=ROWS||c<0||c>=COLS) return 0;
    if (maze[r][c]==1 || visited[r][c]) return 0;
    // reached the destination
    if (r==ROWS-1 && c==COLS-1) {
        visited[r][c] = 1;
        return 1;
    }
    visited[r][c] = 1;
    // try: down -> right -> up -> left
    if (solve(r+1,c)) return 1;
    if (solve(r,c+1)) return 1;
    if (solve(r-1,c)) return 1;
    if (solve(r,c-1)) return 1;
    visited[r][c] = 0;  // backtrack
    return 0;
}

int main(void) {
    if (solve(0, 0)) {
        printf("Path found!\n");
        for (int r=0;r<ROWS;r++){
            for(int c=0;c<COLS;c++)
                printf(visited[r][c]?"* ":"# ");
            printf("\n");
        }
    } else printf("No solution!\n");
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int backtrack(state) {
    if (goal reached) {
        record the solution;
        return 1;  // success
    }
    if (out of bounds || invalid) return 0;  // failure

    mark the current state as visited;
    for (each choice) {
        if (backtrack(new state)) return 1;  // recurse
    }
    undo the mark;  // backtrack
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>
int main(void) {
    // declaration
    int arr[5];  // 5 ints, uninitialized (garbage values)

    // declare and initialize
    int nums[] = {10, 20, 30, 40, 50};
    int scores[5] = {90, 85, 78};  // the last two become 0 automatically
    int zeros[100] = {0};  // all initialized to 0

    // C99: designated initializers
    int a[5] = {[2] = 30, [4] = 50};  // {0,0,30,0,50}

    // access
    printf("%d\n", nums[0]);   // 10 (index starts at 0)
    printf("%d\n", nums[4]);   // 50
    nums[2] = 99;  // modify
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int nums[] = {10, 20, 30, 40, 50};
int n = sizeof(nums) / sizeof(nums[0]);  // compute the element count!

// sum
int sum = 0;
for (int i = 0; i < n; i++) {
    sum += nums[i];
}
printf("sum = %d, avg = %.1f\n", sum, (double)sum / n);
// sum = 150, avg = 30.0

// find the maximum
int max = nums[0];
for (int i = 1; i < n; i++) {
    if (nums[i] > max) max = nums[i];
}
printf("max = %d\n", max);  // 50

1
2
3
4
5
6
7
8
9
10

int arr[4] = {10, 20, 30, 40};

// memory layout (contiguous):
// address: 0x100  0x104  0x108  0x10c
// content: [ 10  |  20  |  30  |  40 ]
// index:     [0]    [1]    [2]    [3]

// array name = address of the first element
printf("%p\n", arr);      // 0x100
printf("%p\n", &arr[0]);  // 0x100 (same!)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void reverse(int arr[], int n) {
    int left = 0, right = n - 1;
    while (left < right) {
        // swap
        int tmp = arr[left];
        arr[left] = arr[right];
        arr[right] = tmp;
        left++;
        right--;
    }
}

int main(void) {
    int a[] = {1, 2, 3, 4, 5};
    reverse(a, 5);
    // a = {5, 4, 3, 2, 1}
    for (int i = 0; i < 5; i++) printf("%d ", a[i]);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11

// rotate right by k: [1,2,3,4,5] k=2 -> [4,5,1,2,3]
void rotate(int arr[], int n, int k) {
    k = k % n;  // handle the k > n case
    // three-step reversal:
    // 1. reverse the whole array: [5,4,3,2,1]
    reverse(arr, n);
    // 2. reverse the first k: [4,5,3,2,1]
    reverse(arr, k);
    // 3. reverse the last n-k: [4,5,1,2,3]
    reverse(arr + k, n - k);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// returns the deduplicated length
int dedup(int arr[], int n) {
    if (n == 0) return 0;
    int write = 1;  // write position
    for (int read = 1; read < n; read++) {
        if (arr[read] != arr[read - 1]) {
            arr[write++] = arr[read];
        }
    }
    return write;  // new length
}

int a[] = {1,1,2,3,3,3,4,5,5};
int len = dedup(a, 9);  // len=5, a={1,2,3,4,5}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

int matrix[3][4];  // 3 rows, 4 columns

// initialization
int grid[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

// partial initialization (unspecified become 0)
int g[3][3] = {
    {1},
    {0, 2},
    {0, 0, 3}
};
// g = {{1,0,0}, {0,2,0}, {0,0,3}}

// all zeros
int zero[5][5] = {0};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

int grid[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
int rows = 3, cols = 3;

// print
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        printf("%d ", grid[i][j]);
    }
    printf("\n");
}

// sum of the main diagonal
int diag = 0;
for (int i = 0; i < rows; i++) {
    diag += grid[i][i];
}
printf("diagonal = %d\n", diag);  // 1+5+9=15

1
2
3
4
5
6
7
8
9
10
11

// transpose: swap rows and columns
void transpose(int m[][3], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int tmp = m[i][j];
            m[i][j] = m[j][i];
            m[j][i] = tmp;
        }
    }
}
// note: j starts from i+1, otherwise it would swap twice and restore the original!