SEO PACKAGE

1. SEO Title

Maximum Product of Three Numbers in Python — The Two-Negatives Trap Every Coder Falls For (LeetCode 628)

2. SEO Subtitle

Learn why the three biggest numbers don't always win, and how the Two Corners pattern gives you a clean, correct Python solution in five lines.

3. Featured Quote

"Size isn't the same as product once negatives enter the room. The answer always hides at the corners of a sorted array."

4. Meta Description

Solve LeetCode 628 Maximum Product of Three Numbers in Python. Master the two-negatives trap, the Two Corners pattern, sorting vs O(n), and every edge case.

5. URL Slug

maximum-product-of-three-numbers-python-two-corners

6. Keywords

Maximum Product of Three Numbers, LeetCode 628, Python coding interview, two negatives trap, Two Corners pattern, array algorithms, sorting interview problem, O(n) array scan, product of three numbers, negative numbers algorithm, data structures Python, coding interview preparation, algorithm intuition, edge cases interview, greedy array problem, Python list sort, time complexity analysis, LeetCode daily challenge, software engineering interview, beginner algorithms

7. Tags

python, leetcode, coding-interview, algorithms, data-structures, arrays, sorting, problem-solving, dsa, interview-preparation, two-corners, greedy, time-complexity

---

8. Introduction

Some coding problems are hard because the algorithm is complex. Maximum Product of Three Numbers is hard for the opposite reason — it looks trivial, and that is exactly the trap.

Ask any developer for the answer and you'll hear the same instant reply: "Sort the array, take the three biggest, multiply them." It sounds airtight. It feels done. And for a list of all-positive numbers, it's even correct. That confidence is the problem, because a single negative-heavy input turns the obvious rule inside out.

Interviewers love this question precisely because it separates people who pattern-match to keywords from people who reason about the actual math. The word "largest" pulls your brain toward the biggest values, and you skip right past the fact that two large negative numbers multiply into a large positive one. The interviewer isn't testing whether you can call sort(). They're testing whether you notice the case that breaks your first answer — and whether you handle it cleanly instead of bolting on messy special cases.

This is a foundational skill for every coding interview: recognizing that "biggest input" and "biggest result" are not the same claim. Get comfortable with it here on an approachable LeetCode problem, and you'll carry the instinct into far harder algorithms and data structures questions where the same corner-case reasoning shows up in disguise.

---

9. Problem Overview

You're given a list of integers. Your task is to choose exactly three of them whose product is as large as possible, then return that product.

