Destroy Sequential Targets - Practice Coding Problems

Destroy Sequential Targets - Problem

Imagine you have a powerful targeting system that can destroy targets on a number line. You're given an array nums of positive integers representing target positions, and an integer space that defines the spacing pattern.

Here's the key: when you seed your machine with any target value nums[i], it creates a chain reaction that destroys all targets at positions nums[i] + c × space, where c can be any non-negative integer (0, 1, 2, 3, ...).

Your mission: Choose the optimal seed value that destroys the maximum number of targets. If multiple seeds can destroy the same maximum number of targets, return the smallest seed value.

Example: With targets [3, 7, 8, 1, 1, 5] and space = 2, seeding with 1 destroys targets at positions 1, 3, 5, 7, ... which captures 4 targets from our array!

Input & Output

example_1.py — Basic Case

$ Input: nums = [3, 7, 8, 1, 1, 5], space = 2

› Output: 1

💡 Note: Seeding with 1 destroys targets at positions 1, 3, 5, 7, ... which includes 5 targets from our array: {1, 1, 3, 5, 7}. This is the maximum possible.

example_2.py — Tie Breaker

$ Input: nums = [6, 2, 5], space = 100

› Output: 2

💡 Note: Each target forms its own group since space=100 is larger than the differences. All seeds destroy exactly 1 target, so we return the smallest: 2.

example_3.py — All Same Remainder

$ Input: nums = [1, 3, 5, 7], space = 2

› Output: 1

💡 Note: All targets have remainder 1 when divided by 2, so any target can destroy all others. We return the minimum: 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ space ≤ 10⁹
All elements in nums are positive integers

Visualization

Tap to expand

Understanding the Visualization

Position targets

Place all targets on a number line: [1, 1, 3, 5, 7, 8]

Group by pattern

Group by remainder mod 2: odd positions {1,1,3,5,7} vs even {8}

Chain reaction

Seeding at position 1 destroys all odd positions in the sequence

Key Takeaway

🎯 Key Insight: Targets with the same remainder (mod space) form destruction chains. Find the largest chain and return its minimum seed value.

Asked in

a Amazon 35 G Google 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses hash table grouping with the key insight that targets can be destroyed by the same seed if they have the same remainder when divided by space. Group targets by num % space, count each group, and return the minimum value from the largest group. Time: O(n), Space: O(min(n, space)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Seed)	O(n²)	O(1)	Try each possible seed value and count how many targets it can destroy
One-Pass Hash Table (Optimal)	O(n)	O(min(n, space))	Group targets by remainder and find the group with most targets in one pass

Brute Force (Try Every Seed) — Algorithm Steps

Initialize maxCount = 0 and bestSeed = infinity
For each nums[i] as potential seed:
Count how many targets can be destroyed (including nums[i] itself)
If count > maxCount or (count == maxCount and nums[i] < bestSeed), update result
Return bestSeed

Visualization

Tap to expand

Step-by-Step Walkthrough

Try seed 3

Count targets: 3(✓), 5(✓), 7(✓), 1(✗), 8(✗) → 3 targets

Try seed 1

Count targets: 1(✓), 3(✓), 5(✓), 7(✓), 8(✗) → 4 targets

Continue for all

Test remaining seeds and track the best result

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

int destroyTargets(int* nums, int numsSize, int space) {
    int maxCount = 0;
    int bestSeed = INT_MAX;
    
    for (int i = 0; i < numsSize; i++) {
        int seed = nums[i];
        int count = 0;
        
        for (int j = 0; j < numsSize; j++) {
            int target = nums[j];
            if (target >= seed && (target - seed) % space == 0) {
                count++;
            }
        }
        
        if (count > maxCount || (count == maxCount && seed < bestSeed)) {
            maxCount = count;
            bestSeed = seed;
        }
    }
    
    return bestSeed;
}

int main() {
    int nums[] = {3, 7, 8, 1, 1, 5};
    int space = 2;
    printf("%d\n", destroyTargets(nums, 6, space));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we check all n elements to count destroyable targets

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track the best result

✓ Linear Space

23.5K Views

Medium-High Frequency

~15 min Avg. Time

847 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try Every Seed) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler