Related Articles
Minimum prime numbers required to be subtracted to make all array elements equal
• Last Updated : 16 Apr, 2021

Given an array arr[] consisting of N positive integers, the task is to find the minimum number of primes numbers required to be subtracted from the array elements to make all array elements equal.

Examples:

Input: arr[]= {7, 10, 4, 5}
Output: 5
Explanation: Following subtraction of primes numbers makes all array elements equal:

1. Subtracting 5 from arr modifies arr[] to {2, 10, 4, 5}.
2. Subtracting 5 from arr modifies arr[] to {2, 5, 4, 5}.
3. Subtracting 3 from arr modifies arr[] to {2, 2, 4, 5}.
4. Subtracting 2 from arr modifies arr[] to {2, 2, 2, 5}.
5. Subtracting 3 from arr modifies arr[] to {2, 2, 2, 2}.

Therefore, the total numbers of operations required is 5.

Input: arr[]= {10, 17, 37, 43, 50}
Output: 8

Approach: The given problem can be solved using the below observations:

• Every even number greater than 2 is the sum of two prime numbers.
• Every odd number greater than 1, can be represented as the sum of at most 3 prime numbers. Below are the possible cases for the same:
• Case 1: If N is prime.
• Case 2: If (N – 2) is prime. Therefore, 2 numbers required i.e., 2 and N – 2.
• Case 3: If (N – 3) is even, then using Goldbach’s conjecture. (N – 3) can be represented as the sum of two prime numbers.
• Therefore, the idea is to reduce each array element to the minimum value of the array(say M) arr[] and if there exists an element in the array having value (M + 1) then reduce each element to the value (M – 2).

Follow the steps below to solve this problem:

