GCJMain - nise-nabe/topcoder GitHub Wiki

import java.io.IOException;
import java.io.InputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;
import java.util.concurrent.Executors;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Solution {
    public static void main(String[] args) throws IOException {
        new GCJMain().main(s -> {
            return "";
        });
    }

    public static class GCJMain implements Comparable<GCJMain> {
        @Override
        public int compareTo(GCJMain o) {
            return t - o.t;
        }

        @Override
        public String toString() {
            return String.format("Case #%d: %s", t, output);
        }

        public void main(Function<Scanner, String> f) throws IOException {
            main(s -> new Scanner(s.nextLine()), f);
        }

        public void main(
                Function<Scanner, Scanner> g,
                Function<Scanner, String> f
        ) throws IOException {
            InputStream is = System.in;
            boolean debug = false;
            if (debug) {
                PipedOutputStream pos = new PipedOutputStream();
                PrintWriter pw = new PrintWriter(pos);

                is = new PipedInputStream(pos);

                Executors.newSingleThreadExecutor().execute(() -> {
                    pw.println("");
                    pw.close();
                });
            }

            Scanner s = new Scanner(is);
            IntStream.iterate(1, t -> 1 + t).limit(Integer.valueOf(s.nextLine()))
                     .mapToObj(i -> builder().t(i).s(s).f(f).g(g).build())
                     .collect(Collectors.toList())
                     .parallelStream().map(GCJMain::run).sorted()
                     .collect(Collectors.toList())
                     .forEach(System.out::println);
        }

        private static class GCJMainBuilder {
            GCJMain main = new GCJMain();

            public GCJMainBuilder t(int t) {
                main.t = t;
                return this;
            }

            public GCJMainBuilder s(Scanner s) {
                main.s = main.g.apply(s);
                return this;
            }

            public GCJMainBuilder f(Function<Scanner, String> f) {
                main.f = f;
                return this;
            }

            public GCJMainBuilder g(Function<Scanner, Scanner> g) {
                main.g = g;
                return this;
            }

            public GCJMain build() {
                return main;
            }
        }

        public static GCJMainBuilder builder() {
            return new GCJMainBuilder();
        }

        private int t;
        private Scanner s;
        private String output;
        private Function<Scanner, String> f;
        private Function<Scanner, Scanner> g;

        private IntStream it(int init) {
            return IntStream.iterate(init, i -> i + 1);
        }


        public GCJMain run() {
            output = f.apply(s);
            return this;
        }
    }
}