Fruit Jar Labeling Puzzle: Three Mislabeled Jars, One Pick

The Fruit Jar Labeling Puzzle: Three Mislabeled Jars, One Fruit Picked

The fruit jar labeling puzzle is a famous lateral-thinking interview question that appears at quant trading firms (Jane Street, SIG, Optiver), consulting interviews, and FAANG behavioral rounds. The setup: three jars contain apples, oranges, or a mix; all three labels are wrong; you can pick exactly one fruit from one jar to determine the correct labeling. The key insight — labels are all wrong, not “may be wrong” — unlocks the solution. This guide covers the puzzle, the elegant one-pick solution, and the variants that come up.

Problem Statement

You have three jars labeled “Apples,” “Oranges,” and “Apples and Oranges.” Each label is incorrect — you know with certainty that no jar’s label matches its contents. You may reach into one jar, pick one fruit (without looking inside), and observe what fruit you picked. Based on that single observation, correctly label all three jars.

The Solution

Pick from the jar labeled “Apples and Oranges.”

The label is wrong, so this jar does not contain a mix. It must contain either all apples or all oranges. Whichever fruit you pick tells you which.

Suppose you pick an apple. Then this jar is the apples-only jar. Now consider the remaining two jars: one labeled “Apples” (incorrect — so it’s not apples), one labeled “Oranges” (incorrect — so it’s not oranges).

• The jar labeled “Apples” must be the mix or oranges. Since the apples-only jar is identified, this is the mix.
• The jar labeled “Oranges” must be the apples or mix. Since the mix is identified, this is the oranges-only jar.

Wait, that’s contradictory. Let me redo this.

Three jars: contents are apples (A), oranges (O), and mix (M). Labels are A, O, M; all wrong, so:

• Jar labeled A doesn’t contain A — it’s O or M.
• Jar labeled O doesn’t contain O — it’s A or M.
• Jar labeled M doesn’t contain M — it’s A or O.

Pick from the jar labeled M. It’s not M (label is wrong) — so it’s A or O.

Case 1: you pick an apple. The jar labeled M contains only apples. Now:

• Jar labeled A is O or M. Since A is identified, it’s not A — it’s O or M. By elimination of A: it’s O or M.
• Jar labeled O is A or M. A is identified — so this is M.
• Jar labeled A: by process of elimination, it’s O.

Case 2: you pick an orange. The jar labeled M contains only oranges.

• Jar labeled O is A or M. O is identified, so it’s A or M.
• Jar labeled A is O or M. O is identified, so this is M.
• Jar labeled O: by elimination, it’s A.

In both cases, picking from the M-labeled jar uniquely determines all three labels.

Why This Works

The key insight is that the “all labels are wrong” constraint is informative. The mixed-label jar must be a single-fruit jar (apples or oranges); identifying which one constrains the other two jars uniquely (since their labels are also wrong, they can’t be the identified single-fruit content, and one of them must be the mix).

Without the “all wrong” constraint, the puzzle is unsolvable in one pick. The puzzle’s elegance comes from how strict the constraint is: every label is exactly wrong, which is much stronger than “labels may be wrong.”

Why Picking from Other Jars Doesn’t Work

If you pick from the jar labeled “Apples” — which contains either oranges or the mix — the result is:

• Pick an apple: the jar labeled A contains apples or mix. Since A is wrong, it must be the mix. But this only identifies one jar; the other two could still be A and O in either order.
• Pick an orange: the jar contains oranges or mix. Could be either; the answer is ambiguous.

So picking from the “Apples” jar leaves ambiguity. Same for the “Oranges” jar. Only the M-labeled jar’s contents are constrained to a single-fruit jar (since the label is wrong about being mixed), so picking from it gives unambiguous information.

Variations

Two jars, one mislabel

Trivial — given one mislabel, picking from any jar identifies it. Used as a warm-up sometimes.

N jars, all mislabeled, single-pick

For N > 3 with similar “all labels wrong” constraint, the puzzle becomes harder. Sometimes one pick suffices; sometimes more. The general pattern: pick from a jar whose label-content combination is most constrained.

K wrong labels, but you don’t know which

Different problem; harder. Cannot be solved in one pick if you don’t know in advance which labels are wrong.

Three jars, label may or may not be correct

Different problem entirely. With “labels may be correct,” picking one fruit isn’t enough information.

What Interviewers Test

• Recognize the strength of the “all labels wrong” constraint
• Identify which jar has the most-constrained single-pick outcome (the mix-labeled one)
• Walk through the elimination logic correctly
• Communicate the reasoning clearly

If you’ve heard the puzzle before, say so. Interviewers ask follow-ups: “what if there are 4 jars?” or “what if 2 of 3 labels are wrong but you don’t know which?”

Frequently Asked Questions

See also: Bridge Crossing Puzzle • Burning Ropes Puzzle • Two Eggs / 80-Floor Building

function fruitJar(capacity, fruits) {
    // fruits = [{value, weight}, ...]
    const n = fruits.length;

    // dp[i][w] = max value using first i fruits with capacity w
    const dp = Array(n + 1).fill(null)
        .map(() => Array(capacity + 1).fill(0));

    // Build dp table
    for (let i = 1; i <= n; i++) {
        const {value, weight} = fruits[i - 1];

        for (let w = 0; w <= capacity; w++) {
            // Don't take this fruit
            dp[i][w] = dp[i - 1][w];

            // Take this fruit (if it fits)
            if (weight <= w) {
                dp[i][w] = Math.max(
                    dp[i][w],
                    value + dp[i - 1][w - weight]
                );
            }
        }
    }

    return dp[n][capacity];
}

// Test
const fruits = [
    {value: 60, weight: 10},
    {value: 100, weight: 20},
    {value: 120, weight: 30}
];

console.log(fruitJar(50, fruits));  // 220 (fruits 2 and 3)

function fruitJarOptimized(capacity, fruits) {
    const n = fruits.length;
    const dp = Array(capacity + 1).fill(0);

    for (let i = 0; i < n; i++) {
        const {value, weight} = fruits[i];

        // Iterate backwards to avoid overwriting
        for (let w = capacity; w >= weight; w--) {
            dp[w] = Math.max(
                dp[w],
                value + dp[w - weight]
            );
        }
    }

    return dp[capacity];
}

console.log(fruitJarOptimized(50, fruits));  // 220

function fruitJarUnbounded(capacity, fruits) {
    const dp = Array(capacity + 1).fill(0);

    for (let w = 1; w <= capacity; w++) {
        for (const {value, weight} of fruits) {
            if (weight <= w) {
                // Can take this fruit again
                dp[w] = Math.max(
                    dp[w],
                    value + dp[w - weight]
                );
            }
        }
    }

    return dp[capacity];
}

// Test with same fruits
console.log(fruitJarUnbounded(50, fruits));  // 300 (5x fruit 1)

function fruitJarWithItems(capacity, fruits) {
    const n = fruits.length;
    const dp = Array(n + 1).fill(null)
        .map(() => Array(capacity + 1).fill(0));

    // Build dp table
    for (let i = 1; i <= n; i++) {
        const {value, weight} = fruits[i - 1];
        for (let w = 0; w <= capacity; w++) {
            dp[i][w] = dp[i - 1][w];
            if (weight <= w) {
                dp[i][w] = Math.max(
                    dp[i][w],
                    value + dp[i - 1][w - weight]
                );
            }
        }
    }

    // Backtrack to find items
    const selected = [];
    let i = n, w = capacity;

    while (i > 0 && w > 0) {
        // Was this item taken?
        if (dp[i][w] !== dp[i - 1][w]) {
            selected.push(i - 1);  // 0-indexed
            w -= fruits[i - 1].weight;
        }
        i--;
    }

    return {
        maxValue: dp[n][capacity],
        items: selected.reverse()
    };
}

const result = fruitJarWithItems(50, fruits);
console.log("Max value:", result.maxValue);     // 220
console.log("Items:", result.items);            // [1, 2]
console.log("Weights:", result.items.map(i => fruits[i].weight));  // [20, 30]

dp table:
       w=0  10   20   30
i=0     0   0    0    0
i=1     0  60   60   60  (can take fruit 1)
i=2     0  60  100  160  (can take fruit 2, or both)

At dp[2][30]:
  Don't take fruit 2: dp[1][30] = 60
  Take fruit 2: 100 + dp[1][30-20] = 100 + 60 = 160 ✓

Answer: 160 (take both fruits)