Input in comptetion java best

Link-> Link 

Haan bhai, Java me input lene ke 2–3 tareeke hote hain, aur competitive programming (Codeforces, CodeChef, AtCoder) me Scanner slow hota hai, isliye log fast I/O use karte hain.

Neeche main sari approaches explain karta hoon example ke saath:

---

✅ 1. Scanner (Slow – avoid in CP)

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();

Yeh easy hai, par slow hai because:

• Har read par regex check hota hai

• Synchronization cost high hoti hai

---

✅ 2. BufferedReader + StringTokenizer (Fast – CP standard)

➡️ Competitive programming me sabse zyada use hota hai

Example:

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

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());

        System.out.println(a + b);
    }
}

Kyu fast hai?

• BufferedReader ek baar me bada chunk read karta hai

• StringTokenizer bina regex ke fast splitting karta hai

⭐ Codeforces ke 90% Java users yahi use karte hain.

---

✅ 3. Custom FastReader Class (Fastest & Cleanest)

Jab bahut saara input ho (1e6 integers), log FastReader banate hain:

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

class FastReader {
    BufferedReader br;
    StringTokenizer st;

    FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() throws IOException {
        while (st == null || !st.hasMoreElements()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    String nextLine() throws IOException {
        return br.readLine();
    }
}

Use:

FastReader fr = new FastReader();
int n = fr.nextInt();

⭐ Yeh CP me best mix of speed + convenience deta hai.

---

⚡ 4. Even Faster: InputStream-based Reader (Ultra Fast)

Jab input extremely huge ho (10^7 chars), yeh use hota hai:

private static final InputStream in = System.in;
private static byte[] buffer = new byte[1 << 16];
private static int ptr = 0, len = 0;

private static int read() throws IOException {
    if (ptr >= len) {
        len = in.read(buffer);
        ptr = 0;
        if (len <= 0) return -1;
    }
    return buffer[ptr++];
}

static int nextInt() throws Exception {
    int c;
    while ((c = read()) <= ' ') ;
    int sign = (c == '-') ? -1 : 1;
    if (c == '-') c = read();

    int val = 0;
    while (c > ' ') {
        val = val * 10 + (c - '0');
        c = read();
    }
    return val * sign;
}

⚠️ Hard to write → only extreme input cases me use hota hai.

---

🔥 Summary: Which one to use?

Method	Speed	CP Suitable?	Notes
Scanner	❌ Slow	❌ No	Easy but slow
BufferedReader + StringTokenizer	⭐ Fast	⭐ Yes	Most common
FastReader class	⭐⭐ Very Fast	⭐⭐ Yes	Best mix
Custom InputStream parser	🚀 Ultra Fast	⚡ Only heavy input	Hard to write

---

⭐ Recommended for you

Codeforces, LeetCode hard I/O problems me FastReader ya BufferedReader + StringTokenizer use karo.

Agar chaahe to main tumhare liye ek template bana dun jo tum directly CF me paste kar sako?