JavaScript for Hackerrank & Hackerearth: A Beginner's Guide to Input/Output Handling in Competitive Programming

Table of Contents#

1. Understanding the Environment
2. Input Handling in JavaScript
   • Methods for Reading Input
   • Common Input Formats & How to Parse Them
3. Output Handling in JavaScript
4. Common Pitfalls to Avoid
5. Platform-Specific Tips (Hackerrank vs. Hackerearth)
6. Practice Problems with Solutions
7. Conclusion
8. References

Understanding the Environment#

Before diving into I/O, it’s critical to understand the execution environment. Both Hackerrank and Hackerearth run JavaScript code using Node.js (a JavaScript runtime for server-side execution). This means you’ll have access to Node.js-specific modules like fs (file system) and readline for I/O operations.

In competitive programming, input is typically passed via standard input (stdin), and output is expected via standard output (stdout). Unlike browser-based JavaScript, there’s no prompt() or alert()—you’ll need to interact directly with stdin/stdout using Node.js APIs.

Input Handling in JavaScript#

Reading input correctly is the first step to solving any problem. JavaScript offers two primary approaches for reading input in Node.js: asynchronous (using callbacks) and synchronous (blocking until input is read). For competitive programming, synchronous methods are preferred because they simplify code flow and avoid callback-related bugs.

Methods for Reading Input#

1. Synchronous Input with fs.readFileSync#

The fs (file system) module’s readFileSync method reads input synchronously from stdin. This is the most straightforward approach for beginners.

Syntax:

const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8'); // 0 = stdin, 'utf-8' = encoding

• fs.readFileSync(0, 'utf-8') reads all input from stdin as a single string.
• trim(): Often used to remove leading/trailing whitespace (e.g., extra newlines).

2. Asynchronous Input with readline Module#

The readline module reads input line-by-line asynchronously. While powerful, it’s more complex for beginners due to callback functions.

Syntax:

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});
 
let inputLines = [];
rl.on('line', (line) => {
  inputLines.push(line); // Collect lines as they are read
});
 
rl.on('close', () => {
  // Process input here after all lines are read
});

Common Input Formats & How to Parse Them#

Input formats vary by problem, but these are the most common scenarios:

A. Single Line of Input#

Example: A single integer (e.g., 5) or a string (e.g., hello).

Solution: Read the entire input, trim, and use directly.

const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim(); 
console.log(input); // Output: 5 or hello

B. Space-Separated Values (Single Line)#

Example: Two integers on one line (e.g., 3 4 for a sum problem).

Solution: Split the input string by spaces and parse as numbers.

const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim().split(' '); 
const a = parseInt(input[0]); // 3
const b = parseInt(input[1]); // 4
console.log(a + b); // Output: 7

• Use split(/\s+/) instead of split(' ') to handle multiple spaces/tabs:
  input.split(/\s+/) splits on one or more whitespace characters.

C. Multiple Lines of Input#

Example: First line = number of test cases T, followed by T lines of input (e.g., 2\n5\n10 for summing 5 and 10).

Solution: Split the input into an array of lines.

const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim().split('\n'); 
const T = parseInt(input[0]); // Number of test cases
const values = input.slice(1, T + 1).map(Number); // Extract next T lines and parse as numbers
const sum = values.reduce((acc, val) => acc + val, 0);
console.log(sum); // Output: 15 (5 + 10)

D. Comma-Separated Values#

Example: A line with comma-separated integers (e.g., 1,2,3,4).

Solution: Split by ',' instead of spaces.

const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim().split(','); 
const numbers = input.map(Number); // [1, 2, 3, 4]

Output Handling in JavaScript#

Output must match the problem’s requirements exactly—even a trailing space can cause a "Wrong Answer". Use console.log() for stdout, but format carefully.

Common Output Scenarios#

1. Single Value#

Print a single number, string, or boolean.

console.log(42); // Output: 42
console.log("hello"); // Output: hello

2. Multiple Values (Space-Separated)#

Print an array of values separated by spaces.

const result = [1, 2, 3, 4];
console.log(result.join(' ')); // Output: 1 2 3 4

3. Multiple Lines#

Print each value on a new line.

const lines = ["apple", "banana", "cherry"];
lines.forEach(line => console.log(line)); 
// Output:
// apple
// banana
// cherry

4. Formatted Numbers (e.g., Decimals)#

Use toFixed() for rounding to specific decimal places.

const average = 7.666666;
console.log(average.toFixed(2)); // Output: 7.67

Common Pitfalls to Avoid#

1. Forgetting to Parse Input: Input is read as a string—always convert to numbers with parseInt(), parseFloat(), or Number().
   ❌ Wrong: const a = input[0]; (string, e.g., "5" instead of 5).
   ✅ Correct: const a = parseInt(input[0]);

2. Extra Whitespace: Use trim() to remove leading/trailing newlines/spaces from input.

   const input = fs.readFileSync(0, 'utf-8').trim(); // Avoids empty lines at the end

3. Splitting on Single Spaces: Use split(/\s+/) instead of split(' ') to handle multiple spaces/tabs.

   const tokens = input.split(/\s+/); // Splits "1  2   3" into ["1", "2", "3"]

4. Async Code Bugs: Asynchronous methods (e.g., readline) can execute code before input is fully read. Stick to readFileSync for simplicity.

Platform-Specific Tips (Hackerrank vs. Hackerearth)#

Both platforms support Node.js, but there are minor nuances:

Hackerrank#

• Input is often well-formatted, but always trim to avoid trailing newlines.
• Use fs.readFileSync for synchronous input—no additional setup needed.

Hackerearth#

• Some problems may have hidden trailing spaces in input; trim() is critical.
• For large inputs, readFileSync is still efficient (platforms handle it well).

Practice Problems with Solutions#

Problem 1: Sum of Two Integers#

Task: Read two integers from stdin and print their sum.
Input: 3 5
Output: 8

Solution:

const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim().split(/\s+/);
const a = parseInt(input[0]);
const b = parseInt(input[1]);
console.log(a + b); // Output: 8

Problem 2: Average of N Numbers#

Task: Read N, then N numbers. Print their average (rounded to 2 decimals).
Input:

4  
10  
20  
30  
40  

Output: 25.00

Solution:

const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim().split('\n');
const N = parseInt(input[0]);
const numbers = input.slice(1, N + 1).map(Number);
const sum = numbers.reduce((acc, val) => acc + val, 0);
const average = sum / N;
console.log(average.toFixed(2)); // Output: 25.00

Problem 3: Reverse a String#

Task: Read a string and print its reverse.
Input: hello
Output: olleh

Solution:

const fs = require('fs');
const input = fs.readFileSync(0, 'utf-8').trim();
const reversed = input.split('').reverse().join('');
console.log(reversed); // Output: olleh

Conclusion#

Mastering input/output handling is foundational for competitive programming in JavaScript. By using synchronous methods like fs.readFileSync, parsing input carefully, and formatting output strictly, you’ll avoid common pitfalls and solve problems with confidence. Remember: read input → process → output—and always test with sample inputs!

References#

• Node.js fs Module Documentation
• Node.js readline Module Documentation
• Hackerrank JavaScript Guide
• Hackerearth Coding Environment
• MDN Web Docs: String Methods