Minimum increment and decrement by K of each pair elements required to make all array elements equal
Last Updated :
29 Oct, 2023
Given an array arr[], the task is to check if it is possible to make all array elements equal by repeatedly choosing a triplet (i, j, k), where i and j are different, and subtract k from arr[i] and add k to arr[j].
Examples:
Input: arr[] = {1, 5, 6, 4}
Output: Yes
Explanation:
Operations performed:
Choose i = 2, j = 0, k = 2 and perform the given operations. The array arr[] modifies to {3, 5, 4, 4}.
Choose i = 1, j = 0, k = 1 and perform the given operations. The array arr[] modifies to {4, 4, 4, 4}.
Now, all array elements are equal. Therefore, print Yes.
Input: arr[] = {2, 5, 3, 2, 2}
Output: No
Naive Approach: The simplest approach is based on the observation that the sum of the modified array will be equal to the sum of the initial array. Follow the steps below to solve this problem:
- Considering Y to be the value of all the array elements after making all array elements equal. Therefore, Y * N ( where N is the array size) must be equal to sum of the given array.
- Iterate up to the maximum value in the array and check for the possible value of Y. If found to be satisfying given conditions, print "Yes". Otherwise, print "No".
Proof:
- Choose some i, j and k at any step.
- Assume sum of the array elements to be equal to sum.
- Sum of array elements after removing arr[i] and arr[j] is sum - arr[i] - arr[j].
- Now, adding arr[i] - k and arr[j] + k into the array modifies the sum of the array to sum - arr[i] - arr[j] + arr[i] - k + arr[j] + k = sum.
Time Complexity: O(max(arr[i]))
Auxiliary Space: O(1)
Efficient Approach: The optimal idea is to check whether the sum of the given array is a factor of N or not. Follow the steps below to solve the problem:
- Assuming that the array elements modifies to X after all array elements are made equal, X should be an integer such that the sum of the array is divisible by N.
- If the sum is not divisible by N, then X would not be an integer, and it's not possible to make all array elements equal. If not found to be an integer, print "No". Otherwise, 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 its possible to
// make all array elements equal or not
void arrayElementEqual(int arr[], int N)
{
// Stores the sum of the array
int sum = 0;
// Traverse the array
for (int i = 0; i < N; i++) {
sum += arr[i];
}
// If sum is divisible by N
if (sum % N == 0) {
cout << "Yes";
}
// Otherwise, not possible to make
// all array elements equal
else {
cout << "No" << endl;
}
}
// Driver Code
int main()
{
// Given array
int arr[] = { 1, 5, 6, 4 };
// Size of the array
int N = sizeof(arr) / sizeof(arr[0]);
arrayElementEqual(arr, N);
}
// Java program for the above approach
import java.util.*;
class GFG
{
// Function to check if its possible to
// make all array elements equal or not
static void arrayElementEqual(int arr[], int N)
{
// Stores the sum of the array
int sum = 0;
// Traverse the array
for (int i = 0; i < N; i++)
{
sum += arr[i];
}
// If sum is divisible by N
if (sum % N == 0)
{
System.out.print("Yes");
}
// Otherwise, not possible to make
// all array elements equal
else
{
System.out.print("No" +"\n");
}
}
// Driver Code
public static void main(String[] args)
{
// Given array
int arr[] = { 1, 5, 6, 4 };
// Size of the array
int N = arr.length;
arrayElementEqual(arr, N);
}
}
// This code is contributed by 29AjayKumar
# Python program for the above approach
# Function to check if its possible to
# make all array elements equal or not
def arrayElementEqual(arr, N):
# Stores the sum of the array
sum = 0
# Traverse the array
for i in range(N):
sum += arr[i]
# If sum is divisible by N
if (sum % N == 0):
print('Yes')
# Otherwise, not possible to make
# all array elements equal
else:
print("No")
# Driver Code
# Given array
arr = [ 1, 5, 6, 4 ]
# Size of the array
N = len(arr)
arrayElementEqual(arr, N)
# This code is contributed by rohitsingh07052
// C# program for the above approach
using System;
using System.Collections.Generic;
public class GFG
{
// Function to check if its possible to
// make all array elements equal or not
static void arrayElementEqual(int[] arr, int N)
{
// Stores the sum of the array
int sum = 0;
// Traverse the array
for (int i = 0; i < N; i++)
{
sum += arr[i];
}
// If sum is divisible by N
if (sum % N == 0)
{
Console.WriteLine("Yes");
}
// Otherwise, not possible to make
// all array elements equal
else
{
Console.Write("No" +"\n");
}
}
// Driver Code
static public void Main()
{
// Given array
int[] arr = { 1, 5, 6, 4 };
// Size of the array
int N = arr.Length;
arrayElementEqual(arr, N);
}
}
// This code is contributed by sanjoy_62.
<script>
// Javascript program for the above approach
// Function to check if its possible to
// make all array elements equal or not
function arrayElementEqual(arr , N)
{
// Stores the sum of the array
var sum = 0;
// Traverse the array
for (i = 0; i < N; i++) {
sum += arr[i];
}
// If sum is divisible by N
if (sum % N == 0) {
document.write("Yes");
}
// Otherwise, not possible to make
// all array elements equal
else {
document.write("No" + "\n");
}
}
// Driver Code
// Given array
var arr = [ 1, 5, 6, 4 ];
// Size of the array
var N = arr.length;
arrayElementEqual(arr, N);
// This code contributed by umadevi9616
</script>
Time Complexity: O(N)
Auxiliary Space: O(1)
Brute Force:
Approach:
In this approach, we will try all possible combinations of i, j, and k and check if we can make all array elements equal. For each combination, we will apply the given operations and check if all elements are equal. If yes, we will return "Yes" else we will try the next combination
- We will start by trying all possible combinations of i, j, and k using three nested loops.
- For each combination, we will create a temporary array by copying the original array.
- We will apply the given operations on the temporary array using the indices i, j, and k.
- We will check if all elements of the temporary array are equal.
- If yes, we will return "Yes".
- If all possible combinations have been tried and we haven't found a solution yet, we will return "No".
C++
#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;
string checkIfPossible(vector<int>& arr) {
int n = arr.size();
// Nested loops to iterate through all possible combinations of i, j, and k
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
if (i != j && i != k && j != k) {
vector<int> temp = arr; // Create a copy of the original array
temp[i] += 1;
temp[j] -= 1;
temp[k] += 1;
unordered_set<int> unique_elements(temp.begin(), temp.end());
if (unique_elements.size() == 2) {
return "Yes";
}
}
}
}
}
return "No";
}
int main() {
// Example Input 1
vector<int> arr1 = {1, 5, 6, 4};
cout << checkIfPossible(arr1) << endl; // Output: Yes
// Example Input 2
vector<int> arr2 = {2, 5, 3, 2, 2};
cout << checkIfPossible(arr2) << endl; // Output: No
return 0;
}
import java.util.HashSet;
import java.util.Set;
public class Main {
public static String checkIfPossible(int[] arr) {
int n = arr.length;
// Nested loops to iterate through all possible combinations of i, j, and k
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
if (i != j && i != k && j != k) {
int[] temp = arr.clone(); // Create a copy of the original array
temp[i] += 1;
temp[j] -= 1;
temp[k] += 1;
Set<Integer> uniqueElements = new HashSet<>();
for (int element : temp) {
uniqueElements.add(element);
}
if (uniqueElements.size() == 2) {
return "Yes";
}
}
}
}
}
return "No";
}
public static void main(String[] args) {
// Example Input 1
int[] arr1 = {1, 5, 6, 4};
System.out.println(checkIfPossible(arr1)); // Output: Yes
// Example Input 2
int[] arr2 = {2, 5, 3, 2, 2};
System.out.println(checkIfPossible(arr2)); // Output: No
}
}
// This code is contributed by akshitaguprzj3
def check_if_possible(arr):
n = len(arr)
for i in range(n):
for j in range(n):
for k in range(n):
if i != j and i != k and j != k:
temp = arr.copy()
temp[i] += 1
temp[j] -= 1
temp[k] += 1
if len(set(temp)) == 2:
return "Yes"
return "No"
# Example Input 1
arr = [1, 5, 6, 4]
print(check_if_possible(arr)) # Output: Yes
# Example Input 2
arr = [2, 5, 3, 2, 2]
print(check_if_possible(arr)) # Output: No
using System;
using System.Collections.Generic;
class Program
{
// Function to check if it's possible to make two unique elements in the array
static string CheckIfPossible(List<int> arr)
{
int n = arr.Count;
// Nested loops to iterate through all possible combinations of i, j, and k
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
for (int k = 0; k < n; ++k)
{
if (i != j && i != k && j != k)
{
List<int> temp = new List<int>(arr); // Create a copy of the original list
temp[i] += 1;
temp[j] -= 1;
temp[k] += 1;
HashSet<int> uniqueElements = new HashSet<int>(temp);
if (uniqueElements.Count == 2)
{
return "Yes";
}
}
}
}
}
return "No";
}
static void Main()
{
// Example Input 1
List<int> arr1 = new List<int> { 1, 5, 6, 4 };
Console.WriteLine(CheckIfPossible(arr1));
// Example Input 2
List<int> arr2 = new List<int> { 2, 5, 3, 2, 2 };
Console.WriteLine(CheckIfPossible(arr2));
}
}
function checkIfPossible(arr) {
const n = arr.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
for (let k = 0; k < n; k++) {
if (i !== j && i !== k && j !== k) {
const temp = [...arr]; // Create a copy of the original array
temp[i] += 1;
temp[j] -= 1;
temp[k] += 1;
const uniqueElements = new Set(temp);
if (uniqueElements.size === 2) {
return "Yes";
}
}
}
}
}
return "No";
}
// Example Input 1
const arr1 = [1, 5, 6, 4];
console.log(checkIfPossible(arr1)); // Output: Yes
// Example Input 2
const arr2 = [2, 5, 3, 2, 2];
console.log(checkIfPossible(arr2)); // Output: No
Time Complexity: O(N^3) where N is the length of the array.
Space Complexity: O(1)
Similar Reads
Minimize moves required to make array elements equal by incrementing and decrementing pairs | Set 2 Given an array arr[] of size N, the task is to print the minimum number of moves required to make all array elements equal by selecting any pair of distinct indices and then increment the element at the first index and decrement the element at the other index by 1 each time. If it is impossible to m
7 min read
Minimize increment or increment and decrement of Pair to make all Array elements equal Given an array arr[] of size N, the task is to minimize the number of steps to make all the array elements equal by performing the following operations: Choose an element of the array and increase it by 1.Select two elements simultaneously (arr[i], arr[j]) increase arr[i] by 1 and decrease arr[j] by
8 min read
Minimize moves to make Array elements equal by incrementing and decrementing pairs Given an array arr[] of size N, the task is to print the minimum number of moves needed to make all array elements equal by selecting any two distinct indices and then increment the element at the first selected index and decrement the element at the other selected index by 1 in each move. If it is
14 min read
Minimum Increment / decrement to make array elements equal Given an array of integers where 1 \leq A[i] \leq 10^{18} . In one operation you can either Increment/Decrement any element by 1. The task is to find the minimum operations needed to be performed on the array elements to make all array elements equal. Examples: Input : A[] = { 1, 5, 7, 10 } Output :
7 min read
Minimum Increment / decrement to make array elements equal Given an array of integers where 1 \leq A[i] \leq 10^{18} . In one operation you can either Increment/Decrement any element by 1. The task is to find the minimum operations needed to be performed on the array elements to make all array elements equal. Examples: Input : A[] = { 1, 5, 7, 10 } Output :
7 min read
Minimum value of X to make all array elements equal by either decreasing or increasing by X Given an array of N elements and you can perform two operations on it: Increase any of the array element by X once.Decrease any of the array element by X once. The task is to find the minimum most value of X such that all array elements are equal by either applying operation 1, 2 or not applying any
7 min read