Wednesday, July 3, 2024
HomeData ModellingData Structure & AlgorithmFind whether it is possible to make array elements same using one...

Find whether it is possible to make array elements same using one external number | Set 2

Given an array arr[] consisting of N integers and following are the three operations that can be performed using any external number X:

  1. Add X to an array element once.
  2. Subtract X from an array element once.
  3. Perform no operation on the array element.

The task is to check whether there exists a number X, such that if the above operations are performed with the number X, the array elements become equal. If the number exists, print “Yes” and the value of X. Otherwise, print “No”.

Examples:

Input: arr[] = {2, 3, 3, 4, 2}
Output: Yes 1
Explanation:
Consider the value of X as 1 and increment the array element arr[0](= 2) and arr[4](= 2) by 1, and decrement arr[3](= 4) by 1 modifies the array to {3, 3, 3, 3, 3}.
Therefore, print Yes with the value X as 1.

Input: arr[] = {4, 3, 2, 1}
Output: No

Approach: The given problem can be solved based on the following observations:

  • If all numbers are equal, the answer is “YES“.
  • If there are two distinct numbers in the array, the answer is “YES“, as every distinct number can be converted to another integer following the operation.
  • If there are at least four distinct numbers in the array, the answer is “NO“, because of the property of the addition.
  • In other cases, if there are three distinct numbers A < B < C, then all array elements can be made equal by incrementing all the As by B – A and decrementing all the Cs by C – A. Therefore, the answer will be “YES” only if 2 * B equals (C + A) / 2.

Follow the steps below to solve the problem:

  • Initialize 3 variables, say, X, Y, and Z as -1 to store all the 3 distinct integers of the array arr[].
  • Traverse the given array arr[] using the variable i and perform the following steps:
    • If any of X, Y, and Z are -1 then assign arr[i] to that variable.
    • Otherwise, if none of the X, Y, and Z are equal to arr[i], then print “NO” and return.
  • If any one of X, Y, and Z is equal to -1, then print “YES“.
  • Store the smallest element in X, the next largest element in Y, and the largest element in Z.
  • Now, if Z-Y is equal to (Y – X),  then print “YES“. Otherwise, print “NO“.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find whether it is possible
// to make array elements equal using
// one external number
void isPossMakeThemEqual(int arr[],
                         int N)
{
 
    int X = -1;
    int Y = -1;
    int Z = -1;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
        // If X is equal to -1
        if (X == -1) {
 
            // Update the value of X
            X = arr[i];
        }
 
        // Otherwise, if X is not
        // equal to arr[i]
        else if (X != arr[i]) {
 
            // If Y is equal to -1
            if (Y == -1) {
                // Update Y
                Y = arr[i];
            }
 
            // Otherwise, if Y is not
            // equal to arr[i]
            else if (Y != arr[i]) {
 
                // If  Z is equal to -1
                if (Z == -1) {
 
                    // Update the value
                    // of Z
                    Z = arr[i];
                }
 
                // Otherwise If Z is not
                // equal to arr[i], then
                // there are at least four
                // distinct numbers in array
                else if (Z != arr[i]) {
                    cout << "NO";
                    return;
                }
            }
        }
    }
 
    // If Y is equal to -1, then all
    // the array elements are equal
    if (Y == -1) {
        cout << "YES 0";
        return;
    }
 
    // If Z is equal to -1, then there
    // are only two distinct elements
    if (Z == -1) {
        cout << "YES " << abs(X - Y);
        return;
    }
 
    int a = X, b = Y, c = Z;
 
    X = min(a, min(b, c));
    Z = max(a, max(b, c));
    Y = a + b + c - X - Z;
 
    // If Y - X is not equal to Z - Y
    if (Y - X != Z - Y) {
        cout << "NO";
        return;
    }
 
    // Finally print "Yes"
    cout << "Yes " << (Y - X);
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 3, 3, 4, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
    isPossMakeThemEqual(arr, N);
 
    return 0;
}


Java




// Java program for the above approach
import java.io.*;
 
class GFG {
 
  // Function to find whether it is possible
  // to make array elements equal using
  // one external number
  static void isPossMakeThemEqual(int arr[],
                                  int N)
  {
 
    int X = -1;
    int Y = -1;
    int Z = -1;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
      // If X is equal to -1
      if (X == -1) {
 
        // Update the value of X
        X = arr[i];
      }
 
      // Otherwise, if X is not
      // equal to arr[i]
      else if (X != arr[i]) {
 
        // If Y is equal to -1
        if (Y == -1)
        {
 
          // Update Y
          Y = arr[i];
        }
 
        // Otherwise, if Y is not
        // equal to arr[i]
        else if (Y != arr[i]) {
 
          // If  Z is equal to -1
          if (Z == -1) {
 
            // Update the value
            // of Z
            Z = arr[i];
          }
 
          // Otherwise If Z is not
          // equal to arr[i], then
          // there are at least four
          // distinct numbers in array
          else if (Z != arr[i]) {
            System.out.println("NO");
            return;
          }
        }
      }
    }
 
    // If Y is equal to -1, then all
    // the array elements are equal
    if (Y == -1) {
      System.out.println("YES 0");
      return;
    }
 
    // If Z is equal to -1, then there
    // are only two distinct elements
    if (Z == -1) {
      System.out.println("YES "+ Math.abs(X - Y));
      return;
    }
 
    int a = X, b = Y, c = Z;
 
    X = Math.min(a, Math.min(b, c));
    Z = Math.max(a, Math.max(b, c));
    Y = a + b + c - X - Z;
 
    // If Y - X is not equal to Z - Y
    if (Y - X != Z - Y) {
      System.out.println("NO");
      return;
    }
 
    // Finally print "Yes"
    System.out.println("Yes "+(Y - X));
  }
 
  // Driver Code
  public static void main (String[] args)
  {
    int arr[] = { 2, 3, 3, 4, 2 };
    int N =arr.length;
    isPossMakeThemEqual(arr, N);
  }
}
 
// This code is contributed by Potta Lokesh


Python3




# Python 3 program for the above approach
 
# Function to find whether it is possible
# to make array elements equal using
# one external number
def isPossMakeThemEqual(arr, N):
    X = -1
    Y = -1
    Z = -1
 
    # Traverse the array arr[]
    for i in range(N):
       
        # If X is equal to -1
        if (X == -1):
 
            # Update the value of X
            X = arr[i]
 
        # Otherwise, if X is not
        # equal to arr[i]
        elif (X != arr[i]):
           
            # If Y is equal to -1
            if (Y == -1):
               
                # Update Y
                Y = arr[i]
 
            # Otherwise, if Y is not
            # equal to arr[i]
            elif (Y != arr[i]):
               
                # If  Z is equal to -1
                if (Z == -1):
                   
                    # Update the value
                    # of Z
                    Z = arr[i]
                     
                # Otherwise If Z is not
                # equal to arr[i], then
                # there are at least four
                # distinct numbers in array
                elif (Z != arr[i]):
                    print("NO")
                    return
 
    # If Y is equal to -1, then all
    # the array elements are equal
    if (Y == -1):
        print("YES 0")
        return
 
    # If Z is equal to -1, then there
    # are only two distinct elements
    if (Z == -1):
        print("YES ",abs(X - Y))
        return
 
    a = X
    b = Y
    c = Z
    X = min(a, min(b, c))
    Z = max(a, max(b, c))
    Y = a + b + c - X - Z
 
    # If Y - X is not equal to Z - Y
    if (Y - X != Z - Y):
        print("NO")
        return
 
    # Finally print "Yes"
    print("Yes ",(Y - X))
 
# Driver Code
if __name__ == '__main__':
    arr = [2, 3, 3, 4, 2]
    N = len(arr)
    isPossMakeThemEqual(arr, N)
     
    # This code is contributed by bgangwar59.


C#




// C# program for above approach
using System;
 
class GFG{
 
  // Function to find whether it is possible
  // to make array elements equal using
  // one external number
  static void isPossMakeThemEqual(int[] arr,
                                  int N)
  {
 
    int X = -1;
    int Y = -1;
    int Z = -1;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
      // If X is equal to -1
      if (X == -1) {
 
        // Update the value of X
        X = arr[i];
      }
 
      // Otherwise, if X is not
      // equal to arr[i]
      else if (X != arr[i]) {
 
        // If Y is equal to -1
        if (Y == -1)
        {
 
          // Update Y
          Y = arr[i];
        }
 
        // Otherwise, if Y is not
        // equal to arr[i]
        else if (Y != arr[i]) {
 
          // If  Z is equal to -1
          if (Z == -1) {
 
            // Update the value
            // of Z
            Z = arr[i];
          }
 
          // Otherwise If Z is not
          // equal to arr[i], then
          // there are at least four
          // distinct numbers in array
          else if (Z != arr[i]) {
                Console.Write("NO");
            return;
          }
        }
      }
    }
 
