Destroy Sequential Targets

Destroy Sequential Targets - Problem

You are given a 0-indexed array nums consisting of positive integers, representing targets on a number line. You are also given an integer space.

You have a machine which can destroy targets. Seeding the machine with some nums[i] allows it to destroy all targets with values that can be represented as nums[i] + c * space, where c is any non-negative integer.

You want to destroy the maximum number of targets in nums.

Return the minimum value of nums[i] you can seed the machine with to destroy the maximum number of targets.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,6,2,4,1], space = 2

› Output: 2

💡 Note: Seeding with 2 destroys targets [2,4,6] (3 targets). Seeding with 1 destroys [1,3] (2 targets). Choose 2 for maximum targets.

Example 2 — Tie Breaker

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

› Output: 1

💡 Note: Both remainder groups have 3 targets: [1,3,5] and [2,4,6]. Choose seed=1 (minimum value) from the first group.

Example 3 — Single Group

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

› Output: 2

💡 Note: Since space=100 is larger than differences, each target forms its own group. Choose minimum value 2.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i], space ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that targets with the same remainder when divided by space can be destroyed by the same seed. Use modular arithmetic to group targets efficiently. Best approach is hash map grouping. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force

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

For each number in the array, simulate seeding the machine with it and count how many targets can be destroyed. Keep track of the seed that destroys the maximum targets with minimum value.

Modular Arithmetic with Hash Map

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

Use modular arithmetic to group targets. Targets that have the same remainder when divided by space can be destroyed by seeding with the smallest target in that group. Count frequency of each remainder and find the one with maximum count.

Brute Force — Algorithm Steps

For each nums[i], count targets that can be destroyed
A target nums[j] can be destroyed if (nums[j] - nums[i]) % space == 0 and nums[j] >= nums[i]
Track maximum count and minimum seed value

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Each Seed

Test every number in array as potential seed

Count Targets

For each seed, count how many targets can be destroyed

Find Best

Choose seed with maximum targets (minimum value if tied)

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int space) {
    int maxCount = 0;
    int result = 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 < result)) {
            maxCount = count;
            result = seed;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = 0;
    char* ptr = line + 1;
    char* token;
    while ((token = strtok(ptr, ",]")) != NULL) {
        nums[numsSize++] = atoi(token);
        ptr = NULL;
    }
    
    int space;
    scanf("%d", &space);
    
    printf("%d\n", solution(nums, numsSize, space));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, check all n elements to see if they can be destroyed

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track count and result

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

456 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler