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 = 1Output:YesExplanation:Operation 1:Select the pair {arr[0], arr[3]} ( = (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[0], arr[1]} ( = (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 = 1Output: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:

- Sort the given array
**arr[]**in decreasing order. - Traverse the array
**arr[]**over the range of indices**[0, N – 2]**. If the absolute values of**arr[i]**and**arr[i + 1]**are greater than**K**, then print**“No”**and break out of the loop. - If the loop is completely executed, then print
**“Yes”**.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `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[0]);` ` ` `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.