Standard Algorithms (EK 2.9.A.1)

The CED identifies five categories of standard algorithms you must be able to write, trace, and modify on the AP exam. These appear in FRQ problems and MCQ trace questions every year. All five use only loops and selection — no data structures required.

Algorithm 1: Divisibility

An integer a is evenly divisible by b when the remainder of a / b is zero, expressed as a % b == 0. This is the most fundamental loop-and-selection algorithm on the AP exam. Every odd/even check, every prime test, every factor-finding algorithm uses this pattern.

// Is n even?
if (n % 2 == 0) { System.out.println("Even"); }

// Count even numbers from 1 to 100
int evenCount = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 2 == 0) {
        evenCount++;
    }
}
// evenCount = 50

// Count multiples of 3 that are also multiples of 5 (i.e., multiples of 15)
int count = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 3 == 0 && i % 5 == 0) {
        count++;
    }
}
// count = 6  (15, 30, 45, 60, 75, 90)

Algorithm 2: Digit Extraction

Individual digits of a positive integer are extracted using two operations: n % 10 gives the last (ones) digit, and n / 10 removes the last digit. Repeating this in a loop processes every digit from right to left.

int n = 1234;
int digitSum = 0;
while (n > 0) {
    int lastDigit = n % 10;   // 4, then 3, then 2, then 1
    digitSum += lastDigit;
    n = n / 10;               // 123, then 12, then 1, then 0
}
System.out.println(digitSum); // 10  (1+2+3+4)

Algorithm 3: Frequency Counting

Count how many times a specific criterion is met by initializing a counter to 0 and incrementing it inside the loop whenever the condition is true.

String s = "Hello World";
int upperCount = 0;
for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if (Character.isUpperCase(c)) {
        upperCount++;
    }
}
System.out.println(upperCount); // 2 (H and W)

Algorithm 4: Minimum and Maximum

Find the extreme value in a sequence by initializing a tracker to the first value, then updating it inside the loop whenever a more extreme value is found. Never initialize to 0 — use the actual first value or Integer.MAX_VALUE/Integer.MIN_VALUE.

int a = 42, b = 17, c = 89;
int max = a;              // initialize to first value
if (b > max) max = b;     // update if b is larger
if (c > max) max = c;     // update if c is larger
System.out.println(max);  // 89

// General pattern with a loop:
int[] values = {42, 17, 89, 5, 73};
int maximum = values[0];   // start with first element
for (int i = 1; i < values.length; i++) {
    if (values[i] > maximum) {
        maximum = values[i];
    }
}

Algorithm 5: Sum and Average

The accumulator pattern: initialize a sum variable to 0 before the loop, add each value to it inside the body, then divide after the loop to compute the average. The average requires casting to avoid integer division truncation.

int n = 10;
int sum = 0;
for (int i = 1; i <= n; i++) {
    sum += i;               // accumulate
}
double average = (double) sum / n;   // cast to get decimal result
System.out.println("Sum: " + sum);       // Sum: 55
System.out.println("Average: " + average); // Average: 5.5

Real-World Connection

These five algorithms are the atoms of computational thinking. Divisibility underlies every calendar calculation (is this year a leap year?), cryptography (prime checking), and validation system. Digit extraction powers barcode validators, credit card checkers (Luhn algorithm), and integer parsing. Frequency counting drives analytics dashboards, vote tallying, and log analysis. Min/max appears in everything from game high scores to financial portfolio risk. Sum/average is the basis of every statistical calculation ever written.

Summary

• Divisibility: a % b == 0. Foundation of odd/even, prime, and factor tests.
• Digit extraction: n % 10 = last digit, n / 10 = remove last digit. Repeat in a while loop.
• Frequency: counter initialized to 0, incremented when criterion is met.
• Min/max: tracker initialized to first value, updated when more extreme value found. Never initialize to 0.
• Sum/average: accumulator initialized to 0, add inside loop, cast before dividing for average.
• FRQ pattern: AP problems combine multiple algorithms. Identify each component separately.

int n = 1234;
int sum = 0;
while (n > 0) {
    sum += n % 10;
    n /= 10;
}
System.out.println(sum);

int max = 0;
if (a > max) max = a;
if (b > max) max = b;
if (c > max) max = c;

int max = a;
if (b > max) max = b;
if (c > max) max = c;

int max = a;
if (b > max) b = max;
if (c > max) c = max;

int max = 0;
max = a + b + c;

int sum = 0;
for (int i = 1; i <= 4; i++) {
    sum += i;
}
double avg = sum / 4;

int min = 0;
for (int i = 0; i < 10; i++) {
    if (getValue(i) < min) {
        min = getValue(i);
    }
}

int n = 10000;
int count = 0;
while (n > 0) {
    count++;
    n /= 10;
}

int sum=0;
for(int i=1;i<=100;i+=2) sum+=i;

int sum=0;
for(int i=2;i<=100;i+=2) sum+=i;

int sum=0;
for(int i=0;i<100;i++) if(i%2==0) sum+=i;

int sum=0;
for(int i=2;i<100;i+=2) sum+=i;

int n = 36;
int count = 0;
for (int i = 1; i <= n; i++) {
    if (n % i == 0) count++;
}
System.out.println(count);

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

return n / 10;

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

return (int)Math.log10(n);

int[] vals = {7, 2, 9, 1, 5};
int min = vals[0];
for (int i = 1; i < vals.length; i++) {
    if (vals[i] < min) min = vals[i];
}
System.out.println(min);