• A Question and Likely Response:
  • Ask someone how to add a column of numbers by hand
  • They will probably say something like "just add them up"
• An Easy Challenge:
  • They'll probably be able to succeed with a column of fifty single-digit numbers
• Making it Harder:
  • Talk to them while their adding the numbers
• A Suggestion:
  • Tell them to write things down as they go

• Sometimes:
  • Each iteration of a loop is independent of other iterations
• Frequently:
  • This isn't the case and we need to "keep track of" something across iterations
• An Example:
  • Calculating the sum of the elements of a double[]

Getting Started

javaexamples/programmingpatterns/accumulators/Accumulators.java (Fragment: loop)

        for (int i = 0; i < n; i++) {
            // Do something with data[i]
        }
        

What "needs to be done" at each iteration?

• Finding the Sum of a Long List of Numbers:
  • People commonly keep a running total (e.g., 7 plus 3 is 10, plus 2 is 12, ...)
• Programming this Algorithm:
  • You need a variable for the running total

• Getting Started:
  • Decide the type of the running value (i.e., the accumulator)
• Initialization:
  • Declare and initialize the accumulator outside of the loop
• Iteration:
  • Update the accumulator in the body of the loop (if necessary)

• Numeric (e.g., int, double):
  • Sums/Totals
  • Counts/Tallies (e.g., of positive numbers, even numbers)
  • Minima
  • Maxima
• String:
  • Concatenation of words/lines
• boolean:
  • Containment/existence checks
  • Identical elements check

javaexamples/programmingpatterns/accumulators/Accumulators.java (Fragment: max)

        double maximum;       
        int n;
       
        n = Array.getLength(data);       
        maximum = Double.NEGATIVE_INFINITY;       

        for (int i = 0; i < n; i++) {
            if (data[i] > maximum) maximum = data[i];
        }
        

javaexamples/programmingpatterns/accumulators/Accumulators.java (Fragment: contains)

        boolean      found;       
        int          n;
       
        n = Array.getLength(data);       
        found = false;

        for (int i = 0; ((i < n) && !found); i++) {
            if (target == data[i]) found = true;
        }
        

javaexamples/programmingpatterns/accumulators/Accumulators.java (Fragment: droplowest)

        double lowest, result, total;       
        int n;
       
        n = Array.getLength(data);       
        total = 0.0;       
        lowest = Double.POSITIVE_INFINITY;

        for (int i = 0; i < n; i++) {
            total += data[i];
            if (data[i] < lowest) lowest = data[i];
        }
        result = (total - lowest) / (n - 1);
        

javaexamples/programmingpatterns/accumulators/Accumulators.java (Fragment: argmax)

        double maximum;       
        int index, n;
       
        n = Array.getLength(data);       
        maximum = Double.NEGATIVE_INFINITY;       
        index = -1;

        for (int i = 0; i < n; i++) {
            if (data[i] > maximum) {
                index   = i;
                maximum = data[i];
            }
        }