Skip to content
Related Articles

Related Articles

Modify array to another given array by replacing array elements with the sum of the array

Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 28 Oct, 2022
Improve Article
Save Article

Given an array input[] consisting only of 1s initially and an array target[] of size N, the task is to check if the array input[] can be converted to target[] by replacing input[i] with the sum of array elements in each step. If found to be true, then print “YES”. Otherwise, print “NO”.

Examples:

Input: input[] = { 1, 1, 1 }, target[] = { 9, 3, 5 } 
Output: YES 
Explanation: 
Replacing input[1] with (input[0] + input[1] + input[2]) modifies input[] to { 1, 3, 1 } 
Replacing input[2] with (input[0] + input[1] + input[2]) modifies input[] to { 1, 3, 5 } 
Replacing input[0] with (input[0] + input[1] + input[2]) modifies input[] to { 9, 3, 5 } 
Since the array input[] equal to the target[] array, the required output is “YES”.

Input: input[] = { 1, 1, 1, 1 }, target[] = { 1, 1, 1, 2 } 
Output: NO

Approach: The problem can be solved using Greedy technique. The idea is to always decrement the largest element of target[] array by the sum of the remaining array elements and check if the largest element of the target[]. If found to be true then print “YES”. Otherwise, print “NO”. Following are the observations:

If target[] = { 9, 3, 5 } and input[] = { 1, 1, 1 } 
Decrementing target[0] by (target[1] + target[2]) modifies target[] to { 1, 3, 5 } 
Decrementing target[2] by (target[0] + target[1]) modifies target[] to { 1, 3, 1 } 
Decrementing target[1] by (target[0] + target[2]) modifies target[] to { 1, 1, 1 } 
Since input[] array and target[] equal, the required output is YES. 
 

  • If the largest element in the array target[] is less than 1, then print “NO”.
  • If the largest element in the array target[] is equal to 1, then print “YES”.
  • Otherwise, decrement the largest element in the array target[] by the sum of remaining elements present in the array target[] while the largest element of the array is greater than 1.

Below is the implementation of the above approach:

C++




// CPP program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if the arr[] can be
// converted to target[] by replacing
// any element in arr[] by the sum of arr[]
bool isPossible(int target[], int n)
{
 
  // Store the maximum element
  int max = 0;
 
  // Store the index of
  // the maximum element
  int index = 0;
 
  // Traverse the array target[]
  for (int i = 0; i < n; i++) {
 
    // If current element is
    // greater than max
    if (max < target[i]) {
      max = target[i];
      index = i;
    }
  }
 
  // If max element is 1
  if (max == 1)
    return true;
 
  // Traverse the array, target[]
  for (int i = 0; i < n; i++) {
 
    // If current index is not equal to
    // maximum element index
    if (i != index) {
 
      // Update max
      max -= target[i];
 
      // If max is less than
      // or equal to 0,
      if (max <= 0)
        return false;
    }
  }
 
  // Update the maximum element
  target[index] = max;
 
  // Recursively call the function
  return isPossible(target,n);
}
 
// Driver Code
int main()
{
  int target[] = { 9, 3, 5 };
   
  // Size of the array
   int n = sizeof(target) / sizeof(target[0]);
 
  bool res = isPossible(target,n);
 
  if (res)
  {
 
    cout << "YES";
  }
  else
  {
    cout << "NO";
  }
  return 0;
}
 
// This code is contributed by 29AjayKumar

Java




// Java program to implement
// the above approach
 
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Function to check if the arr[] can be
    // converted to target[] by replacing
    // any element in arr[] by the sum of arr[]
    public static boolean isPossible(int[] target)
    {
 
        // Store the maximum element
        int max = 0;
 
        // Store the index of
        // the maximum element
        int index = 0;
 
        // Traverse the array target[]
        for (int i = 0; i < target.length; i++) {
 
            // If current element is
            // greater than max
            if (max < target[i]) {
                max = target[i];
                index = i;
            }
        }
 
        // If max element is 1
        if (max == 1)
            return true;
 
        // Traverse the array, target[]
        for (int i = 0; i < target.length; i++) {
 
            // If current index is not equal to
            // maximum element index
            if (i != index) {
 
                // Update max
                max -= target[i];
 
                // If max is less than
                // or equal to 0,
                if (max <= 0)
                    return false;
            }
        }
 
        // Update the maximum element
        target[index] = max;
 
        // Recursively call the function
        return isPossible(target);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] target = { 9, 3, 5 };
 
        boolean res = isPossible(target);
 
        if (res) {
 
            System.out.println("YES");
        }
        else {
            System.out.println("NO");
        }
    }
}

Python3




# Python program to implement the above approach
 
# Function to check if the arr[] can be
# converted to target[] by replacing
# any element in arr[] by the sum of arr[]
def isPossible(target):
   
  # Store the maximum element
  max = 0
 
  # Store the index of
  # the maximum element
  index = 0
 
  # Traverse the array target[]
  for i in range(len(target)):
     
    # If current element is
    # greater than max
    if (max < target[i]):
      max = target[i]
      index = i
 
  # If max element is 1
  if (max == 1):
    return True
 
  # Traverse the array, target[]
  for i in range(len(target)):
     
    # If current index is not equal to
    # maximum element index
    if (i != index):
       
      # Update max
      max -= target[i]
       
      # If max is less than
      # or equal to 0,
      if (max <= 0):
        return False
       
  # Update the maximum element
  target[index] = max
 
  # Recursively call the function
  return isPossible(target)
 
