0071EasyArrayMathSorting

Largest Triple Drift

Tracked in this browser only

Trains the technique from

LeetCode 628Maximum Product of Three Numbers

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A calibration rig logs how far a gauge drifted each shift. drifts[i] is the signed drift for shift i, negative when the gauge fell short and positive when it overshot.

The rig's stress score for three shifts is the product of their three drift values. Pick three shifts at three different positions and return the largest stress score reachable.

Note that two badly negative drifts multiply into a large positive number, so the three biggest values are not always the winning pick.

Examples

Example 1

Input: drifts = [3, 5, 1, 8]
Output: 120

Every value is positive, so the three largest, 3, 5 and 8, give the best score of 120.

Example 2

Input: drifts = [-9, -8, 1, 2]
Output: 144

Taking -9 and -8 together cancels both signs, and pairing them with 2 beats the 1 * 2 * -8 available from the three largest values.

Example 3

Input: drifts = [-5, -4, -3]
Output: -60

Only one triple exists, and its score is negative; that is still the answer.

Constraints

3 <= drifts.length <= 10^4
-1000 <= drifts[i] <= 1000

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def largest_triple_drift(drifts: list[int]) -> int:

Java

public int largestTripleDrift(int[] drifts)

The intended approach

Time O(n)Space O(1)

Only two candidate triples can ever win: the three largest values, or the two smallest (most negative) values paired with the single largest value. One pass keeps the top three and bottom two seen so far, so no sorting is needed and only a handful of variables are held.

Pythonentry point: largest_triple_drift

def largest_triple_drift(drifts):
    high1 = high2 = high3 = None
    low1 = low2 = None
    for value in drifts:
        if high1 is None or value > high1:
            high1, high2, high3 = value, high1, high2
        elif high2 is None or value > high2:
            high2, high3 = value, high2
        elif high3 is None or value > high3:
            high3 = value
        if low1 is None or value < low1:
            low1, low2 = value, low1
        elif low2 is None or value < low2:
            low2 = value
    return max(high1 * high2 * high3, low1 * low2 * high1)

The obvious version

Enumerate every triple of positions with three nested loops and keep the largest product, O(n^3).

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_largest_triple_drift(drifts):
    n = len(drifts)
    best = None
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j + 1, n):
                product = drifts[i] * drifts[j] * drifts[k]
                if best is None or product > best:
                    best = product
    return best

How this problem was checked

Reference solution executed against 12 test cases — 12 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in