GFG App
Open App
Browser
Continue

# Minimum prime numbers required to be subtracted to make all array elements equal

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[0] modifies arr[] to {2, 10, 4, 5}.
2. Subtracting 5 from arr[1] modifies arr[] to {2, 5, 4, 5}.
3. Subtracting 3 from arr[1] modifies arr[] to {2, 2, 4, 5}.
4. Subtracting 2 from arr[2] modifies arr[] to {2, 2, 2, 5}.
5. Subtracting 3 from arr[3] 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)` `{` `    ``// Perform sieve of eratosthenes` `    ``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` `    ``// subtraction 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)` `{` `    `  `    ``// Perform sieve of eratosthenes` `    ``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` `    ``// subtraction 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):` `    `  `    ``# Perform sieve of eratosthenes` `    ``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` `    ``# subtraction 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)` `{` `    `  `    ``// Perform sieve of eratosthenes` `    ``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` `    ``// subtraction 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)

My Personal Notes arrow_drop_up