ICS3U vs ICS3C: which Grade 11 computer course fits?

# Fuel use for a car trip, with checked input (ours, an ICS3C-style task)

def read_number(prompt, low, high):
    """Keep asking until the user types a number from low to high."""
    while True:
        text = input(prompt)
        try:
            value = float(text)
        except ValueError:
            print("That is not a number. Try again.")
            continue
        if low < value <= high:
            return value
        print("Please type a number above", low, "and up to", high)


def litres_per_100_km(litres, km):
    return litres / km * 100


km = read_number("Distance driven in km: ", 0, 5000)
litres = read_number("Fuel used in litres: ", 0, 500)
rate = litres_per_100_km(litres, km)
print("Fuel use:", round(rate, 1), "L/100 km")
if rate < 6:
    print("Rating: efficient")
elif rate <= 10:
    print("Rating: typical")
else:
    print("Rating: thirsty")

Run with the inputs four hundred, -20, 412 and 31.5, it rejects the first two, then prints Fuel use: 7.6 L/100 km and Rating: typical. The try and except block is the run-time error handling the ICS3C expectations ask for.

// Fuel use for a car trip, with checked input (ours, an ICS3C-style task)
import java.util.Scanner;

public class Fuel {
    static Scanner in = new Scanner(System.in);

    // Keep asking until the user types a number above low and up to high.
    static double readNumber(String prompt, double low, double high) {
        while (true) {
            System.out.print(prompt);
            String text = in.nextLine().trim();
            try {
                double value = Double.parseDouble(text);
                if (value > low && value <= high) {
                    return value;
                }
                System.out.println("Please type a number above " + low + " and up to " + high);
            } catch (NumberFormatException e) {
                System.out.println("That is not a number. Try again.");
            }
        }
    }

    public static void main(String[] args) {
        double km = readNumber("Distance driven in km: ", 0, 5000);
        double litres = readNumber("Fuel used in litres: ", 0, 500);
        double rate = litres / km * 100;
        System.out.printf("Fuel use: %.1f L/100 km%n", rate);
    }
}

Same inputs, same result line. One small difference worth noticing: Java prints the limits as 0.0 and 5000.0 because they are doubles, where the Python version prints 0 and 5000.

# Add a value to a sorted list without sort() or insert() (ours, an ICS3U-style task)

def insert_sorted(values, new):
    """values is sorted from low to high. Return a new list with
    new placed so the order is kept."""
    result = values + [None]          # one extra slot at the end
    i = len(values) - 1
    while i >= 0 and result[i] > new:
        result[i + 1] = result[i]     # shift bigger values one place right
        i -= 1
    result[i + 1] = new               # the gap is where new belongs
    return result


marks = [52, 61, 70, 84, 93]
print(insert_sorted(marks, 77))
print(insert_sorted(marks, 40))
print(insert_sorted(marks, 99))
print(insert_sorted([], 5))

Prints [52, 61, 70, 77, 84, 93], then [40, 52, 61, 70, 84, 93], then [52, 61, 70, 84, 93, 99], then [5]. The last three lines test the edges: a new smallest value, a new largest value and an empty list.

// Add a value to a sorted array, keeping the order (ours, an ICS3U-style task)
import java.util.Arrays;

public class InsertSorted {

    // count says how many slots of values are in use; the array has room for one more.
    public static int insertSorted(int[] values, int count, int newValue) {
        int i = count - 1;
        while (i >= 0 && values[i] > newValue) {
            values[i + 1] = values[i];      // shift bigger values one place right
            i--;
        }
        values[i + 1] = newValue;           // the gap is where newValue belongs
        return count + 1;                   // one more slot is now in use
    }

    public static void main(String[] args) {
        int[] marks = new int[6];
        int[] start = {52, 61, 70, 84, 93};
        for (int k = 0; k < start.length; k++) {
            marks[k] = start[k];
        }
        int count = insertSorted(marks, 5, 77);
        System.out.println(Arrays.toString(Arrays.copyOf(marks, count)));
    }
}

Prints [52, 61, 70, 77, 84, 93]. A Java array cannot grow, so the program keeps a count of the slots in use: a pattern ICS3U Java classes meet often.