Case Study: Quiz Grading

Subsection 14.9.1 Understanding the problem

We are not really writing a full program here. Instead, we are just trying to build a toolbox that we can use on a certain type of data.

There are two different tasks we are looking to write code for. The first is to calculate the score for each student. The second is to calculate the average score for each question (how hard it was). The two tasks likely will share some logic, but it does not seem like either one depends on the other.

Both functions will depend on the same data, the key and the student answers. So let’s start by thinking how to represent that data.

Subsection 14.9.2 Designing Data

The key for the quiz can be represented as a list of characters. The key for a 5 question quiz might look like:

A C C D B

And the student answers as a list where each “row” is a different student’s responses to the. A set of four student’s responses to a 5 question quiz might look like this (where _ represents an unanswered question):

A C B D B
C C C C C
A C C D B
B C _ D B

The key looks like a single dimensional vector of characters. The student answers a 2-D grid of characters. Let’s write some typedefs to name vectors with the appropriate dimensions:

typedef vector<char> Answers;
typedef vector<Answers> ResponseSet;

We could write our code without those definitions, but they should help make our code a little more readable.

Subsection 14.9.3 Student Grades

To compute student grades, we need to compare each student’s answers to the key and count how many match. I think that whenever I calculate the grades I will want to do so for all the students. So let’s build a function that calculates all the grades and returns a vector of them.

This function will need to accept the grid of student answers and the key. It should return a vector of scores. We will represent the score as number of correct answers (not as percents) to avoid having to worry about rounding issues.

Checkpoint 14.9.1.

Most of this function is written. All that is missing (look for ???) are the indexes to use when comparing a student’s answer to the key. Fill in those blanks with the correct counting variable - either studentNumber or questionNumber.

#include <iostream>
#include <vector>
using namespace std;

typedef vector<char> Answers;
typedef vector<Answers> ResponseSet;
^^^!

// Take a set of student answers and an answer key, and return a vector
// of scores, one per student.
vector<int> studentScores(const ResponseSet& studentAnswers, const Answers& key) {
    // the list of scores to return
    vector<int> scores;

size_t numStudents = studentAnswers.size();
    size_t numQuestions = key.size();
    for (size_t studentNumber = 0; studentNumber < numStudents; ++studentNumber) {
        // compute this student's score
        int score = 0;
        for (size_t questionNumber = 0; questionNumber < numQuestions; ++questionNumber) {
            if (studentAnswers.at(???).at(???) == key.at(???)) {
                ++score;
            }
        }
        // add to the list of scores we will return
        scores.push_back(score);
    }
    return scores;
}
===!

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

// Test data. Global scope is used to avoid declaring data in each test case.
// Data is marked const to avoid accidental changes.

const Answers KEY1 = {'A', 'B', 'C', 'D', 'E'};
const Answers KEY2 = {'A', 'C', 'C', 'D', 'B'};

const ResponseSet RESPONSES1 = {
    {'A', 'C', 'B', 'D', 'B'},
    {'C', 'C', 'C', 'C', 'C'},
    {'A', 'C', 'C', 'D', 'B'},
    {'B', 'C', '_', 'D', 'B'}
};

void printVector(const string& label, const vector<int>& vec) {
    cout << label << ": ";
    for (int i : vec) {
        cout << i << " ";
    }
    cout << endl;
}

TEST_CASE("studentScores") {
    // Test with key 1
    vector<int> expected1 = {2, 1, 3, 1};
    vector<int> studentScores1 = studentScores(RESPONSES1, KEY1);
    printVector("studentScores1", studentScores1);
    printVector("Expected", expected1);
    CHECK(studentScores1 == expected1);

// Test with key 2
    vector<int> expected2 = {4, 2, 5, 3};
    vector<int> studentScores2 = studentScores(RESPONSES1, KEY2);
    printVector("studentScores2", studentScores2);
    printVector("Expected", expected2);
    CHECK(studentScores2 == expected2);
}

Hint.

Remember that studentAnswers is a grid where each student is a row and each question is a column.

Note 14.9.1.

We did not do any error checking to make sure that each student has enough answers. If the key is longer than a student’s row of answers, we will end up going out of bounds on the student grid. In that case the vector will generate an exception. If we wanted, we could try to catch that exception. But it is not clear what we should do to fix the problem. So we will just let any possible exception propagate to whatever program calls this.

Subsection 14.9.4 Question Difficulty

Now we need to build a function to calculate the difficulty of questions. This time, let’s build a function that just focuses on one question at a time. We will need to iterate through all of the students, but we will just be looking at one question. So we will only need a single loop.

Checkpoint 14.9.2.

Complete the code below to calculate the difficulty of a question. You will not need all of the blocks.

double questionDifficulty(
    const ResponseSet& studentAnswers,
    const Answers& key,
    int questionNum
) {
---
    // want to produce a decimal eventually
    double numCorrect = 0;
---
    size_t numStudents = studentAnswers.size();
    for (size_t i = 0; i < numStudents; ++i) {
---
    size_t numQuestions = key.size();
    for (size_t i = 0; i < numQuestions; ++i) { #distractor
---
        char answer = studentAnswers.at(i).at(questionNum);
        char correctAnswer = key.at(questionNum);
---
        char answer = studentAnswers.at(questionNum).at(i);
        char correctAnswer = key.at(questionNum); #distractor
---
        if (answer == correctAnswer) {
            ++numCorrect;
        }
---
    }
---
    return numCorrect / numStudents;
}

Section 14.9 Case Study: Quiz Grading

Subsection 14.9.1 Understanding the problem

Subsection 14.9.2 Designing Data

Subsection 14.9.3 Student Grades

Checkpoint 14.9.1.

Note 14.9.1.

Subsection 14.9.4 Question Difficulty

Checkpoint 14.9.2.