What Is Informal Code Analysis?

Informal code analysis means reading a method and answering questions like:

• "What does this method return?"
• "What does this method print?"
• "Under what conditions does this method produce the correct result?"
• "What is wrong with this implementation?"

You're not running the code — you're tracing it mentally, applying your understanding of the language and algorithms.

Strategy: Read the Method in Layers

1. Identify the return type and parameters — what goes in and what comes out.
2. Find the loop structure — what range does it cover, and does it modify the collection?
3. Trace with a small example — pick 3–4 element input and trace manually.
4. Check the edge cases — empty collection, single element, all-same values.
5. Match to known patterns — is this min/max? filter? linear search? insertion sort?

public static int mystery(int[] arr) {
    int result = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < result) {
            result = arr[i];
        }
    }
    return result;
}

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

Common AP Exam Analysis Patterns

The AP exam repeatedly tests these analysis questions across Unit 4 topics:

• Off-by-one: Does the loop start at 0 or 1? Does it use < or <=?
• Wrong getter: Does the method call the right getter method on each object?
• Early return: Is return false inside or outside the loop?
• Initialization: Is min/max initialized to 0 or to the first element?
• Modification during traversal: Does the method remove elements inside a for-each loop?
• Integer division: Is the average cast to double before or after dividing?
• Wrong comparison: Is == used for Strings instead of .equals()?

Summary

• Informal code analysis means reading code and reasoning about its behavior without running it.
• Trace with a small example to verify your understanding quickly.
• Preconditions are assumptions a method makes about its inputs — binary search requires sorted input; min/max assumes the array is non-empty.
• Every bug pattern from Units 1–4 can appear in an analysis question.

public static int mystery(int[] arr) {
    int count = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        if (arr[i] > arr[i + 1]) count++;
    }
    return count;
}

public static int findMax(ArrayList list) {
    int max = list.get(0);
    for (int i = 1; i < list.size(); i++) {
        if (list.get(i) > max) max = list.get(i);
    }
    return max;
}

public static boolean mystery(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        if (arr[i] > arr[i + 1]) return false;
    }
    return true;
}

public static double average(ArrayList list) {
    int total = 0;
    for (int x : list) {
        total += x;
    }
    return total / list.size();
}

public static int mystery(int[][] grid) {
    int sum = 0;
    for (int row = 0; row < grid.length; row++) {
        sum += grid[row][grid[row].length - 1];
    }
    return sum;
}

public static String topStudent(ArrayList roster) {
    int maxScore = 0;
    String topName = "";
    for (Student s : roster) {
        if (s.getScore() > maxScore) {
            maxScore = s.getScore();
            topName = s.getName();
        }
    }
    return topName;
}

public static int mystery(int[][] grid) {
    int total = 0;
    for (int i = 0; i < grid.length; i++) {
        total += grid[i][i];
    }
    return total;
}

public static String mystery(int n) {
    if (n == 0) return "";
    return mystery(n / 2) + (n % 2);
}

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

public static int mystery(ArrayList books, String genre) {
    int total = 0;
    for (Book b : books) {
        if (b.getGenre().equals(genre)) {
            total += b.getPages();
        }
    }
    return total;
}