APCSA 2015 Q3, grading criteria

Question

If a question (eg free response 2015 #3) has the following criteria:

+1 Accesses all necessary elements of entries (No bounds errors)

+1 Returns identified value or returns 0 if no entry exists in entries with row index row and column index col

... and the student prematurely exits a loop with this common if-else return mistake:

for(SparseArrayEntry entry : entries) {
    if(entry.getRow() == row && entry.getCol() == col) {
        return entry.getValue();
    } else { // mistake, loop will only ever run once
        return 0; // should do this return after loop
    }
}

Does the student lose both of the above points because 1) the premature return prevents accessing all necessary elements, and 2) a zero might be returned in spite of the fact an entry does exist.

It feels like double jeopardy but I was hoping an AP grader or someone with more experience teaching the course could weigh in on the decision.

Answer 1

I am also not an AP Grader, though I have taught the class for well over a decade now, and I am pretty sure about this would be approached on the actual AP test.

(If you pursue this further, and I do turn out to be wrong, please post a new answer with a correction.)

There are two considerations:

1. My understanding has been that every area of code is examined in isolation, and examined as if all of the code around it were good.

2. Furthermore, the first rubric point concerns itself with the loop, and the second point with the return. This is a philosophical separation in addition to the code separation I outlined above.

For both reasons, then, since the loop itself is fine, the student would receive that point. However, the student would lose the second point, since they are returning the wrong answer much of the time.

The reason for the separation of concerns in point 1 is because otherwise you get into sudden death scenarios where one small mistake brings you from 5 points on a large item to 0, since none of the items are ever actually fulfilled. Such scores are clearly out of line with the work produced by the students.

Answer 2

I know this is coming a week after you wanted it... but, I am an APCS-A teacher and I have been a AP Reader in the past.

The scoring guidelines are applied thusly:

1. mistake in the code causes bounds error - Deduct the point for accessing array
2. having deducted a point, pretend the problem is fixed
3. continue scoring with fix

The goal is to not have a single issue rob a student of all the points.

The one exception is the "did they get it right" point. This would be the result of debate with your elbow partner, the table leader and the question leaders.

In your specific example the student would probably lose both points as the guideline is specifically mentioning a completed condition that was never reached.

Answer 3

I don't educate on the AP level, but let me trot out one or two of my hobby horses^W^W things that I try to teach my students.

One. I object to this code structure. Semantically, a loop serves to compute something, so you want a code structure

int your_result;
for (whatever) { do something }
return your_result.

By having the return in the loop you subvert this structure, conflating the loop and the surrounding function.

I try to prevent this sort of construct by showing how to derive code by textual refinement. You go from

// compute a result

to

result = compute_result()

to

function compute_result() {
    result = init;
    // do all tests
    return result;
}

to the full code. (This principle of textual refinement also postpones introducing local variables to the last moment, so they automatically are in the correct scope!)

Two. Loops that serve some test are (usually) either a for-all predicate or a there-is predicate. So, with the above structure, this is a there-exists problem:

bool element_is_present = false;
for ( elements )
  if ( condition )
     element_is_present = true;

and then you can jump out of the loop prematurely because a single true test is enough for the conclusion. And then refine this loop to suit the problem.