Skip to content
Related Articles
Open in App
Not now

Related Articles

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

Improve Article
Save Article
Like Article
  • Last Updated : 27 Mar, 2023
Improve Article
Save Article
Like Article

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 <iostream>
#include <vector>
 
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:

a, \ b, \ c, \ d\\ b-a, \ c-b, \ d-c\\ (c-b)-(b-a), \ (d-c)-(c-b) = c-2b+a, \ d-2c+b\\ -a+3b-3c+d

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

a, \ b, \ c, \ d, \ e\\ \vdots\\ a - 4b + 6c - 4d + e

  • 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




<script>
// JavaScript program for the above approach
 
// Function to find the last remaining
// array element after performing
// the given operations repeatedly
function lastElement(arr, n)
{
 
    // Stores the resultant sum
    let sum = 0;
    let multiplier = n % 2 == 0 ? -1 : 1;
 
    // Traverse the array
    for (let 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
    let arr = [ 3, 4, 2, 1 ];
    let N = arr.length;
    document.write(lastElement(arr, N));
 
// This code is contributed by Surbhi Tyagi.
</script>


Output

4

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


My Personal Notes arrow_drop_up
Like Article
Save Article
Related Articles

Start Your Coding Journey Now!