Related Articles
Reduce an array to a single element by repeatedly removing larger element from a pair with absolute difference at most K
• Last Updated : 17 Mar, 2021

Given an array arr[] consisting of N integers and a positive integer K, the task is to check if the given array can be reduced to a single element by repeatedly removing the larger of the two elements present in a pair whose absolute difference is at most K. If the array can be reduced to a single element, then print “Yes”. Otherwise, print “No”.

Examples:

Input: arr[] = {2, 1, 1, 3}, K = 1
Output: Yes
Explanation:
Operation 1: Select the pair {arr, arr} ( = (2, 3), as | 3 – 2 | ≤ 1. Now, remove 3 from the array. The array modifies to {2, 1, 1}.
Operation 2: Select the pair {arr, arr} ( = (2, 1), as | 2 – 1 | ≤ 1. Now, remove 2 from the array. The array modifies to {1, 1}.
Operation 3: Remove 1 from the array. The array modifies to {1}.
Therefore, the last remaining array element is 1.

Input: arr[] = {1, 4, 3, 6}, K = 1
Output: No

Approach: The given problem can be solved using a Greedy Approach. The idea is to remove the element with a maximum value in every possible moves. Follow the given steps to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to check if an array can be``// reduced to single element by removing``// maximum element among any chosen pairs``void` `canReduceArray(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Sort the array in descending order``    ``sort(arr, arr + N, greater<``int``>());` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N - 1; i++) {` `        ``// If the absolute difference``        ``// of 2 consecutive array``        ``// elements is greater than K``        ``if` `(arr[i] - arr[i + 1] > K) {` `            ``cout << ``"No"``;``            ``return``;``        ``}``    ``}` `    ``// If the array can be reduced``    ``// to a single element``    ``cout << ``"Yes"``;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, 1, 1, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `K = 1;` `    ``// Function Call to check``    ``// if an array can be reduced``    ``// to a single element``    ``canReduceArray(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG``{` `// Function to check if an array can be``// reduced to single element by removing``// maximum element among any chosen pairs``static` `void` `canReduceArray(``int` `arr[], ``int` `N, ``int` `K)``{``  ` `    ``// Sort the array in descending order``    ``Arrays.sort(arr);``    ``int` `b[] = ``new` `int``[N];``        ``int` `j = N;``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``b[j - ``1``] = arr[i];``            ``j = j - ``1``;``        ``}``    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < N - ``1``; i++) {` `        ``// If the absolute difference``        ``// of 2 consecutive array``        ``// elements is greater than K``        ``if` `(arr[i] - arr[i + ``1``] > K) {` `            ``System.out.print(``"No"``);``            ``return``;``        ``}``    ``}` `    ``// If the array can be reduced``    ``// to a single element``    ``System.out.print(``"Yes"``);``}` `// Driven Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``2``, ``1``, ``1``, ``3` `};``    ``int` `N = arr.length;``    ``int` `K = ``1``;` `    ``// Function Call to check``    ``// if an array can be reduced``    ``// to a single element``    ``canReduceArray(arr, N, K);``}``}` `// This code is contributed by splevel62`

## Python3

 `# Python3 program for the above approach` `# Function to check if an array can be``# reduced to single element by removing``# maximum element among any chosen pairs``def` `canReduceArray(arr, N, K):``    ` `    ``# Sort the array in descending order``    ``arr ``=` `sorted``(arr)` `    ``# Traverse the array``    ``for` `i ``in` `range``(N ``-` `1``):``        ` `        ``# If the absolute difference``        ``# of 2 consecutive array``        ``# elements is greater than K``        ``if` `(arr[i] ``-` `arr[i ``+` `1``] > K):``            ``print` `(``"No"``)``            ``return` `    ``# If the array can be reduced``    ``# to a single element``    ``print` `(``"Yes"``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[``2``, ``1``, ``1``, ``3``]``    ``N ``=` `len``(arr)``    ``K ``=` `1` `    ``# Function Call to check``    ``# if an array can be reduced``    ``# to a single element``    ``canReduceArray(arr, N, K)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to check if an array can be``// reduced to single element by removing``// maximum element among any chosen pairs``static` `void` `canReduceArray(``int``[] arr, ``int` `N,``                           ``int` `K)``{``    ` `    ``// Sort the array in descending order``    ``Array.Sort(arr);``    ``int``[] b = ``new` `int``[N];``    ``int` `j = N;``    ` `    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``b[j - 1] = arr[i];``        ``j = j - 1;``    ``}``    ` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N - 1; i++)``    ``{``        ` `        ``// If the absolute difference``        ``// of 2 consecutive array``        ``// elements is greater than K``        ``if` `(arr[i] - arr[i + 1] > K)``        ``{``            ``Console.WriteLine(``"No"``);``            ``return``;``        ``}``    ``}` `    ``// If the array can be reduced``    ``// to a single element``    ``Console.WriteLine(``"Yes"``);``}` `// Driver Code``public` `static` `void` `Main(String []args)``{``    ``int``[] arr = { 2, 1, 1, 3 };``    ``int` `N = arr.Length;``    ``int` `K = 1;` `    ``// Function Call to check``    ``// if an array can be reduced``    ``// to a single element``    ``canReduceArray(arr, N, K);``}``}` `// This code is contributed by souravghosh0416`
Output:
`Yes`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up