File: defuse-the-bomb/solution.py

Date: 2026-06-06

Time: 16:13

defuse-the-bomb/solution.py

Purpose

This file solves LeetCode 1652 — Defuse the Bomb. It decrypts a circular array by replacing each element with the sum of its next or previous k neighbors, depending on the sign of k. It's a self-contained solution module following the repo's standard per-problem layout.

Key Components

Solution.minOperations(code, k) — Despite the method name (minOperations rather than the canonical decrypt), this implements the decryption logic. The contract:

• Input: code — a circular integer array; k — signed integer controlling direction and window size.
• Output: A new list of the same length where each element is replaced per the decryption rule.
• Three branches on k:
• k == 0: every element becomes 0.
• k > 0: each element becomes the sum of the next k elements (wrapping circularly).
• k < 0: each element becomes the sum of the previous |k| elements (wrapping circularly).

Patterns

• Brute-force circular indexing via % n. Every neighbor access uses modular arithmetic to wrap around the array, which is the textbook approach for circular arrays.
• No sliding window optimization — for each of the n positions, it sums |k| elements from scratch, giving O(n * |k|) time. A prefix-sum or sliding-window approach would reduce this to O(n), but the brute-force is acceptable for the problem's constraints (n, |k| ≤ 100).
• Follows the repo convention: single Solution class, typed signature, docstring with Args/Returns.

Dependencies

• Imports: Only typing.List — no external libraries.
• Imported by: defuse-the-bomb/test_solution.py (the "Imported By" list in the prompt is the repo-wide test import graph for Solution, not specific to this file).

Flow

1. Compute n = len(code).

2. Short-circuit: if k == 0, return a zero-filled list immediately.

3. For each index i in [0, n):

• If k > 0: sum code[(i+1) % n] through code[(i+k) % n].
• If k < 0: sum code[(i-1) % n] through code[(i-|k|) % n].
• Append the sum to result.

4. Return result.

Python's % operator always returns a non-negative result for positive divisors, so (i - j) % n correctly wraps negative indices — no special handling needed.

Invariants

• The output list always has the same length as code.
• When k == 0, every output element is exactly 0 regardless of input.
• The summation window never includes code[i] itself — the inner loop starts at j = 1, not j = 0.

Error Handling

None. The function trusts its inputs match the LeetCode contract (non-empty list, |k| < n). No validation, no exceptions.

Notable Quirk

The method is named minOperations rather than the LeetCode-canonical decrypt. This is likely a copy-paste artifact from another problem's scaffold. It won't affect correctness (the test file presumably calls whatever method name is defined), but it would fail on LeetCode's judge as-is.