Open in App
Not now

# Find original Array from given Array where each element is sum of prefix and postfix sum

• Difficulty Level : Medium
• Last Updated : 26 Dec, 2022

Given an array arr[] of length N, where arr is derived from an array nums[] which is lost. Array arr[] is derived as:

arr[i] = (nums[0] + nums[1] + … + nums[i]) + (nums[i] + nums[i+1] + … + nums[N-1]).

The task is to find nums[] array of length N.

Examples:

Input: N = 4, arr[] = {9, 10, 11, 10}
Output: {1, 2, 3, 2}
Explanation: If nums[] = {1, 2, 3, 2}, then according to above definition
arr[0] = (nums[0]) + (nums[0] + nums[1] + nums[2] + nums[3]) = 1 + 1 + 2 + 3 + 2 = 9
arr[1] = (nums[0] + nums[1]) + (nums[1] + nums[2] + nums[3]) = 1 + 2 + 2 + 3 + 2 = 10
arr[2] = (nums[0] + nums[1] + nums[2]) + (nums[2] + nums[3]) = 1 + 2 + 3 + 3 + 2 = 11
arr[3] = (nums[0] + nums[1] + nums[2] + nums[3]) + (nums[3]) = 1 + 2 + 3 + 2 + 2 = 10

Input: N = 2, arr[] = [25, 20]
Output: [10, 5]

Approach: Follow the below idea to solve the problem:

Suppose nums[] contains [a1, a2, a3, …, aN]
Then, sum = a1 + a2 + a3 + . . . + aN.
We are given
b1 = a1 + a1 + a2 + . . . + aN = a1 + sum …..(1)
Similarily,
b2 = a1 + a2 + a2 + . . . + aN = a2 + sum    …..(2)
. . .  (so on) and in last
b1 = a1 + a2 + a3 + . . . + aN + aN = aN + sum …..(N)
where [b1, b2, b3 , . . ., bN] are elements of arr[] and,
total = b1 + b2 + b3 + . . . + bN

Adding all equation (1) + (2) + (3) + …. + (N) we will get

b1 + b2 + b3 + . . . + bN = (a1 + sum) + (a2 + sum) + . . . + (aN + sum)
total = (a1 + a1 + a2 + . . . + aN) + (N * sum)
total = (sum) + (N * sum)
total = (N + 1) * sum

Now find the value of sum variable after that simply:
a1 = (b1 – sum), a2 = (b2 – sum), . . ., aN = (bN – sum)

Using the above idea follow the below steps to implement the code:

• First of all, try to store the sum of elements of arr[] in a variable let’s say total
• Using the formula (N + 1) * sum = total, we will get the value of variable sum which denotes the sum of elements present in the nums[] array.
• At last traverse N times to find nums[0] = arr[0] – sum, nums[1] = arr[1] – sum and so on.
• Return the array and print it.

Below is the implementation of the above approach:

## C++

 `// C++ Algorithm for the above approach`   `#include ` `#include ` `using` `namespace` `std;`   `// Function to find the original` `// array nums[]` `vector<``int``> findOrgArray(vector<``int``> arr, ``int` `N)` `{` `    ``// Total variable stores the sum of` `    ``// elements of arr[]` `    ``int` `total = 0;` `    ``for` `(``int` `val : arr)` `        ``total += val;`   `    ``// Sum variable stores the sum of` `    ``// elements of nums[]` `    ``int` `sum = (total / (N + 1));` `    ``vector<``int``> v;`   `    ``// Traversing to find the elements` `    ``// of nums[]` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``int` `val = arr[i] - sum;` `        ``v.push_back(val);` `    ``}`   `    ``// Returning nums[]` `    ``return` `v;` `}`   `int` `main()` `{`   `    ``int` `N = 4;` `    ``vector<``int``> arr = { 9, 10, 11, 10 };`   `    ``vector<``int``> v = findOrgArray(arr, N);` `    ``for` `(``auto` `val : v)` `        ``cout << val << ``" "``;` `    ``return` `0;` `}`

