#include <stdio.h>
 
int main() {
  printf("Hello, World!");
  return 0;
}

Classic first program. Entry point with main().

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

Basic I/O with scanf and printf.

#include <stdio.h>
 
int main() {
  int a, b, sum;
  scanf("%d %d", &a, &b);
  sum = a + b;
  printf("%d", sum);
}

Basic arithmetic operation.

#include <stdio.h>
 
int main() {
  int a = 10, b = 3;
  printf("%d", a - b);
}

Subtraction operation.

#include <stdio.h>
 
int main() {
  int a = 7, b = 8;
  printf("%d", a * b);
}

Multiplication operation.

#include <stdio.h>
 
int main() {
  int a = 20, b = 5;
  printf("%d", a / b);
}

Integer division.

#include <stdio.h>
 
int main() {
  int a = 17, b = 5;
  printf("%d", a % b);
}

Remainder operation.

#include <stdio.h>
 
int main() {
  float radius = 5.0;
  float area = 3.14 * radius * 
                radius;
  printf("%.2f", area);
}

π × r². Formula application.

#include <stdio.h>
 
int main() {
  float p = 1000, r = 5, t = 2;
  float si = (p * r * t) / 100;
  printf("%.2f", si);
}

SI = (P×R×T)/100

#include <stdio.h>
 
int main() {
  int x = 5;
  printf("%d %d", x++, ++x);
  return 0;
}

Post/Pre increment differences.

int isPalindrome(int n) {
  int rev = 0, temp = n;
  while(n != 0) {
    rev = rev * 10 + n % 10;
    n /= 10;
  }
  return (temp == rev);
}

O(log n) complexity.

int isPrime(int n) {
  if(n <= 1) return 0;
  if(n <= 3) return 1;
  if(n % 2 == 0 || 
      n % 3 == 0)
    return 0;
  for(int i = 5; 
      i * i <= n; i += 6)
    if(n % i == 0)
      return 0;
  return 1;
}

O(√n) with 6k±1 optimization.

long long factorial(
    int n) {
  long long result = 1;
  for(int i = 2; i <= n; i++)
    result *= i;
  return result;
}

O(n), avoids stack issues.

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

Classic recursion example.

int fib(int n) {
  if(n <= 1)
    return n;
  return fib(n-1) + 
         fib(n-2);
}

O(2^n), slow for large n.

void fibonacci(int n) {
  int a = 0, b = 1, c;
  printf("%d %d ", a, b);
  for(int i = 2; i < n; i++) {
    c = a + b;
    printf("%d ", c);
    a = b;
    b = c;
  }
}

O(n) time, O(1) space.

long long memo[100];
 
long long fib(int n) {
  if(n <= 1) return n;
  if(memo[n] != 0)
    return memo[n];
  memo[n] = fib(n-1) + 
            fib(n-2);
  return memo[n];
}

O(n) with memoization.

int gcd(int a, int b) {
  if(b == 0)
    return a;
  return gcd(b, a % b);
}

O(log min(a,b)).

int lcm(int a, int b) {
  int gcd_val = gcd(a, b);
  return (a * b) / gcd_val;
}
 
int gcd(int a, int b) {
  while(b) {
    int t = b;
    b = a % b;
    a = t;
  }
  return a;
}

Uses GCD formula.

long long power(
    long long x, 
    int y) {
  if(y == 0)
    return 1;
  long long res = 
    power(x, y/2);
  if(y % 2 == 0)
    return res * res;
  return x * res * res;
}

Binary exponentiation, O(log y).

int isArmstrong(int n) {
  int orig = n, sum = 0;
  while(n > 0) {
    int d = n % 10;
    sum += d * d * d;
    n /= 10;
  }
  return (sum == orig);
}

Sum of digit cubes.

int isPerfect(int n) {
  int sum = 0;
  for(int i = 1; i < n; i++)
    if(n % i == 0)
      sum += i;
  return (sum == n);
}

Sum of proper divisors.

int isHarshad(int n) {
  int sum = 0, temp = n;
  while(temp > 0) {
    sum += temp % 10;
    temp /= 10;
  }
  return (n % sum == 0);
}