    // If Y is equal to -1, then all
    // the array elements are equal
    if (Y == -1) {
      Console.Write("YES 0");
      return;
    }
 
    // If Z is equal to -1, then there
    // are only two distinct elements
    if (Z == -1) {
      Console.Write("YES "+ Math.Abs(X - Y));
      return;
    }
 
    int a = X, b = Y, c = Z;
 
    X = Math.Min(a, Math.Min(b, c));
    Z = Math.Max(a, Math.Max(b, c));
    Y = a + b + c - X - Z;
 
    // If Y - X is not equal to Z - Y
    if (Y - X != Z - Y) {
      Console.Write("NO");
      return;
    }
 
    // Finally print "Yes"
    Console.Write("Yes "+(Y - X));
  }
 
// Driver Code
public static void Main(String[] args)
{
    int[] arr = { 2, 3, 3, 4, 2 };
    int N =arr.Length;
    isPossMakeThemEqual(arr, N);
}
}
 
// This code is contributed by mukesh07.


Javascript




<script>
    // JavaScript Program for the above approach
 
  // Function to find whether it is possible
  // to make array elements equal using
  // one external number
  function isPossMakeThemEqual(arr, N)
  {
 
    let X = -1;
    let Y = -1;
    let Z = -1;
 
    // Traverse the array arr[]
    for (let i = 0; i < N; i++) {
 
      // If X is equal to -1
      if (X == -1) {
 
        // Update the value of X
        X = arr[i];
      }
 
      // Otherwise, if X is not
      // equal to arr[i]
      else if (X != arr[i]) {
 
        // If Y is equal to -1
        if (Y == -1)
        {
 
          // Update Y
          Y = arr[i];
        }
 
        // Otherwise, if Y is not
        // equal to arr[i]
        else if (Y != arr[i]) {
 
          // If  Z is equal to -1
          if (Z == -1) {
 
            // Update the value
            // of Z
            Z = arr[i];
          }
 
          // Otherwise If Z is not
          // equal to arr[i], then
          // there are at least four
          // distinct numbers in array
          else if (Z != arr[i]) {
            document.write("NO");
            return;
          }
        }
      }
    }
 
    // If Y is equal to -1, then all
    // the array elements are equal
    if (Y == -1) {
      document.write("YES 0");
      return;
    }
 
    // If Z is equal to -1, then there
    // are only two distinct elements
    if (Z == -1) {
      document.write("YES "+ Math.abs(X - Y));
      return;
    }
 
    let a = X, b = Y, c = Z;
 
    X = Math.min(a, Math.min(b, c));
    Z = Math.max(a, Math.max(b, c));
    Y = a + b + c - X - Z;
 
    // If Y - X is not equal to Z - Y
    if (Y - X != Z - Y) {
      document.write("NO");
      return;
    }
 
    // Finally print "Yes"
    document.write("Yes "+(Y - X));
  }
 
    // Driver Code
 
    let arr = [ 2, 3, 3, 4, 2 ];
    let N =arr.length;
    isPossMakeThemEqual(arr, N);
 
// This code is contributed by sanjoy_62.
</script>


Output: 

Yes 1

 

Time Complexity: O(N)
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

Commit to GfG’s Three-90 Challenge! Purchase a course, complete 90% in 90 days, and save 90% cost click here to explore.

Last Updated :
16 Sep, 2021
Like Article
Save Article


Previous

<!–

8 Min Read | Java

–>


Next


<!–

8 Min Read | Java

–>

Share your thoughts in the comments

Calisto Chipfumbu
Calisto Chipfumbuhttp://cchipfumbu@gmail.com
I have 5 years' worth of experience in the IT industry, primarily focused on Linux and Database administration. In those years, apart from learning significant technical knowledge, I also became comfortable working in a professional team and adapting to my environment, as I switched through 3 roles in that time.
RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments