Flipkart Online Assessment 2026: OA Pattern + Solutions

Quick answer (updated 8 June 2026): Flipkart's fresher SDE Online Assessment in 2026 is usually a timed test with two to three DSA coding problems, often alongside a debugging or aptitude section depending on the drive (Runway, GiRL, or standard). It is auto-graded with hidden test cases and partial scoring. Common topics are arrays and strings, hashing, greedy, trees, graphs, and dynamic programming. The pattern below is compiled from 2023 to 2025 candidate reports, not an official spec, so confirm the sections and timing in your invite from the Flipkart careers portal.

The Flipkart OA is the gate to the machine-coding round and interviews. It rewards clean, efficient DSA and careful reading of constraints. This guide breaks down the pattern, the repeating topics, and full worked solutions.

Flipkart OA Structure for Freshers

Based on candidate reports for 2023 to 2025 fresher SDE drives:

Sections and timing are candidate-reported (2023 to 2025) and vary by drive. Runway and GiRL contest rounds may differ slightly from standard OAs. Your invite email is binding.

Topics That Repeat in the Flipkart OA

Compiled from candidate reports across 2023 to 2025; relative frequency, not an official syllabus:

Relative frequencies from candidate aggregates (2023 to 2025), labelled approximate. Arrays, strings, hashing, and greedy are the safest priorities.

Worked Solution 1: Sliding Window

Problem: Given an array of positive integers and a target sum, find the minimum length of a contiguous subarray whose sum is at least the target, or 0 if none exists.

Approach: Variable-size sliding window. Expand the right edge, and whenever the window sum reaches the target, shrink from the left to find the minimum length.

def min_subarray_len(target, nums):
    left = 0
    total = 0
    best = float('inf')
    for right in range(len(nums)):
        total += nums[right]
        while total >= target:
            best = min(best, right - left + 1)
            total -= nums[left]
            left += 1
    return best if best != float('inf') else 0

Complexity: O(n) time, O(1) space. Each element enters and leaves the window once, which is the insight that beats the O(n squared) double loop.

Worked Solution 2: Greedy (Intervals)

Problem: Given intervals, find the maximum number of non-overlapping intervals you can keep (equivalently, the minimum to remove).

Approach: Sort by end time; greedily keep each interval whose start is at or after the last kept end.

def max_non_overlapping(intervals):
    intervals.sort(key=lambda x: x[1])
    count = 0
    last_end = float('-inf')
    for start, end in intervals:
        if start >= last_end:
            count += 1
            last_end = end
    return count

Complexity: O(n log n) time for the sort, O(1) extra space. Sorting by end time, not start time, is the classic greedy insight Flipkart likes to probe.

Worked Solution 3: Hashing

Problem: Given an array, find the length of the longest consecutive sequence of integers (not necessarily contiguous in the array).

Approach: Put all numbers in a set; for each number that is the start of a run (no predecessor in the set), count forward.

def longest_consecutive(nums):
    s = set(nums)
    best = 0
    for x in s:
        if x - 1 not in s:
            length = 1
            while x + length in s:
                length += 1
            best = max(best, length)
    return best

Complexity: O(n) time, O(n) space. The "only start counting from a run's beginning" check keeps it linear instead of O(n log n) sorting.

Worked Solution 4: Dynamic Programming

Problem: Given an array, find the maximum sum of a subsequence with no two chosen elements adjacent (house robber).

Approach: DP where at each index you either skip it (carry the previous best) or take it (previous-previous best plus current).

def rob(nums):
    prev = 0
    curr = 0
    for x in nums:
        prev, curr = curr, max(curr, prev + x)
    return curr

Complexity: O(n) time, O(1) space. The rolling-variable form is what interviewers want when they ask you to reduce the O(n) DP array to constant space.

Flipkart OA Timing Strategy

1. Read all problems first. Solve the recognisable one first to lock in marks.
2. Use constraints to choose complexity. Large n rules out quadratic solutions.
3. Exploit partial scoring. Submit a working solution, then optimise.
4. Handle edge cases. Empty, single element, duplicates, and extreme values.
5. Do not over-invest in aptitude. If your drive has it, mark-and-move; the coding section weighs more.
6. Save time for the debugging section. It is quick marks if you find the single intended bug.

How to Prepare for the Flipkart OA

• Drill arrays, strings, hashing, and greedy until automatic; these dominate the OA.
• Add trees, graphs (BFS/DFS), and core DP for the harder slots.
• If your drive includes aptitude, revise quant and logical reasoning basics.
• Take timed two-to-three-problem mock OAs to build pacing.

After the OA comes the machine-coding round, so start practising clean class design in parallel. See Flipkart hiring process 2026.

How to Approach the Flipkart OA and What Comes Next

The Flipkart OA is the gate to the machine-coding round and interviews, and approaching it well is about disciplined time management and reading the problem correctly. Begin by reading all the coding problems before starting, then solve the one you recognise first to bank marks. Use the constraints as a hint about complexity: an input that can be large rules out a quadratic solution, so reach for a hash map, two-pointer, or sliding-window approach instead. Because the OA is auto-graded with partial scoring, always submit a working solution that passes some test cases rather than leaving a problem blank while chasing a perfect answer.

If your drive includes an aptitude or debugging section, treat them differently from the coding section. For aptitude, mark and move; do not let a single hard question consume time that the coding section needs, since coding carries more weight. For debugging, do not rewrite the snippet, find the single intended bug, an off-by-one, a wrong operator, a flipped condition, by mentally running the provided example and seeing where the output diverges. These are quick marks for a disciplined reader.

