2021

Questions

Q1 WordMatch.java

public class WordMatch {
    // instance variable
    private String secret;

    /**
     * Constructor: initializes the secret word
     * @param word the secret word
     */
    public WordMatch(String word) {
        secret = word;
    }

    /**
     * Part (a): Returns a score based on how many times the guess appears in the secret word
     * and how long the guess is.
     * 
     * @param guess the guess word
     * @return the score
     */
    public int scoreGuess(String guess) {
        // TODO: Count number of times guess appears in secret
        // Multiply count by length of guess
        return 0; // placeholder
    }

    /**
     * Part (b): Returns the guess with the highest score
     * If two guesses have the same score, returns the one that comes first alphabetically.
     * 
     * @param options an array of guess words
     * @return the best guess
     */
    public String findBetterGuess(String guess1, String guess2) {
        // TODO: Use scoreGuess to compare the two guesses
        return ""; // placeholder
    }

    // You may include a main method to test your class
    public static void main(String[] args) {
        WordMatch game = new WordMatch("mississippi");
        
        // Example tests (students should add more)
        System.out.println(game.scoreGuess("is")); // expected: 8
        System.out.println(game.scoreGuess("sip")); // expected: 6
        System.out.println(game.findBetterGuess("is", "sip")); // expected: "is"
    }
}

Q2 CombinedTable.java

public class CombinedTable {
    private SingleTable table1;
    private SingleTable table2;

    public CombinedTable(SingleTable t1, SingleTable t2) {
        table1 = t1;
        table2 = t2;
    }

    public boolean canSeat(int num) {
        // TODO: Return true if both tables can seat the given number of guests together
        return false; // Placeholder
    }

    public double getDesirability() {
        // TODO: Compute and return the desirability based on the formula
        return 0.0; // Placeholder
    }
}

Q2 SingleTable.java

public class SingleTable {
    private int seats;
    private double viewQuality;
    private boolean cloth;

    public SingleTable(int s, double vq, boolean c) {
        seats = s;
        viewQuality = vq;
        cloth = c;
    }

    public int getNumSeats() {
        return seats;
    }

    public double getViewQuality() {
        return viewQuality;
    }

    public boolean hasTablecloth() {
        return cloth;
    }
}

Q2 CombinedTableTester.java

public class CombinedTableTester {
    public static void main(String[] args) {
        // Create two SingleTable objects
        SingleTable table1 = new SingleTable(4, 7.5, true);
        SingleTable table2 = new SingleTable(6, 6.0, false);

        // Create a CombinedTable with table1 and table2
        CombinedTable combined = new CombinedTable(table1, table2);

        // Test canSeat
        System.out.println("Can seat 9 guests: " + combined.canSeat(9)); // Expected: true
        System.out.println("Can seat 11 guests: " + combined.canSeat(11)); // Expected: false

        // Test getDesirability
        System.out.println("Desirability: " + combined.getDesirability());
        // Expected: average of 7.5 and 6.0 = 6.75 (no tablecloth on both, so not multiplied)
    }
}

Q3 MemberInfo.java

import java.util.ArrayList;

public class MemberInfo {
    private String name;
    private int gradYear;
    private boolean hasGoodStanding;

    /** Constructs a MemberInfo object for the club member with name, gradYear, and hasGoodStanding */
    public MemberInfo(String name, int gradYear, boolean hasGoodStanding) {
        this.name = name;
        this.gradYear = gradYear;
        this.hasGoodStanding = hasGoodStanding;
    }

    /** Returns the graduation year of the club member. */
    public int getGradYear() {
        return gradYear;
    }

    /** Returns true if the member is in good standing and false otherwise. */
    public boolean inGoodStanding() {
        return hasGoodStanding;
    }

    /** Optional: Returns the name of the member (useful for debugging or display) */
    public String toString() {
        return name + " (" + gradYear + ") - Good Standing: " + hasGoodStanding;
    }
}

Q3 ClubMembers.java

