PayPal·Machine Learning Engineer·Technical Phone Screen·Senior

Senior

Jul 2026

Summary

PayPal ML engineer interview with a coding round that leaned heavier on algorithms than I expected. The question was classic sliding window territory but they pushed into streaming territory pretty fast, which is where things got interesting.

Questions Asked (1)

Given a binary array and an integer k, find the length of the longest contiguous subarray you can get by flipping at most k zeros to ones. Walk through an efficient algorithm, its time and space complexity, and how you'd adapt the approach for a streaming data source.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

The base sliding window solution came to me pretty quickly, two pointers, track zero count, shrink left when zeros exceed k.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Use a sliding window (two-pointer) technique to maintain a window with at most k zeros, expanding the right pointer and shrinking the left when zeros exceed k. Track the maximum window length seen. For streaming, adapt to a circular buffer or maintain a queue of zero indices to handle unbounded data.

Pro tip: Emphasize that the sliding window is optimal for this problem and that for streaming, you can maintain a deque of zero positions to efficiently shrink the window when needed, achieving O(n) time and O(k) space.

1. Clarify the problem and constraints

Confirm that the array is binary, k is non-negative, and we want the longest contiguous subarray after flipping at most k zeros. Discuss edge cases like k=0 or all ones.

2. Present the sliding window algorithm

Initialize left=0, zeros=0, max_len=0. Iterate right from 0 to n-1: if arr[right]==0, increment zeros. While zeros > k, if arr[left]==0 decrement zeros; increment left. Update max_len = max(max_len, right-left+1).

3. Analyze time and space complexity

Time complexity is O(n) since each element is visited at most twice. Space complexity is O(1) for the basic approach, as we only use a few variables.

4. Adapt for streaming data

For streaming, we cannot store the entire array. Use a queue (or deque) to store indices of zeros. When zeros exceed k, remove the oldest zero index and set left to that index+1. Maintain the current window length and max length. Space is O(k) for the queue.

5. Discuss trade-offs and potential optimizations

Mention that the streaming approach uses O(k) space, which is efficient if k is small. If k is large, consider alternative approaches like maintaining a count of zeros in a sliding window with a fixed-size buffer, but note that the deque method is optimal.

Key Points to Mention

Sliding window technique with two pointers
Time complexity O(n) and space complexity O(1) for static array
Streaming adaptation using a queue/deque of zero indices
Space complexity O(k) for streaming version
Edge cases: k=0, k >= number of zeros, empty array
Comparison with alternative approaches like binary search or prefix sums

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.