Skip to content
Related Articles

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[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 = 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 <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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :