Jobs

Interviews

Discussions

Construct Target Array With Multiple Sums

Hard

Quora

1 view

Topics:

ArraysGreedy Algorithms

You are given an array target of n integers. From a starting array arr consisting of n 1's, you may perform the following procedure :

let x be the sum of all elements currently in your array.
choose index i, such that 0 <= i < n and set the value of arr at index i to x.
You may repeat this procedure as many times as needed.

Return true if it is possible to construct the target array from arr, otherwise, return false.

Example 1:

Input: target = [9,3,5]
Output: true
Explanation: Start with arr = [1, 1, 1] 
[1, 1, 1], sum = 3 choose index 1
[1, 3, 1], sum = 5 choose index 2
[1, 3, 5], sum = 9 choose index 0
[9, 3, 5] Done

Example 2:

Input: target = [1,1,1,2]
Output: false
Explanation: Impossible to create target array from [1,1,1,1].

Example 3:

Input: target = [8,5]
Output: true

Constraints:

n == target.length
1 <= n <= 5 * 10⁴
1 <= target[i] <= 10⁹

Try coding it in LeetCode

Construct Target Array With Multiple Sums

Hard

Quora

1 view

Topics:

ArraysGreedy Algorithms

You are given an array target of n integers. From a starting array arr consisting of n 1's, you may perform the following procedure :

let x be the sum of all elements currently in your array.
choose index i, such that 0 <= i < n and set the value of arr at index i to x.
You may repeat this procedure as many times as needed.

Return true if it is possible to construct the target array from arr, otherwise, return false.

Example 1:

Input: target = [9,3,5]
Output: true
Explanation: Start with arr = [1, 1, 1] 
[1, 1, 1], sum = 3 choose index 1
[1, 3, 1], sum = 5 choose index 2
[1, 3, 5], sum = 9 choose index 0
[9, 3, 5] Done

Example 2:

Input: target = [1,1,1,2]
Output: false
Explanation: Impossible to create target array from [1,1,1,1].

Example 3:

Input: target = [8,5]
Output: true

Constraints:

n == target.length
1 <= n <= 5 * 10⁴
1 <= target[i] <= 10⁹

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What are the possible value ranges for the integers within the `target` array?
Can the input array `target` be empty or contain null values?
If it's not possible to transform the initial array into the target array, should I return false or throw an exception?
Are there any constraints on the number of operations I can perform?
Does the order of elements in the `target` array matter? For example, does [2, 3, 5] differ from [5, 3, 2]?

Brute Force Solution

Approach

The brute force strategy involves attempting every possible sequence of operations to transform an initial all-ones array into the target array. We repeatedly subtract from the largest element until we reach a state where all elements are ones, or we determine it's impossible to reach the target.

Here's how the algorithm would work step-by-step:

Find the largest number in your array.
Figure out the sum of all the other numbers in the array.
Subtract the sum of the other numbers from the largest number.
Replace the largest number with the result of the subtraction.
Repeat this process of finding the largest number, calculating the sum of the rest, subtracting, and replacing.
Continue until all numbers in the array are equal to one. If this happens, you've successfully transformed the array.
If at any point during the subtraction, the new largest number becomes less than one, it means it's impossible to transform the array. You'll also want to keep track of cases where the largest number doesn't change, resulting in getting stuck in a loop; that also means a solution is not possible.
If after many, many tries, you still haven't made all numbers one, give up, it probably can't be done.

Code Implementation

def construct_target_array_with_multiple_sums_brute_force(target_array):
    current_array = [1] * len(target_array)
    max_iterations = 1000

    for _ in range(max_iterations):
        largest_number_index = current_array.index(max(current_array))
        largest_number = current_array[largest_number_index]
        sum_of_other_numbers = sum(current_array) - largest_number

        # If largest number is already 1, check if target is reached
        if largest_number == 1:
            if current_array == target_array:
                return True
            else:
                return False

        new_largest_number = largest_number - sum_of_other_numbers

        # Impossible if new largest number is less than 1
        if new_largest_number < 1:
            return False

        # Detect getting stuck in a loop
        if new_largest_number == largest_number:
            return False

        current_array[largest_number_index] = new_largest_number

        if current_array == target_array:
            return True

    return False

Big(O) Analysis

Time Complexity

