Defuse the Bomb - Practice Coding Problems

Defuse the Bomb - Problem

🎯 Mission: Defuse the Bomb!

You're a bomb disposal expert with seconds left on the clock! Your informant has given you a circular array code of length n and a crucial decryption key k.

Decryption Rules:

If k > 0: Replace each number with the sum of the next k numbers
If k < 0: Replace each number with the sum of the previous k numbers
If k == 0: Replace each number with 0 (bomb is disabled!)

Important: The array is circular - after the last element comes the first, and before the first comes the last. All replacements happen simultaneously.

Example: code = [5,7,1,4], k = 3
• Position 0: sum of next 3 = 7+1+4 = 12
• Position 1: sum of next 3 = 1+4+5 = 10
• Result: [12,10,16,13]

Return the decrypted code to save the day!

Input & Output

example_1.py — Basic Positive k

$ Input: code = [5,7,1,4], k = 3

› Output: [12,10,16,13]

💡 Note: For k=3, each element is replaced by the sum of the next 3 elements: Position 0: 7+1+4=12, Position 1: 1+4+5=10 (wraps to start), Position 2: 4+5+7=16, Position 3: 5+7+1=13

example_2.py — Negative k

$ Input: code = [1,2,3,4], k = -2

› Output: [7,9,1,3]

💡 Note: For k=-2, each element is replaced by the sum of the previous 2 elements: Position 0: 4+3=7 (wraps to end), Position 1: 1+4=5, Position 2: 2+1=3, Position 3: 3+2=5

example_3.py — Zero k

$ Input: code = [2,4,9,3], k = 0

› Output: [0,0,0,0]

💡 Note: When k=0, the bomb is defused and all elements become 0

Visualization

Tap to expand

Understanding the Visualization

Setup Window

Position the detection window at the first sensor

Calculate Initial

Sum the readings from the window's sensors

Slide Window

Move window to next position by removing old sensor and adding new one

Update Efficiently

Update sum with just two operations instead of recalculating everything

Key Takeaway

🎯 Key Insight: The sliding window technique transforms this from O(n×k) to O(n) by reusing calculations - perfect for circular arrays!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array after initial window setup

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space besides result array

✓ Linear Space

Constraints

n == code.length
1 ≤ n ≤ 100
1 ≤ code[i] ≤ 100
-n ≤ k ≤ n
The array is circular - elements wrap around

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a sliding window technique to achieve O(n) time complexity. Instead of recalculating sums for each position, we calculate the initial window sum and then slide the window by removing one element and adding another. This eliminates redundant calculations and works perfectly with the circular array structure.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n * \|k\|)	O(1)	For each position, manually sum the required k neighbors using modular arithmetic
Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to calculate sums efficiently in one pass

Brute Force (Nested Loops) — Algorithm Steps

Create result array of same size
For each position i in the array:
If k = 0, set result[i] = 0
If k > 0, sum the next k elements using (i+j) % n
If k < 0, sum the previous |k| elements using (i-j+n) % n
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create result array and start with first position

Calculate Sum

For current position, iterate through k neighbors

Handle Circular

Use modular arithmetic to wrap around the array

Repeat

Move to next position and repeat the process

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int* decrypt(int* code, int codeSize, int k, int* returnSize) {
    *returnSize = codeSize;
    int* result = (int*)calloc(codeSize, sizeof(int));
    
    if (k == 0) {
        return result;
    }
    
    for (int i = 0; i < codeSize; i++) {
        int total = 0;
        if (k > 0) {
            // Sum next k elements
            for (int j = 1; j <= k; j++) {
                total += code[(i + j) % codeSize];
            }
        } else {
            // Sum previous |k| elements
            for (int j = 1; j <= abs(k); j++) {
                total += code[(i - j + codeSize) % codeSize];
            }
        }
        result[i] = total;
    }
    
    return result;
}

int main() {
    int n, k;
    scanf("%d", &n);
    int* code = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &code[i]);
    }
    scanf("%d", &k);
    
    int returnSize;
    int* result = decrypt(code, n, k, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(" ");
    }
    printf("\n");
    
    free(code);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * |k|)

For each of n elements, we sum |k| neighbors

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for the result array

✓ Linear Space

Constraints

n == code.length
1 ≤ n ≤ 100
1 ≤ code[i] ≤ 100
-n ≤ k ≤ n
The array is circular - elements wrap around

38.5K Views

Medium Frequency

~15 min Avg. Time

1.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler