Fast I/O in java for Competitive programming

CSES problem Set.

One day I was solving a problem on the CSES problem set of graph theory and one famous problem LCMSUM of SPOJ which the application of Eular totient function in Number theory . I got TLE again and again I was surprised because I debug my code twice but still, I got TLE. I thought can I try in c++ and after that, I wrote the same code in c++ and got accepted. I understand why this thing happen because I was using Scanner class for Input which was too slow for cp. I searched on the Internet and I got to know about different types of classes used for fast I/O.Some of them I am going to discuss with you. Reader class is my favorite class for cp which is accepted in around 0.29 sec which is the fastest one among all the I/O classes. In competitive programming, it is important to read input as fast as possible so we save valuable time.

spoj

1. Scanner:- It is easy to type but still it is slow. So I can’t recommend it for cp. In most cases, we get TLE while using the scanner class. It uses built-in next(), next long(), nextDouble methods to read the desired object after initiating the scanner object with the input stream. This method takes 3.37s and 106M.

e.g.

import java.util.Scanner;

public class Main {

public static void main(String[] args)

{

Scanner s = new Scanner(System.in);

int n = s.nextInt();

int k = s.nextInt();

int count = 0;

while (n-- > 0) {

int x = s.nextInt();

if (x % k == 0)

count++;

}

System.out.println(count);}}

2. BufferedReader :-These get accepted with a running time of approx 0.89 s.but still as you can see it requires a lot of typing altogether.

eg.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
public static void main(String[] args)
throws IOException
{

BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));

StringTokenizer st
= new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int k = Integer.parseInt(st.nextToken());
int count = 0;
while (n → 0) {
int x = Integer.parseInt(br.readLine());
if (x % k == 0)
count++;
}
System.out.println(count);
}
}

3.Reader Class :-There is yet another fast way through the problem, I would say the fastest way.These get accepted with a surprising time of just 0.28 s. Although this is ultra-fast.

e.g.Template of this class from oracle documentation

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;

public Reader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}

public Reader(String file_name) throws IOException
{
din = new DataInputStream(
new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}

public String readLine() throws IOException
{
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == ‘\n’) {
if (cnt != 0) {
break;
}
else {
continue;
}
}
buf[cnt++] = (byte)c;
}
return new String(buf, 0, cnt);
}

public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ‘ ‘) {
c = read();
}
boolean neg = (c == ‘-’);
if (neg)
c = read();
do {
ret = ret * 10 + c — ‘0’;
} while ((c = read()) >= ‘0’ && c <= ‘9’);

if (neg)
return -ret;
return ret;
}

public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ‘ ‘)
c = read();
boolean neg = (c == ‘-’);
if (neg)
c = read();
do {
ret = ret * 10 + c — ‘0’;
} while ((c = read()) >= ‘0’ && c <= ‘9’);
if (neg)
return -ret;
return ret;
}

public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ‘ ‘)
c = read();
boolean neg = (c == ‘-’);
if (neg)
c = read();

do {
ret = ret * 10 + c — ‘0’;
} while ((c = read()) >= ‘0’ && c <= ‘9’);

if (c == ‘.’) {
while ((c = read()) >= ‘0’ && c <= ‘9’) {
ret += (c — ‘0’) / (div *= 10);
}
}

if (neg)
return -ret;
return ret;
}

private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0,
BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}

private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}

public void close() throws IOException
{
if (din == null)
return;
din.close();
}
}

public static void main(String[] args)
throws IOException
{
Reader s = new Reader();
int n = s.nextInt();
int k = s.nextInt();
int count = 0;
while (n → 0) {
int x = s.nextInt();
if (x % k == 0)
count++;
}
System.out.println(count);
}
}