# Destroy Sequential Targets

## Problem Statement:

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

We have a machine that 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. We want to destroy the maximum number of targets in numbers.

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

### Java Implementation using Brute Force Approach

Output:

Code Explanation:

• The code implements a solution to find the target element in an array that, when destroyed, maximizes the count of elements with a specific spacing. It takes user input for the array and spacing, sorts the array, and iterates through pairs of elements to calculate the count of elements with the given spacing. The answer is updated based on the maximum count encountered.
• The program returns the element that, when destroyed, maximizes the count. The solution utilizes sorting and nested loops to handle array elements and spacing, providing a straightforward approach to solving the problem.

Time Complexity:

• The time complexity is O(n^2 log n) of the input size 'n'. It is the outer loop that spans over a pair of performance time definition timers, and the sorting operation takes O(n log n).

Space Complexity:

• The space complexity is O(1). The algorithm requires a fixed space for extra memory irrespective of the input size.

Drawback:

• The proposed solution needs a fundamental imperfection as it needs more efficiency. It contains a nested loop, suggesting that its time complexity is O (n^2), where n stands for the length of an input array.
• This quadratic time complexity may result in a poor performance of the algorithm, given bigger input sizes. Therefore, the solution might need to be more scalable and may suffer from performance bottlenecks in handling large or rapidly increasing datasets.

### Java Approach using HashMap

Output:

Code Explanation:

• The destroyTargets method aims to find a target element that minimizes the frequency of elements having the same remainder when divided by the given space value. It uses a HashMap to store the count of elements modulo space. First, it iterates through the nums array, updating the HashMap and tracking the maximum frequency.
• Then, it iterates again to find the target element by comparing the count of elements' modulo values with the maximum frequency. The method returns the target element, which ensures minimizing the frequency of elements with the same remainder

Time Complexity:

• DestroyTargets method has O(N) time complexity, where N represents the length of the nums array. In each iteration, the method runs in constant time and traverses the array twice.

Space Complexity:

• The space complexity is O(M), where M denotes the number of distinct modulo values in the nums array. The approach involves a hash map to keep track of the number of distinct elements modulo space, and the required amount is proportionate by an extensive or quickly increasing dataset.

### Java Approach using Double Hash Maps

Output:

Code Explanation:

• The destroyTargets method first sorts the given nums array in ascending order. It utilizes two HashMaps (map and ans) to track the frequency and the minimum element for each modulo value. While iterating through the sorted array, it updates these HashMaps accordingly.
• After processing all elements, it finds the modulo value with the maximum frequency. In case of a tie, it selects the modulo value with the smaller corresponding minimum element. The method returns the minimum element associated with the chosen modulo value.

Time Complexity:

• The solution's time complexity is largely dominated by sorting, yielding O(N log N). The second run-through of the array and HashMap operations has a linear effect on time, adding O(N) to the whole complexity.

Space Complexity:

• The space complexity is O(N) because there are two HashMaps (map and ans), each of which may contain all N different modulo values.