Java OA Coding

Research checked: 13 November 2026. This is an original practice curriculum for the 16 November internship OA, not a list of promised questions. Recent internship reports describe Java as an available language and easy–medium coding; confirm the version and permitted languages in your own mock.

Java survival notesCopy Anchor Link

Use int[] for fixed-size numeric data, StringBuilder for repeated string construction, HashMap for counts, and HashSet for membership. Arrays use .length, strings use .length(), and collections use .size(). Compare string contents with .equals(), not ==.

An int can overflow around 2.1 billion. Accumulate large totals in long; cast before multiplication: (long) a * b. Integer division truncates toward zero. Java % can be negative for negative operands. Sort with Arrays.sort(a); this changes the original array, so copy it if the contract requires preservation.

Input contract: the snippets below are methods. Put them inside class Solution; add import java.util.*; when a snippet uses collections or arrays. For a local test, add a main with System.out.println(method(...)). In the OA, keep the supplied class/method signature. If standard input is required, use the exact specified token/line layout; do not print prompts or extra labels.

import java.util.*;

class Solution {
    static long sum(int[] a) {
        long total = 0;
        for (int x : a) total += x;
        return total;
    }
    public static void main(String[] args) {
        System.out.println(sum(new int[]{2, 3, 4})); // 9
    }
}

For each exercise: clarify inputs, try for 15–20 minutes, test the examples and an edge case, then open the solution. The independent exercises and two mixed mocks are separate sets.

J1 — Sum the qualifying readingsCopy Anchor Link

Return the sum of array elements divisible by both 3 and 5. Empty input returns zero; negative values are allowed. At most 100,000 values, each within the Java int range. [15, 9, 30, -15, 0] → 30.

static long qualifyingSum(int[] a) {
    long total = 0;
    for (int x : a) {
        if (x % 15 == 0) total += x;
    }
    return total;
}

• Solve J1 and explain why the accumulator is long.

J2 — Keep even-length vowel wordsCopy Anchor Link

Given a non-null sentence of ASCII letters separated by whitespace, return the words whose length is even and whose first letter is a vowel, ignoring case. Preserve order and original spelling; join matches with one space. Empty or whitespace-only input returns "". "An owl eats APPLE under ice" → "An eats".

static String vowelWords(String sentence) {
    String s = sentence.trim();
    if (s.isEmpty()) return "";
    StringBuilder result = new StringBuilder();
    for (String word : s.split("\\s+")) {
        char first = Character.toLowerCase(word.charAt(0));
        if (word.length() % 2 == 0 && "aeiou".indexOf(first) >= 0) {
            if (result.length() > 0) result.append(' ');
            result.append(word);
        }
    }
    return result.toString();
}

• Solve J2 with mixed case and repeated whitespace.

J3 — First unique lowercase characterCopy Anchor Link

Return the index of the first character occurring once in a lowercase-English string, or -1 if none exists. "swiss" → 1; "aabb" → -1.

static int firstUnique(String s) {
    int[] count = new int[26];
    for (int i = 0; i < s.length(); i++) count[s.charAt(i) - 'a']++;
    for (int i = 0; i < s.length(); i++) {
        if (count[s.charAt(i) - 'a'] == 1) return i;
    }
    return -1;
}

• Solve J3 without losing the original character order.

J4 — Second distinct smallest valueCopy Anchor Link

Return the second distinct smallest integer in an array, or null if fewer than two distinct values exist. Do not mutate the input. [4, 1, 1, 3] → 3.

static Integer secondSmallest(int[] a) {
    if (a.length < 2) return null;
    int[] sorted = Arrays.copyOf(a, a.length);
    Arrays.sort(sorted);
    for (int i = 1; i < sorted.length; i++) {
        if (sorted[i] != sorted[0]) return sorted[i];
    }
    return null;
}

• Solve J4 and distinguish second smallest from second distinct smallest.

J5 — Count divisible digit windowsCopy Anchor Link

Given a non-null decimal digit string, count its contiguous windows of exactly three digits whose numeric value is divisible by 3. Leading zeros are permitted. "11021" → 2: the windows are 110, 102, and 021; both 102 and 021 qualify.

static int divisibleTriples(String digits) {
    int sum = 0, answer = 0;
    for (int i = 0; i < digits.length(); i++) {
        sum += digits.charAt(i) - '0';
        if (i >= 3) sum -= digits.charAt(i - 3) - '0';
        if (i >= 2 && sum % 3 == 0) answer++;
    }
    return answer;
}

• Solve J5 and handle overlapping windows and leading zeros.

J6 — Longest segment within a budgetCopy Anchor Link

Given non-negative item costs and a non-negative long budget, return the maximum length of a contiguous segment whose sum is at most the budget. At most 100,000 costs. [2, 1, 3, 1, 1], budget 5 → 3.

static int longestAffordable(int[] costs, long budget) {
    int left = 0, best = 0;
    long sum = 0;
    for (int right = 0; right < costs.length; right++) {
        sum += costs[right];
        while (sum > budget && left <= right) sum -= costs[left++];
        best = Math.max(best, right - left + 1);
    }
    return best;
}

• Solve J6 and explain why non-negative costs matter.

J7 — Pairs of matching labelsCopy Anchor Link

Count unordered pairs of equal integers at different indices. Return long. [2, 2, 2, 3, 3] → 4: three pairs of 2 and one pair of 3. At most 100,000 values.

static long matchingPairs(int[] a) {
    Map<Integer, Integer> seen = new HashMap<>();
    long pairs = 0;
    for (int x : a) {
        int previous = seen.getOrDefault(x, 0);
        pairs += previous;
        seen.put(x, previous + 1);
    }
    return pairs;
}

• Solve J7 without nested loops or double-counting pairs.

J8 — Best non-adjacent rewardCopy Anchor Link

Choose a subset of non-negative rewards with no two adjacent indices. Return the largest total; choosing none is allowed. At most 100,000 rewards, each at most 1 billion. [2, 7, 9, 3, 1] → 12 by selecting 2, 9, 1. This original exercise teaches the same include/skip pattern as House Robber, which one internship report named.

static long bestReward(int[] rewards) {
    long twoBack = 0, oneBack = 0;
    for (int reward : rewards) {
        long current = Math.max(oneBack, twoBack + reward);
        twoBack = oneBack;
        oneBack = current;
    }
    return oneBack;
}

• Solve J8 and explain both recurrence choices before coding.

Targeted resourcesCopy Anchor Link

• Dev.java learning paths: use Language Basics for loops, arrays, operators, and strings; use Collections for maps and sets. Skip deployment and JVM deep dives for this crash plan.
• HackerRank Java: practise Java stdin/stdout, loops, and strings if the platform interface is unfamiliar. An account may be needed for submissions.
• House Robber: an optional DP reattempt after J8; explain the recurrence without reading an editorial.

Readiness check: implement one array/string task from a blank file, test normal/empty/boundary cases, and explain the time and space costs. Then return to the crash plan and mocks.