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

Last Updated : 24 Jan, 2023

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 ` `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

 ``

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:

## Java

 `// Java 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[]` `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)` `  ``{` `    ``// sort the target array` `    ``Arrays.sort(target);` `    ``// store length of target into n` `    ``int` `n = target.length;` `    ``// 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` `(``int` `i = ``1``; i < n; i++) {` `      ``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``;` `  ``}`   `  ``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"``);` `    ``}` `  ``}` `}`   `// This code is contributed by lokesh.`

## 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)... """`

## C#

 `// C# code for the above approach` `using` `System;`   `public` `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)` `  ``{` `    ``// sort the target array` `    ``Array.Sort(target);` `    ``// store length of target into n` `    ``int` `n = target.Length;` `    ``// 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` `(``int` `i = 1; i < n; i++) {` `      ``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``;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``int``[] target = { 9, 3, 5 };` `    ``bool` `res = IsPossible(target);` `    ``if` `(res) {` `      ``Console.WriteLine(``"YES"``);` `    ``}` `    ``else` `{` `      ``Console.WriteLine(``"NO"``);` `    ``}` `  ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Javascript

 `// JS 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)` `{` `    ``// sort the target array` `    ``// this step is dominating step ` `    ``// in time complexity having` `    ``//time complexity O(n logn).` `    ``target.sort(``function``(a, b)` `    ``{` `        ``return` `a - b;` `    ``})` `    `  `    ``// store length of target into n` `    ``let n = target.length` `    `  `    ``// 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` `(``var` `i = 1; i < n; i++)` `        ``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` `let target = [9, 3, 5]` `let res = isPossible(target)` `if` `(res)` `    ``console.log(``"YES"``)` `else` `    ``console.log(``"NO"``)`   `// This code is contributed by phasing17.`

## C++14

 `#include ` `#include ` `#include `   `// Function to check if the arr[] can be` `// converted to target[] by replacing` `// any element in arr[] by the sum of arr[]` `bool` `isPossible(std::vector<``int``> target) {` `  ``// sort the target array` `  ``std::sort(target.begin(), target.end());` `  ``// store length of target into n` `  ``int` `n = target.size();` `  ``// 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` `(``int` `i = 1; i < n; i++) {` `    ``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``;` `}`   `int` `main() {` `  ``std::vector<``int``> target = {9, 3, 5};` `  ``bool` `res = isPossible(target);` `  ``if` `(res) {` `    ``std::cout << ``"YES"` `<< std::endl;` `  ``}` `  ``else` `{` `    ``std::cout << ``"NO"` `<< std::endl;` `  ``}` `  ``return` `0;` `}`

Output

`YES`

Time Complexity: O(nlogn) as sorting takes O(nlogn)
Auxiliary Space: O(1).