Reduce an array to a single element by repeatedly removing larger element from a pair with absolute difference at most K
Last Updated :
04 Dec, 2023
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 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 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# 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
<script>
// JavaScript 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
function canReduceArray(arr, N, K)
{
// Sort the array in descending order
arr.sort();
let b = Array(N ).fill(0);
let j = N;
for (let i = 0; i < N; i++) {
b[j - 1] = arr[i];
j = j - 1;
}
// Traverse the array
for (let 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) {
document.write("No");
return;
}
}
// If the array can be reduced
// to a single element
document.write("Yes");
}
// Driver Code
let arr = [ 2, 1, 1, 3 ];
let N = arr.length;
let K = 1;
// Function Call to check
// if an array can be reduced
// to a single element
canReduceArray(arr, N, K);
</script>
Time Complexity: O(N * log N)
Auxiliary Space: O(1)
Using a loop to repeatedly find the maximum difference pair and remove the larger element until only one element remains:
Approach:
Define a function reduce_array that takes in an array arr and an integer k.
Use a while loop to repeatedly execute the following steps as long as the length of arr is greater than 1:
Initialize max_diff to -1 and max_diff_pair to None.
Use a for loop to iterate over each adjacent pair of elements in arr.
Calculate the absolute difference diff between the two elements and check if diff is less than or equal to k and greater than max_diff.
If diff meets the above criteria, update max_diff to diff and max_diff_pair to the indices of the pair.
If max_diff_pair is not None, remove the element at the higher index of max_diff_pair from arr using the pop method.
Otherwise, return "No" since no pairs with absolute difference at most k were found.
Return "Yes" since there is only one element left in arr.
C++
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
string reduceArray(vector<int>& arr, int k) {
while (arr.size() > 1) {
int max_diff = -1;
pair<int, int> max_diff_pair;
for (int i = 0; i < arr.size() - 1; i++) {
int diff = abs(arr[i] - arr[i + 1]);
if (diff <= k && diff > max_diff) {
max_diff = diff;
max_diff_pair = make_pair(i, i + 1);
}
}
if (!max_diff_pair.first && !max_diff_pair.second) {
return "No";
} else {
arr.erase(arr.begin() + max_diff_pair.second);
}
}
return "Yes";
}
int main() {
vector<int> arr1 = {2, 1, 1, 3};
int k1 = 1;
cout << reduceArray(arr1, k1) << endl; // Output: Yes
vector<int> arr2 = {1, 4, 3, 6};
int k2 = 1;
cout << reduceArray(arr2, k2) << endl; // Output: No
return 0;
}
import java.util.ArrayList;
import java.util.List;
public class Main {
// Function to reduce the array based on given conditions
static String reduceArray(List<Integer> arr, int k) {
// Continue the process until the array size becomes 1
while (arr.size() > 1) {
int maxDiff = -1;
int maxDiffIndex = -1;
// Iterate through the array to find the maximum difference within the given constraint
for (int i = 0; i < arr.size() - 1; i++) {
int diff = Math.abs(arr.get(i) - arr.get(i + 1));
if (diff <= k && diff > maxDiff) {
maxDiff = diff;
maxDiffIndex = i;
}
}
// If no valid pair is found, return "No"
if (maxDiffIndex == -1) {
return "No";
} else {
// Remove the second element of the pair with the maximum difference
arr.remove(maxDiffIndex + 1);
}
}
// If array size becomes 1, return "Yes"
return "Yes";
}
public static void main(String[] args) {
// Test case 1
List<Integer> arr1 = new ArrayList<>(List.of(2, 1, 1, 3));
int k1 = 1;
System.out.println(reduceArray(arr1, k1)); // Output: Yes
// Test case 2
List<Integer> arr2 = new ArrayList<>(List.of(1, 4, 3, 6));
int k2 = 1;
System.out.println(reduceArray(arr2, k2)); // Output: No
}
}
def reduce_array(arr, k):
while len(arr) > 1:
max_diff = -1
max_diff_pair = None
for i in range(len(arr)-1):
diff = abs(arr[i] - arr[i+1])
if diff <= k and diff > max_diff:
max_diff = diff
max_diff_pair = (i, i+1)
if max_diff_pair:
arr.pop(max_diff_pair[1])
else:
return "No"
return "Yes"
# Example usage:
arr1 = [2, 1, 1, 3]
k1 = 1
print(reduce_array(arr1, k1)) # Output: Yes
arr2 = [1, 4, 3, 6]
k2 = 1
print(reduce_array(arr2, k2)) # Output: No
using System;
using System.Collections.Generic;
class GFG
{
static string ReduceArray(List<int> arr, int k)
{
while (arr.Count > 1)
{
int maxDiff = -1;
Tuple<int, int> maxDiffPair = null;
for (int i = 0; i < arr.Count - 1; i++)
{
int diff = Math.Abs(arr[i] - arr[i + 1]);
if (diff <= k && diff > maxDiff)
{
maxDiff = diff;
maxDiffPair = Tuple.Create(i, i + 1);
}
}
if (maxDiffPair == null)
{
return "No";
}
else
{
arr.RemoveAt(maxDiffPair.Item2);
}
}
return "Yes";
}
static void Main()
{
List<int> arr1 = new List<int> { 2, 1, 1, 3 };
int k1 = 1;
Console.WriteLine(ReduceArray(arr1, k1)); // Output: Yes
List<int> arr2 = new List<int> { 1, 4, 3, 6 };
int k2 = 1;
Console.WriteLine(ReduceArray(arr2, k2)); // Output: No
}
}
function reduceArray(arr, k) {
while (arr.length > 1) {
let maxDiff = -1;
let maxDiffPair = { first: -1, second: -1 };
// Find the pair of adjacent elements with the maximum difference
for (let i = 0; i < arr.length - 1; i++) {
const diff = Math.abs(arr[i] - arr[i + 1]);
if (diff <= k && diff > maxDiff) {
maxDiff = diff;
maxDiffPair.first = i;
maxDiffPair.second = i + 1;
}
}
// If no suitable pair is found, return "No"
if (maxDiffPair.first === -1 && maxDiffPair.second === -1) {
return "No";
} else {
// Remove the second element of the pair
arr.splice(maxDiffPair.second, 1);
}
}
// If only one element remains in the array, return "Yes"
return "Yes";
}
// Driver code
const arr1 = [2, 1, 1, 3];
const k1 = 1;
console.log(reduceArray(arr1, k1)); // Output: Yes
const arr2 = [1, 4, 3, 6];
const k2 = 1;
console.log(reduceArray(arr2, k2)); // Output: No
Time Complexity: O(n^2)
Auxiliary Space: O(n)
Similar Reads
Remaining array element after repeated removal of the smallest element from pairs with absolute difference of 2 or 0 Given an array arr[] consisting of N positive integers, the task is to check if it is possible to reduce the size of the array to 1 by repeatedly removing the smallest element from a pair having absolute difference of 2 or 0 between them. If it is not possible to reduce, then print "-1". Otherwise,
6 min read
Minimize remaining array element by removing pairs and replacing them by their absolute difference Given an array arr[] consisting of N positive integers, the task is to minimize the remaining array element that can be obtained by repeatedly removing a pair of array elements and replacing them by their absolute difference. Examples: Input: arr[] ={ 2, 7, 4, 1, 8, 1 } Output: 1 Explanation: Removi
15 min read
Count elements in first Array with absolute difference greater than K with an element in second Array Given two arrays arr1[] and arr2[] and an integer K, our task is to find the number elements in the first array, for an element x, in arr1[], there exists at least one element y, in arr2[] such that absolute difference of x and y is greater than the integer K. Examples: Input: arr1 = {3, 1, 4}, arr2
7 min read
Minimize maximum difference between adjacent elements possible by removing a single array element Given an sorted array arr[] consisting of N elements, the task is to find the minimum of all maximum differences between adjacent elements of all arrays obtained by removal of any single array element. Examples: Input: arr[ ] = { 1, 3, 7, 8}Output: 5Explanation:All possible arrays after removing a s
6 min read
Maximize the minimum difference between any element pair by selecting K elements from given Array Given an array of N integers the task is to select K elements out of these N elements in such a way that the minimum difference between each of the K numbers is the Largest. Return the largest minimum difference after choosing any K elements. Examples: Input: N = 4, K = 3, arr = [2, 6, 2, 5]Output:
11 min read
Array value by repeatedly replacing max 2 elements with their absolute difference Given an array arr size N, the task is to print the final array value remaining in the array when the maximum and second maximum element of the array is replaced by their absolute difference in the array, repeatedly. Note: If the maximum two elements are same, then both are removed from the array, w
6 min read