O(n*m) – The algorithm iteratively finds the largest element in the target array (costing O(n) where n is the size of the array). It then calculates the sum of the remaining elements, also O(n). The subtraction and replacement operation is O(1). The algorithm repeats these steps until all elements are 1 or it determines it is impossible. The number of iterations of this main loop is bounded by the largest number m in the input array since we are repeatedly subtracting from it. Therefore, in the worst-case scenario, the algorithm runs for m iterations, with each iteration costing O(n) for finding the largest element and calculating the sum. This results in a total time complexity of O(n*m).

Space Complexity

O(1) – The provided algorithm operates in place, modifying the input array directly. It only requires a few constant extra variables such as the index of the largest element and the sum of other elements. Therefore, the auxiliary space used does not scale with the input size N (the number of elements in the target array). The algorithm's space complexity is constant.

Optimal Solution

Approach

The problem asks us to determine if we can reach a target array by repeatedly summing the other elements of the array and replacing one element with that sum. We work backwards from the target to see if we can reach an array of all ones. By focusing on the largest number, we can reverse the summing process efficiently.

Here's how the algorithm would work step-by-step:

Find the biggest number in the array.
Figure out the sum of all the other numbers in the array.
Subtract the sum of the other numbers from the biggest number. This gives you the number that was replaced in the previous step.
Check if the result after subtraction is less than 1. If so, we can't reach the target array and should stop.
Replace the biggest number with this newly calculated number.
Repeat the whole process until you have an array where all numbers are 1, in which case the answer is yes, or until you reach a point where you can't proceed, in which case the answer is no.

Code Implementation

def is_possible(target_array):
    total_sum = sum(target_array)
    target_array = [-number for number in target_array]

    import heapq
    heapq.heapify(target_array)

    while True:
        largest_number = -heapq.heappop(target_array)
        sum_of_others = total_sum - largest_number

        if largest_number == 1:
            return True

        if largest_number <= sum_of_others or sum_of_others == 0:
            return False

        number_to_insert = largest_number % sum_of_others

        # If the sum of others is 1, all other numbers are 1.
        if sum_of_others == 1:
            number_to_insert = 1

        total_sum = sum_of_others + number_to_insert

        #If number to insert is 0, it means largest_number is divisible by sum_of_others
        if number_to_insert == 0:
            return False

        heapq.heappush(target_array, -number_to_insert)

    return True

Big(O) Analysis

Time Complexity

O(n log n) – The primary driver of the time complexity is the repeated process of finding the largest element and updating the array. Finding the largest element can be done efficiently using a max heap (priority queue) of size n, which takes O(log n) time for insertion, deletion, and finding the maximum. We iterate as long as the largest element is greater than 1. In the worst-case scenario, each element is updated which results in constructing the max heap multiple times. Since heap operations occur at most a number of times proportional to the sum of the target array and there are at most n heap operations, the overall complexity is approximately O(Sum(target) log n) in the worst case, or an average O(n log n) assuming the target array values are not extremely large.

Space Complexity

O(log N) – The plain English explanation describes repeatedly finding the biggest number and replacing it. A heap data structure (specifically a max heap) would be used in practice to efficiently find the largest number. Building a heap from an array of size N requires O(N) space initially, which can be done in-place if you don't consider the array itself, so we would transform the existing input array into a max heap. However, the heap modification operations involve 'heapify' which takes O(log N) space in the worst-case due to the recursion stack depth required for balancing operations of the heap. Therefore the auxiliary space used scales logarithmically with the size of the input array, leading to an O(log N) space complexity.

Edge Cases

Case	How to Handle
Null or empty input array	Return false since an empty target cannot be constructed from an initial array of ones.
Single element array where the element is 1	Return true as a single element array of 1 is the initial state.
Single element array where the element is not 1	Return false as you can't transform [1] into [x] where x != 1.
Array with only 1s	Return true if the initial array is all 1s, as no transformation is needed.
Array contains very large numbers that could lead to integer overflow during summation	Use a data type that can accommodate large sums (e.g., long in Java/C++, or bigint in Python) to prevent integer overflow.
Array with a very large number and many small numbers (skewed distribution)	The algorithm should still work correctly but may take longer as the largest number is repeatedly reduced.
The sum of all elements is less than or equal to the largest element	The operation will repeatedly reduce the largest element, potentially leading to a state where it cannot be further reduced to 1, thus return false.
A number appears multiple times, each requiring a different number of operations to reach 1	The priority queue/heap based approach correctly handles duplicates as it iteratively reduces the largest number.

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What are the possible value ranges for the integers within the `target` array?
Can the input array `target` be empty or contain null values?
If it's not possible to transform the initial array into the target array, should I return false or throw an exception?
Are there any constraints on the number of operations I can perform?
Does the order of elements in the `target` array matter? For example, does [2, 3, 5] differ from [5, 3, 2]?

Brute Force Solution

Approach

Here's how the algorithm would work step-by-step:

Find the largest number in your array.
Figure out the sum of all the other numbers in the array.
Subtract the sum of the other numbers from the largest number.
Replace the largest number with the result of the subtraction.
Repeat this process of finding the largest number, calculating the sum of the rest, subtracting, and replacing.
Continue until all numbers in the array are equal to one. If this happens, you've successfully transformed the array.
If at any point during the subtraction, the new largest number becomes less than one, it means it's impossible to transform the array. You'll also want to keep track of cases where the largest number doesn't change, resulting in getting stuck in a loop; that also means a solution is not possible.
If after many, many tries, you still haven't made all numbers one, give up, it probably can't be done.

Code Implementation

def construct_target_array_with_multiple_sums_brute_force(target_array):
    current_array = [1] * len(target_array)
    max_iterations = 1000

    for _ in range(max_iterations):
        largest_number_index = current_array.index(max(current_array))
        largest_number = current_array[largest_number_index]
        sum_of_other_numbers = sum(current_array) - largest_number

        # If largest number is already 1, check if target is reached
        if largest_number == 1:
            if current_array == target_array:
                return True
            else:
                return False

        new_largest_number = largest_number - sum_of_other_numbers

        # Impossible if new largest number is less than 1
        if new_largest_number < 1:
            return False

        # Detect getting stuck in a loop
        if new_largest_number == largest_number:
            return False

        current_array[largest_number_index] = new_largest_number

        if current_array == target_array:
            return True

    return False

Big(O) Analysis

Time Complexity

Space Complexity

Optimal Solution

Approach

Here's how the algorithm would work step-by-step:

Find the biggest number in the array.
Figure out the sum of all the other numbers in the array.
Subtract the sum of the other numbers from the biggest number. This gives you the number that was replaced in the previous step.
Check if the result after subtraction is less than 1. If so, we can't reach the target array and should stop.
Replace the biggest number with this newly calculated number.
Repeat the whole process until you have an array where all numbers are 1, in which case the answer is yes, or until you reach a point where you can't proceed, in which case the answer is no.

Code Implementation

def is_possible(target_array):
    total_sum = sum(target_array)
    target_array = [-number for number in target_array]

    import heapq
    heapq.heapify(target_array)

    while True:
        largest_number = -heapq.heappop(target_array)
        sum_of_others = total_sum - largest_number

        if largest_number == 1:
            return True

        if largest_number <= sum_of_others or sum_of_others == 0:
            return False

        number_to_insert = largest_number % sum_of_others

        # If the sum of others is 1, all other numbers are 1.
        if sum_of_others == 1:
            number_to_insert = 1

        total_sum = sum_of_others + number_to_insert

        #If number to insert is 0, it means largest_number is divisible by sum_of_others
        if number_to_insert == 0:
            return False

        heapq.heappush(target_array, -number_to_insert)

    return True

Big(O) Analysis

Time Complexity

Space Complexity

Edge Cases

Case	How to Handle
Null or empty input array	Return false since an empty target cannot be constructed from an initial array of ones.
Single element array where the element is 1	Return true as a single element array of 1 is the initial state.
Single element array where the element is not 1	Return false as you can't transform [1] into [x] where x != 1.
Array with only 1s	Return true if the initial array is all 1s, as no transformation is needed.
Array contains very large numbers that could lead to integer overflow during summation	Use a data type that can accommodate large sums (e.g., long in Java/C++, or bigint in Python) to prevent integer overflow.
Array with a very large number and many small numbers (skewed distribution)	The algorithm should still work correctly but may take longer as the largest number is repeatedly reduced.
The sum of all elements is less than or equal to the largest element	The operation will repeatedly reduce the largest element, potentially leading to a state where it cannot be further reduced to 1, thus return false.
A number appears multiple times, each requiring a different number of operations to reach 1	The priority queue/heap based approach correctly handles duplicates as it iteratively reduces the largest number.