Fast data input-output for competitive programming in Java 11

#	User	Rating
1	tourist	4009
2	jiangly	3823
3	Benq	3738
4	Radewoosh	3633
5	jqdai0815	3620
6	orzdevinwang	3529
7	ecnerwala	3446
8	Um_nik	3396
9	ksun48	3390
10	gamegame	3386

#	User	Contrib.
1	cry	165
2	maomao90	163
2	Um_nik	163
4	atcoder_official	161
5	adamant	160
6	-is-this-fft-	158
7	awoo	157
8	TheScrasse	154
9	nor	153
9	Dominater069	153

Hello Codeforces Community,

This is an educational blog intended for some newbie and pupil rating members. I assume that members with higher rating and many other members are already aware of its contents. It is well-known that the Time-Limit Exceeded (TLE) Verdict received from the automatic judge in competitive programming contests and practicing using Java language is sometimes not because the computations involved in solving the problem are too time-consuming, but because the data input operations from System.in stream and/or data output operations to System.out stream are not fast enough. The following is a Java 11 simple template for data input-output using InputStreamReader, BufferedReader and BufferedOutputStream library classes.

Fast data input-output in Java

import java.io.*;
import java.math.*;
import java.util.*;

public final class Main {
	private static final class tokens extends LinkedList<String> {
		tokens(String line) { 
			super(new LinkedList<String>()); 
			for (var token: line.split(" "))
				add(token); } 
		String        nextStr() { return remove(); }
		int           nextInt() { return Integer.parseInt(remove()); } 
		long         nextLong() { return Long.parseLong(remove()); }
		double        nextDbl() { return Double.parseDouble(remove()); } 
		BigInteger nextBigInt() { return new BigInteger(remove()); } }
	private static tokens nextLine(BufferedReader cin) { 
		String line = null;
		try { line = cin.readLine(); }
		catch (IOException e) { e.printStackTrace(); }
		return new tokens(line); }
	private static byte[] to_bytes(String s)           { return s.getBytes(); }
	private static byte[] to_bytes(Integer x)          { return to_bytes(x.toString()); }
	private static byte[] to_bytes(Long x)             { return to_bytes(x.toString()); }
	private static byte[] to_bytes(String f, Double x) { return to_bytes(String.format(f,x)); }
	private static byte[] to_bytes(BigInteger x)       { return to_bytes(x.toString()); }
	private final static byte[] space = to_bytes(" ");
	private final static byte[] endl  = to_bytes("\n");
	public static void main(String[] args) throws IOException {
		final var cin  = new BufferedReader(new InputStreamReader(System.in));
		final var cout = new BufferedOutputStream(System.out);
		cout.flush(); } }

The program declares a queue-based tokens class to parse multiple data items in the same line and push them to the rear of the data queue using LinkedList utility object. The next...() member function, where ... stands for the data-item type, is used to get the next data item from the queue front. Helper functions to_bytes(... x), where ... stands for the data-item type, are declared to convert data item to byte[] array that can be written to the buffered output stream using BufferedOutputStream::write(byte[]) function call. It is always necessary to call the BufferedOutputStream::flush() member function before quitting from the main() function, so as to flush the buffered output stream by sending its contents to System.out.

The following is the main() function has been used for solving 1100C - NN and the Optical Illusion based on this template program.

Example


    public static void main(String[] args) throws IOException {
        final var cin  = new BufferedReader(new InputStreamReader(System.in));
        final var cout = new BufferedOutputStream(System.out);
        final var input = nextLine(cin);
        final var n = input.nextInt();
        final var r = input.nextInt();
        cout.write(to_bytes("%.7f",r/(1.0/Math.sin(Math.PI/n)-1.0)));
        cout.flush(); }

Note that writing floating-point data items requires an additional format string parameter to specify the number of decimal digits after the decimal floating point.

References

A GitHub.com version of this blog can be found in the following link: Fast data input-output for competitive programming in Java 11.

Your constructive comments and feedback are welcome.

Update

The following is another example for the template program: Submissions for 1600J - Robot Factory which use the same code except for the input-output streams.