• Initialize an array, say prime[], of size 105, to store at every ith index, whether i is prime number or not using Sieve Of Eratosthenes.
• Find the minimum element present in the array, say M.
• If there exists any element in the array arr[] with value (M + 1), then update M to (M – 2).
• Initialize a variable, say count, to store the number of operations required to make all array elements equal.
• Traverse the given array arr[] and perform the following steps:
• Find the difference between arr[i] and M, say D.
• Update the value of count according to the following values of D:
• If the value of D is a prime number, then increment count by 1.
• If the value of D is an even number, then increment count by 2.
• If the value of D is an odd number, and if (D – 2) is a prime number, then increment count by 2. Otherwise, increment count by 3.
• After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``#define limit 100000``using` `namespace` `std;` `// Stores the sieve of prime numbers``bool` `prime[limit + 1];` `// Function that performs the Sieve of``// Eratosthenes``void` `sieve()``{``    ``// Initialize all numbers as prime``    ``memset``(prime, ``true``, ``sizeof``(prime));` `    ``// Iterate over the range [2, 1000]``    ``for` `(``int` `p = 2; p * p <= limit; p++) {` `        ``// If the current element``        ``// is a prime number``        ``if` `(prime[p] == ``true``) {` `            ``// Mark all its multiples as false``            ``for` `(``int` `i = p * p; i <= limit; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to find the minimum number of``// subtraction of primes numbers required``// to make all array elements the same``int` `findOperations(``int` `arr[], ``int` `n)``{``    ``// Peform sieve of eratoshthenes``    ``sieve();` `    ``int` `minm = INT_MAX;` `    ``// Find the minimum value``    ``for` `(``int` `i = 0; i < n; i++) {``        ``minm = min(minm, arr[i]);``    ``}` `    ``// Stores the value to each array``    ``// element should be reduced``    ``int` `val = minm;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If an element exists with``        ``// value (M + 1)``        ``if` `(arr[i] == minm + 1) {``            ``val = minm - 2;``            ``break``;``        ``}``    ``}` `    ``// Stores the minimum count of``    ``// substraction of prime numbers``    ``int` `cnt = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `D = arr[i] - val;` `        ``// If D is equal to 0``        ``if` `(D == 0) {``            ``continue``;``        ``}` `        ``// If D is a prime number``        ``else` `if` `(prime[D] == ``true``) {` `            ``// Increase count by 1``            ``cnt += 1;``        ``}` `        ``// If D is an even number``        ``else` `if` `(D % 2 == 0) {` `            ``// Increase count by 2``            ``cnt += 2;``        ``}``        ``else` `{` `            ``// If D - 2 is prime``            ``if` `(prime[D - 2] == ``true``) {` `                ``// Increase count by 2``                ``cnt += 2;``            ``}` `            ``// Otherwise, increase``            ``// count by 3``            ``else` `{``                ``cnt += 3;``            ``}``        ``}``    ``}` `    ``return` `cnt;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 7, 10, 4, 5 };``    ``int` `N = 4;``    ``cout << findOperations(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `static` `int` `limit = ``100000``;` `// Stores the sieve of prime numbers``static` `boolean` `prime[];` `// Function that performs the Sieve of``// Eratosthenes``static` `void` `sieve()``{``    ``prime = ``new` `boolean``[limit + ``1``];` `    ``// Initialize all numbers as prime``    ``Arrays.fill(prime, ``true``);` `    ``// Iterate over the range [2, 1000]``    ``for``(``int` `p = ``2``; p * p <= limit; p++)``    ``{``        ` `        ``// If the current element``        ``// is a prime number``        ``if` `(prime[p] == ``true``)``        ``{``            ` `            ``// Mark all its multiples as false``            ``for``(``int` `i = p * p; i <= limit; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to find the minimum number of``// subtraction of primes numbers required``// to make all array elements the same``static` `int` `findOperations(``int` `arr[], ``int` `n)``{``    ` `    ``// Peform sieve of eratoshthenes``    ``sieve();` `    ``int` `minm = Integer.MAX_VALUE;` `    ``// Find the minimum value``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``minm = Math.min(minm, arr[i]);``    ``}` `    ``// Stores the value to each array``    ``// element should be reduced``    ``int` `val = minm;` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ` `        ``// If an element exists with``        ``// value (M + 1)``        ``if` `(arr[i] == minm + ``1``)``        ``{``            ``val = minm - ``2``;``            ``break``;``        ``}``    ``}` `    ``// Stores the minimum count of``    ``// substraction of prime numbers``    ``int` `cnt = ``0``;` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``int` `D = arr[i] - val;` `        ``// If D is equal to 0``        ``if` `(D == ``0``)``        ``{``            ``continue``;``        ``}` `        ``// If D is a prime number``        ``else` `if` `(prime[D] == ``true``)``        ``{``            ` `            ``// Increase count by 1``            ``cnt += ``1``;``        ``}` `        ``// If D is an even number``        ``else` `if` `(D % ``2` `== ``0``)``        ``{``            ` `            ``// Increase count by 2``            ``cnt += ``2``;``        ``}``        ``else``        ``{``            ` `            ``// If D - 2 is prime``            ``if` `(prime[D - ``2``] == ``true``)``            ``{``                ` `                ``// Increase count by 2``                ``cnt += ``2``;``            ``}` `            ``// Otherwise, increase``            ``// count by 3``            ``else``            ``{``                ``cnt += ``3``;``            ``}``        ``}``    ``}``    ``return` `cnt;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``7``, ``10``, ``4``, ``5` `};``    ``int` `N = ``4``;``    ` `    ``System.out.println(findOperations(arr, N));``}``}` `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach``import` `sys` `limit ``=` `100000` `# Stores the sieve of prime numbers``prime ``=` `[``True``] ``*` `(limit ``+` `1``)` `# Function that performs the Sieve of``# Eratosthenes``def` `sieve():` `    ``# Iterate over the range [2, 1000]``    ``p ``=` `2``    ``while``(p ``*` `p <``=` `limit):` `        ``# If the current element``        ``# is a prime number``        ``if` `(prime[p] ``=``=` `True``):` `            ``# Mark all its multiples as false``            ``for` `i ``in` `range``(p ``*` `p, limit, p):``                ``prime[i] ``=` `False``        ` `        ``p ``+``=` `1``    ` `# Function to find the minimum number of``# subtraction of primes numbers required``# to make all array elements the same``def` `findOperations(arr, n):``    ` `    ``# Peform sieve of eratoshthenes``    ``sieve()` `    ``minm ``=` `sys.maxsize` `    ``# Find the minimum value``    ``for` `i ``in` `range``(n):``        ``minm ``=` `min``(minm, arr[i])``    ` `    ``# Stores the value to each array``    ``# element should be reduced``    ``val ``=` `minm` `    ``for` `i ``in` `range``(n):` `        ``# If an element exists with``        ``# value (M + 1)``        ``if` `(arr[i] ``=``=` `minm ``+` `1``):``            ``val ``=` `minm ``-` `2``            ``break``        ` `    ``# Stores the minimum count of``    ``# substraction of prime numbers``    ``cnt ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):``        ``D ``=` `arr[i] ``-` `val` `        ``# If D is equal to 0``        ``if` `(D ``=``=` `0``):``            ``continue``        ` `        ``# If D is a prime number``        ``elif` `(prime[D] ``=``=` `True``):` `            ``# Increase count by 1``            ``cnt ``+``=` `1``        ` `        ``# If D is an even number``        ``elif` `(D ``%` `2` `=``=` `0``):` `            ``# Increase count by 2``            ``cnt ``+``=` `2``        ` `        ``else``:` `            ``# If D - 2 is prime``            ``if` `(prime[D ``-` `2``] ``=``=` `True``):``                ` `                ``# Increase count by 2``                ``cnt ``+``=` `2` `            ``# Otherwise, increase``            ``# count by 3``            ``else``:``                ``cnt ``+``=` `3` `    ``return` `cnt` `# Driver Code``arr ``=` `[ ``7``, ``10``, ``4``, ``5` `]``N ``=` `4` `print``(findOperations(arr, N))` `# This code is contributed by splevel62`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `static` `int` `limit = 100000;` `// Stores the sieve of prime numbers``static` `bool``[] prime;` `// Function that performs the Sieve of``// Eratosthenes``static` `void` `sieve()``{``    ``prime = ``new` `bool``[limit + 1];` `    ``// Initialize all numbers as prime``    ``Array.Fill(prime, ``true``);` `    ``// Iterate over the range [2, 1000]``    ``for``(``int` `p = 2; p * p <= limit; p++)``    ``{``        ` `        ``// If the current element``        ``// is a prime number``        ``if` `(prime[p] == ``true``)``        ``{``            ` `            ``// Mark all its multiples as false``            ``for``(``int` `i = p * p; i <= limit; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to find the minimum number of``// subtraction of primes numbers required``// to make all array elements the same``static` `int` `findOperations(``int``[] arr, ``int` `n)``{``    ` `    ``// Peform sieve of eratoshthenes``    ``sieve();` `    ``int` `minm = Int32.MaxValue;` `    ``// Find the minimum value``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``minm = Math.Min(minm, arr[i]);``    ``}` `    ``// Stores the value to each array``    ``// element should be reduced``    ``int` `val = minm;` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// If an element exists with``        ``// value (M + 1)``        ``if` `(arr[i] == minm + 1)``        ``{``            ``val = minm - 2;``            ``break``;``        ``}``    ``}` `    ``// Stores the minimum count of``    ``// substraction of prime numbers``    ``int` `cnt = 0;` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``int` `D = arr[i] - val;` `        ``// If D is equal to 0``        ``if` `(D == 0)``        ``{``            ``continue``;``        ``}` `        ``// If D is a prime number``        ``else` `if` `(prime[D] == ``true``)``        ``{``            ` `            ``// Increase count by 1``            ``cnt += 1;``        ``}` `        ``// If D is an even number``        ``else` `if` `(D % 2 == 0)``        ``{``            ` `            ``// Increase count by 2``            ``cnt += 2;``        ``}``        ``else``        ``{``            ` `            ``// If D - 2 is prime``            ``if` `(prime[D - 2] == ``true``)``            ``{``                ` `                ``// Increase count by 2``                ``cnt += 2;``            ``}` `            ``// Otherwise, increase``            ``// count by 3``            ``else``            ``{``                ``cnt += 3;``            ``}``        ``}``    ``}``    ``return` `cnt;``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = { 7, 10, 4, 5 };``    ``int` `N = 4;` `    ``Console.WriteLine(findOperations(arr, N));``}``}` `// This code is contributed by ukasp`

## Javascript

 ``
Output:
`5`

Time Complexity: O(N + M * log(log(M))), M is the size of
Auxiliary Space: O(M)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up