Popcorn Hack 1

/**
 * Calculates the sum of all positive even integers in the given array.
 * <p>
 * The method iterates through each element of the {@code nums} array and adds it to a running total
 * only if the element is greater than zero and evenly divisible by two. The method then returns
 * the final sum.
 * </p>
 *
 * <p><b>Preconditions:</b></p>
 * <ul>
 *   <li>{@code nums} must not be {@code null}.</li>
 *   <li>{@code nums} may contain any integer values (positive, negative, or zero).</li>
 * </ul>
 *
 * <p><b>Postconditions:</b></p>
 * <ul>
 *   <li>Returns the sum of all positive even numbers in {@code nums}.</li>
 *   <li>If there are no positive even numbers, returns {@code 0}.</li>
 * </ul>
 *
 * @param nums an array of integers to evaluate
 * @return the sum of all positive even integers in {@code nums}; {@code 0} if none exist
 *
 * <p><b>Example:</b></p>
 * <pre>
 * int[] numbers = {1, 2, 3, 4, -6};
 * int result = doSomething(numbers);  // result = 6
 * </pre>
 */
public static int doSomething(int[] nums) {
    int result = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] > 0 && nums[i] % 2 == 0) {
            result += nums[i];
        }
    }
    return result;
}

// Example test to verify output
int[] testArray = {1, 2, 3, 4, -6};
System.out.println(doSomething(testArray));  // Expected output: 6


6

Popcorn Hack 2


/**
 * Manages student grades and calculates final grades based on weighted categories.
 * <p>
 * This class allows teachers or students to track assignments across different categories
 * (such as homework, tests, and projects) and compute a final grade using category weights.
 * It can also handle extra credit and generate a summary report of all recorded data.
 * </p>
 *
 * <p><b>Key Features:</b></p>
 * <ul>
 *   <li>Store assignments organized by category</li>
 *   <li>Apply custom weights to each grade category</li>
 *   <li>Track and include extra credit points</li>
 *   <li>Generate formatted grade reports</li>
 * </ul>
 *
 * <p><b>Usage Example:</b></p>
 * <pre>
 * GradeBook myGrades = new GradeBook();
 * myGrades.setCategoryWeight("Homework", 0.30);
 * myGrades.setCategoryWeight("Tests", 0.70);
 * myGrades.addAssignment("Homework", "HW1", 95.0);
 * myGrades.addAssignment("Tests", "Unit Test 1", 88.0);
 * double finalGrade = myGrades.calculateFinalGrade();
 * System.out.println("Final Grade: " + finalGrade);
 * </pre>
 *
 * @author Ahaan
 * @version 1.0
 * @since 2025-10-06
 */
public class GradeBook {
    private HashMap<String, Double> assignments;
    private HashMap<String, Double> categoryWeights;
    private double extraCredit;

    /**
     * Adds an assignment score to a specific category.
     *
     * <p><b>Preconditions:</b></p>
     * <ul>
     *   <li>{@code category} and {@code name} must not be {@code null}.</li>
     *   <li>{@code score} should typically be between 0 and 100.</li>
     * </ul>
     *
     * <p><b>Postconditions:</b></p>
     * <ul>
     *   <li>The assignment is stored under the specified category.</li>
     * </ul>
     *
     * @param category the category name (e.g., "Homework", "Tests")
     * @param name the assignment name
     * @param score the score earned (0–100)
     */
    public void addAssignment(String category, String name, double score) { }

    /**
     * Sets the weight for a specific grade category.
     *
     * <p><b>Preconditions:</b></p>
     * <ul>
     *   <li>{@code category} must not be {@code null}.</li>
     *   <li>{@code weight} should be between 0.0 and 1.0.</li>
     * </ul>
     *
     * <p><b>Postconditions:</b></p>
     * <ul>
     *   <li>The specified weight is stored for that category.</li>
     * </ul>
     *
     * @param category the category name
     * @param weight the weight as a decimal (e.g., 0.30 for 30%)
     */
    public void setCategoryWeight(String category, double weight) { }

    /**
     * Calculates the final weighted grade including any extra credit.
     *
     * <p><b>Postconditions:</b></p>
     * <ul>
     *   <li>Returns a final numeric grade between 0 and 100 (or higher if extra credit applies).</li>
     * </ul>
     *
     * @return the final grade as a percentage
     */
    public double calculateFinalGrade() { return 0.0; }

    /**
     * Generates a formatted text report of all assignments, categories, and weights.
     *
     * @return a formatted {@code String} containing the grade report
     */
    public String generateReport() { return ""; }
}

Homework Hacks

Part 1 Documentation Analysis

Improved Code

/**
 * Demonstrates a simple example of adding two integers and displaying the result.
 * <p>
 * This program defines a method {@code add(int, int)} that returns the sum of two integers,
 * and calls it from the {@code main} method to print the result to the console.
 * </p>
 *
 * <p><b>Example Output:</b></p>
 * <pre>
 * ans is 15
 * </pre>
 *
 * @author Ahaan
 * @version 1.0
 * @since 2025-10-07
 */
public class Stuff {

    /**
     * The main entry point of the program.
     * Initializes two integers, adds them, and prints the result.
     *
     * @param args command-line arguments (not used)
     */
    public static void main(String[] args) {
        int x = 5;
        int y = 10;
        int z = add(x, y);
        System.out.println("ans is " + z);
    }

    /**
     * Adds two integers and returns their sum.
     *
     * <p><b>Preconditions:</b></p>
     * <ul>
     *   <li>Inputs {@code a} and {@code b} are valid integers.</li>
     * </ul>
     *
     * <p><b>Postconditions:</b></p>
     * <ul>
     *   <li>Returns the arithmetic sum of {@code a} and {@code b}.</li>
     * </ul>
     *
     * @param a the first integer
     * @param b the second integer
     * @return the sum of {@code a} and {@code b}
     */
    static int add(int a, int b) {
        return a + b;
    }
}

Explanation

I Added Javadoc comments for the class and both methods, used proper class name capitalization, added @param and @return tags for method documentation, provided an example output and clear descriptions of purpose, and I also improved the legibility with correct naming connventions.

Part 2 Document a Complex Method

/**
 * Attempts to enroll a student in a specific course for a given semester.
 * <p>
 * This method checks for various conditions such as course availability,
 * schedule conflicts, prerequisite completion, and credit limits before
 * enrolling the student. If all checks pass, the student and course records
 * are updated, and the enrollment transaction is recorded.
 * </p>
 *
 * <p><b>Preconditions:</b></p>
 * <ul>
 *   <li>The student and course records exist in the system.</li>
 *   <li>The semester value is valid (e.g., Fall = 1, Spring = 2).</li>
 * </ul>
 *
 * <p><b>Postconditions:</b></p>
 * <ul>
 *   <li>The student is added to the course roster and the course is added to the student’s schedule, if successful.</li>
 *   <li>A transaction record is created for the enrollment.</li>
 *   <li>If any condition fails, the enrollment is not processed and {@code false} is returned.</li>
 * </ul>
 *
 * @param studentId the unique identifier of the student attempting to enroll
 * @param courseCode the unique code identifying the course
 * @param semester the semester number in which the enrollment occurs
 * @return {@code true} if enrollment succeeds; {@code false} otherwise
 */
public boolean enrollStudent(String studentId, String courseCode, int semester) {
    Student student = findStudentById(studentId);
    if (student == null) return false;

    Course course = findCourseByCode(courseCode);
    if (course == null) return false;

    if (course.isFull()) return false;
    if (student.hasScheduleConflict(course)) return false;
    if (!student.hasPrerequisites(course)) return false;
    if (student.getCreditHours() + course.getCreditHours() > 18) return false;

    student.addCourse(course);
    course.addStudent(student);
    recordEnrollmentTransaction(studentId, courseCode, semester);
    return true;
}

Part 3 Reflection Questions

Even if they didn’t write the code, documentation guarantees that everyone on the team is aware of how it operates. It makes sure long-term maintainability, expedites the onboarding of new members in understanding a project, and helps prevent duplication of effort. Someone might be able to remeber what they wrote in a project they made on your own, but in a team project, the documentation becomes something that anyone can remeber and understand

Extra Credit

Challenge 1 Document a Recursive Method

/**
 * Computes the factorial of a non-negative integer recursively.
 * <p>
 * The factorial of a number {@code n} is defined as:
 * {@code n! = n × (n - 1) × ... × 1}, with the base case {@code 0! = 1}.
 * </p>
 *
 * <p><b>Base Case:</b> If {@code n == 0}, return 1.</p>
 * <p><b>Recursive Case:</b> If {@code n > 0}, return {@code n * factorial(n - 1)}.</p>
 *
 * <p><b>Time Complexity:</b> O(n)</p>
 * <p><b>Space Complexity:</b> O(n) due to recursion stack</p>
 *
 * @param n the number to compute factorial for (must be non-negative)
 * @return the factorial of {@code n}
 * @throws IllegalArgumentException if {@code n} is negative
 *
 * <p>Example:</p>
 * <pre>
 * int result = factorial(5);  // returns 120
 * </pre>
 */
public static int factorial(int n) {
    if (n < 0) {
        throw new IllegalArgumentException("n must be non-negative");
    }
    if (n == 0) return 1;  // base case
    return n * factorial(n - 1);  // recursive case
}

// --- Test / Output ---
int testValue = 5;
System.out.println("Factorial of " + testValue + " is: " + factorial(testValue));


Factorial of 5 is: 120

Challenge 2 Team Documentation Standard

Document:

  • Public classes and methods
  • Anything that’s tricky, like recursive stuff or complex algorithms
  • Methods that change data, save files, talk to databases, etc.
  • Anything other people will actually use

Don’t need documenting:

  • Private helper methods that are super simple
  • Getters/setters that just return or set a value
  • Code that’s obvious (no need to write “adds 1 to x”)

JavaDoc Tags Guide

Public Methods

  • @param → what the inputs mean
  • @return → what it gives back
  • @throws → any errors it might throw
  • @since → when it was added
  • @version → version number

Classes

  • @author
  • @version
  • @since
  • Maybe a short example usage

Private / Simple Methods

  • Optional comment only if it will help

Challenge 3 Team Documentation Standard

Before

public double calculateTotal(List<Item> items) {
    double total = 0;
    for (Item item : items) {
        total += item.getPrice();
    }
    return total;
}

After

/**
 * Calculates the total price of a list of items.
 *
 * This method will iterate through the provided list of {@link Item} objects,
 * summing their prices to compute the total amount.
 *
 * @param items a list of {@link Item} objects to calculate the total price for
 * @return the total price as a {@code double}
 * @throws IllegalArgumentException if the {@code items} list is {@code null}
 *
 * @see Item
 */
public double calculateTotal(List<Item> items) {
    if (items == null) {
        throw new IllegalArgumentException("Items list cannot be null");
    }
    double total = 0;
    for (Item item : items) {
        total += item.getPrice();
    }
    return total;
}