← Back to blog IBM SWE OA Real Questions: 3 HackerRank Problem Types
OA IBM

IBM SWE OA Real Questions: 3 HackerRank Problem Types

2026-06-14

IBM's US General Software role uses a HackerRank online assessment—the problems are engineering-flavored and medium difficulty, valuing correctness and edge-case handling over flashy tricks. Organized from an oavoservice student's IBM OA debrief, this piece lays out the flow and three high-frequency coding types—a practical reference for grinding problems and prepping the IBM online assessment.

1. IBM OA Flow

Stage Format Duration Focus
Online Assessment (OA) HackerRank 60–90 min 2–3 coding problems, some multiple choice
Technical Interview Coding + projects 45–60 min Medium algorithms + resume deep dive
Manager / Behavioral Behavioral 30–45 min Teamwork, motivation

The IBM OA is medium difficulty, weighting correctness against test cases. Problems are typically strings, matrices, and graphs—basic but requiring careful edge handling.

2. Type 1: String Normalization (Count + Rebuild)

Problem

Given a string, count each character's occurrences and reorder the output by descending count, breaking ties by lexicographic order.

Approach

Hash count, then sort. In Python, a Counter plus a composite sorted key does it in one step.

from collections import Counter

def reorder_by_frequency(s):
    counts = Counter(s)
    # descending count first, then ascending character on ties
    chars = sorted(counts, key=lambda c: (-counts[c], c))
    return "".join(c * counts[c] for c in chars)

Time complexity: O(n + k log k), where k is the number of distinct characters. Space complexity: O(k). The point is a composite sort key and stable output.

3. Type 2: Matrix Region Traversal (DFS / Counting)

Problem

Given a 0/1 matrix where 1 is land, find the largest connected region area formed by adjacent 1s (up/down/left/right)—the classic "max island area" variant.

Approach

Run DFS flood fill from each unvisited 1, count that component's size, and keep the maximum.

def max_area(grid):
    if not grid:
        return 0
    m, n = len(grid), len(grid[0])

    def dfs(r, c):
        if r < 0 or r >= m or c < 0 or c >= n or grid[r][c] != 1:
            return 0
        grid[r][c] = 0                      # mark visited
        return 1 + dfs(r+1, c) + dfs(r-1, c) + dfs(r, c+1) + dfs(r, c-1)

    best = 0
    for i in range(m):
        for j in range(n):
            if grid[i][j] == 1:
                best = max(best, dfs(i, j))
    return best

Time complexity: O(m·n)—each cell visited once. Space complexity: O(m·n) recursion stack in the worst case. Watch out-of-bounds and the visited marker to avoid double counting.

4. Type 3: Account / Network Merge (Union-Find)

Problem

Given pairs (a, b) meaning a and b are directly connected, find how many connected components remain. IBM often wraps this as a "server cluster" or "account merge" scenario.

Approach

Union-Find with path compression—merge all edges, then count distinct roots.

def count_components(n, edges):
    parent = list(range(n))

    def find(x):
        while parent[x] != x:
            parent[x] = parent[parent[x]]   # path compression
            x = parent[x]
        return x

    for a, b in edges:
        ra, rb = find(a), find(b)
        if ra != rb:
            parent[ra] = rb
    return len({find(i) for i in range(n)})

Time complexity: roughly O((n + e)·α(n)), where α is the inverse Ackermann function—effectively near linear. Space complexity: O(n). The point is the union-find template and component counting.

5. Prep Tips

FAQ

Q1: What platform does IBM use, and how many problems?

HackerRank, 60–90 minutes, 2–3 coding problems, sometimes with multiple choice. Medium difficulty, weighting correctness and edge handling, commonly strings, matrices, and graphs.

Q2: Is the IBM OA hard?

Medium overall—it doesn't test very hard algorithms, but it cares about details: edges, empty input, test-case coverage. Get the string / matrix / union-find templates fluent and your pass rate will be high.

Q3: What does IBM value in interviews?

After the OA comes a technical interview plus a behavioral round. The technical interview is medium algorithms plus a resume deep dive; the behavioral round looks at teamwork and motivation. The overall pace is gentler than top-tier big tech.

Q4: How do I prep efficiently for the IBM OA?

Drill strings / matrix DFS / union-find in timed blocks, focusing on edge coverage. For timed mocks and live think-aloud practice, contact oavoservice for a tailored IBM track.

Preparing for the IBM OA?

IBM US General Software runs a HackerRank OA that values correctness and edges. oavoservice offers full-flow IBM coaching: timed HackerRank high-frequency mocks, a string / matrix / union-find template track, edge and test-case coverage polishing, and technical and behavioral round prep. Coaches include senior engineers with big-tech backgrounds to train your code and your delivery together.

Add WeChat Coding0201 now and get IBM real questions and coaching.

Contact