# Driver Code
target = [ 9, 3, 5 ]
res = isPossible(target)
if (res):
  print("YES")
else:
  print("NO")
 
  # This code is contributed by RohitSingh07052.

C#




// C# program for the above approach
using System;
class GFG
{
 
    // Function to check if the arr[] can be
    // converted to target[] by replacing
    // any element in arr[] by the sum of arr[]
    public static bool isPossible(int[] target)
    {
 
        // Store the maximum element
        int max = 0;
 
        // Store the index of
        // the maximum element
        int index = 0;
 
        // Traverse the array target[]
        for (int i = 0; i < target.Length; i++) {
 
            // If current element is
            // greater than max
            if (max < target[i])
            {
                max = target[i];
                index = i;
            }
        }
 
        // If max element is 1
        if (max == 1)
            return true;
 
        // Traverse the array, target[]
        for (int i = 0; i < target.Length; i++) {
 
            // If current index is not equal to
            // maximum element index
            if (i != index) {
 
                // Update max
                max -= target[i];
 
                // If max is less than
                // or equal to 0,
                if (max <= 0)
                    return false;
            }
        }
 
        // Update the maximum element
        target[index] = max;
 
        // Recursively call the function
        return isPossible(target);
    }
 
   
// Driver Code
static public void Main()
{
        int[] target = { 9, 3, 5 };
 
        bool res = isPossible(target);
 
        if (res)
        {
            Console.WriteLine("YES");
        }
        else
        {
            Console.WriteLine("NO");
        }
    }
}
 
// This code is contributed by jana_sayantan.

Javascript




<script>
 
// javascript program to implement
// the above approach
 
 
// Function to check if the arr can be
// converted to target by replacing
// any element in arr by the sum of arr
function isPossible(target)
{
 
    // Store the maximum element
    var max = 0;
 
    // Store the index of
    // the maximum element
    var index = 0;
 
    // Traverse the array target
    for (i = 0; i < target.length; i++) {
 
        // If current element is
        // greater than max
        if (max < target[i]) {
            max = target[i];
            index = i;
        }
    }
 
    // If max element is 1
    if (max == 1)
        return true;
 
    // Traverse the array, target
    for (i = 0; i < target.length; i++) {
 
        // If current index is not equal to
        // maximum element index
        if (i != index) {
 
            // Update max
            max -= target[i];
 
            // If max is less than
            // or equal to 0,
            if (max <= 0)
                return false;
        }
    }
 
    // Update the maximum element
    target[index] = max;
 
    // Recursively call the function
    return isPossible(target);
}
 
// Driver Code
var target = [ 9, 3, 5 ];
 
res = isPossible(target);
 
if (res) {
 
    document.write("YES");
}
else {
    document.write("NO");
}
// This code is contributed by 29AjayKumar
</script>

Output

YES

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: This type of problem are purely intuition based and can be solved easily just by doing some observations …

Notice that we are getting a pattern in the target array if we make it sorted.Take a look at examples

Examples: 

1:       input[] = { 1, 1, 1 }, target[] = { 9, 3, 5 }

         sorted(target[])={3,5,9} and the output will be for this array is YES

2:       input[] = { 1, 1, 1,1 }, target[] = { 4,,25,7,13} 

        sorted(target[])={4,7,13,25} and the output will be for this array is YES

3:       input[]={1,1,1,1,1} ,target[]={33,65,5,9,17}

        sorted(target[])={5,9,17,33,65} and the output will be for this array is YES
 

From the above mentioned examples, it is clear that for size(target[])=n, sorted(target[]) should start from n and successive elements of the target[] array will be as : target[i]=2*target[i-1]-1 and so on.

if sorted(target) array follows this pattern, then result will be YES ,else NO….

 Approach Steps: 

  • Sort the target[] array first.
  • Store length of target[] array into n.
  • if sorted(target[]) does not start from n, then return  “NO”.
  • Traverse sorted(target[]) from index 1 to last.
  •  If target[i] != 2* target[ i-1]-1 at any step,then return “NO”, else after completing traversal return “YES”………….improved by Rajat Kumar.

Below is the implementation of the above approach:

Python3




# Python program to implement the above approach
# Function to check if the arr[] can be
# converted to target[] by replacing
# any element in arr[] by the sum of arr[]
 
 
def isPossible(target):
    # sort the target array
    # this step is dominating step
    # in time complexity having
    #time complexity O(n logn).
    target.sort()
    # store length of target into n
    n = len(target)
    # check if target[0] is equal to n or not?
    if target[0] != n:
        return False
    # Traverse the array further for checking
    # whether array follows the pattern or not ?
    for i in range(1, n):
        if target[i] != 2*target[i-1]-1:
            # if an element does not follow the pattern
            # return False
            return False
    # After checking all the elements at the last, return True
    return True
 
 
# Driver Code
target = [9, 3, 5]
res = isPossible(target)
if (res):
    print("YES")
else:
    print("NO")
 
""" Code is written by Rajat kumar(rajatkumargla19)... """

Output

YES

Time Complexity: O(nlogn) as sorting takes O(nlogn)

Space Complexity: O(1).


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!