Defuse the Bomb

Defuse the Bomb - Problem

You have a bomb to defuse, and your time is running out! Your informer will provide you with a circular array code of length n and a key k.

To decrypt the code, you must replace every number. All the numbers are replaced simultaneously.

If k > 0, replace the i^th number with the sum of the next k numbers.
If k < 0, replace the i^th number with the sum of the previous k numbers.
If k == 0, replace the i^th number with 0.

As code is circular, the next element of code[n-1] is code[0], and the previous element of code[0] is code[n-1].

Return the decrypted code to defuse the bomb!

Input & Output

Example 1 — Positive k

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

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

💡 Note: For i=0: sum of next 3 elements = 7+1+4 = 12. For i=1: sum of next 3 elements = 1+4+5 = 10 (wraps around). For i=2: sum of next 3 elements = 4+5+7 = 16. For i=3: sum of next 3 elements = 5+7+1 = 13.

Example 2 — Negative k

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

› Output: [7,5,3,5]

💡 Note: For i=0: sum of previous 2 elements = 4+3 = 7 (positions -1,-2 wrap to indices 3,2). For i=1: sum of previous 2 elements = 1+4 = 5 (positions 0,-1 wrap to indices 0,3). For i=2: sum of previous 2 elements = 2+1 = 3 (positions 1,0). For i=3: sum of previous 2 elements = 3+2 = 5 (positions 2,1).

Example 3 — Zero k

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

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

💡 Note: When k=0, all elements are replaced with 0.

Constraints

n == code.length
1 ≤ n ≤ 100
1 ≤ code[i] ≤ 100
-(n-1) ≤ k ≤ n-1

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8

The key insight is to recognize this as a sliding window problem where we sum k consecutive elements in a circular array. The brute force approach recalculates sums for each position (O(n×k)), while the optimal sliding window approach calculates once and slides efficiently (O(n)). Best approach is sliding window. Time: O(n), Space: O(1).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n × k) Space: O(1)

For each element in the array, we manually iterate through the next k or previous k elements (using modular arithmetic for circular access) and sum them up. This approach recalculates the entire sum for each position.

Sliding Window

⏱️ Time: O(n) Space: O(1)

Instead of recalculating the entire sum for each position, we calculate the sum for the first position, then slide the window by removing the leftmost element and adding the new rightmost element. This eliminates redundant calculations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int parseArray(char* line, int* arr) {
    int n = 0;
    int i = 0;
    
    // Skip whitespace and find '['
    while (line[i] && line[i] != '[') i++;
    if (!line[i]) return 0;
    i++; // Skip '['
    
    // Parse numbers
    while (line[i] && line[i] != ']') {
        if (line[i] >= '0' && line[i] <= '9') {
            int num = 0;
            while (line[i] >= '0' && line[i] <= '9') {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            arr[n++] = num;
        } else {
            i++;
        }
    }
    
    return n;
}

int mod(int a, int b) {
    int result = a % b;
    return result < 0 ? result + b : result;
}

void solution(int* code, int n, int k, int* result) {
    // Initialize result array to 0
    for (int i = 0; i < n; i++) {
        result[i] = 0;
    }
    
    if (k == 0) {
        return;
    }
    
    int window_sum = 0;
    
    if (k > 0) {
        // Calculate initial window sum for positive k
        for (int i = 1; i <= k; i++) {
            window_sum += code[i % n];
        }
        
        // Slide the window
        for (int i = 0; i < n; i++) {
            result[i] = window_sum;
            // Remove the leftmost element of current window
            window_sum -= code[(i + 1) % n];
            // Add the rightmost element of next window
            window_sum += code[(i + k + 1) % n];
        }
    } else {
        // Calculate initial window sum for negative k
        int abs_k = -k;
        for (int i = 1; i <= abs_k; i++) {
            window_sum += code[mod(-i, n)];
        }
        
        // Slide the window
        for (int i = 0; i < n; i++) {
            result[i] = window_sum;
            // Remove the rightmost element of current window
            window_sum -= code[mod(i - 1, n)];
            // Add the leftmost element of next window
            window_sum += code[mod(i - abs_k, n)];
        }
    }
}

int main() {
    char line1[1000];
    char line2[100];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int code[1000];
    int n = parseArray(line1, code);
    int k = atoi(line2);
    
    int result[1000];
    solution(code, n, k, result);
    
    // Print result in JSON format
    printf("[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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