Divisible by digit sum.

#include <stdio.h>
 
void checkEvenOdd(int n) {
  if(n % 2 == 0)
    printf("Even");
  else
    printf("Odd");
}

Modulo 2 check.

int countDigits(int n) {
  int count = 0;
  while(n != 0) {
    count++;
    n = n / 10;
  }
  return count;
}

O(log n).

int sumOfDigits(int n) {
  int sum = 0;
  while(n > 0) {
    sum += n % 10;
    n = n / 10;
  }
  return sum;
}

Sum all digits recursively.

int isLeapYear(int yr) {
  if((yr % 400 == 0) ||
     (yr % 4 == 0 && 
      yr % 100 != 0))
    return 1;
  return 0;
}

Divisibility rules.

int stringLength(
    char str[]) {
  int count = 0;
  while(str[count] != '\0')
    count++;
  return count;
}

Count until null terminator.

void reverseString(
    char str[]) {
  int n = strlen(str);
  for(int i = 0; i < n/2; 
      i++) {
    char t = str[i];
    str[i] = str[n-i-1];
    str[n-i-1] = t;
  }
}

O(n) time, O(1) space.

int isPalindrome(
    char str[]) {
  int n = strlen(str);
  for(int i = 0; 
      i < n/2; i++)
    if(str[i] != str[n-i-1])
      return 0;
  return 1;
}

Check string equality backward.

void concat(
    char dest[], 
    char src[]) {
  int i = strlen(dest);
  int j = 0;
  while(src[j] != '\0') {
    dest[i++] = src[j++];
  }
  dest[i] = '\0';
}

Manual string join.

int strCompare(
    char s1[], 
    char s2[]) {
  while(*s1 && *s1 == *s2) {
    s1++;
    s2++;
  }
  return *s1 - *s2;
}

Compare two strings.

int hasSubstring(
    char str[], 
    char sub[]) {
  int n = strlen(str);
  int m = strlen(sub);
  for(int i = 0; i <= n-m; i++) {
    int j;
    for(j = 0; j < m; j++)
      if(str[i+j] != sub[j])
        break;
    if(j == m) return i;
  }
  return -1;
}

Find substring index.

void toUppercase(
    char str[]) {
  for(int i = 0; 
      str[i] != '\0'; i++) {
    if(str[i] >= 'a' && 
        str[i] <= 'z')
      str[i] = str[i] - 32;
  }
}

ASCII manipulation.

void toLowercase(
    char str[]) {
  for(int i = 0; 
      str[i] != '\0'; i++) {
    if(str[i] >= 'A' && 
        str[i] <= 'Z')
      str[i] = str[i] + 32;
  }
}

Convert uppercase to lowercase.

void charFrequency(
    char str[]) {
  int freq[256] = {0};
  for(int i = 0; 
      str[i] != '\0'; i++)
    freq[str[i]]++;
  for(int i = 0; i < 256; i++)
    if(freq[i] > 0)
      printf("%c: %d\n", 
             i, freq[i]);
}

Count char occurrences.

void checkVowel(
    char ch) {
  ch = tolower(ch);
  if(ch == 'a' || 
     ch == 'e' ||
     ch == 'i' || 
     ch == 'o' ||
     ch == 'u')
    printf("Vowel");
}

5 vowels check.

int wordCount(
    char str[]) {
  int count = 0;
  for(int i = 0; 
      str[i] != '\0'; i++) {
    if(str[i] == ' ')
      count++;
  }
  return count + 1;
}

Count words via spaces.

int sumArray(
    int arr[], 
    int n) {
  int sum = 0;
  for(int i = 0; i < n; i++)
    sum += arr[i];
  return sum;
}

O(n).

double average(
    int arr[], 
    int n) {
  int sum = 0;
  for(int i = 0; i < n; i++)
    sum += arr[i];
  return 
    ((double)sum / n);
}

Average calculation.

int findMax(
    int arr[], 
    int n) {
  int max = arr[0];
  for(int i = 1; i < n; i++)
    if(arr[i] > max)
      max = arr[i];
  return max;
}

