ICS3U computer science help, in Python or Java

The problem. A student logs the minutes they practise coding each day. Given the daily log and a goal, find the longest run of consecutive days on which they practised at least the goal, and the day that run started. Days are numbered from 1. If no day meets the goal, report 0 and 0. If two runs tie, report the earlier one.

1. Restate the output. Two numbers: a length and a start day. Writing this down first stops the classic half-answer that reports the length and forgets the start.
2. Decide what to remember while walking the array once. The current run (how long, and where it began) and the record so far (how long, and where it began). Four variables, each with one job.
3. Write the rule for one day. If the day meets the goal, the current run grows by one, and if it was 0 it begins today. If the day misses the goal, the current run drops to 0.
4. Decide when to update the record. Every time the current run grows, compare it with the record. Updating only when a run breaks misses a run that lasts to the final day, which is the bug in practice question 7.
5. Decide the tie rule in code. Use strictly greater than. An equal run never replaces the record, so the earlier run wins, as the problem asks.
6. List the extreme cases before running anything. An empty log, a log where no day qualifies, a single day exactly at the goal, a run that ends on the last day, and two runs of equal length.

# Longest run of days at or above a goal (ours)

def longest_run(minutes, goal):
    """Return (length, start_day) of the longest run of days
    with minutes >= goal. Days are numbered from 1.
    No qualifying day gives (0, 0). On a tie, the earlier run wins."""
    record_len = 0
    record_start = 0
    run_len = 0
    run_start = 0
    for i in range(len(minutes)):
        if minutes[i] >= goal:
            if run_len == 0:          # a new run begins today
                run_start = i + 1     # day numbers start at 1
            run_len += 1
            if run_len > record_len:  # strictly greater: a tie keeps the earlier run
                record_len = run_len
                record_start = run_start
        else:
            run_len = 0               # the run is broken
    return record_len, record_start


log = [35, 40, 10, 30, 45, 50, 20, 30, 30, 30]
length, start = longest_run(log, 30)
print("Longest run:", length, "days, starting on day", start)

// Longest run of days at or above a goal (ours)
public class LongestRun {

    // Returns {length, startDay}. Days are numbered from 1.
    // No qualifying day gives {0, 0}. On a tie, the earlier run wins.
    public static int[] longestRun(int[] minutes, int goal) {
        int recordLen = 0;
        int recordStart = 0;
        int runLen = 0;
        int runStart = 0;
        for (int i = 0; i < minutes.length; i++) {
            if (minutes[i] >= goal) {
                if (runLen == 0) {          // a new run begins today
                    runStart = i + 1;       // day numbers start at 1
                }
                runLen++;
                if (runLen > recordLen) {   // strictly greater: a tie keeps the earlier run
                    recordLen = runLen;
                    recordStart = runStart;
                }
            } else {
                runLen = 0;                 // the run is broken
            }
        }
        return new int[] {recordLen, recordStart};
    }

    public static void main(String[] args) {
        int[] log = {35, 40, 10, 30, 45, 50, 20, 30, 30, 30};
        int[] result = longestRun(log, 30);
        System.out.println("Longest run: " + result[0] + " days, starting on day " + result[1]);
    }
}

