Defuse the Bomb

Problem Statement

In this coding challenge, you are presented with a high-stakes scenario where you need to decrypt a circular array named code to defuse a bomb effectively. The length of this array is denoted as n, and the decryption key is an integer k. The primary task is to transform each element in the array based on the following rules:

1. If k is positive, you should replace each element with the sum of the next k elements.
2. If k is negative, each element should be replaced by the sum of the previous k elements (counting backwards).
3. If k equals zero, every element should be straightforwardly replaced with zero.

The array is defined as circular, meaning the array's endpoint wraps around to the start. Hence, after the last element (code[n-1]), the next element is the first element (code[0]), and inversely, before the first element (code[0]), lies the last element (code[n-1]).

The final outcome to be returned is the decrypted version of the code array following the aforementioned rules for transformation based on the key k.

Examples

Example 1

Input:

code = [5,7,1,4], k = 3

Output:

[12,10,16,13]

Explanation:

Each number is replaced by the sum of the next 3 numbers. The decrypted code is [7+1+4, 1+4+5, 4+5+7, 5+7+1]. Notice that the numbers wrap around.

Example 2

Input:

code = [1,2,3,4], k = 0

Output:

[0,0,0,0]

Explanation:

When k is zero, the numbers are replaced by 0.

Example 3

Input:

code = [2,4,9,3], k = -2

Output:

[12,5,6,13]

Explanation:

The decrypted code is [3+9, 2+3, 4+2, 9+4]. Notice that the numbers wrap around again. If k is negative, the sum is of the previous numbers.

Constraints

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

Approach and Intuition

To successfully and efficiently decrypt the code array, consider the following approach based on the value of k and the circular nature of the array:

1. Initialize a result array of size n to store the decrypted code.

2. For positive k:

   • For each index i in the code, calculate the sum of the next k elements.
   • Because the array is circular, use modulo arithmetic ((i + j) % n) to find the correct indices for elements to sum when iterating beyond the array's last index.

3. For negative k:

   • Convert k to a positive by negating it (abs(k)).
   • Iterate similarly as for positive k, but in the opposite direction, using ((i - j + n) % n) to handle the circular wrap of the array.

4. For k == 0:

   • Directly fill the result array with zeros.

Thus, based on the provided input and the sign of k, the strategy dynamically adheres to summing the precise elements (forward for positive k and backward for negative k), or straightforward replacement for k equal to zero. This optimized, step-wise methodology ensures that each situation is addressed with the correct arithmetic operations, observing the constraints of a circular array for consistent and error-free results.

Solutions

class Solution {
public:
    vector<int> decrypt(vector<int>& code, int k) {
        vector<int> decrypted(code.size(), 0);
        if (k == 0) return decrypted;
        int lIndex = 1, rIndex = k, currSum = 0;
        if (k < 0) {
            lIndex = code.size() - abs(k);
            rIndex = code.size() - 1;
        }
        for (int i = lIndex; i <= rIndex; i++) currSum += code[i];
        for (int i = 0; i < code.size(); i++) {
            decrypted[i] = currSum;
            currSum -= code[lIndex % code.size()];
            currSum += code[(rIndex + 1) % code.size()];
            lIndex++;
            rIndex++;
        }
        return decrypted;
    }
};