Apple 2025 Fall SDE/SWE interview questions review

This time I reviewed it for my classmates. Apple The two rounds of pure coding, the overall pace is quite fast. Although the questions are all conventional routines, they all test the entire link of "writing code → deducing ideas → ability to resist questioning". Below I have sorted out the questions, key ideas, and the interviewer’s questioning directions for the two rounds. You can compare the key points when answering questions/preparing.

Round 1｜Subarray Sum Equals K

The questions given by the interviewer were very direct:
Given an array nums and an integer k, find the number of consecutive subarrays whose sum exactly equals k.

Dismantling of ideas

The most common mistake in this question is to use a sliding window. But as long as there are negative numbers or 0 in the array, the window method is directly unavailable. So there is only one truly stable solution:

Prefix sum + hash table

1. Traverse the array, maintaining the current prefix and sum
2. If prefix = sum – k has appeared before, it means that the sum of the subarrays from the position of prefix to the current one is k
3. The hash table records how many times each prefix sum appears
4. Initialization {0:1} that means "from the beginning to the current position is exactly equal to k" can also be counted

In a word: the prefix sum is responsible for positioning, and the hash table is responsible for counting quantities.

Code examples (Python)

def subarray_sum(nums, k):
    from collections import defaultdict
    cnt = defaultdict(int)
    cnt[0] = 1
    s = 0
    ans = 0
    for x in nums:
        s += x
        ans += cnt[s - k]
        cnt[s] += 1
    return ans

Complexity

Time O(n), space O(n)

The interviewer asked

1) Will negative numbers or 0 affect your algorithm?

It will not affect the prefix and scheme, but will completely invalidate the sliding window. If you can explain this clearly, the interviewer will directly recognize your understanding of the question structure.

2) Can the space be optimized?

If the question requires "counting quantities", it is basically impossible to reduce it from O(n).
If you just want to "determine whether there is a certain subarray whose sum is k", you can use sets, but they are not suitable for counting.

3) Why is the "prefix and number of occurrences" stored in the hash table?

Because different prefix positions may form a new subarray, it is necessary to count the number of occurrences, not just record whether they occur or not.

Round 2 | Binary tree in-order traversal iterator

The question requires designing an iterator for in-order traversal. It cannot traverse the entire tree in advance and must be lazy.

Dismantling of ideas

The essence of this question is to test whether you can change the "recursive in-order traversal process" into "explicit stack + lazy logic".

Core approach: Maintain a path from the current node to the left and to the end

Initialization: push all nodes from the root node to the left onto the stack
next()：

1. Pop stack
2. If there is a right subtree, push the right subtree all the way to the left onto the stack
3. Returns the value of the current node

Code examples (Python)

class InorderIterator:
    def __init__(self, root):
        self.st = []
        self._push_left(root)

    def _push_left(self, node):
        while node:
            self.st.append(node)
            node = node.left

    def hasNext(self):
        return bool(self.st)

    def next(self):
        node = self.st.pop()
        if node.right:
            self._push_left(node.right)
        return node.val

Complexity

Next() amortized O(1)
Space O(h)

The interviewer asked for directions

1) Will there be any problem if multiple iterators access the same tree at the same time?

• If the tree is read-only (interviews generally default to read-only), multiple iterators each maintain their own stack, no problem
• If the tree will be written, you need to add:
  • Version number (fail-fast)
  • Read-write lock
  • Or snapshot policy
    Just be able to clearly explain the advantages and disadvantages

2) If the tree degenerates into a linked list, will it consume a lot of space?

Yes, but this is the lower bound of in-order traversal and is inevitable. As long as you can explain "why you can't reduce the space," the interviewer won't dig any further.

3) Compared with recursive in-order traversal, what improvements are there?

Recursion is not lazy and has system stack limits; iterators are controllable space and can be accessed on demand.

Why choose ProgramHelp？We will protect your Offer.

We are the "spokesmen" of the elite team:

• Elite Background: The team consists of Google, Meta, Amazon It is composed of former senior engineers and alumni of CMU, Stanford, Tsinghua and Peking University.
• Absolute control: We own north america CS/Quant/Data The latest question bank on the market, with a thorough understanding of the interview styles and Gating Factors of major companies.

Refuse to be cheap and low-end, we provide High-End solutions:

Alex Ma Staff Software Engineer

Currently working at Google, with more than 10 years of development experience, currently serving as Senior Solution Architect. He has a bachelor's degree in computer science from Peking University and is good at various algorithms, Java, C++ and other programming languages. While in school, he participated in many competitions such as ACM and Tianchi Big Data, and owned a number of top papers and patents.

See Full Bio