Amazon Online Assessment

Amazon OA Structure

Section	Questions	Time	Focus
Coding	2 problems	70 min	Arrays, Strings, HashMap, Trees
Debugging	7-9 code snippets	20 min	Find and fix bugs
Work Style	25-35 MCQ	15-20 min	Amazon Leadership Principles

Time Management Strategy

Coding Section (70 minutes):

• Problem 1 (Easy/Medium): 20-25 minutes
• Problem 2 (Medium/Hard): 25-30 minutes
• Buffer time: 10-15 minutes for edge cases and testing

Debugging Section (20 minutes):

• ~2 minutes per snippet
• Don't spend more than 3 minutes on any single bug
• Common bugs: off-by-one, null checks, boundary conditions

Java Templates for OA

// Fast I/O for large inputs
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

// Read integer
int n = Integer.parseInt(br.readLine().trim());

// Read array from space-separated line
int[] arr = Arrays.stream(br.readLine().split(" "))
                 .mapToInt(Integer::parseInt)
                 .toArray();

// Common utility methods
public static int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

public static long modPow(long base, long exp, long mod) {
    long result = 1;
    base %= mod;
    while (exp > 0) {
        if ((exp & 1) == 1) result = result * base % mod;
        base = base * base % mod;
        exp >>= 1;
    }
    return result;
}

Common OA Problem Types

1. Array/String Manipulation: Rotate array, string compression, anagram checking
2. HashMap Problems: Two sum variations, frequency counting, group anagrams
3. Tree Problems: BST validation, level order traversal, path sum
4. Greedy/Interval: Meeting rooms, task scheduling, jump game
5. Prefix Sum/Subarray: Range queries, subarray sums, difference arrays
6. Matrix Problems: Island counting, rotation, spiral order

Common Bug Categories

1. Off-by-One Errors

// Bug: Wrong loop boundary
for (int i = 0; i <= arr.length; i++) {  // Should be < not <=
    System.out.println(arr[i]);
}

// Fix:
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

2. Null Pointer Exceptions

// Bug: Missing null check
public int getLength(String s) {
    return s.length();  // s could be null
}

// Fix:
public int getLength(String s) {
    if (s == null) return 0;
    return s.length();
}

3. Integer Overflow

// Bug: Overflow in multiplication
int product = a * b;  // May overflow for large values

// Fix:
long product = (long) a * b;
// Or use BigInteger for very large numbers

4. Array Index Issues

// Bug: Wrong index calculation
int mid = (low + high) / 2;  // Can overflow

// Fix:
int mid = low + (high - low) / 2;

5. Missing Edge Cases

// Bug: Empty input not handled
public int findMax(int[] arr) {
    int max = arr[0];  // Crashes if arr is empty
    for (int i = 1; i < arr.length; i++) {
        max = Math.max(max, arr[i]);
    }
    return max;
}

// Fix:
public int findMax(int[] arr) {
    if (arr == null || arr.length == 0) throw new IllegalArgumentException("Empty array");
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        max = Math.max(max, arr[i]);
    }
    return max;
}

6. Incorrect Return Values

// Bug: Returns wrong value for edge case
public boolean isPalindrome(String s) {
    int left = 0, right = s.length() - 1;
    while (left < right) {
        if (s.charAt(left) != s.charAt(right)) return false;
        left++;
        right--;
    }
    return false;  // Should be true!
}

// Fix: return true at the end

Quick Debug Checklist

1. Check loop boundaries (< vs <=)
2. Look for null checks on objects/arrays
3. Verify return values for edge cases
4. Check for integer overflow in arithmetic
5. Validate array index ranges
6. Ensure proper variable initialization