Minimum increment and decrement by K of each pair elements required to make all array elements equal
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++
#include <bits/stdc++.h>
using namespace std;
void arrayElementEqual( int arr[], int N)
{
int sum = 0;
for ( int i = 0; i < N; i++) {
sum += arr[i];
}
if (sum % N == 0) {
cout << "Yes" ;
}
else {
cout << "No" << endl;
}
}
int main()
{
int arr[] = { 1, 5, 6, 4 };
int N = sizeof (arr) / sizeof (arr[0]);
arrayElementEqual(arr, N);
}
|
Java
import java.util.*;
class GFG
{
static void arrayElementEqual( int arr[], int N)
{
int sum = 0 ;
for ( int i = 0 ; i < N; i++)
{
sum += arr[i];
}
if (sum % N == 0 )
{
System.out.print( "Yes" );
}
else
{
System.out.print( "No" + "\n" );
}
}
public static void main(String[] args)
{
int arr[] = { 1 , 5 , 6 , 4 };
int N = arr.length;
arrayElementEqual(arr, N);
}
}
|
Python3
def arrayElementEqual(arr, N):
sum = 0
for i in range (N):
sum + = arr[i]
if ( sum % N = = 0 ):
print ( 'Yes' )
else :
print ( "No" )
arr = [ 1 , 5 , 6 , 4 ]
N = len (arr)
arrayElementEqual(arr, N)
|
C#
using System;
using System.Collections.Generic;
public class GFG
{
static void arrayElementEqual( int [] arr, int N)
{
int sum = 0;
for ( int i = 0; i < N; i++)
{
sum += arr[i];
}
if (sum % N == 0)
{
Console.WriteLine( "Yes" );
}
else
{
Console.Write( "No" + "\n" );
}
}
static public void Main()
{
int [] arr = { 1, 5, 6, 4 };
int N = arr.Length;
arrayElementEqual(arr, N);
}
}
|
Javascript
<script>
function arrayElementEqual(arr , N)
{
var sum = 0;
for (i = 0; i < N; i++) {
sum += arr[i];
}
if (sum % N == 0) {
document.write( "Yes" );
}
else {
document.write( "No" + "\n" );
}
}
var arr = [ 1, 5, 6, 4 ];
var N = arr.length;
arrayElementEqual(arr, N);
</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();
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;
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() {
vector< int > arr1 = {1, 5, 6, 4};
cout << checkIfPossible(arr1) << endl;
vector< int > arr2 = {2, 5, 3, 2, 2};
cout << checkIfPossible(arr2) << endl;
return 0;
}
|
Java
import java.util.HashSet;
import java.util.Set;
public class Main {
public static String checkIfPossible( int [] arr) {
int n = arr.length;
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();
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) {
int [] arr1 = { 1 , 5 , 6 , 4 };
System.out.println(checkIfPossible(arr1));
int [] arr2 = { 2 , 5 , 3 , 2 , 2 };
System.out.println(checkIfPossible(arr2));
}
}
|
Python3
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"
arr = [ 1 , 5 , 6 , 4 ]
print (check_if_possible(arr))
arr = [ 2 , 5 , 3 , 2 , 2 ]
print (check_if_possible(arr))
|
C#
using System;
using System.Collections.Generic;
class Program
{
static string CheckIfPossible(List< int > arr)
{
int n = arr.Count;
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);
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()
{
List< int > arr1 = new List< int > { 1, 5, 6, 4 };
Console.WriteLine(CheckIfPossible(arr1));
List< int > arr2 = new List< int > { 2, 5, 3, 2, 2 };
Console.WriteLine(CheckIfPossible(arr2));
}
}
|
Javascript
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];
temp[i] += 1;
temp[j] -= 1;
temp[k] += 1;
const uniqueElements = new Set(temp);
if (uniqueElements.size === 2) {
return "Yes" ;
}
}
}
}
}
return "No" ;
}
const arr1 = [1, 5, 6, 4];
console.log(checkIfPossible(arr1));
const arr2 = [2, 5, 3, 2, 2];
console.log(checkIfPossible(arr2));
|
Time Complexity: O(N^3) where N is the length of the array.
Space Complexity: O(1)
Last Updated :
29 Oct, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...