The HackerRank Platform

HackerRank is a coding assessment platform used by companies worldwide. TCS uses it for HSE and sometimes PRA coding sections. Here's how it works:

• Online code editor — you write code in the browser, no local IDE
• Language locked to Java for TCS HSE (other exams may allow more)
• Input comes from stdin — System.in in Java
• Output goes to stdout — System.out in Java
• Your output is compared character-by-character against expected output
• No partial credit per test case — each test case is pass or fail
• You cannot see hidden test case inputs — only pass/fail status

HSE Exam Format (HackerRank Software Engineering Assessment)

HSE stands for HackerRank Software Engineering Assessment. It is one of the toughest exams in TCS ILP.

How to Read HackerRank Questions

Most students start coding immediately. This is the biggest mistake. The problem statement contains critical details that determine whether your solution passes or fails.

Step-by-step approach:

1. Read the full problem statement — top to bottom, don't skim
2. Read the "Note" section — this is where they hide critical info like "case-insensitive comparison" or exact output format
3. Study the Input Format section — understand what each line of input contains
4. Study the Output Format section — copy the exact string format. Letter by letter.
5. Trace through Sample Input/Output — manually work through the example. Make sure your understanding matches
6. Check the Constraints section — input size tells you if brute force is OK or you need optimization
7. Plan your approach in comments — write pseudocode before real code

What to look for in the problem statement:

I/O Handling — The #1 Killer

On HackerRank, your program reads from stdin and writes to stdout. There are no prompts, no GUI, no file I/O. Just raw input → processing → raw output.

The Golden Rules:

• Never print prompts — no "Enter a number:", no "Input:", nothing
• Never leave debug prints — every extra System.out.println() fails test cases
• Always trim input — sc.nextLine().trim() removes trailing whitespace
• Match output exactly — one extra space, one wrong capital letter = fail

Safe Input Pattern (recommended):

Scanner sc = new Scanner(System.in);

// Reading an integer — SAFE way
int n = Integer.parseInt(sc.nextLine().trim());

// Reading a string
String name = sc.nextLine().trim();

// Reading a double
double price = Double.parseDouble(sc.nextLine().trim());

// Reading multiple values on one line
String[] parts = sc.nextLine().trim().split(" ");
int a = Integer.parseInt(parts[0]);
int b = Integer.parseInt(parts[1]);

The Scanner Trap — Memorize This

This single bug causes more HSE failures than any other issue. If you understand nothing else on this page, understand this.

The Problem:

Scanner sc = new Scanner(System.in);

int n = sc.nextInt();          // reads "3" but leaves "\n" in buffer
String name = sc.nextLine();  // reads the leftover "\n" → EMPTY STRING!

// name is now "" (empty), NOT the actual next line of input
// Your entire program breaks from here

Why it happens:

When you type 3 and press Enter, the input buffer contains "3\n". nextInt() reads "3" but leaves the "\n" in the buffer. The next nextLine() reads that leftover "\n" and returns an empty string.

The Fix — Option 1 (consume the newline):

int n = sc.nextInt();
sc.nextLine();              // ← consume the leftover newline
String name = sc.nextLine(); // NOW this reads the actual next line

The Fix — Option 2 (recommended — avoid nextInt entirely):

int n = Integer.parseInt(sc.nextLine().trim());  // reads full line, no leftover
String name = sc.nextLine().trim();               // reads next line cleanly

The same trap with nextDouble:

// DANGEROUS
double price = sc.nextDouble();  // leaves "\n"
String category = sc.nextLine(); // reads "" (empty)

// SAFE
double price = Double.parseDouble(sc.nextLine().trim());
String category = sc.nextLine().trim(); // works correctly

Exact Output Matching

HackerRank compares your output character by character against the expected output. Here's what kills submissions:

Output formatting patterns:

// Print a line with newline at end (use this for most output)
System.out.println("Result: " + value);

// Format decimals to exactly 2 places
System.out.println(String.format("Average: %.2f", avg));
// If avg = 95.5 → prints "Average: 95.50"

// Print object details in a specific format
System.out.println(emp.getName() + " - " + emp.getDept() + " - " + emp.getSalary());

// When no result found — copy the EXACT string from the problem
System.out.println("No employee found");  // EXACT match required

How HackerRank Test Cases Work

Every HackerRank problem has multiple test cases. Your program runs once per test case — fresh input each time.

Types of test cases:

Scoring:

• Each test case has a point value (not always equal)
• No partial credit per test case — pass completely or get 0
• Total score = sum of all passed test case points
• Sample test cases may carry 0 points — they're just for you to verify

What Hidden Test Cases Check

You can't see these, but you can predict them. Hidden cases almost always test these scenarios:

Common Mistakes (and How to Avoid Them)

1. The Scanner nextLine trap

// WRONG — will silently break your program
int n = sc.nextInt();
String name = sc.nextLine();  // reads empty string

// RIGHT
int n = Integer.parseInt(sc.nextLine().trim());

2. Debug prints left in code

// You wrote this while testing:
System.out.println("DEBUG: array size = " + arr.length);  // REMOVE before submitting!

// This extra line WILL fail every single test case

3. Not handling the "not found" case

// You filtered and found nothing — what now?
if (result == null) {
    System.out.println("No employee found");  // MUST print this
}
// If you don't handle null, you get NullPointerException → 0 marks

4. Using == for String comparison

// WRONG — compares memory addresses
if (name == "Sales") { ... }

// RIGHT — compares actual string content
if (name.equals("Sales")) { ... }

// BEST — case-insensitive (TCS problems almost always need this)
if (name.equalsIgnoreCase("Sales")) { ... }

5. Integer overflow on sums

// WRONG — if salaries are large, int overflows silently
int total = 0;
for (Employee e : employees) total += e.getSalary();

// RIGHT — use long for sums
long total = 0;
for (Employee e : employees) total += e.getSalary();

6. Wrong data type

// Problem says "price" — could be 99.99
int price = ...;     // WRONG — loses decimal part
double price = ...;  // RIGHT

7. Hardcoded values

// Testing with sample input and accidentally leaving:
int n = 3;  // WRONG — must READ from input

// RIGHT
int n = Integer.parseInt(sc.nextLine().trim());

Exam Day Strategy

General time management:

Step-by-step for a coding problem:

1. Read the problem twice — don't touch the keyboard yet
2. Identify the class structure — what attributes, what types
3. Write the class first — private fields, constructor, getters
4. Write the input reading code — use the safe nextLine().trim() pattern
5. Write the filtering/processing logic
6. Handle the "not found" case
7. Copy the exact output format from the problem statement
8. Run against sample test cases
9. Mentally check edge cases — 0 matches, all matches, 1 element
10. Remove all debug prints
11. Submit

What NOT To Do

Pre-Submit Checklist

Run through this checklist before hitting Submit. Every single item has caused students to fail: