Open in App
Not now

# Remaining array element after repeated removal of last element and subtraction of each element from next adjacent element

• Last Updated : 27 Mar, 2023

Given an array arr[] consisting of N integers, the task is to find the remaining array element after subtracting each element from its next adjacent element and removing the last array element repeatedly.

Examples:

Input: arr[] = {3, 4, 2, 1}
Output: 4
Explanation:
Operation 1: The array arr[] modifies to {4 – 3, 2 – 4, 1 – 2} = {1, -2, -1}.
Operation 2: The array arr[] modifies to {-2 – 1, -1 + 2} = {-3, 1}.
Operation 3: The array arr[] modifies to {1 + 3} = {4}.
Therefore, the last remaining array element is 4.

Input: arr[] = {1, 8, 4}
Output: -11
Explanation:
Operation 1: The array arr[] modifies to {1 – 8, 4 – 8} = {7, -4}.
Operation 2: The array arr[] modifies to {-4 – 7 } = {-11}.
Therefore, the last remaining array element is -11.

Naive Approach: The simplest approach is to traverse the array until its size reduces to 1 and perform the given operations on the array. After completing the traversal, print the remaining elements. Below is the implementation of the above approach.

## C++

 `#include ` `#include `   `using` `namespace` `std;`   `// Function to find the remaining array element` `int` `findRemainingElement(vector<``int``>& arr) {` `    ``int` `n = arr.size();`   `    ``while` `(n > 1) {` `        ``for` `(``int` `i = 0; i < n - 1; i++) {` `            ``arr[i] = arr[i+1] - arr[i];` `        ``}` `        ``n--;` `    ``}`   `    ``return` `arr[0];` `}`   `// Driver code` `int` `main() {` `    ``// Given input` `    ``vector<``int``> arr = {3, 4, 2, 1};`   `    ``// Function call` `    ``int` `remainingElement = findRemainingElement(arr);`   `    ``// Print the remaining element` `    ``cout << ``"Remaining element: "` `<< remainingElement << endl;`   `    ``return` `0;` `}`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `MainClass {` `    ``// Function to find the remaining array element` `    ``static` `int` `FindRemainingElement(List<``int``> arr) {` `        ``int` `n = arr.Count;`   `        ``while` `(n > 1) {` `            ``for` `(``int` `i = 0; i < n - 1; i++) {` `                ``arr[i] = arr[i+1] - arr[i];` `            ``}` `            ``n--;` `        ``}`   `        ``return` `arr[0];` `    ``}`   `    ``// Driver code` `    ``static` `void` `Main() {` `        ``// Given input` `        ``List<``int``> arr = ``new` `List<``int``> {3, 4, 2, 1};`   `        ``// Function call` `        ``int` `remainingElement = FindRemainingElement(arr);`   `        ``// Print the remaining element` `        ``Console.WriteLine(``"Remaining element: "` `+ remainingElement);` `    ``}` `}` `// This code is contributed by sarojmcy2e`

## Javascript

 `function` `findRemainingElement(arr) {` `    ``let n = arr.length;`   `    ``while` `(n > 1) {` `        ``for` `(let i = 0; i < n - 1; i++) {` `            ``arr[i] = arr[i+1] - arr[i];` `        ``}` `        ``n--;` `    ``}`   `    ``return` `arr[0];` `}`   `// Given input` `let arr = [3, 4, 2, 1];`   `// Function call` `let remainingElement = findRemainingElement(arr);`   `// Print the remaining element` `console.log(``"Remaining element: "` `+ remainingElement);`

Output

`Remaining element: 4`

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

Efficient Approach: The above approach can be optimized based on the following observations:

• Suppose the given array is arr[] = {a, b, c, d}. Then, performing the operations:

• Now, suppose the array arr[] = {a, b, c, d, e}. Then, performing the operations:

