☕ 30 Important APCS-A Algorithms & Code Patterns

for (int i = 0; i < arr.length; i++) {
    // process arr[i]
}

for (int value : arr) {
    // process value
}

int max = arr[0];
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}

int count = 0;
for (int num : arr) {
    if (num % 2 == 0) {
        count++;
    }
}

ArrayList<Integer> evens = new ArrayList<>();
for (int num : arr) {
    if (num % 2 == 0) {
        evens.add(num);
    }
}

for (int r = 0; r < matrix.length; r++) {
    for (int c = 0; c < matrix[0].length; c++) {
        // process matrix[r][c]
    }
}

int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
        // found at i
    }
}

for (int i = 0; i < str.length(); i++) {
    char ch = str.charAt(i);
}

list.add(value);
list.remove(index);
list.get(index);

int sum = 0;
for (int num : arr) {
    sum += num;
}

boolean found = false;
for (int num : arr) {
    if (num == target) {
        found = true;
        break;
    }
}

for (int i = arr.length - 1; i >= 0; i--) {
    // process arr[i]
}

for (int i = 0; i < arr.length - 1; i++) {
    int minIndex = i;
    for (int j = i + 1; j < arr.length; j++) {
        if (arr[j] < arr[minIndex]) {
            minIndex = j;
        }
    }
    // swap arr[i] and arr[minIndex]
}

public class MyClass {
    private int x;
    public MyClass(int val) {
        x = val;
    }
}

public int sum(int a, int b) {
    return a + b;
}

public class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("Woof!");
    }
}

public static int add(int a, int b) { ... }
public int getValue() { ... }

for (int i = list.size() - 1; i >= 0; i--) {
    if (list.get(i) < 0) {
        list.remove(i);
    }
}

if (str1.equals(str2)) { ... }
if (obj1 == obj2) { ... }

int low = 0, high = arr.length - 1;
while (low <= high) {
    int mid = (low + high) / 2;
    if (arr[mid] == target) return mid;
    else if (arr[mid] < target) low = mid + 1;
    else high = mid - 1;
}

for (int i = 1; i < arr.length; 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;
}

!(a && b) equals (!a || !b)
!(a || b) equals (!a && !b)

// Example:
if (!(x > 5 && y < 10)) { ... }
// is equivalent to:
if (x <= 5 || y >= 10) { ... }

// Random integer from min to max (inclusive)
int randomNum = (int)(Math.random() * (max - min + 1)) + min;

// Example: Random number from 1 to 6 (dice roll)
int dice = (int)(Math.random() * 6) + 1;

// Assuming arr is already sorted
if (arr.length % 2 == 1) {
    // Odd length: return middle element
    median = arr[arr.length / 2];
} else {
    // Even length: return average of two middle elements
    int mid1 = arr[arr.length / 2 - 1];
    int mid2 = arr[arr.length / 2];
    median = (mid1 + mid2) / 2.0;
}

for (int r = 0; r < matrix.length; r++) {
    int rowSum = 0;
    for (int c = 0; c < matrix[r].length; c++) {
        rowSum += matrix[r][c];
    }
    // process rowSum
}

for (int c = 0; c < matrix[0].length; c++) {
    int colSum = 0;
    for (int r = 0; r < matrix.length; r++) {
        colSum += matrix[r][c];
    }
    // process colSum
}

int[][] directions = {{-1,0}, {1,0}, {0,-1}, {0,1}};
for (int[] dir : directions) {
    int newR = r + dir[0];
    int newC = c + dir[1];
    if (newR >= 0 && newR < matrix.length && 
        newC >= 0 && newC < matrix[0].length) {
        // process matrix[newR][newC]
    }
}

for (int[] row : matrix) {
    for (int value : row) {
        // process value
    }
}

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

// Another common pattern: countdown
public void countdown(int n) {
    if (n <= 0) return;  // base case
    System.out.println(n);
    countdown(n - 1);    // recursive call
}