# Generate Array such that replacing any two element by their difference gives same or greater sum

Given a non-negative integer **N**, the task is to generate an array such that if any two elements of that array are replaced by their absolute difference then the sum of the current array is either greater or more than the generated array.

**Note:** If there are multiple possible arrays, then return any of them

**Examples:**

Input: N = 2Output:arr[] = [1, 3]Explanation:In the above example the sum of array is 4.

Select two indices 0 and 1 and replace 1 and 3 by |1-3| = 2, then array is [2, 2].

So now the sum is 4 which is equal to the previous sum.

Input:N = 3Output:arr[] = [1, 10, 40]Explanation:Firstly the total sum of array is 51.

Select two indices 0 and 1 and replace them with |arr[0] – arr[1]|.

Then the array would be arr = [9, 9, 40].

So now the total sum is 58 hence the sum is increased.

For another pair of indices 0 and 2

Replace arr[0] and arr[2] by |arr[0] – arr[2]|.

Then the array would be arr = [39, 10, 39].

So now the total sum is 88 hence the sum is increased.

For pair of indices 1 and 2

Replace arr[1] and arr[2] by |arr[1] – arr[2]|.

Then the array would be arr = [1, 30, 30].

So now the total sum is 61 hence the sum is increased.

So the above array is a possible answer

**Approach: **This problem can be solved based on the following mathematical observation:

If there are two numbers

aandband we want to replace them by|a – b|such that the total sum remains same or increases then:

a + b ≤ |a – b| + |a – b|

=> a + b ≤ 2*|a – b|Now consider a is the larger element, then

a + b ≤ 2*a – 2*b

=> b + 2*b ≤ 2*a – a

=>3*b ≤ aSo the greater element must be at least 3 times of the smaller element.

Based on the above observation it can be seen that if for the generated array (say **arr[]**) any **ith** element has a value at least **3*arr[i-1]** then the array will satisfy the given condition.

Follow the steps mentioned below to implement the above observation:

- Generate an array
**arr[]**of size N and initialize**arr[0] = 1**. - Iterate from
**i = 1 to N-1**in the array:- Set
**arr[i]**to**3*arr[i-1]**.

- Set
- Return the array generated.

Below is the implementation of the above approach.

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `#define ll long long int` `// Function to generate the array` `vector<` `int` `> createArray(` `int` `N)` `{` ` ` `vector<` `int` `> res;` ` ` `// Initializing the arr[0] with 1` ` ` `long` `long` `int` `ans = 1;` ` ` `while` `(N--) {` ` ` `res.push_back(ans);` ` ` `// For every number we are multiplying` ` ` `// the previous number with 3` ` ` `ans *= 3;` ` ` `}` ` ` `return` `res;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `N = 3;` ` ` `// Function call` ` ` `vector<` `int` `> ans = createArray(N);` ` ` `for` `(` `int` `x : ans)` ` ` `cout << x << ` `" "` `;` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to generate the array` ` ` `static` `Vector<Integer> createArray(` `int` `N)` ` ` `{` ` ` `Vector<Integer> res = ` `new` `Vector<Integer>();` ` ` `// Initializing the arr[0] with 1` ` ` `int` `ans = ` `1` `;` ` ` `while` `(N != ` `0` `) {` ` ` `res.add(ans);` ` ` `// For every number we are multiplying` ` ` `// the previous number with 3` ` ` `ans *= ` `3` `;` ` ` `N -= ` `1` `;` ` ` `}` ` ` `return` `res;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main (String[] args) { ` ` ` `int` `N = ` `3` `;` ` ` `// Function call` ` ` `Vector<Integer> ans = createArray(N);` ` ` `ans.forEach((n) -> System.out.print(n));` ` ` `}` `}` `// This code is contributed by hrithikgarg03188` |

## Python3

`# Python program for above approach` `# Function to generate the array` `def` `createArray(N):` ` ` `res ` `=` `[]` ` ` `# Initializing the arr[0] with 1` ` ` `ans ` `=` `1` ` ` `while` `(N):` ` ` `res.append(ans)` ` ` `# For every number we are multiplying` ` ` `# the previous number with 3` ` ` `ans ` `*` `=` `3` ` ` `N ` `-` `=` `1` ` ` `return` `res` `# Driver code` `N ` `=` `3` `# Function call` `ans ` `=` `createArray(N)` `for` `x ` `in` `ans:` ` ` `print` `(x, end ` `=` `" "` `)` `# This code is contributed by shinjanpatra` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {` ` ` `// Function to generate the array` ` ` `static` `List<` `int` `> createArray(` `int` `N)` ` ` `{` ` ` `List<` `int` `> res = ` `new` `List<` `int` `>();` ` ` `// Initializing the arr[0] with 1` ` ` `int` `ans = 1;` ` ` `while` `(N != 0) {` ` ` `res.Add(ans);` ` ` `// For every number we are multiplying` ` ` `// the previous number with 3` ` ` `ans *= 3;` ` ` `N -= 1;` ` ` `}` ` ` `return` `res;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `int` `Main()` ` ` `{` ` ` `int` `N = 3;` ` ` `// Function call` ` ` `List<` `int` `> ans = createArray(N);` ` ` `for` `(` `int` `i = 0; i < N; ++i) {` ` ` `Console.Write(ans[i] + ` `" "` `);` ` ` `}` ` ` `return` `0;` ` ` `}` `}` `// This code is contributed by Taranpreet` |

## Javascript

`<script>` `// JavaScript program for above approach` `// Function to generate the array` `function` `createArray(N)` `{` ` ` `let res = [];` ` ` `// Initializing the arr[0] with 1` ` ` `let ans = 1;` ` ` `while` `(N--) {` ` ` `res.push(ans);` ` ` `// For every number we are multiplying` ` ` `// the previous number with 3` ` ` `ans *= 3;` ` ` `}` ` ` `return` `res;` `}` `// Driver code` `let N = 3;` `// Function call` `let ans = createArray(N);` `for` `(let x of ans)` ` ` `document.write(x,` `" "` `);` `// This code is contributed by shinjanpatra` `</script>` |

**Output**

1 3 9

**Time Complexity: **O(N)**Auxiliary Space: **O(N)