## Java

 `// Java algorithm of the above approach`   `import` `java.util.*;`   `class` `GFG {`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``4``;` `        ``int``[] arr = { ``9``, ``10``, ``11``, ``10` `};` `        ``List nums = findOrgArray(arr, N);` `        ``for` `(``int` `x : nums)` `            ``System.out.print(x + ``" "``);` `    ``}`   `    ``// Function to find the original` `    ``// array nums[]` `    ``public` `static` `List findOrgArray(``int``[] arr,` `                                             ``int` `N)` `    ``{`   `        ``// Total variable stores the sum of` `        ``// elements of arr[]` `        ``int` `total = ``0``;` `        ``for` `(``int` `val : arr)` `            ``total += val;`   `        ``// Sum variable stores the sum of` `        ``// elements of nums[]` `        ``int` `sum = (total / (N + ``1``));` `        ``List nums = ``new` `ArrayList<>();`   `        ``// Traversing to find the elements` `        ``// of nums[]` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``int` `val = arr[i] - sum;` `            ``nums.add(val);` `        ``}`   `        ``// Returning nums[]` `        ``return` `nums;` `    ``}` `}`

## Python3

 `# python3 Algorithm for the above approach` `    `  `# Function to find the original` `# array nums[]` `def` `findOrgArray(arr, N) :` `    `  `    ``# Total variable stores the sum of` `    ``# elements of arr[]` `    ``total ``=` `0` `    ``for` `i ``in` `arr :` `        ``total``+``=` `i`   `    ``# Sum variable stores the sum of` `    ``# elements of nums[]` `    ``sum` `=` `int``(total ``/` `(N ``+` `1``));` `    ``v ``=` `[]`   `    ``# Traversing to find the elements` `    ``# of nums[]` `    ``for` `i ``in` `range` `(N) :` `        ``val ``=` `arr[i] ``-` `sum` `        ``v.append(val)`   `    ``# Returning nums[]` `    ``return` `v`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:` `    `  `    ``N ``=` `4` `    ``arr ``=` `[ ``9``, ``10``, ``11``, ``10` `]`   `    ``v ``=` `findOrgArray(arr, N)` `    ``for` `val ``in` `v :` `        ``print``(val,end``=``' '``)`   `# this code is contributed by aditya942003patil`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{`   `  ``// Function to find the original` `  ``// array nums[]` `  ``public` `static` `List<``int``> findOrgArray(``int``[] arr,` `                                       ``int` `N)` `  ``{`   `    ``// Total variable stores the sum of` `    ``// elements of arr[]` `    ``int` `total = 0;` `    ``//for (int x = 0;  x < arr.count; x++)` `    ``foreach` `(``int` `val ``in` `arr)` `      ``total += val;`   `    ``// Sum variable stores the sum of` `    ``// elements of nums[]` `    ``int` `sum = (total / (N + 1));` `    ``List<``int``> nums = ``new` `List<``int``>();`   `    ``// Traversing to find the elements` `    ``// of nums[]` `    ``for` `(``int` `i = 0; i < N; i++) {` `      ``int` `val = arr[i] - sum;` `      ``nums.Add(val);` `    ``}`   `    ``// Returning nums[]` `    ``return` `nums;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String []args)` `  ``{` `    ``int` `N = 4;` `    ``int``[] arr = { 9, 10, 11, 10 };` `    ``List<``int``> nums = findOrgArray(arr, N);` `    ``for` `(``int` `x = 0;  x < nums.Count; x++)` `      ``Console.Write(nums[x] + ``" "``);` `  ``}` `}`   `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output

`1 2 3 2 `

Time Complexity: O(N)
Auxiliary Space: O(N), to further reduce it to O(1), store the value in the same given array arr[] rather than storing it in a new array.

My Personal Notes arrow_drop_up
Related Articles