# Change in Median of given array after deleting given elements

• Difficulty Level : Medium
• Last Updated : 17 Aug, 2021

Given two arrays arr1[] and arr2[]. The array arr1[] is sorted. The task is to print the change in the median after removing each element from array arr2[] one by one.

Note: The array arr2[] has only those elements that are present in array arr1[].

Examples:

Input: arr1[] = {2, 4, 6, 8, 10}, arr2[] = {4, 6}
Output: 1 1
Explanation:
Initially median is 6.
After removing 4, array becomes arr1[] = {2, 6, 8, 10}, median = 7, therefore the difference is 7 – 6 = 1.
After removing 6, array becomes arr1[] = {2, 8, 10}, median = 8, therefore the difference is 8 – 7 = 1.

Input: arr1[] = {1, 100, 250, 251}, arr2[] = {250, 1}
Output: -75 75.5
Explanation:
Initially median is 175.
After removing 250, array becomes arr1[] = {1, 100, 251}, median = 100, therefore the difference is 100 – 175 = -75.
After removing 1, array becomes arr1[] = {100, 251}, median = 175.5, therefore the difference is 175.5 – 100 = 75.5.

Approach: The idea is to traverse each element of the array arr2[] and remove each element from the array arr1[] and store the median of the array arr1[] after each removal of element in an array(say temp[]). Print the consecutive difference of the elements of the array to get change in median after removing elements from arr2[].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the median change``// after removing elements from arr2[]``void` `medianChange(vector<``int``>& arr1,``                  ``vector<``int``>& arr2)``{``    ``int` `N = arr1.size();` `    ``// To store the median``    ``vector<``float``> median;` `    ``// Store the current median` `    ``// If N is odd``    ``if` `(N & 1) {``        ``median``            ``.push_back(arr1[N / 2] * 1.0);``    ``}` `    ``// If N is even``    ``else` `{``        ``median``            ``.push_back((arr1[N / 2]``                        ``+ arr1[(N - 1) / 2])``                       ``/ 2.0);``    ``}` `    ``for` `(``auto``& x : arr2) {` `        ``// Find the current element``        ``// in arr1``        ``auto` `it = find(arr1.begin(),``                       ``arr1.end(),``                       ``x);` `        ``// Erase the element``        ``arr1.erase(it);` `        ``// Decrement N``        ``N--;` `        ``// Find the new median``        ``// and append` `        ``// If N is odd``        ``if` `(N & 1) {``            ``median``                ``.push_back(arr1[N / 2] * 1.0);``        ``}` `        ``// If N is even``        ``else` `{``            ``median``                ``.push_back((arr1[N / 2]``                            ``+ arr1[(N - 1) / 2])``                           ``/ 2.0);``        ``}``    ``}` `    ``// Print the corresponding``    ``// difference of median``    ``for` `(``int` `i = 0;``         ``i < median.size() - 1;``         ``i++) {``        ``cout << median[i + 1] - median[i]``             ``<< ``' '``;``    ``}``}` `// Driven Code``int` `main()``{``    ``// Given arrays``    ``vector<``int``> arr1 = { 2, 4, 6, 8, 10 };``    ``vector<``int``> arr2 = { 4, 6 };` `    ``// Function Call``    ``medianChange(arr1, arr2);` `    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;` `class` `GFG{``    ` `// Function to find the median``// change after removing elements``// from arr2[]``public` `static` `void` `medianChange(List arr1,``                                ``List arr2)``{``    ``int` `N = arr1.size();`` ` `    ``// To store the median``    ``List median = ``new` `ArrayList<>();`` ` `    ``// Store the current median`` ` `    ``// If N is odd``    ``if` `((N & ``1``) != ``0``)``        ``median.add(arr1.get(N / ``2``) * ``1``);`` ` `    ``// If N is even``    ``else``        ``median.add((arr1.get(N / ``2``) +``                    ``arr1.get((N - ``1``) / ``2``)) / ``2``);`` ` `    ``for``(``int` `x = ``0``; x < arr2.size(); x++)``    ``{``        ` `        ``// Find the current element``        ``// in arr1``        ``int` `it = arr1.indexOf(arr2.get(x));`` ` `        ``// Erase the element``        ``arr1.remove(it);`` ` `        ``// Decrement N``        ``N--;`` ` `        ``// Find the new median``        ``// and append`` ` `        ``// If N is odd``        ``if` `((N & ``1``) != ``0``)``        ``{``            ``median.add(arr1.get(N / ``2``) * ``1``);``        ``}``        ` `        ``// If N is even``        ``else``        ``{``            ``median.add((arr1.get(N / ``2``) +``                        ``arr1.get((N - ``1``) / ``2``)) / ``2``);``        ``}``    ``}`` ` `    ``// Print the corresponding``    ``// difference of median``    ``for``(``int` `i = ``0``; i < median.size() - ``1``; i++)``    ``{``        ``System.out.print(median.get(i + ``1``) -``                         ``median.get(i) + ``" "``);``    ``}``}` `// Driver Code             ``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given arrays``    ``List arr1  = ``new` `ArrayList(){``        ``{ add(``2``); add(``4``); add(``6``); add(``8``); add(``10``); } };``    ``List arr2 = ``new` `ArrayList(){``        ``{ add(``4``); add(``6``); } };`` ` `    ``// Function Call``    ``medianChange(arr1, arr2);``}``}` `// This code is contributed by divyesh072019`

