Box ‘o Numbers – Tech Interview Dot Org

Arrange the numbers 1 to 8 in the grid below such that adjacent numbers are not in adjacent boxes (horizontally, vertically, or diagonally):

       ___
      | 1 |
  =============
  | 6 | 4 | 3 |
  =============
  | 2 | 7 | 5 |
  =============
      | 8 |
      =====

The arrangement above, for example, is wrong because 3 & 4, 4 & 5, 6 & 7, and 7 & 8 are adjacent.

Solution

The key is putting the 1 & 8 in the center spots – which is required, because those spots both border all but one of the other spots, and 1 & 8 are the only numbers that are only adjacent to one number.

From there, the 2 & 7 are forced, then you have your choice of the next number, which then forces the rest. Really, though there are only two valid solutions, and they are mirror images of each other.

💡Strategies for Solving This Problem

Array Processing Problem

Without seeing the exact problem, this is likely about processing arrays of numbers with specific operations. Common themes: find patterns, calculate sums/products, or determine properties.

Common "Box of Numbers" Problems

1. Find missing/duplicate: Covered elsewhere

2. Maximum subarray sum: Kadane's algorithm

3. Product of array except self: Prefix/suffix products

4. Find equilibrium: Left sum = right sum

Maximum Subarray (Kadane's)

Find contiguous subarray with largest sum.

Key insight: At each position, decide whether to extend current subarray or start new one.

maxEndingHere = max(nums[i], maxEndingHere + nums[i])

O(n) time, O(1) space. Classic DP problem.

Product Except Self

Return array where output[i] is product of all elements except nums[i].

Can't use division (what if there's a zero?). Use prefix and suffix products.

O(n) time, O(1) space (using output array doesn't count).

Equilibrium Index

Find index where sum of left elements equals sum of right elements.

Calculate total sum, then iterate tracking left sum. When leftSum == totalSum - leftSum - nums[i], found it.

O(n) time, O(1) space.

✅Solution

Solution: Maximum Subarray (Kadane's)

function maxSubarraySum(nums) {
    if (nums.length === 0) return 0;

    let maxEndingHere = nums[0];
    let maxSoFar = nums[0];

    for (let i = 1; i < nums.length; i++) {
        // Either extend current subarray or start new one
        maxEndingHere = Math.max(nums[i], maxEndingHere + nums[i]);
        maxSoFar = Math.max(maxSoFar, maxEndingHere);
    }

    return maxSoFar;
}

// Tests
console.log(maxSubarraySum([-2, 1, -3, 4, -1, 2, 1, -5, 4]));  // 6 ([4,-1,2,1])
console.log(maxSubarraySum([1, 2, 3, 4]));                     // 10
console.log(maxSubarraySum([-1, -2, -3]));                     // -1

Product Except Self

function productExceptSelf(nums) {
    const n = nums.length;
    const output = Array(n).fill(1);

    // Calculate prefix products
    let prefix = 1;
    for (let i = 0; i < n; i++) {
        output[i] = prefix;
        prefix *= nums[i];
    }

    // Calculate suffix products and multiply
    let suffix = 1;
    for (let i = n - 1; i >= 0; i--) {
        output[i] *= suffix;
        suffix *= nums[i];
    }

    return output;
}

// Tests
console.log(productExceptSelf([1, 2, 3, 4]));     // [24, 12, 8, 6]
console.log(productExceptSelf([2, 3, 4, 5]));     // [60, 40, 30, 24]
console.log(productExceptSelf([1, 0, 3, 4]));     // [0, 12, 0, 0]

Equilibrium Index

function equilibriumIndex(nums) {
    const totalSum = nums.reduce((sum, num) => sum + num, 0);
    let leftSum = 0;

    for (let i = 0; i < nums.length; i++) {
        // Check if left sum equals right sum
        // Right sum = totalSum - leftSum - nums[i]
        if (leftSum === totalSum - leftSum - nums[i]) {
            return i;
        }

        leftSum += nums[i];
    }

    return -1;  // No equilibrium found
}

// Tests
console.log(equilibriumIndex([-7, 1, 5, 2, -4, 3, 0]));  // 3 (left: -1, right: -1)
console.log(equilibriumIndex([1, 2, 3]));                 // -1
console.log(equilibriumIndex([1, 3, 5, 2, 2]));           // 2

Find Pair with Sum

function findPairWithSum(nums, target) {
    const seen = new Set();

    for (const num of nums) {
        if (seen.has(target - num)) {
            return [target - num, num];
        }
        seen.add(num);
    }

    return null;
}

console.log(findPairWithSum([1, 2, 3, 4, 5], 7));  // [3, 4] or [2, 5]

Maximum Product Subarray

function maxProductSubarray(nums) {
    if (nums.length === 0) return 0;

    let maxSoFar = nums[0];
    let minSoFar = nums[0];  // Track min for negative numbers
    let result = nums[0];

    for (let i = 1; i < nums.length; i++) {
        const num = nums[i];

        // If negative, swap max and min
        if (num < 0) {
            [maxSoFar, minSoFar] = [minSoFar, maxSoFar];
        }

        maxSoFar = Math.max(num, maxSoFar * num);
        minSoFar = Math.min(num, minSoFar * num);

        result = Math.max(result, maxSoFar);
    }

    return result;
}

console.log(maxProductSubarray([2, 3, -2, 4]));     // 6 ([2,3])
console.log(maxProductSubarray([-2, 0, -1]));       // 0
console.log(maxProductSubarray([-2, 3, -4]));       // 24 (all)

Complexity Summary

Problem	Time	Space
Max subarray	O(n)	O(1)
Product except self	O(n)	O(1)*
Equilibrium	O(n)	O(1)
Max product	O(n)	O(1)

* Not counting output array

Solution

💡Strategies for Solving This Problem

Array Processing Problem

Common "Box of Numbers" Problems

Maximum Subarray (Kadane's)

Product Except Self

Equilibrium Index

✅Solution

Solution: Maximum Subarray (Kadane's)

Product Except Self

Equilibrium Index

Find Pair with Sum

Maximum Product Subarray

Complexity Summary

Related Problems