Crucially, prepare for what comes after the OA in parallel. Flipkart's signature machine-coding round, where you build a small working program with clean classes, tests a different skill from the OA, and candidates who start practising clean object-oriented design only after clearing the OA are often underprepared. Even while you drill DSA for the assessment, spend a little time each week building a small console application end to end, an expense splitter, a parking lot, a snake-and-ladder game, so that the transition from OA to machine-coding is smooth. The candidates who progress furthest treat the OA and the machine-coding round as one continuous preparation rather than two separate hurdles.

More Worked Solutions

Worked Solution 5: Two Sum (Hashing)

Single-pass complement lookup.

def two_sum(nums, target):
    seen = {}
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

Time O(n), space O(n).

Worked Solution 6: Number of Islands (Graph DFS)

Count connected land components.

def num_islands(grid):
    rows, cols = len(grid), len(grid[0])
    count = 0

    def sink(r, c):
        if 0 <= r < rows and 0 <= c < cols and grid[r][c] == '1':
            grid[r][c] = '0'
            for dr, dc in ((1,0),(-1,0),(0,1),(0,-1)):
                sink(r + dr, c + dc)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                count += 1
                sink(r, c)
    return count

Time O(rows times cols).

Worked Solution 7: Coin Change (DP)

Fewest coins to make an amount.

def coin_change(coins, amount):
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0
    for a in range(1, amount + 1):
        for c in coins:
            if c <= a:
                dp[a] = min(dp[a], dp[a - c] + 1)
    return dp[amount] if dp[amount] != float('inf') else -1

Time O(amount times coins).

Why Candidates Lose Marks in the Flipkart OA

Candidate reports point to recurring reasons strong candidates underperform:

• Leaving a problem blank. Partial scoring rewards passing some test cases; submit a working partial.
• Misreading constraints. Large inputs rule out quadratic solutions; read constraints to choose your approach.
• Skipping edge cases. Empty input, single element, and duplicates are common hidden tests.
• Over-investing in aptitude. If your drive includes it, mark and move; the coding section weighs more.
• Ignoring the debugging section. It is quick marks if you find the single intended bug.

Preparation Timeline (6 to 8 Weeks)

• Weeks 1 to 2: Foundations. Arrays, strings, hashing, greedy. Solve 30 to 40 problems.
• Weeks 3 to 4: Core DSA. Trees, graphs, and basic DP. If your drive includes aptitude, revise it.
• Weeks 5 to 6: Machine-coding prep in parallel. Start building small clean-design systems since the OA leads into the machine-coding round.
• Weeks 7 to 8: Mocks. Timed two-to-three-problem mock OAs to build pacing.

Related Resources

• Flipkart hiring process 2026, the full loop including the machine-coding round
• Flipkart interview questions 2026, commonly asked questions
• Flipkart placement papers 2026, solved past-drive papers
• 7-day coding round crash plan 2026, last-week prep
• System design interview questions freshers 2026, design fundamentals
• Off campus placement guide 2026, the master off-campus guide

FAQs: Flipkart Online Assessment 2026

Q: How many problems are in the Flipkart OA?

Candidate reports for 2023 to 2025 describe two to three DSA coding problems, sometimes with a debugging or aptitude section depending on the drive. The exact count varies; your invite email is the binding source.

Q: Is the Flipkart OA the same for Runway and GiRL drives?

The core competencies, DSA and clean coding, are the same, but contest rounds for branded drives like Runway and GiRL may differ in format and timing from the standard OA. Check the specific drive notification for details.

Q: Does the Flipkart OA have partial scoring?

Yes, candidate reports describe auto-graded hidden test cases with partial credit. Submit a working partial solution rather than leaving a problem blank, and aim to pass as many test cases as possible.

Q: What topics should I prioritise for the Flipkart OA?

Arrays and strings, hashing, and greedy appear most often in candidate reports, followed by trees, graphs, and dynamic programming. Drill the high-frequency topics first, then add the rest.

Q: How long is the Flipkart OA?

Candidate reports cite roughly 60 to 120 minutes depending on the number of sections and the drive. Your invite email states the exact duration; plan your per-problem pacing around it.

Q: What comes after the Flipkart OA?

The machine-coding round, where you build a small working program, followed by DSA interviews, sometimes a design round, and HR. Start practising clean class design alongside DSA so the machine-coding round does not catch you off guard.

Q: How should I handle the aptitude section if my Flipkart drive has one?

Mark and move. Do not let a single hard aptitude question consume time the coding section needs, since coding carries more weight. Practise quant and logical reasoning beforehand so you can move quickly and accurately through this section.

Q: How do I tackle the Flipkart debugging section?

Find the single intended bug rather than rewriting the snippet. Mentally run the provided example and see where the output diverges from expectation, then fix that one issue, an off-by-one, a wrong operator, or a flipped condition. These are quick marks for a careful reader.

Q: How many test cases should I aim to pass in the Flipkart OA?

As many as you can across both or all problems, since partial scoring rewards every passing case. Strong coverage on two problems usually beats a perfect score on one and a blank on another, so submit working partial solutions and keep improving them.

Q: Should I start machine-coding prep before clearing the Flipkart OA?

Yes. Flipkart's machine-coding round tests clean object-oriented design, a different skill from the OA, and candidates who start only after clearing the OA are often underprepared. Build a small console application each week while you drill DSA so the transition is smooth.

Q: What DSA topics give the best return for the Flipkart OA?

Arrays and strings, hashing, and greedy appear most often, followed by trees, graphs, and dynamic programming. Drilling the high-frequency patterns to the point of automatic recall gives the best return on limited preparation time.