## Python3

 `# Python3 program for the``# above approach` `# Function to find the median``# change after removing elements``# from arr2[]``def` `medianChange(arr1, arr2):` `    ``N ``=` `len``(arr1)` `    ``# To store the median``    ``median ``=` `[]` `    ``# Store the current median` `    ``# If N is odd``    ``if` `(N & ``1``):``        ``median.append(arr1[N ``/``/` `2``] ``*` `1``)` `    ``# If N is even``    ``else``:``        ``median.append((arr1[N ``/``/` `2``] ``+``                       ``arr1[(N ``-` `1``) ``/``/` `2``]) ``/``/` `2``)` `    ``for` `x ``in` `arr2:` `        ``# Find the current``        ``# element in arr1``        ``it ``=` `arr1.index(x)` `        ``# Erase the element``        ``arr1.pop(it)` `        ``# Decrement N``        ``N ``-``=` `1` `        ``# Find the new median``        ``# and append` `        ``# If N is odd``        ``if` `(N & ``1``):``            ``median.append(arr1[N ``/``/` `2``] ``*` `1``)` `        ``# If N is even``        ``else``:``            ``median.append((arr1[N ``/``/` `2``] ``+``                           ``arr1[(N ``-` `1``) ``/``/` `2``]) ``/``/` `2``)` `    ``# Print the corresponding``    ``# difference of median``    ``for` `i ``in` `range``(``len``(median) ``-` `1``):``        ``print``(median[i ``+` `1``] ``-` `median[i],``              ``end ``=` `' '``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Given arrays``    ``arr1 ``=` `[``2``, ``4``, ``6``,``            ``8``, ``10``]``    ``arr2 ``=` `[``4``, ``6``]` `    ``# Function Call``    ``medianChange(arr1, arr2)` `# This code is contributed by Chitranayal`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `// Function to find the median change``// after removing elements from arr2[]``static` `void` `medianChange(List<``int``> arr1,``                         ``List<``int``> arr2)``{``    ``int` `N = arr1.Count;`` ` `    ``// To store the median``    ``List<``double``> median = ``new` `List<``double``>();`` ` `    ``// Store the current median`` ` `    ``// If N is odd``    ``if` `((N & 1) != 0)``    ``{``        ``median.Add(arr1[N / 2] * 1.0);``    ``}`` ` `    ``// If N is even``    ``else``    ``{``        ``median.Add((arr1[N / 2] +``              ``arr1[(N - 1) / 2]) / 2.0);``    ``}`` ` `    ``foreach``(``int` `x ``in` `arr2)``    ``{``        ` `        ``// Find the current element``        ``// in arr1``        ``int` `it = arr1.IndexOf(x);`` ` `        ``// Erase the element``        ``arr1.RemoveAt(it);`` ` `        ``// Decrement N``        ``N--;`` ` `        ``// Find the new median``        ``// and append`` ` `        ``// If N is odd``        ``if` `((N & 1) != 0)``        ``{``            ``median.Add(arr1[N / 2] * 1.0);``        ``}`` ` `        ``// If N is even``        ``else``        ``{``            ``median.Add((arr1[N / 2] +``                  ``arr1[(N - 1) / 2]) / 2.0);``        ``}``    ``}`` ` `    ``// Print the corresponding``    ``// difference of median``    ``for``(``int` `i = 0; i < median.Count - 1; i++)``    ``{``        ``Console.Write(median[i + 1] -``                      ``median[i] + ``" "``);``    ``}``}` `// Driver Code``static` `void` `Main()``{``    ` `    ``// Given arrays``    ``List<``int``> arr1 = ``new` `List<``int``>(``        ``new` `int``[]{ 2, 4, 6, 8, 10 });``    ``List<``int``> arr2 = ``new` `List<``int``>(``        ``new` `int``[]{ 4, 6 });`` ` `    ``// Function Call``    ``medianChange(arr1, arr2);``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`1 1`

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

My Personal Notes arrow_drop_up