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

Last Updated : 25 Apr, 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;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main {``    ``// Function to find the remaining array element``    ``public` `static` `int``    ``findRemainingElement(List arr)``    ``{``        ``int` `n = arr.size();` `        ``while` `(n > ``1``) {``            ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {``                ``arr.set(i, arr.get(i + ``1``) - arr.get(i));``            ``}``            ``n--;``        ``}` `        ``return` `arr.get(``0``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given input``        ``List arr = Arrays.asList(``3``, ``4``, ``2``, ``1``);` `        ``// Function call``        ``int` `remainingElement = findRemainingElement(arr);` `        ``// Print the remaining element``        ``System.out.println(``"Remaining element: "``                           ``+ remainingElement);``    ``}``}``// This code is contributed by user_dtewbxkn77n`

## Python3

 `# Python3 impelementation``def` `find_remaining_element(arr):``    ``n ``=` `len``(arr)` `    ``while` `n > ``1``:``        ``for` `i ``in` `range``(n ``-` `1``):``            ``arr[i] ``=` `arr[i``+``1``] ``-` `arr[i]``        ``n ``-``=` `1` `    ``return` `arr[``0``]` `# Driver code``arr ``=` `[``3``, ``4``, ``2``, ``1``]` `# Function call``remaining_element ``=` `find_remaining_element(arr)` `# Print the remaining element``print``(``"Remaining element:"``, remaining_element)` `# written by kk`

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

## Javascript

 ``

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

Output
`4`

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

Previous
Next