Skip to content
Related Articles

Related Articles

Improve Article

Print prime numbers with prime sum of digits in an array

  • Difficulty Level : Easy
  • Last Updated : 06 May, 2021

Given an array arr[] and the task is to print the additive primes in an array. 
Additive primes: Primes such that the sum of their digits is also a prime, such as 2, 3, 7, 11, 23 are additive primes but not 13, 19, 31 etc.
Examples: 
 

Input: arr[] = {2, 4, 6, 11, 12, 18, 7}
Output: 2, 11, 7 

Input: arr[] = {2, 3, 19, 13, 25, 7}
Output: 2, 3, 7

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

A simple approach is to traverse through all array elements. For every element check if it is Additive prime or not. 
This above approach is fine when array is small or when array values are large. For large sized arrays having relatively small values, we use Sieve to store primes up to maximum element of the array. Then check if the current element is prime or not. If yes then check the sum of its digit is also prime or not. If yes then print that number. 
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to store the primes
void sieve(int maxEle, int prime[])
{
    prime[0] = prime[1] = 1;
 
    for (int i = 2; i * i <= maxEle; i++) {
        if (!prime[i]) {
            for (int j = 2 * i; j <= maxEle; j += i)
                prime[j] = 1;
        }
    }
}
 
// Function to return the sum of digits
int digitSum(int n)
{
    int sum = 0;
    while (n) {
        sum += n % 10;
        n = n / 10;
    }
    return sum;
}
 
// Function to print additive primes
void printAdditivePrime(int arr[], int n)
{
 
    int maxEle = *max_element(arr, arr + n);
 
    int prime[maxEle + 1];
    memset(prime, 0, sizeof(prime));
    sieve(maxEle, prime);
 
    for (int i = 0; i < n; i++) {
 
        // If the number is prime
        if (prime[arr[i]] == 0) {
            int sum = digitSum(arr[i]);
 
            // Check if it's digit sum is prime
            if (prime[sum] == 0)
                cout << arr[i] << " ";
        }
    }
}
 
// Driver code
int main()
{
 
    int a[] = { 2, 4, 6, 11, 12, 18, 7 };
    int n = sizeof(a) / sizeof(a[0]);
 
    printAdditivePrime(a, n);
 
    return 0;
}
Java



// Java implementation of the above approach
import java.util.Arrays;
 
class GFG
{
     
// Function to store the primes
static void sieve(int maxEle, int prime[])
{
    prime[0] = prime[1] = 1;
 
    for (int i = 2; i * i <= maxEle; i++)
    {
        if (prime[i]==0)
        {
            for (int j = 2 * i; j <= maxEle; j += i)
                prime[j] = 1;
        }
    }
}
 
// Function to return the sum of digits
static int digitSum(int n)
{
    int sum = 0;
    while (n > 0)
    {
        sum += n % 10;
        n = n / 10;
    }
    return sum;
}
 
// Function to print additive primes
static void printAdditivePrime(int arr[], int n)
{
 
    int maxEle = Arrays.stream(arr).max().getAsInt();
 
    int prime[] = new int[maxEle + 1];
    sieve(maxEle, prime);
 
    for (int i = 0; i < n; i++)
    {
 
        // If the number is prime
        if (prime[arr[i]] == 0)
        {
            int sum = digitSum(arr[i]);
 
            // Check if it's digit sum is prime
            if (prime[sum] == 0)
                System.out.print(arr[i]+" ");
        }
    }
}
 
// Driver code
public static void main(String[] args)
{
 
    int a[] = { 2, 4, 6, 11, 12, 18, 7 };
    int n =a.length;
    printAdditivePrime(a, n);
}
}
 
// This code is contributed by chandan_jnu
Python3



# Python3 implementation of the
# above approach
 
# from math lib import sqrt
from math import sqrt
 
# Function to store the primes
def sieve(maxEle, prime) :
     
    prime[0], prime[1] = 1 , 1
 
    for i in range(2, int(sqrt(maxEle)) + 1) :
        if (not prime[i]) :
            for j in range(2 * i , maxEle + 1, i) :
                prime[j] = 1
     
# Function to return the sum of digits
def digitSum(n) :
    sum = 0
    while (n) :
         
        sum += n % 10
        n = n // 10
    return sum
 
# Function to print additive primes
def printAdditivePrime(arr, n):
    maxEle = max(arr)
    prime = [0] * (maxEle + 1)
    sieve(maxEle, prime)
    for i in range(n) :
         
        # If the number is prime
        if (prime[arr[i]] == 0):
            sum = digitSum(arr[i])
             
            # Check if it's digit sum is prime
            if (prime[sum] == 0) :
                print(arr[i], end = " ")
     
# Driver code
if __name__ == "__main__" :
    a = [ 2, 4, 6, 11, 12, 18, 7 ]
    n = len(a)
    printAdditivePrime(a, n)
 
# This code is contributed by Ryuga
C#



// C# implementation of the above approach
using System.Linq;
using System;
 
class GFG
{
     
// Function to store the primes
static void sieve(int maxEle, int[] prime)
{
    prime[0] = prime[1] = 1;
 
    for (int i = 2; i * i <= maxEle; i++)
    {
        if (prime[i] == 0)
        {
            for (int j = 2 * i; j <= maxEle; j += i)
                prime[j] = 1;
        }
    }
}
 
// Function to return the sum of digits
static int digitSum(int n)
{
    int sum = 0;
    while (n > 0)
    {
        sum += n % 10;
        n = n / 10;
    }
    return sum;
}
 
// Function to print additive primes
static void printAdditivePrime(int []arr, int n)
{
 
    int maxEle = arr.Max();
 
    int[] prime = new int[maxEle + 1];
    sieve(maxEle, prime);
 
    for (int i = 0; i < n; i++)
    {
 
        // If the number is prime
        if (prime[arr[i]] == 0)
        {
            int sum = digitSum(arr[i]);
 
            // Check if it's digit sum is prime
            if (prime[sum] == 0)
                Console.Write(arr[i] + " ");
        }
    }
}
 
// Driver code
static void Main()
{
    int[] a = { 2, 4, 6, 11, 12, 18, 7 };
    int n = a.Length;
    printAdditivePrime(a, n);
}
}
 