public class ClubMembers {
    private ArrayList<MemberInfo> memberList;

    /** Constructs an empty list of members */
    public ClubMembers() {
        memberList = new ArrayList<MemberInfo>();
    }

    /**
     * Adds new club members to memberList, as described in part (a).
     * Precondition: names is a non-empty array.
     */
    public void addMembers(String[] names, int gradYear) {
        // To be implemented
    }

    /**
     * Removes members who have graduated and returns a list of members who have
     * graduated and are in good standing, as described in part (b).
     */
    public ArrayList<MemberInfo> removeMembers(int year) {
        // To be implemented
        return null;
    }

    /** Optional: View members for testing */
    public void printMembers() {
        for (MemberInfo m : memberList) {
            System.out.println(m);
        }
    }
}

Q3 ClubTester.java

public class ClubTester {
    public static void main(String[] args) {
        ClubMembers club = new ClubMembers();

        // Example addMembers call (to test part a when implemented)
        String[] newNames = {"Alice Brown", "Carlos Diaz"};
        club.addMembers(newNames, 2024);

        // Add more members manually
        club.addMembers(new String[]{"Emily Stone"}, 2022);

        // Test print
        System.out.println("Before removal:");
        club.printMembers();

        // Test removeMembers call (to test part b when implemented)
        ArrayList<MemberInfo> graduated = club.removeMembers(2023);

        System.out.println("\nAfter removal:");
        club.printMembers();

        System.out.println("\nGraduated and in good standing:");
        for (MemberInfo m : graduated) {
            System.out.println(m);
        }
    }
}

Q4 ArrayResizer.java

public class ArrayResizer {

    /** Returns true if and only if every value in row r of array2D is non-zero.
     *  Precondition: r is a valid row index in array2D.
     *  Postcondition: array2D is unchanged.
     */
    public static boolean isNonZeroRow(int[][] array2D, int r) {
        // To be implemented in part (a)
        return false;
    }

    /** Returns the number of rows in array2D that contain all non-zero values.
     *  Postcondition: array2D is unchanged.
     */
    public static int numNonZeroRows(int[][] array2D) {
        int count = 0;
        for (int r = 0; r < array2D.length; r++) {
            if (isNonZeroRow(array2D, r)) {
                count++;
            }
        }
        return count;
    }

    /** Returns a new, possibly smaller, two-dimensional array that contains only rows
     *  from array2D with no zeros, as described in part (b).
     *  Precondition: array2D contains at least one column and at least one row with no zeros.
     *  Postcondition: array2D is unchanged.
     */
    public static int[][] resize(int[][] array2D) {
        // To be implemented in part (b)
        return null;
    }
}

ArrayResizerTester.java

public class ArrayResizerTester {
    public static void main(String[] args) {
        int[][] arr = {
            {2, 1, 0},
            {1, 3, 2},
            {0, 0, 0},
            {4, 5, 6}
        };

        System.out.println("isNonZeroRow(arr, 0): " + ArrayResizer.isNonZeroRow(arr, 0)); // false
        System.out.println("isNonZeroRow(arr, 1): " + ArrayResizer.isNonZeroRow(arr, 1)); // true
        System.out.println("isNonZeroRow(arr, 2): " + ArrayResizer.isNonZeroRow(arr, 2)); // false
        System.out.println("isNonZeroRow(arr, 3): " + ArrayResizer.isNonZeroRow(arr, 3)); // true

        int[][] smaller = ArrayResizer.resize(arr);
        System.out.println("Resized array:");
        if (smaller != null) {
            for (int[] row : smaller) {
                for (int val : row) {
                    System.out.print(val + " ");
                }
                System.out.println();
            }
        } else {
            System.out.println("Returned null.");
        }
    }
}

Scoring Guidelines

Chief Reader Report

Scoring Statistics

Scoring Distribution

Samples and Commentary

Sample Responses Q1

Sample Responses Q2

Sample Responses Q3

Sample Responses Q4