Node.js Input Masterclass for Competitive Programming

1. Conceptual Comparison (Java vs. Node.js)

To understand why Node.js uses these code styles, see how they match up to the Java classes you already know:

Java Concept	Node.js Equivalent	Execution Type	Behavioral Difference
`Scanner` (reading tokens)	`fs.readFileSync(0).trim().split(/\s+/)`	Synchronous	Reads the whole block as one string instantly, and tokenizes it by empty whitespace characters.
`BufferedReader` (line-by-line)	`readline` with `.on("line")`	Asynchronous	Doesn't pause execution. Instead, processes lines as separate asynchronous events pushed to the stack.
`StringTokenizer`	`line.split(/\s+/)`	Synchronous	Parses strings directly on delimiter regex sequences instantly.

2. The 5 Core Node.js Input Methods

Select any method to view its optimal, clean boilerplate configuration:

🚀 Best Practice: Use this for Codeforces, AtCoder, and any timed standard runtimes.

const fs = require("fs");

function solve() {
  // Reads entire input instantly, splits into lines, and trims outer space
  const input = fs.readFileSync(0, "utf-8").trim().split(/\r?\n/);
  if (input.length === 0 || input[0] === "") return;

  // Assuming input: 
  // Line 1: "5 3"
  // Line 2: "10 20 30 40 50"
  const [n, k] = input[0].split(" ").map(Number);
  const arr = input[1].split(" ").map(Number);

  console.log(`N: ${n}, K: ${k}`);
  console.log("Array Elements:", arr);
}

solve();

💡 Perfect for interactive live code editor interviews (e.g., CoderPad).

const readline = require("readline/promises");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

async function main() {
  const line1 = await rl.question("");
  const [n, k] = line1.split(" ").map(Number);

  const line2 = await rl.question("");
  const arr = line2.split(" ").map(Number);

  console.log(`Parsed: N=${n}, K=${k}`, arr);
  rl.close();
}

main();

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Avoid using this nested callback approach unless your node environment is < v16.0.0
rl.question("", (line1) => {
  const [n, k] = line1.split(" ").map(Number);

  rl.question("", (line2) => {
    const arr = line2.split(" ").map(Number);
    console.log(`Success: N=${n}, K=${k}`, arr);
    
    rl.close();
  });
});

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

const inputLines = [];

rl.on("line", (line) => {
  inputLines.push(line.trim());
});

rl.on("close", () => {
  if (inputLines.length < 2) return;
  const [n, k] = inputLines[0].split(" ").map(Number);
  const arr = inputLines[1].split(" ").map(Number);

  console.log("Processed Stream Lines:", arr);
});

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";

process.stdin.on("data", (chunk) => {
  inputString += chunk;
});

process.stdin.on("end", () => {
  const lines = inputString.trim().split(/\s+/);
  if (lines.length < 2) return;

  const n = Number(lines[0]);
  const k = Number(lines[1]);
  const arr = lines.slice(2).map(Number);

  console.log(`Parsed directly: N=${n}, K=${k}`, arr);
});

3. Understanding Platform Formats

Depending on the website, you are either given an empty slate or a direct class method stub:

Function-Based (LeetCode / CodeSignal)

You write ZERO parsing wrappers

The system reads inputs, parses the types internally, and passes them as functional inputs directly inside the execution method wrapper.

class Solution {
  solve(nums, target) {
    // Write plain logic here. Output by returning values.
    return nums.filter(x => x > target);
  }
}

Stream-Based (Codeforces / AtCoder)

You write the complete code file

No code wraps your script. You must load files, split standard output sequences, execute your logic, and print directly into standard console output.

const fs = require("fs");

function solve() {
  const data = fs.readFileSync(0, "utf-8").trim();
  // ... split lines, parse values, compute logic ...
  console.log(result);
}
solve();

4. String to Number Live Lab

JavaScript can be unpredictable with conversions. Type a custom string below to see how different native engines parse standard strings to numeric types:

Test String Value

Try values like "", " 100", "07", or "abc".

Number(s)

parseInt(s, 10)

+s (Unary)

~~s (Double NOT)

5. The Magic of `JSON.parse()`

When platform test inputs format multidimensional arrays directly inside single-line strings (like [[1,2],[3,4]]), skip complex regex parsing and use native JSON parsers.

Raw Platform Input String

[[10, 20], [30, 40], [50, 60]]

Type arrays, nested matrices, or coordinate inputs. It instantly turns them into functional multidimensional variables!

Computed JavaScript Object Output