The values can be positive, negative, or zero. You must pick three distinct positions in the array (you can't reuse the same element twice), and the list is guaranteed to contain at least three numbers.

That's the entire specification. No sorting is required by the problem, no ordering of the output — just a single integer: the maximum product achievable by any group of three elements.

The subtlety lives entirely in one word: integers. If the problem promised only positive numbers, this would be a warm-up. Because negatives are allowed, the "obvious" answer is only sometimes right, and your job is to find the approach that is always right.

---

10. Example

Let's ground the problem in concrete inputs.

Example 1 — all positive

Input:  [1, 2, 3, 4]
Output: 24

The three largest values are 2, 3, 4, and 2 × 3 × 4 = 24. Here the intuitive answer is correct. Nothing negative exists to upset it.

Example 2 — the trap

Input:  [-9, -8, 1, 2, 3]
Output: 216

The "three biggest" are 1, 2, 3, giving 6. But look at the corners: -9 × -8 = 72, and 72 × 3 = 216. Two negatives cancelled their signs and produced a huge positive. The smallest numbers just beat the biggest ones.

Example 3 — all negative

Input:  [-1, -2, -3]
Output: -6

Every product is negative here, so we want the one closest to zero. The three largest values (-1, -2, -3) give -6, which is the best available. This is the case that quietly breaks naive solutions that only guard against negatives by pairing them — more on that below.

---

11. Intuition

Let's discover the solution the way an experienced engineer actually does — by breaking our own first guess.

The starting instinct is honest: the three largest numbers. Multiply them, done. So write that down as Candidate A. It's clearly right when everything is positive, because bigger factors make a bigger product.

Now stress-test it. What kind of input could beat "the three biggest"? The only thing that changes the rules is a negative number, because a negative flips the sign of a product. One negative in your trio makes the whole product negative — bad. But two negatives multiply back into a positive. And if those two negatives are large in magnitude (say -9 and -8), their product (72) can dwarf anything the positive side offers.

So there's a second way to build a large product: take the two most-negative numbers and multiply them by the single largest number. Call that Candidate B. The two negatives give a big positive, and the largest positive scales it up further.

Here's the key insight that ties it together. If you sort the array, both candidates live at predictable, opposite ends:

• The three largest values sit at the right end (Candidate A).
• The two smallest — your potential negative pair — sit at the left end, and the single largest is still on the right (Candidate B).

The answer is always one of these two. This is the pattern worth naming: Two Corners. After sorting, you never need to search the middle. You only ever compare two products and return the bigger one. That's the whole algorithm.

Why only two candidates and not more? Because a maximum product of three needs either zero negatives (three positives → the top three) or exactly two negatives (two negatives + one positive → the biggest positive). Any trio with one or three negatives has a negative sign and can't be the maximum unless everything is negative — and even that case is covered, because when all numbers are negative, the "three largest" are the three closest to zero, which correctly yields the least-negative product.

---

12. Brute Force Solution

Idea: If the answer is "some three elements," just try every combination of three elements and keep the largest product.

Algorithm:

1. Generate all possible triples of indices (i, j, k).
2. Compute the product for each triple.
3. Track and return the maximum.

from itertools import combinations

def maximum_product_brute(nums):
    best = float("-inf")
    for a, b, c in combinations(nums, 3):
        best = max(best, a * b * c)
    return best

Advantages:

• Impossible to get wrong logically — it literally checks everything.
• No clever insight required; great as a sanity check against a smarter solution.

Disadvantages:

• Cubic blow-up. For an array of size n, there are roughly n³/6 triples.
• Completely impractical for large inputs — thousands of elements make it crawl.

Time complexity: O(n³) — three nested choices over the array. Space complexity: O(1) if you iterate lazily with combinations (it yields one triple at a time).

The brute force is useful for understanding and verifying, never for shipping.

---

13. Optimal Solution

We only ever need to compare two candidates, so we don't need to look at every triple. Sort once, then read the corners.

After sorting ascending:

Position	nums[0]	nums[1]	...	nums[-3]	nums[-2]	nums[-1]
Role	smallest	2nd smallest	...	3rd largest	2nd largest	largest

• Candidate A (three largest): nums[-1] * nums[-2] * nums[-3]
• Candidate B (two smallest × largest): nums[0] * nums[1] * nums[-1]

Return max(A, B).

Let's trace the pattern on [-9, -8, 1, 2, 3] after sorting (already sorted):

[-9, -8, 1, 2, 3]
  ↑   ↑        ↑
  two smallest  largest      →  Candidate B: -9 × -8 × 3 = 216

[-9, -8, 1, 2, 3]
            ↑  ↑  ↑
            three largest     →  Candidate A: 1 × 2 × 3 = 6

max(216, 6) = 216  ✅

Two products, one comparison. That's the optimal use of sorting.

---

14. Python Code

from typing import List


class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        nums.sort()
        # Candidate A: the three largest values (right corner).
        top_three = nums[-1] * nums[-2] * nums[-3]
        # Candidate B: the two smallest (possibly negative) times the largest.
        two_neg_one_pos = nums[0] * nums[1] * nums[-1]
        return max(top_three, two_neg_one_pos)

If you want the sort-free, linear-time version:

from typing import List


class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        max1 = max2 = max3 = float("-inf")   # three largest
        min1 = min2 = float("inf")           # two smallest

        for n in nums:
            # Update the three largest.
            if n > max1:
                max1, max2, max3 = n, max1, max2
            elif n > max2:
                max2, max3 = n, max2
            elif n > max3:
                max3 = n
            # Update the two smallest.
            if n < min1:
                min1, min2 = n, min1
            elif n < min2:
                min2 = n

        return max(max1 * max2 * max3, min1 * min2 * max1)

---

15. Code Walkthrough

Sorting version:

• nums.sort() — sorts in place, ascending. This forces the largest values to the right end and the smallest (including any negatives) to the left end, so both candidates land at fixed, predictable positions.
• nums[-1] * nums[-2] * nums[-3] — the three rightmost elements, i.e. the three largest. This is Candidate A.
• nums[0] * nums[1] * nums[-1] — the two leftmost (smallest) times the single largest. This is Candidate B, the one that catches the two-negatives case.
• max(...) — Python's built-in comparison hands back whichever candidate is larger. No branching, no special cases.

Linear version:

• We track five running values: the three largest (max1 ≥ max2 ≥ max3) and the two smallest (min1 ≤ min2).
• For each number, the if/elif cascade slots it into the correct rank if it beats the current holder, shifting the others down. The ordering of assignments matters — we update max1 first so its old value can flow into max2.
• After one pass, we form the same two candidates as before and return the larger.

The linear version does exactly what sorting does, but only keeps the five numbers it actually needs.

---

16. Dry Run

Let's fully trace the sorting solution on the challenge input from the video: [-5, -4, 1, 2, 3].

Step 1 — sort:

[-5, -4, 1, 2, 3]   (already ascending)

Step 2 — Candidate A (three largest):

nums[-1] * nums[-2] * nums[-3] = 3 * 2 * 1 = 6

Step 3 — Candidate B (two smallest × largest):

nums[0] * nums[1] * nums[-1] = (-5) * (-4) * 3 = 20 * 3 = 60

Step 4 — compare:

max(6, 60) = 60

Output: 60. The two-negatives corner wins, exactly as the pattern predicts. If we had only checked the top three, we'd have returned 6 and been wrong.

---

17. Complexity Analysis

Sorting solution

• Time: O(n log n) — dominated entirely by the sort. Reading five elements and doing a handful of multiplications is O(1).
• Space: O(1) extra if you accept an in-place sort (CPython's Timsort uses O(n) in the worst case internally, but no extra data structure is built by your code).

Linear solution

• Time: O(n) — a single pass, constant work per element.
• Space: O(1) — just five tracking variables, regardless of input size.

Why these are correct: the sorting version's cost is bounded by the sort because everything after it is fixed constant work. The linear version touches each element once and stores a fixed set of five numbers, so both time and space scale as described.

Honest take: for the input sizes this problem uses, the O(n) scan's speed advantage is mostly theoretical. The sorted version is five lines you can't misread, and readability wins in an interview. Mention the O(n) version, code it if asked, but don't reach for it by default.

---

18. Alternative Solutions

The linear scan shown above is the main alternative, and the comparison is a great interview talking point:

Approach	Time	Space	Readability	When to use
Sort + two corners	O(n log n)	O(1)	Very high	Default choice; small inputs
Single-pass scan	O(n)	O(1)	Moderate	Large inputs, or when interviewer asks to beat O(n log n)

The trade-off is honest: the scan is asymptotically faster but juggles more variables, and one wrong elif ordering silently breaks it. The sort is bulletproof and self-documenting. In interviews, lead with the sort, then say, "If you want O(n), I can track the top three and bottom two in a single pass" — that sentence alone signals you understand the trade-off.

---

19. Edge Cases

• Exactly three elements: [a, b, c] — both candidates reduce to the same single product. Handled naturally.
• All negative: [-1, -2, -3] — Candidate A (the three closest to zero) gives -6, the least-negative and therefore maximum product. max picks it correctly. This is the case that famously breaks solutions checking only the "top three" logic that assumes positivity — here it works because we also consider it as a corner.
• Mix with zeros: [-4, -3, 0, 2] — Candidate B: (-4)(-3)(2) = 24 beats Candidate A: (0)(2)(-3) = 0. Zeros are handled with no special code.
• Two large negatives dominate: [-100, -99, 1, 2, 3] — Candidate B: 9900 × 3 = 29700 crushes Candidate A's 6.
• Large / extreme values: Python integers are arbitrary-precision, so products of very large numbers never overflow. In languages with fixed-width integers, this is where you'd guard against overflow — worth mentioning to your interviewer.
• Duplicates: [3, 3, 3, 3] — the corners still work; duplicate values are just ordinary elements.

---

20. Common Mistakes

1. Checking only the three largest. The single most common failure. It passes the all-positive tests, then dies on [-9, -8, 1, 2, 3] and on all-negative inputs.
2. Pairing negatives without also considering the all-positive case. Some people flip too far and only compute nums[0] * nums[1] * nums[-1], which fails when there are no useful negatives (e.g. [1, 2, 3, 4] → they'd return 1×2×4 = 8 instead of 24). You need both candidates and the max.
3. Forgetting to sort. Reading nums[0] and nums[-1] only means "smallest" and "largest" after sorting. Skip the sort and you're reading arbitrary positions.
4. Wrong assignment order in the linear version. Writing max2 = n before max1 = n loses the old max1. The updates must cascade top-down.
5. Assuming a "smallest three" candidate matters. The two smallest matter (as a negative pair), but the three smallest never do — three negatives give a negative product. Adding that candidate is harmless but reveals a shaky grasp of why only two corners exist.
6. Worrying about overflow in Python. Python won't overflow, so guarding against it here is wasted code — though naming the concern for other languages is a plus.

---

21. Interview Questions

Expect follow-ups like these:

• "Can you do it without sorting?" — Yes: the single-pass scan tracking three max and two min values, O(n) time, O(1) space.
• "Why exactly two candidates? Prove it." — A maximum product of three needs an even count of negatives (0 or 2) to stay positive; those map to "three largest" and "two smallest × largest."
• "What changes for the maximum product of k numbers?" — The corner idea generalizes but the case analysis grows: you compare pairing the smallest negatives (in even counts) against the largest positives. It becomes a more careful DP or greedy selection.
• "How would you handle integer overflow in Java or C++?" — Use a 64-bit long for the product, or reason about value bounds; Python sidesteps this entirely.
• "What if you needed the actual three indices, not just the product?" — Track which elements formed the winning candidate during the scan.

---

22. Similar Problems

• LeetCode 152 — Maximum Product Subarray. Same two-negatives insight, applied to contiguous subarrays. You track both a running max and a running min because a negative can flip them. This is literally "tomorrow's harder corner problem."
• LeetCode 628 — Maximum Product of Three Numbers. (This problem.)
• LeetCode 1913 — Maximum Product Difference Between Two Pairs. Also solved by looking at the sorted corners (two largest, two smallest).
• LeetCode 414 — Third Maximum Number. Reinforces tracking the top-k values in a single pass, exactly like the linear version here.
• LeetCode 53 — Maximum Subarray. Different operation (sum, not product) but the same "scan once, track a running best" muscle.

They're related because they all reward the habit of reasoning about sign and magnitude at the extremes instead of naively grabbing the biggest values.

---

23. Key Takeaways

• "Largest input" ≠ "largest product." Negatives break that assumption, and spotting it fast is the real skill.
• Two Corners pattern: after sorting, the answer is either the three rightmost values or the two leftmost times the single rightmost. Compare two, return the max.
• Even count of negatives is what keeps a product positive — that's why only two candidates exist.
• Sort for clarity, scan for speed. Both are O(1) space; pick the sort unless the interviewer pushes for O(n).
• All-negative and zero inputs fall out of the two-candidate max for free — no special cases needed.

---

24. Watch the Video

Reading builds understanding, but watching the trap spring in real time is what makes it stick. In the video I walk through the two-negatives moment live, build the Two Corners pattern from scratch, and pause for a challenge so you can test yourself before the reveal.

▶️ Watch the full walkthrough here: {LINK}

---

25. About the Series

This is part of Fun with Learning Technology — a daily series where we take one LeetCode problem and turn it into real, durable intuition. No memorizing solutions, no hand-waving. Every episode builds the why first: how an experienced engineer actually stumbles onto the pattern, where the naive answer breaks, and how to code it cleanly in Python. Whether you're prepping for a coding interview or just sharpening your grasp of algorithms and data structures, there's a fresh problem every day.

---

26. Call To Action

If this helped the two-negatives trap finally click:

• 👍 Like the video on YouTube — it genuinely helps the channel reach more developers.
• 🔔 Subscribe so you catch tomorrow's problem, where this same corner trick cracks a much harder subarray challenge.
• 📬 Subscribe on Substack to get each written breakdown in your inbox.
• 💬 Comment with your answer to the challenge input — did you spot the corner before the reveal?
• 🔁 Share this with someone who's grinding LeetCode. The two-negatives trap catches everyone once.

---

---

SOCIAL MEDIA

LinkedIn Post

Here's a coding interview question that quietly humbles strong engineers: find the maximum product of three numbers in an array.

Almost everyone answers instantly — "sort it, multiply the three biggest." And for all-positive inputs, that's correct. It feels done.

Then the interviewer slides in [-9, -8, 1, 2, 3].

Top three? 1 × 2 × 3 = 6. But -9 × -8 × 3 = 216.

Two large negatives cancelled their signs into a huge positive, and the smallest numbers just beat the biggest. The word "largest" pulled our brains toward magnitude, and we skipped right past the sign.

The clean fix is a pattern I call Two Corners. After sorting, the answer always lives at the extremes:

• the three largest values (right corner), OR • the two smallest values × the single largest (left corner + right)

You compare exactly two candidates and return the max. Five lines, O(n log n), and it survives the all-negative case for free.

def maximumProduct(nums):
    nums.sort()
    return max(nums[-1]*nums[-2]*nums[-3],
               nums[0]*nums[1]*nums[-1])

The real lesson isn't this one problem. It's the habit: "biggest input" and "biggest result" are not the same claim. The engineers who reason about sign and magnitude at the extremes — instead of pattern-matching to the word "largest" — are the ones who catch the case that breaks their first answer.

That instinct shows up everywhere in algorithms and data structures. This problem is just where it's cheapest to learn.

What other "obvious" problems have a trap like this? 👇

#Python #LeetCode #CodingInterview #Algorithms #SoftwareEngineering

---

Twitter/X Thread

1/ "Find the max product of three numbers in an array."

Sounds trivial. Sort, take the top 3, multiply.

That answer is a trap — and it's how this problem quietly beats strong engineers. 🧵

2/ The gut instinct: sort → three biggest → multiply.

For [1, 2, 3, 4] that gives 2×3×4 = 24. Correct.

For all-positive inputs, you're done. That's the dangerous part — it feels finished.

3/ Now try [-9, -8, 1, 2, 3].

Top three: 1 × 2 × 3 = 6. But: -9 × -8 × 3 = 216.

The two SMALLEST numbers just crushed the three biggest.

4/ Why? Two negatives multiply into a positive.

And if those negatives are large in magnitude, their product is huge. Size and product stop meaning the same thing the moment negatives enter.

5/ So there are really only two ways to build the max product of three:

A) three largest numbers B) two smallest (negative) × the single largest

The answer is always one of these.

6/ Sort the array and both candidates sit at the ends:

A = last three (right corner) B = first two × last one (left + right)

I call it the Two Corners pattern. You never check the middle.

7/

def maximumProduct(nums):
    nums.sort()
    return max(nums[-1]*nums[-2]*nums[-3],
               nums[0]*nums[1]*nums[-1])

Five lines. O(n log n). Compare two candidates, return the max.

8/ Bonus: it handles all-negatives for free.

[-1, -2, -3] → candidate A gives -6, the least-negative (best) product. max picks it correctly. No special case needed.

9/ Want O(n)? Skip the sort, track the 3 largest + 2 smallest in one pass.

Technically faster. But more variables to juggle, easy to get an elif wrong. For interview-sized inputs, just sort.

10/ The real takeaway isn't this problem.

It's the habit: "biggest input" ≠ "biggest result." Reason about sign and magnitude at the extremes.

That instinct cracks much harder array problems too. Full walkthrough 👇

---

Facebook Post

Ever been this confident about a coding answer... right before it falls apart? 😅

Here's a classic: find three numbers in a list with the biggest possible product. Easy, right? Sort them, grab the three biggest, multiply. Done.

Then someone hands you [-9, -8, 1, 2, 3].

The three biggest give you 6. But -9 × -8 × 3 = 216! Two negatives multiply into a big positive, and suddenly the smallest numbers win.

The clean trick: after sorting, the answer is always at the "corners" — either the three biggest, or the two smallest times the single biggest. Check both, take the winner. Five lines of Python and it even handles all-negative lists automatically.

I break the whole thing down step by step in today's video — including the challenge where you get to catch the trap yourself before I reveal it. Come learn something new today! 🎥👇

---

Reddit Summary

The two-negatives trap in "Maximum Product of Three Numbers" (LeetCode 628)

Sharing a walkthrough of a deceptively simple array problem, since the reasoning is more useful than the code.

The task: pick three integers from a list with the maximum product. The instinctive answer — sort and multiply the three largest — is correct only for all-positive inputs. It fails on things like [-9, -8, 1, 2, 3], where -9 × -8 × 3 = 216 beats the top three's 6. Two large negatives multiply into a large positive.

The generalization: a max product of three needs an even number of negatives (0 or 2) to stay positive. That leaves exactly two candidates after sorting:

• nums[-1] * nums[-2] * nums[-3] (three largest)
• nums[0] * nums[1] * nums[-1] (two smallest × largest)

Return max() of the two. O(n log n) time, O(1) extra space. It also handles all-negative inputs correctly, since the three-largest candidate becomes the least-negative product.

If you want O(n), track the three largest and two smallest values in a single pass — same two candidates, no sort. Faster asymptotically, but more error-prone with the running-min/max updates, and for typical input sizes the gain is negligible.

The transferable idea: reason about sign and magnitude at the extremes of a sorted array rather than grabbing the biggest values. The same instinct shows up in Maximum Product Subarray (152), where you track a running min alongside the max for the same reason.

Happy to discuss the O(n) version or the k-numbers generalization in the comments.

---

---

GITHUB README

# Maximum Product of Three Numbers (LeetCode 628) — Python

Given an integer array, find three numbers whose product is maximum and return
that product.

## Problem

You are given a list of integers (positive, negative, or zero). Choose exactly
three elements so their product is as large as possible, and return that product.
The array has at least three elements.

- `[1, 2, 3, 4]      → 24`   (2 × 3 × 4)
- `[-9, -8, 1, 2, 3] → 216`  (-9 × -8 × 3)
- `[-1, -2, -3]      → -6`   (least-negative product)

## Intuition

The obvious answer — "sort and multiply the three largest" — is only correct
when all values are positive. Negatives break it, because **two negatives
multiply into a positive**. Two large-magnitude negatives can outproduce the
three biggest numbers.

A maximum product of three needs an **even count of negatives (0 or 2)** to stay
positive. That leaves exactly two candidates once the array is sorted:

- **Three largest** (right corner)
- **Two smallest × the single largest** (left corner + right)

Compare the two, return the larger. This is the **Two Corners** pattern.

## Approach

1. Sort the array ascending.
2. Candidate A = `nums[-1] * nums[-2] * nums[-3]`.
3. Candidate B = `nums[0] * nums[1] * nums[-1]`.
4. Return `max(A, B)`.

The all-negative case is handled for free: Candidate A becomes the
least-negative (maximum) product.

## Python Solution

```python
from typing import List


class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        nums.sort()
        top_three = nums[-1] * nums[-2] * nums[-3]
        two_neg_one_pos = nums[0] * nums[1] * nums[-1]
        return max(top_three, two_neg_one_pos)

O(n) variant (no sort)

from typing import List


class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        max1 = max2 = max3 = float("-inf")
        min1 = min2 = float("inf")
        for n in nums:
            if n > max1:   max1, max2, max3 = n, max1, max2
            elif n > max2: max2, max3 = n, max2
            elif n > max3: max3 = n
            if n < min1:   min1, min2 = n, min1
            elif n < min2: min2 = n
        return max(max1 * max2 * max3, min1 * min2 * max1)

Complexity

Approach	Time	Space
Sort + corners	O(n log n)	O(1)
Single-pass	O(n)	O(1)

Prefer the sort for readability; use the scan when asked to beat O(n log n).

Video

▶️ Full walkthrough: {LINK}

Article

Full explanation with intuition, dry run, edge cases, and common mistakes is in the accompanying article. Part of the Fun with Learning Technology series. ```

    top3 = nums[-1] * nums[-2] * nums[-3]
    low2 = nums[0] * nums[1] * nums[-1]
    return max(top3, low2)