// This code is contributed by chandan_jnu
PHP



<?php
// PHP implementation of the above approach
 
// Function to store the primes
function sieve($maxEle, &$prime)
{
    $prime[0] = $prime[1] = 1;
 
    for ($i = 2; $i * $i <= $maxEle; $i++)
    {
        if (!$prime[$i])
        {
            for ($j = 2 * $i;
                 $j <= $maxEle; $j += $i)
                $prime[$j] = 1;
        }
    }
}
 
// Function to return the sum of digits
function digitSum($n)
{
    $sum = 0;
    while ($n)
    {
        $sum += $n % 10;
        $n = $n / 10;
    }
    return $sum;
}
 
// Function to print additive primes
function printAdditivePrime($arr, $n)
{
 
    $maxEle = max($arr);
 
    $prime = array_fill(0, $maxEle + 1, 0);
    sieve($maxEle, $prime);
 
    for ($i = 0; $i < $n; $i++)
    {
 
        // If the number is prime
        if ($prime[$arr[$i]] == 0)
        {
            $sum = digitSum($arr[$i]);
 
            // Check if it's digit sum is prime
            if ($prime[$sum] == 0)
                print($arr[$i] . " ");
        }
    }
}
 
// Driver code
$a = array(2, 4, 6, 11, 12, 18, 7);
$n = count($a);
 
printAdditivePrime($a, $n);
 
// This code is contributed by chandan_jnu
?>
Javascript



<script>
 
// Javascript implementation of the above approach
 
// Function to store the primes
function sieve(maxEle, prime)
{
    prime[0] = prime[1] = 1;
 
    for (var i = 2; i * i <= maxEle; i++) {
        if (!prime[i]) {
            for (var j = 2 * i; j <= maxEle; j += i)
                prime[j] = 1;
        }
    }
}
 
// Function to return the sum of digits
function digitSum(n)
{
    var sum = 0;
    while (n) {
        sum += n % 10;
        n = parseInt(n / 10);
    }
    return sum;
}
 
// Function to print additive primes
function printAdditivePrime(arr, n)
{
 
    var maxEle = arr.reduce((a,b)=> Math.max(a,b));
 
    var prime = Array(maxEle + 1).fill(0);
    sieve(maxEle, prime);
 
    for (var i = 0; i < n; i++) {
 
        // If the number is prime
        if (prime[arr[i]] == 0) {
            var sum = digitSum(arr[i]);
 
            // Check if it's digit sum is prime
            if (prime[sum] == 0)
                document.write( arr[i] + " ");
        }
    }
}
 
// Driver code
var a = [ 2, 4, 6, 11, 12, 18, 7 ];
var n = a.length;
printAdditivePrime(a, n);
 
 
</script>
Output: 
2 11 7
 



My Personal Notes
arrow_drop_up
Previous
Basic Shell Commands in Linux
Next

JC Penny Interview experience On-campus (Testing Role)
Recommended Articles
Page :
Count numbers in a given range having prime and non-prime digits at prime and non-prime positions respectively
15, Jan 21
Numbers with sum of digits equal to the sum of digits of its all prime factor
20, Sep 18
Numbers of Length N having digits A and B and whose sum of digits contain only digits A and B
31, Jan 19
Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime
22, Jan 19
Sum of prime numbers without odd prime digits
29, Jul 19
Count all prime numbers in a given range whose sum of digits is also prime
30, Jun 20
Count numbers in given range such that sum of even digits is greater than sum of odd digits
26, Jun 19
Count of numbers in range [L, R] having sum of digits of its square equal to square of sum of digits
24, Aug 21
Count N-digits numbers made up of even and prime digits at odd and even positions respectively
29, Jul 21
Absolute Difference between the Sum of Non-Prime numbers and Prime numbers of an Array
02, Nov 18
Maximize difference between sum of prime and non-prime array elements by left shifting of digits minimum number of times
05, Mar 21
Print all n-digit numbers whose sum of digits equals to given sum
31, Jul 16
Minimum digits to be removed to make either all digits or alternating digits same
15, Aug 20
Print all Perfect Numbers from an array whose sum of digits is also a Perfect Number
19, Feb 21
Count prime numbers that can be expressed as sum of consecutive prime numbers
10, Sep 20
Count prime numbers up to N that can be represented as a sum of two prime numbers
14, Apr 21
Count numbers from a given range that can be expressed as sum of digits raised to the power of count of digits
02, Mar 21
Count of numbers between range having only non-zero digits whose sum of digits is N and number is divisible by M
13, Feb 19
Bitwise AND of the sum of prime numbers and the sum of composite numbers in an array
20, Sep 19
Absolute difference between the Product of Non-Prime numbers and Prime numbers of an Array
03, Nov 18
Absolute difference between the XOR of Non-Prime numbers and Prime numbers of an Array
23, Sep 19
Check if sum of digits in the left half is divisible by sum of digits in the right half in the largest permutation of N
15, Jun 21
Print all numbers whose set of prime factors is a subset of the set of the prime factors of X
22, Apr 19
Print the nearest prime number formed by adding prime numbers to N
26, Jul 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
mohit kumar 29
@mohit kumar 29
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox