Fuse on Fire

Solution: 45 Minutes

/*
 * Measure 45 minutes with two 1-hour fuses
 *
 * Algorithm:
 * 1. t=0:  Light fuse A from both ends, fuse B from one end
 * 2. t=30: Fuse A burns out, light other end of fuse B
 * 3. t=45: Fuse B burns out
 *
 * Result: 45 minutes measured
 */

function measureTime(targetMinutes) {
    // Simulate fuse burning
    const fuses = [
        { remainingTime: 60, burnRate: 1 },  // Fuse A: 60 min, 1 end lit
        { remainingTime: 60, burnRate: 1 }   // Fuse B: 60 min, 1 end lit
    ];

    let currentTime = 0;

    // Step 1: Light fuse A from both ends, fuse B from one end
    fuses[0].burnRate = 2;  // Both ends
    fuses[1].burnRate = 1;  // One end

    // Burn until fuse A is done
    const fuseATime = fuses[0].remainingTime / fuses[0].burnRate;
    currentTime += fuseATime;

    // Update fuse B
    fuses[1].remainingTime -= fuseATime * fuses[1].burnRate;

    // Step 2: Light other end of fuse B
    fuses[1].burnRate = 2;

    // Burn until fuse B is done
    const fuseBTime = fuses[1].remainingTime / fuses[1].burnRate;
    currentTime += fuseBTime;

    return currentTime;
}

console.log(measureTime(45));  // 45

General Solution: Measure Any Time

/*
 * What times can we measure with n fuses of duration d?
 *
 * With 2 fuses of 60 minutes:
 * - 30 min: One fuse both ends
 * - 45 min: As shown above
 * - 60 min: One fuse one end
 * - 90 min: One fuse + half of second
 *
 * Pattern: We can measure times that are sums of:
 * d, d/2, d/4, d/8, ... (halving at each step)
 */

function possibleTimes(numFuses, duration) {
    const times = new Set();

    // Generate all possible combinations
    // Each fuse can contribute full time or subdivisions
    function generate(remaining, currentTime, fuseIndex) {
        if (fuseIndex === numFuses || remaining === 0) {
            times.add(currentTime);
            return;
        }

        // Current fuse contribution
        let contrib = duration;
        const maxHalvings = remaining;

        for (let halvings = 0; halvings <= maxHalvings; halvings++) {
            const time = duration / Math.pow(2, halvings);
            generate(
                remaining - halvings,
                currentTime + time,
                fuseIndex + 1
            );
        }
    }

    // Allow up to n-1 "light other end" operations
    generate(numFuses - 1, 0, 0);

    return Array.from(times).sort((a, b) => a - b);
}

console.log(possibleTimes(2, 60));
// [30, 45, 60, 75, 90, 105, 120] and more

Step-by-Step: 45 Minutes

t=0:
  Fuse A: [====60min====] (light both ends)
  Fuse B: [====60min====] (light one end)

t=30:
  Fuse A: BURNED OUT
  Fuse B: [====30min====] (light other end now)

t=45:
  Fuse B: BURNED OUT

Total elapsed: 45 minutes ✓

Common Mistakes

• Assuming uniform burn rate: Problem states irregular, but "both ends" trick still works
• Not using both ends: Key insight is lighting from both ends
• Wrong timing: Remember halving only happens when BOTH ends lit
• Overthinking: Solution is simpler than it seems

Variations

15 minutes:

1. Light both fuses from both ends (30 min each)
2. When first burns out (30 min), second has 30 min left
3. Light other end of second (burns out in 15 min)
4. Total: 30 + 15 = 45... wait, that's wrong!

Actually for 15 min:

1. Light fuse A both ends, fuse B one end
2. At 30 min, fuse A out, fuse B has 30 min left
3. Light fuse B other end
4. Burns in 15 more minutes
5. Total: 15 minutes from step 2!

7.5 minutes:

Continue the halving pattern. After measuring 15 min, you have technique to measure 7.5 min.

Key Principles

1. Halving: Both ends = half time
2. Chaining: Start second fuse at strategic time
3. Remainder: Use remaining burn time of partially burned fuse

Related Problems

• Clock - Time-based problems
• Gold Chain - Logic puzzles
• Classic Weighing - Measurement problems