Related Articles
Change in Median of given array after deleting given elements
• Difficulty Level : Medium
• Last Updated : 10 Dec, 2020

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`

Output:

`1 1`

Time Complexity: O(M*N) My Personal Notes arrow_drop_up
Recommended Articles
Page :