O(n).

int findMin(
    int arr[], 
    int n) {
  int min = arr[0];
  for(int i = 1; i < n; i++)
    if(arr[i] < min)
      min = arr[i];
  return min;
}

O(n).

void reverseArray(
    int arr[], 
    int n) {
  int start = 0, end = n-1;
  while(start < end) {
    int t = arr[start];
    arr[start] = arr[end];
    arr[end] = t;
    start++;
    end--;
  }
}

O(n) time, O(1) space.

void checkDuplicate(
    int arr[], 
    int n) {
  for(int i = 0; i < n; i++) {
    for(int j = i+1; j < n; j++) {
      if(arr[i] == arr[j]) {
        printf("%d dup\n",
               arr[i]);
      }
    }
  }
}

O(n²) brute force.

void copyArray(
    int src[], 
    int dest[], 
    int n) {
  for(int i = 0; i < n; i++)
    dest[i] = src[i];
}

Element-wise copy.

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

Using pointers.

void mergeArrays(
    int a[], int n1,
    int b[], int n2,
    int result[]) {
  for(int i = 0; i < n1; i++)
    result[i] = a[i];
  for(int i = 0; i < n2; i++)
    result[n1+i] = b[i];
}

O(n1 + n2).

int linearSearch(
    int arr[], 
    int n, 
    int key) {
  for(int i = 0; i < n; i++) {
    if(arr[i] == key)
      return i;
  }
  return -1;
}

O(n). Unsorted arrays.

int sum2DArray(
    int arr[][3], 
    int rows,
    int cols) {
  int sum = 0;
  for(int i = 0; i < rows; i++)
    for(int j = 0; j < cols; j++)
      sum += arr[i][j];
  return sum;
}

O(rows × cols).

void bubbleSort(
    int arr[], int n) {
  for(int i = 0; i < n-1; i++)
    for(int j = 0; 
        j < n-i-1; j++)
      if(arr[j] > arr[j+1]) {
        int t = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = t;
      }
}

O(n²). Educational.

void selectionSort(
    int arr[], 
    int n) {
  for(int i = 0; i < n-1; i++) {
    int min = i;
    for(int j = i+1; j < n; j++)
      if(arr[j] < arr[min])
        min = j;
    int t = arr[i];
    arr[i] = arr[min];
    arr[min] = t;
  }
}

O(n²) always.

void insertionSort(
    int arr[], 
    int n) {
  for(int i = 1; i < n; i++) {
    int key = arr[i];
    int j = i - 1;
    while(j >= 0 && 
          arr[j] > key) {
      arr[j+1] = arr[j];
      j--;
    }
    arr[j+1] = key;
  }
}

O(n²) worst, O(n) best.

int partition(int arr[], 
    int low, int high) {
  int pivot = arr[high];
  int i = low - 1;
  for(int j = low; j < high; j++)
    if(arr[j] < pivot) {
      i++;
      int t = arr[i];
      arr[i] = arr[j];
      arr[j] = t;
    }
  int t = arr[i+1];
  arr[i+1] = arr[high];
  arr[high] = t;
  return i + 1;
}

O(n log n) avg.

void merge(int arr[], 
    int l, int m, int r) {
  int n1 = m - l + 1;
  int n2 = r - m;
  int L[n1], R[n2];
  
  for(int i = 0; i < n1; i++)
    L[i] = arr[l + i];
  for(int j = 0; j < n2; j++)
    R[j] = arr[m + 1 + j];
  
  int i = 0, j = 0, k = l;
  while(i < n1 && j < n2)
    arr[k++] = (L[i] <= R[j]) ? 
               L[i++] : R[j++];
}

O(n log n) guaranteed.

void heapify(
    int arr[], int n, 
    int i) {
  int largest = i;
  int left = 2*i + 1;
  int right = 2*i + 2;
  
  if(left < n && 
     arr[left] > arr[largest])
    largest = left;
  if(right < n && 
     arr[right] > arr[largest])
    largest = right;
  if(largest != i) {
    int t = arr[i];
    arr[i] = arr[largest];
    arr[largest] = t;
    heapify(arr, n, largest);
  }
}

