Scoring Rubric (Part A — 4 points)

Solution

public Round(String[] names)
{
    competitorList = new ArrayList();

    for (int i = 0; i < names.length; i++)
    {
        Competitor c = new Competitor(names[i], i + 1);
        competitorList.add(c);
    }
}

Step-by-Step Explanation

Step 1: Initialize competitorList to a new, empty ArrayList. Do not redeclare with a type.

Step 2: Use a standard for loop with index i. You need the index for rank, so an enhanced for loop is less convenient.

Step 3: Construct each Competitor with names[i] and i + 1 as rank (starts at 1, not 0).

Step 4: Add each Competitor to competitorList. Iterating in order and adding to the end preserves order automatically.

Alternate Approach (Enhanced For with Counter)

public Round(String[] names)
{
    competitorList = new ArrayList();
    int rank = 1;

    for (String name : names)
    {
        competitorList.add(new Competitor(name, rank));
        rank++;
    }
}

Scoring Rubric (Part B — 5 points)

Solution

public ArrayList buildMatches()
{
    ArrayList matches = new ArrayList();

    int low = 0;
    if (competitorList.size() % 2 == 1)
    {
        low = 1;
    }

    int high = competitorList.size() - 1;

    while (low < high)
    {
        Match m = new Match(competitorList.get(low),
                            competitorList.get(high));
        matches.add(m);
        low++;
        high--;
    }

    return matches;
}

Step-by-Step Explanation

Step 1: Create a new, empty ArrayList.

Step 2: Set low to 0. If the list size is odd (% 2 == 1), set low to 1 to skip the best-ranked competitor at index 0.

Step 3: Set high to the last valid index: competitorList.size() - 1.

Step 4: Loop while (low < high). Each iteration pairs the competitor at low with the one at high, creates a new Match, adds it to matches, then moves both pointers inward.

Step 5: Return matches.

Alternate Approach (For Loop with Size/2)

public ArrayList buildMatches()
{
    ArrayList matches = new ArrayList();

    if (competitorList.size() % 2 == 0)
    {
        for (int i = 0; i < competitorList.size() / 2; i++)
        {
            matches.add(new Match(competitorList.get(i),
                competitorList.get(competitorList.size() - i - 1)));
        }
    }
    else
    {
        for (int i = 1; i < competitorList.size() / 2 + 1; i++)
        {
            matches.add(new Match(competitorList.get(i),
                competitorList.get(competitorList.size() - i)));
        }
    }

    return matches;
}

This is the College Board’s primary canonical solution. Both earn full credit.