Fast I/O, Judges & Debugging

1class Main {2    public static void main(String[] args) {3        Scanner in = new Scanner(System.in);4        int n = in.nextInt();                  // first token: how many numbers follow5        long sum = 0;                          // n values up to 10^9 overflow int: use long6        for (int i = 0; i < n; i++) sum += in.nextInt(); // any spaces or newlines between them7        System.out.println(sum);8    }9}

1class LineTrap {2    static String readAgeThenName(String input) {3        Scanner in = new Scanner(input);4        int age = in.nextInt();                // reads "21" but leaves the '\n' behind5        String rest = in.nextLine();           // returns "" — the rest of the age line!6        String name = in.nextLine();           // only now the real next line7        return age + "|" + rest + "|" + name;8    }9 10    static String readAgeThenNameFixed(String input) {11        Scanner in = new Scanner(input);12        int age = Integer.parseInt(in.nextLine().trim()); // read whole lines, parse yourself13        String name = in.nextLine();14        return age + "|" + name;15    }16}

1class Main {2    public static void main(String[] args) throws IOException {3        FastReader in = new FastReader(System.in);4        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));5        int n = in.nextInt();6        long sum = 0;7        for (int i = 0; i < n; i++) sum += in.nextInt();8        out.println(sum);9        out.flush();                       // forget this and the judge sees NOTHING10    }11 12    /** Reads whitespace-separated tokens, whatever the line layout. */13    static class FastReader {14        private final BufferedReader br;15        private StringTokenizer st;16 17        FastReader(InputStream stream) {18            br = new BufferedReader(new InputStreamReader(stream), 1 << 16); // 64 KB buffer19        }20 21        String next() throws IOException {22            while (st == null || !st.hasMoreTokens()) {23                String line = br.readLine();24                if (line == null) return null;        // end of input25                st = new StringTokenizer(line);       // splits on spaces and tabs26            }27            return st.nextToken();28        }29 30        int nextInt() throws IOException {31            return Integer.parseInt(next());32        }33 34        long nextLong() throws IOException {35            return Long.parseLong(next());36        }37    }38}

1class ManyLines {2    static void printSquares(int n) {3        StringBuilder sb = new StringBuilder();4        for (int i = 1; i <= n; i++) sb.append((long) i * i).append('\n'); // collect...5        System.out.print(sb);                                              // ...print once6    }7}

1class Main {2    public static void main(String[] args) throws IOException {3        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));4        StringBuilder out = new StringBuilder();5        String line;6        while ((line = br.readLine()) != null) {   // null means: no more input (EOF)7            line = line.trim();8            if (line.isEmpty()) continue;          // tolerate blank lines9            StringTokenizer st = new StringTokenizer(line);10            long a = Long.parseLong(st.nextToken());11            long b = Long.parseLong(st.nextToken());12            out.append(a + b).append('\n');        // one answer per input line13        }14        System.out.print(out);                     // one big write at the end15    }16}

1class MiniJudge {2    interface Program {3        void run() throws Exception;4    }5 6    static String judge(String input, String expected, Program program, long limitMs) {7        InputStream realIn = System.in;8        PrintStream realOut = System.out;9        ByteArrayOutputStream captured = new ByteArrayOutputStream();10        System.setIn(new ByteArrayInputStream(input.getBytes(StandardCharsets.UTF_8))); // test input becomes stdin11        System.setOut(new PrintStream(captured, true, StandardCharsets.UTF_8));         // stdout goes into a buffer12        long start = System.nanoTime();13        try {14            program.run();                                       // your main runs here15        } catch (Throwable crash) {16            return "RE: " + crash.getClass().getSimpleName();    // it crashed17        } finally {18            System.setIn(realIn);19            System.setOut(realOut);20        }21        long ms = (System.nanoTime() - start) / 1_000_000;22        if (ms > limitMs) return "TLE";              // a real judge kills you AT the limit23        String got = normalize(captured.toString(StandardCharsets.UTF_8));24        return got.equals(normalize(expected)) ? "AC" : "WA";25    }26 27    /** Ignores \r, spaces at line ends and blank lines at the very end — nothing else. */28    static String normalize(String text) {29        StringBuilder sb = new StringBuilder();30        for (String line : text.replace("\r", "").split("\n")) sb.append(line.stripTrailing()).append('\n');31        return sb.toString().stripTrailing();32    }33}

1class Submissions {2    /** AC: read n, then n numbers on one line; print their sum. */3    static void correct() throws IOException {4        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));5        int n = Integer.parseInt(br.readLine().trim());6        StringTokenizer st = new StringTokenizer(br.readLine());7        long sum = 0;8        for (int i = 0; i < n; i++) sum += Long.parseLong(st.nextToken());9        System.out.println(sum);10    }11 12    /** WA: the loop stops one number early. */13    static void offByOne() throws IOException {14        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));15        int n = Integer.parseInt(br.readLine().trim());16        StringTokenizer st = new StringTokenizer(br.readLine());17        long sum = 0;18        for (int i = 0; i < n - 1; i++) sum += Long.parseLong(st.nextToken());19        System.out.println(sum);20    }21 22    /** RE: parses the whole line "3 9 4" as ONE number -> NumberFormatException. */23    static void crash() throws IOException {24        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));25        br.readLine();                                   // skip n26        System.out.println(Long.parseLong(br.readLine())); // the line has spaces in it27    }28 29    /** WA with the right logic: the PrintWriter is never flushed, so stdout stays empty. */30    static void noFlush() throws IOException {31        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));32        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));33        int n = Integer.parseInt(br.readLine().trim());34        StringTokenizer st = new StringTokenizer(br.readLine());35        long sum = 0;36        for (int i = 0; i < n; i++) sum += Long.parseLong(st.nextToken());37        out.println(sum);                                // waits in the buffer... then main ends38    }39}

1class Bugs {2    static int lastElement(int[] a) {3        return a[a.length];                  // off by one -> ArrayIndexOutOfBoundsException4    }5 6    static char firstChar(String s) {7        return s.charAt(0);                  // s is null -> NullPointerException8    }                                        // ("" -> StringIndexOutOfBoundsException)9 10    static int parse(String token) {11        return Integer.parseInt(token);      // "12a", "", " 7" -> NumberFormatException12    }13 14    static int average(int sum, int count) {15        return sum / count;                  // count == 0 -> ArithmeticException: / by zero16    }17 18    static void removeEvens(List<Integer> list) {19        for (Integer x : list) {20            if (x % 2 == 0) list.remove(x);  // changing a list while for-each walks it21        }                                    // -> ConcurrentModificationException22    }23 24    static int depth(int n) {25        return 1 + depth(n + 1);             // no base case -> StackOverflowError26    }27 28    static long[] hugeTable() {29        return new long[Integer.MAX_VALUE];  // ~16 GB, far past any judge's limit -> OutOfMemoryError30    }31}

1class Unwinding {2    static int total(String[] rows) {3        try {4            return sumRows(rows);5        } catch (NumberFormatException e) {6            return -1;                                   // the exception lands here7        }8    }9 10    static int sumRows(String[] rows) {                  // no catch here: it just passes through11        int sum = 0;12        for (String row : rows) sum += parseRow(row);13        return sum;14    }15 16    static int parseRow(String row) {                    // no catch here either17        int s = 0;18        for (String token : row.split(",")) {19            s += Integer.parseInt(token.trim());         // "7x" -> throws20        }21        return s;22    }23}

1class Tools {2    static int maxOf(int[] a) {3        assert a.length > 0 : "maxOf needs at least one element"; // checked only with java -ea4        int best = a[0];5        for (int i = 1; i < a.length; i++) {6            // System.err.println("i=" + i + " a[i]=" + a[i] + " best=" + best); // print debugging7            if (a[i] > best) best = a[i];8        }9        return best;10    }11 12    static String trace(int[] a) {13        StringBuilder table = new StringBuilder("i a[i] best\n");   // a dry-run table, printed14        int best = a[0];15        for (int i = 1; i < a.length; i++) {16            if (a[i] > best) best = a[i];17            table.append(i).append(' ').append(a[i]).append(' ').append(best).append('\n');18        }19        return table.toString();20    }21}

1class OwnTests {2    static int failures = 0;3 4    static void expect(String name, int got, int want) {5        if (got != want) {6            failures++;7            System.err.println("FAIL " + name + ": got " + got + ", want " + want);8        }9    }10 11    static int runAll() {12        failures = 0;13        expect("the example", Tools.maxOf(new int[] {3, 9, 2}), 9);14        expect("single element", Tools.maxOf(new int[] {5}), 5);15        expect("all negative", Tools.maxOf(new int[] {-4, -2, -8}), -2);16        expect("max at the end", Tools.maxOf(new int[] {1, 2, 3}), 3);17        expect("all equal", Tools.maxOf(new int[] {7, 7, 7}), 7);18        expect("int limits", Tools.maxOf(new int[] {Integer.MIN_VALUE, Integer.MAX_VALUE}), Integer.MAX_VALUE);19        return failures;20    }21}

1class Shrink {2    interface Bug {3        boolean showsOn(int[] input);4    }5 6    /** Drops one element at a time while the bug still shows: a big failing input becomes a tiny one. */7    static int[] shrink(int[] failing, Bug bug) {8        int[] current = failing.clone();9        boolean smaller = true;10        while (smaller) {11            smaller = false;12            for (int i = 0; i < current.length && !smaller; i++) {13                int[] candidate = without(current, i);14                if (bug.showsOn(candidate)) {    // still broken without element i?15                    current = candidate;         // keep the smaller input and start again16                    smaller = true;17                }18            }19        }20        return current;21    }22 23    static int[] without(int[] a, int skip) {24        int[] b = new int[a.length - 1];25        for (int i = 0, j = 0; i < a.length; i++) if (i != skip) b[j++] = a[i];26        return b;27    }28}