Adobe Coding Interview Questions: DS&A & Machine Coding

Adobe's interview has a distinctive component many candidates aren't ready for: a machine-coding round, where you build a small but working application (a parking-lot system, a splitwise clone, a snake game) in 60–120 minutes, graded on clean design, working features, and extensibility — not algorithmic cleverness. Alongside it sits standard medium DS&A and, for some teams, image/graphics domain questions.

Here's the full loop with four worked DS&A problems and how to approach the machine-coding round.

The full interview process

Stage	Format	Notes
Recruiter screen	30 min	Background, team, logistics
Technical phone screen	45-60 min	1-2 DS&A problems
Machine coding	60-120 min	Build a working mini-app; clean OOD graded
DS&A onsite	45-60 min	Arrays, matrices, trees
Behavioral / hiring manager	45 min	Ownership, craft, team fit

Maximum Subarray (Kadane's algorithm)

Question: Find the contiguous subarray with the largest sum.

At each element, either extend the running subarray or start fresh from this element; track the best.

def maxSubArray(nums):
    best = curr = nums[0]
    for num in nums[1:]:
        curr = max(num, curr + num)
        best = max(best, curr)
    return best

O(n) time, O(1) space. The one-line insight is curr = max(num, curr + num).

Spiral Matrix (simulation)

Question: Return all elements of an m×n matrix in spiral order.

Maintain four boundaries (top, bottom, left, right) and peel layers inward, shrinking the boundaries.

def spiralOrder(matrix):
    res = []
    top, bottom = 0, len(matrix)-1
    left, right = 0, len(matrix[0])-1
    while top <= bottom and left <= right:
        for c in range(left, right+1): res.append(matrix[top][c])
        top += 1
        for r in range(top, bottom+1): res.append(matrix[r][right])
        right -= 1
        if top <= bottom:
            for c in range(right, left-1, -1): res.append(matrix[bottom][c])
            bottom -= 1
        if left <= right:
            for r in range(bottom, top-1, -1): res.append(matrix[r][left])
            left += 1
    return res

O(m×n). The two inner if guards prevent re-reading a row/column on a non-square matrix — the bug most candidates hit.

Group Anagrams (hashing)

Question: Group strings that are anagrams of each other.

Key each word by its sorted letters (or letter-count signature); group words sharing a key.

from collections import defaultdict
def groupAnagrams(strs):
    groups = defaultdict(list)
    for w in strs:
        groups[tuple(sorted(w))].append(w)
    return list(groups.values())

O(n · k log k) for n words of length k. A count-based key (length-26 tuple) makes it O(n · k) if asked to optimize.

LRU Cache (design)

Question: Design a Least-Recently-Used cache with O(1) get and put.

A hash map for lookup plus a recency order. Python's OrderedDict gives both; be ready to build the doubly linked list by hand.

from collections import OrderedDict
class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict(); self.cap = capacity
    def get(self, key):
        if key not in self.cache: return -1
        self.cache.move_to_end(key); return self.cache[key]
    def put(self, key, value):
        if key in self.cache: self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.cap: self.cache.popitem(last=False)

O(1) get and put. Interviewers often ask for the manual doubly-linked-list version — practice the sentinel-node form.

Patterns Adobe asks most

Pattern	Frequency	Note
Arrays & matrices	~30% of loops	Spiral, rotate, subarray sums
Object-oriented design	~25%	The machine-coding round
Hashing / strings	~15%	Grouping, counting
Trees / BFS-DFS	~15%	Traversals
Dynamic programming	~10%	Kadane, basic grids
Heap / intervals	~5%	Top-k, merge

Common pitfalls specific to Adobe

• Treating machine coding like LeetCode. It's graded on clean class design and working features, not the cleverest algorithm. Plan your classes before typing.
• Building everything at once. Get a minimal end-to-end version working first, then add features — partial-but-working beats complete-but-broken.
• Skipping matrix practice. Adobe likes 2-D array problems (spiral, rotate); they trip up candidates who only drilled 1-D arrays.
• No tests in machine coding. Add a couple of quick checks; it signals engineering maturity.

A 4-week prep plan for an Adobe loop

1. Week 1: Arrays and matrices to mastery — spiral, rotate, set-matrix-zeroes, subarray sums.
2. Week 2: Machine coding — build a parking lot, splitwise, and a snake game from scratch with clean classes.
3. Week 3: Trees, hashing, and a couple of DP patterns.
4. Week 4: Timed machine-coding rehearsals and a live-coding run.

FAQ

What is Adobe's machine-coding round?

A 60-120 minute round where you build a small but working application - a parking-lot system, a splitwise clone, a game - graded on clean object-oriented design, working features, and extensibility rather than algorithmic cleverness. Plan your classes before coding and get a minimal version working first.

How do I prepare for Adobe machine coding?

Practice building complete mini-apps from scratch with clean class boundaries: parking lot, splitwise, snake game, an in-memory key-value store. Focus on extensible design, get something end-to-end working early, and add a couple of tests to signal maturity.

What DS&A does Adobe ask?

Medium data-structures problems with an above-average share of arrays and matrices (spiral order, rotate image, subarray sums), plus hashing, strings, and trees. Some teams add image or graphics domain questions.

Is Adobe's interview hard?

The DS&A skews medium, but the machine-coding round catches candidates who only practiced LeetCode - it tests software design and working software under time pressure, which is a different skill. Prepare both tracks.

Can CoPilot Interview help with Adobe prep?

Yes. It returns clean, idiomatic solutions with object-oriented structure and Big-O, useful for both the DS&A rounds and planning the class design for machine coding. Follow Adobe's interview rules during the live round.