• From the above two observations, it can be concluded that the answer is the sum of multiplication of coefficients of terms in the expansion of (x – y)(N – 1) and each array element arr[i].
• Therefore, the idea is to find the sum of the array arr[] after updating each array element as (arr[i]* (N – 1)C(i-1)* (-1)i).

Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include "bits/stdc++.h"` `using` `namespace` `std;`   `// Function to find the last remaining` `// array element after performing` `// the given operations repeatedly` `int` `lastElement(``const` `int` `arr[], ``int` `n)` `{` `    ``// Stores the resultant sum` `    ``int` `sum = 0;`   `    ``int` `multiplier = n % 2 == 0 ? -1 : 1;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Increment sum by arr[i]` `        ``// * coefficient of i-th term` `        ``// in (x - y) ^ (N - 1)` `        ``sum += arr[i] * multiplier;`   `        ``// Update multiplier` `        ``multiplier` `            ``= multiplier * (n - 1 - i)` `              ``/ (i + 1) * (-1);` `    ``}`   `    ``// Return the resultant sum` `    ``return` `sum;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 3, 4, 2, 1 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << lastElement(arr, N);`   `    ``return` `0;` `}`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;`   `class` `GFG {`   `    ``// Function to find the last remaining` `    ``// array element after performing` `    ``// the given operations repeatedly` `    ``public` `static` `int` `lastElement(``int` `arr[], ``int` `n)` `    ``{` `        ``// Stores the resultant sum` `        ``int` `sum = ``0``;`   `        ``int` `multiplier = n % ``2` `== ``0` `? -``1` `: ``1``;`   `        ``// Traverse the array` `        ``for` `(``int` `i = ``0``; i < n; i++) {`   `            ``// Increment sum by arr[i]` `            ``// * coefficient of i-th term` `            ``// in (x - y) ^ (N - 1)` `            ``sum += arr[i] * multiplier;`   `            ``// Update multiplier` `            ``multiplier` `                ``= multiplier * (n - ``1` `- i) / (i + ``1``) * (-``1``);` `        ``}`   `        ``// Return the resultant sum` `        ``return` `sum;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``3``, ``4``, ``2``, ``1` `};` `        ``int` `N = ``4``;` `        ``System.out.println(lastElement(arr, N));` `    ``}` `}`   `// This code is contributed by aditya7409.`

## Python3

 `# Python 3 program for the above approach`   `# Function to find the last remaining` `# array element after performing` `# the given operations repeatedly` `def` `lastElement(arr, n):` `  `  `    ``# Stores the resultant sum` `    ``sum` `=` `0` `    ``if` `n ``%` `2` `=``=` `0``:` `        ``multiplier ``=` `-``1` `    ``else``:` `        ``multiplier ``=` `1`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(n):` `      `  `        ``# Increment sum by arr[i]` `        ``# * coefficient of i-th term` `        ``# in (x - y) ^ (N - 1)` `        ``sum` `+``=` `arr[i] ``*` `multiplier`   `        ``# Update multiplier` `        ``multiplier ``=` `multiplier ``*` `(n ``-` `1` `-` `i) ``/` `(i ``+` `1``) ``*` `(``-``1``)`   `    ``# Return the resultant sum` `    ``return` `sum`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``3``, ``4``, ``2``, ``1``]` `    ``N ``=` `len``(arr)` `    ``print``(``int``(lastElement(arr, N)))` `    `  `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach ` `using` `System;` `class` `GFG ` `{`   `  ``// Function to find the last remaining` `  ``// array element after performing` `  ``// the given operations repeatedly` `  ``public` `static` `int` `lastElement(``int``[] arr, ``int` `n)` `  ``{` `    `  `    ``// Stores the resultant sum` `    ``int` `sum = 0;`   `    ``int` `multiplier = n % 2 == 0 ? -1 : 1;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < n; i++) {`   `      ``// Increment sum by arr[i]` `      ``// * coefficient of i-th term` `      ``// in (x - y) ^ (N - 1)` `      ``sum += arr[i] * multiplier;`   `      ``// Update multiplier` `      ``multiplier` `        ``= multiplier * (n - 1 - i) / (i + 1) * (-1);` `    ``}`   `    ``// Return the resultant sum` `    ``return` `sum;` `  ``}`   `  ``// Driver code` `  ``static` `void` `Main()` `  ``{` `    ``int``[] arr = { 3, 4, 2, 1 };` `    ``int` `N = 4;` `    ``Console.WriteLine(lastElement(arr, N));` `  ``}` `}`   `// This code is contributed by susmitakundugoaldanga.`

## Javascript

 ``

Output

`4`

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

My Personal Notes arrow_drop_up
Related Articles