Fast data input-output for competitive programming in Java 11

#	User	Rating
1	tourist	3985
2	jiangly	3814
3	jqdai0815	3682
4	Benq	3529
5	orzdevinwang	3526
6	ksun48	3517
7	Radewoosh	3410
8	hos.lyric	3399
9	ecnerwala	3392
9	Um_nik	3392

#	User	Contrib.
1	cry	169
2	maomao90	162
2	Um_nik	162
4	atcoder_official	161
5	djm03178	158
6	-is-this-fft-	157
7	adamant	155
8	awoo	154
8	Dominater069	154
10	luogu_official	150

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.