1. 16. range(1, 8, 2) starts at 1, steps by 2 and stops before 8, so k takes 1, 3, 5 and 7, and the total is 1 + 3 + 5 + 7 = 16. The stop value is never included: the habit to check whenever range appears.
2. 3 1 3.5. With two ints, x / y is integer division, so 7 / 2 is 3. x % y is the remainder, 1. The cast turns x into 7.0 before the division, so the third part is 3.5. The cast applies to x only, which is why it has to come first.
3. 42 15 23. len(nums) - 1 is 5, the last index. nums[2] is the third element, because indexes start at 0. nums[-2] counts from the end and is 23. Java has no negative indexes; there you would write nums[nums.length - 2].
4. 9. The trace of n is 12, 6, 3, 10, 5, 16, 8, 4, 2, 1, with steps counting each change, so steps ends at 9. Tracing a while loop is about the condition: the loop body runs only while n is not 1, so the final 1 is never processed.
5. A run-time error. With <=, i reaches 3, but the last index of a three-element array is 2, so Java throws ArrayIndexOutOfBoundsException (Index 3 out of bounds for length 3). Change <= to <. Fixed, it prints 221.
6. It prints 0; it should print -3. This is a logic error: the program runs without complaint and gives a wrong answer. Starting top at 0 assumes every value is positive, and none of these are. Start with the first element instead: top = temps[0], and decide separately what an empty list should do (return None, or refuse it).
7. It prints 0; it should print 3. The record is only updated when a run breaks, and this run never breaks: it lasts to the last day. Either add the same comparison once more after the loop (if run is greater than record, copy it across), or update the record every time the run grows, as the worked problem does. Testing a run that ends on the last day is the extreme case that finds it.
8. It returns 1. Only 90 is strictly greater than 72; both 72s are equal, so they do not count. The test that matters is a value equal to the limit, because that is where greater-than and greater-than-or-equal disagree. Both versions are in the code below.
9. See the code below. Numbers below 2 are not prime. For anything else, try divisors from 2 while the divisor squared is at most n: if n had a factor larger than its square root, its partner factor would be smaller and already tried. Test with -3, 0, 1 (not prime), 2 (the smallest prime and the only even one), 9 (a square, the edge of the loop), 29 (prime) and a large prime. Our run listed 2, 3, 5, 7, 11, 13, 17, 19, 23 and 29 as the primes below 30.
10. (a) A one-dimensional array or list of 30 numbers: one pass to total them, a second pass to count those above the average. (b) At ICS3U level, two parallel arrays, one of words and one of counts, with a linear search for each word; a Python dictionary or a Java HashMap does the same job faster and is worth learning next. (c) Parallel arrays of names and marks work if every swap during sorting moves both arrays together; in ICS4U the cleaner answer is one array of student objects, which the Grade 12 curriculum describes as arrays of “compound data types”.

def count_above(values, limit):
    count = 0
    for v in values:
        if v > limit:        # strictly above: equal does not count
            count += 1
    return count

print(count_above([55, 72, 90, 72, 40], 72))   # 1

public static int countAbove(int[] values, int limit) {
    int count = 0;
    for (int v : values) {
        if (v > limit) {     // strictly above: equal does not count
            count++;
        }
    }
    return count;
}

def is_prime(n):
    if n < 2:                # 1, 0 and negatives are not prime
        return False
    d = 2
    while d * d <= n:        # a factor pair always has one side at most the square root
        if n % d == 0:
            return False
        d += 1
    return True

public static boolean isPrime(int n) {
    if (n < 2) {             // 1, 0 and negatives are not prime
        return false;
    }
    for (int d = 2; d * d <= n; d++) {
        if (n % d == 0) {
            return false;
        }
    }
    return true;
}

1. Find out what the final evaluation is. Ask whether there is a written exam, a coding exam on the computer, a project, or a mix, and how much each part is worth. The curriculum allows an examination, performance, essay or other method.
2. Audit the course outline. List every unit from the school’s own outline and mark each one solid, shaky or lost. Start revision with the shaky ones, not the lost ones: they move fastest.
3. Rebuild the vocabulary. Data type, array, index, bound, parameter, return value, local and global scope, syntax, logic and run-time error. Write a one-line definition and a two-line example for each.
4. Trace by hand every day. Three short programs a day, on paper, with a trace table, before running them. Written questions often ask students to read code, and tracing is how you read it.
5. Rewrite the classic algorithms from a blank file. Total, highest or lowest, count, linear search, then inserting into a sorted array. No notes, no copying, then compare with your class versions.
6. Practise the three kinds of error. Take a working program, plant one syntax, one logic and one run-time error, and swap with a classmate. Naming the kind of error is often its own exam question.
7. Write one complete test plan. For one of your programs: normal values, boundary values and invalid input, with expected results written before you run it.
8. Finish the project before polishing it. Keep a saved working version at every milestone, write the documentation as you go, and stop adding features a week before it is due.
9. Sit one timed practice under exam conditions. Use your own old tests and our ten questions above, at the real length, with no computer for the written part.
10. Use the last day for review only. Reread your error log and trace tables. No new topics the night before.