O(n log n) always.

void countingSort(
    int arr[], int n) {
  int max = arr[0];
  for(int i = 1; i < n; i++)
    if(arr[i] > max)
      max = arr[i];
  
  int count[max+1] = {0};
  for(int i = 0; i < n; i++)
    count[arr[i]]++;
  
  int idx = 0;
  for(int i = 0; i <= max; i++)
    while(count[i] > 0)
      arr[idx++] = i;
}

O(n + k).

int binarySearch(
    int arr[], 
    int n, 
    int target) {
  int left = 0, right = n-1;
  while(left <= right) {
    int mid = left + 
              (right - left) / 2;
    if(arr[mid] == target)
      return mid;
    else if(arr[mid] < target)
      left = mid + 1;
    else
      right = mid - 1;
  }
  return -1;
}

O(log n). Sorted only.

int linearSearch(
    int arr[], 
    int n, 
    int key) {
  for(int i = 0; i < n; i++) {
    if(arr[i] == key)
      return i;
  }
  return -1;
}

O(n). Any array.

#include <math.h>
 
int jumpSearch(
    int arr[], 
    int n, 
    int x) {
  int step = sqrt(n);
  int prev = 0;
  while(arr[step-1] < x) {
    prev = step;
    step += sqrt(n);
    if(prev >= n) 
      return -1;
  }
  while(arr[prev] < x) {
    prev++;
    if(prev == step || 
        prev == n)
      return -1;
  }
  if(arr[prev] == x)
    return prev;
  return -1;
}

O(√n).

int interpolationSearch(
    int arr[], 
    int n, 
    int x) {
  int low = 0, high = n-1;
  while(low <= high && 
        x >= arr[low] && 
        x <= arr[high]) {
    int pos = low + 
      (((x - arr[low]) / 
        (arr[high] - arr[low])) 
      * (high - low));
    
    if(arr[pos] == x)
      return pos;
    if(arr[pos] < x)
      low = pos + 1;
    else
      high = pos - 1;
  }
  return -1;
}

O(log log n) best case.

void hanoi(int n, 
    char source, 
    char dest, 
    char aux) {
  if(n == 1) {
    printf("%c->%c\n", 
           source, dest);
    return;
  }
  hanoi(n-1, source, aux, dest);
  printf("%c->%c\n", 
         source, dest);
  hanoi(n-1, aux, dest, source);
}

O(2^n) moves.

int gcd(int a, int b) {
  if(b == 0)
    return a;
  return gcd(b, a % b);
}

Euclidean algorithm.

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

Sum 1+2+...+n.

int productN(int n) {
  if(n == 0 || n == 1)
    return 1;
  return n * productN(n - 1);
}

Product = factorial.

void reverseStr(
    char str[], 
    int n) {
  if(n == 0)
    return;
  printf("%c", str[n-1]);
  reverseStr(str, n-1);
}

Print reversed.

int isPalindrome(
    char str[], 
    int start, 
    int end) {
  if(start >= end)
    return 1;
  if(str[start] != str[end])
    return 0;
  return isPalindrome(str, 
         start+1, end-1);
}

Two-pointer approach.

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

No temp variable.

int checkKthBit(
    int n, int k) {
  return (n >> k) & 1;
}

Right shift & AND.

int setKthBit(
    int n, int k) {
  return n | (1 << k);
}

OR with shifted 1.

int clearKthBit(
    int n, int k) {
  return n & ~(1 << k);
}

AND with negated.

int toggleKthBit(
    int n, int k) {
  return n ^ (1 << k);
}

XOR flips bit.

int countSetBits(
    int n) {
  int count = 0;
  while(n) {
    count += n & 1;
    n >>= 1;
  }
  return count;
}

Count 1 bits.

int isPowerOf2(
    int n) {
  return (n > 0) && 
    ((n & (n-1)) == 0);
}

Single bit trick.

int multiplyBy2Power(
    int n, int p) {
  return n << p;
}

Left shift = multiply.

int divideBy2Power(
    int n, int p) {
  return n >> p;
}

Right shift = divide.