I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

You are encouraged to solve this task according to the task description, using any language you may know.
Definitions

In mathematics, additive primes are prime numbers for which the sum of their decimal digits are also primes.

Write a program to determine (and show here) all additive primes less than 500.

Optionally, show the number of additive primes.

Also see

## ALGOL 68

`BEGIN # find additive primes - primes whose digit sum is also prime #    # sieve the primes to max prime #    PR read "primes.incl.a68" PR    []BOOL prime = PRIMESIEVE 499;    # find the additive primes #    INT additive count := 0;    FOR n TO UPB prime DO        IF prime[ n ] THEN            # have a prime #            INT digit sum := 0;            INT v         := n;            WHILE v > 0 DO                digit sum +:= v MOD 10;                v OVERAB 10            OD;            IF prime( digit sum ) THEN                # the digit sum is prime #                print( ( " ", whole( n, -3 ) ) );                IF ( additive count +:= 1 ) MOD 20 = 0 THEN print( ( newline ) ) FI            FI        FI    OD;    print( ( newline, "Found ", whole( additive count, 0 ), " additive primes below ", whole( UPB prime + 1, 0 ), newline ) )END`
Output:
```   2   3   5   7  11  23  29  41  43  47  61  67  83  89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449 461 463 467 487
Found 54 additive primes below 500
```

## ALGOL W

`begin % find some additive primes - primes whose digit sum is also prime %    % sets p( 1 :: n ) to a sieve of primes up to n %    procedure Eratosthenes ( logical array p( * ) ; integer value n ) ;    begin        p( 1 ) := false; p( 2 ) := true;        for i := 3 step 2 until n do p( i ) := true;        for i := 4 step 2 until n do p( i ) := false;        for i := 3 step 2 until truncate( sqrt( n ) ) do begin            integer ii; ii := i + i;            if p( i ) then for pr := i * i step ii until n do p( pr ) := false        end for_i ;    end Eratosthenes ;    integer MAX_NUMBER;    MAX_NUMBER := 500;    begin        logical array prime( 1 :: MAX_NUMBER );        integer       aCount;        % sieve the primes to MAX_NUMBER %        Eratosthenes( prime, MAX_NUMBER );        % find the primes that are additive primes %        aCount := 0;        for i := 1 until MAX_NUMBER - 1 do begin            if prime( i ) then begin                integer dSum, v;                v    := i;                dSum := 0;                while v > 0 do begin                    dSum := dSum + v rem 10;                    v    := v div 10                end while_v_gt_0 ;                if prime( dSum ) then begin                    writeon( i_w := 4, s_w := 0, " ", i );                    aCount := aCount + 1;                    if aCount rem 20 = 0 then write()                end if_prime_dSum            end if_prime_i        end for_i ;        write( i_w := 1, s_w := 0, "Found ", aCount, " additive primes below ", MAX_NUMBER )    endend.`
Output:
```    2    3    5    7   11   23   29   41   43   47   61   67   83   89  101  113  131  137  139  151
157  173  179  191  193  197  199  223  227  229  241  263  269  281  283  311  313  317  331  337
353  359  373  379  397  401  409  421  443  449  461  463  467  487
Found 54 additive primes below 500
```

## APL

`((+⌿(4/10)⊤P)∊P)/P←(~P∊P∘.×P)/P←1↓⍳500`
Output:
```2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283
311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487```

## AppleScript

`on sieveOfEratosthenes(limit)    script o        property numberList : {missing value}    end script     repeat with n from 2 to limit        set end of o's numberList to n    end repeat     repeat with n from 2 to (limit ^ 0.5) div 1        if (item n of o's numberList is n) then            repeat with multiple from n * n to limit by n                set item multiple of o's numberList to missing value            end repeat        end if    end repeat     return o's numberList's numbersend sieveOfEratosthenes on sumOfDigits(n) -- n assumed to be a positive decimal integer.    set sum to n mod 10    set n to n div 10    repeat until (n = 0)        set sum to sum + n mod 10        set n to n div 10    end repeat     return sumend sumOfDigits on additivePrimes(limit)    script o        property primes : sieveOfEratosthenes(limit)        property additives : {}    end script     repeat with p in o's primes        if (sumOfDigits(p) is in o's primes) then set end of o's additives to p's contents    end repeat     return o's additivesend additivePrimes -- Task code:tell additivePrimes(499) to return {|additivePrimes<500|:it, numberThereof:count}`
Output:
`{|additivePrimes<500|:{2, 3, 5, 7, 11, 23, 29, 41, 43, 47, 61, 67, 83, 89, 101, 113, 131, 137, 139, 151, 157, 173, 179, 191, 193, 197, 199, 223, 227, 229, 241, 263, 269, 281, 283, 311, 313, 317, 331, 337, 353, 359, 373, 379, 397, 401, 409, 421, 443, 449, 461, 463, 467, 487}, numberThereof:54}`

## Arturo

`additives: select 2..500 'x -> and? prime? x prime? sum digits x loop split.every:10 additives 'a ->    print map a => [pad to :string & 4] print ["\nFound" size additives "additive primes up to 500"]`
Output:
```   2    3    5    7   11   23   29   41   43   47
61   67   83   89  101  113  131  137  139  151
157  173  179  191  193  197  199  223  227  229
241  263  269  281  283  311  313  317  331  337
353  359  373  379  397  401  409  421  443  449
461  463  467  487

Found 54 additive primes up to 500```

## AWK

` # syntax: GAWK -f ADDITIVE_PRIMES.AWKBEGIN {    start = 1    stop = 500    for (i=start; i<=stop; i++) {      if (is_prime(i) && is_prime(sum_digits(i))) {        printf("%4d%1s",i,++count%10?"":"\n")      }    }    printf("\nAdditive primes %d-%d: %d\n",start,stop,count)    exit(0)}function is_prime(x,  i) {    if (x <= 1) {      return(0)    }    for (i=2; i<=int(sqrt(x)); i++) {      if (x % i == 0) {        return(0)      }    }    return(1)}function sum_digits(n,  i,sum) {    for (i=1; i<=length(n); i++) {      sum += substr(n,i,1)    }    return(sum)} `
Output:
```   2    3    5    7   11   23   29   41   43   47
61   67   83   89  101  113  131  137  139  151
157  173  179  191  193  197  199  223  227  229
241  263  269  281  283  311  313  317  331  337
353  359  373  379  397  401  409  421  443  449
461  463  467  487
```

## BASIC

`10 DEFINT A-Z: E=50020 DIM P(E): P(0)=-1: P(1)=-130 FOR I=2 TO SQR(E)40 IF NOT P(I) THEN FOR J=I*2 TO E STEP I: P(J)=-1: NEXT50 NEXT60 FOR I=B TO E: IF P(I) GOTO 10070 J=I: S=080 IF J>0 THEN S=S+J MOD 10: J=J\10: GOTO 8090 IF NOT P(S) THEN N=N+1: PRINT I,100 NEXT110 PRINT: PRINT N;" additive primes found below ";E`
Output:
``` 2             3             5             7             11
23            29            41            43            47
61            67            83            89            101
113           131           137           139           151
157           173           179           191           193
197           199           223           227           229
241           263           269           281           283
311           313           317           331           337
353           359           373           379           397
401           409           421           443           449
461           463           467           487
54  additive primes found below  500```

## BCPL

`get "libhdr"manifest \$( limit = 500 \$)  let dsum(n) =     n=0 -> 0,    dsum(n/10) + n rem 10 let sieve(prime, n) be\$(  0!prime := false    1!prime := false    for i=2 to n do i!prime := true    for i=2 to n/2        if i!prime         \$(  let j=i+i            while j<=n            \$(  j!prime := false                j := j+i            \$)        \$)\$) let additive(prime, n) = n!prime & dsum(n)!prime let start() be\$(  let prime = vec limit    let num = 0    sieve(prime, limit)    for i=2 to limit        if additive(prime,i)        \$(  writed(i,5)            num := num + 1            if num rem 10 = 0 then wrch('*N')        \$)    writef("*N*NFound %N additive primes < %N.*N", num, limit)\$)`
Output:
```    2    3    5    7   11   23   29   41   43   47
61   67   83   89  101  113  131  137  139  151
157  173  179  191  193  197  199  223  227  229
241  263  269  281  283  311  313  317  331  337
353  359  373  379  397  401  409  421  443  449
461  463  467  487

Found 54 additive primes < 500.```

## C++

`#include <iomanip>#include <iostream> bool is_prime(unsigned int n) {    if (n < 2)        return false;    if (n % 2 == 0)        return n == 2;    if (n % 3 == 0)        return n == 3;    for (unsigned int p = 5; p * p <= n; p += 4) {        if (n % p == 0)            return false;        p += 2;        if (n % p == 0)            return false;    }    return true;} unsigned int digit_sum(unsigned int n) {    unsigned int sum = 0;    for (; n > 0; n /= 10)        sum += n % 10;    return sum;} int main() {    const unsigned int limit = 500;    std::cout << "Additive primes less than " << limit << ":\n";    unsigned int count = 0;    for (unsigned int n = 1; n < limit; ++n) {        if (is_prime(digit_sum(n)) && is_prime(n)) {            std::cout << std::setw(3) << n;            if (++count % 10 == 0)                std::cout << '\n';            else                std::cout << ' ';        }    }    std::cout << '\n' << count << " additive primes found.\n";}`
Output:
```Additive primes less than 500:
2   3   5   7  11  23  29  41  43  47
61  67  83  89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229
241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449
461 463 467 487
```

## Common Lisp

` (defun sum-of-digits (n) "Return the sum of the digits of a number"  (do* ((sum 0 (+ sum rem))        rem )       ((zerop n) sum)    (multiple-value-setq (n rem) (floor n 10)) )) (defun additive-primep (n)  (and (primep n) (primep (sum-of-digits n))) )  ; To test if a number is prime we can use a number of different methods. Here I use Wilson's Theorem (see Primality by Wilson's theorem): (defun primep (n)  (unless (zerop n)    (zerop (mod (1+ (factorial (1- n))) n)) )) (defun factorial (n)  (if (< n 2) 1 (* n (factorial (1- n)))) )   `
Output:
```(dotimes (i 500) (when (additive-primep i) (princ i) (princ " ")))
1 2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487

```

## F#

This task uses Extensible Prime Generator (F#)

` // Additive Primes. Nigel Galloway: March 22nd., 2021let rec fN g=function n when n<10->n+g |n->fN(g+n%10)(n/10)primes32()|>Seq.takeWhile((>)500)|>Seq.filter(fN 0>>isPrime)|>Seq.iter(printf "%d "); printfn "" `
Output:
```2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487
```

## Factor

Works with: Factor version 0.99 2021-02-05
`USING: formatting grouping io kernel math math.primesprettyprint sequences ; : sum-digits ( n -- sum )    0 swap [ 10 /mod rot + swap ] until-zero ; 499 primes-upto [ sum-digits prime? ] filter[ 9 group simple-table. nl ][ length "Found  %d  additive primes  <  500.\n" printf ] bi`
Output:
```2   3   5   7   11  23  29  41  43
47  61  67  83  89  101 113 131 137
139 151 157 173 179 191 193 197 199
223 227 229 241 263 269 281 283 311
313 317 331 337 353 359 373 379 397
401 409 421 443 449 461 463 467 487

Found  54  additive primes  <  500.
```

## Forth

Works with: Gforth
`: prime? ( n -- ? ) here + [email protected] 0= ;: notprime! ( n -- ) here + 1 swap c! ; : prime_sieve ( n -- )  here over erase  0 notprime!  1 notprime!  2  begin    2dup dup * >  while    dup prime? if      2dup dup * do        i notprime!      dup +loop    then    1+  repeat  2drop ; : digit_sum ( u -- u )  dup 10 < if exit then  10 /mod recurse + ; : print_additive_primes ( n -- )  ." Additive primes less than " dup 1 .r ." :" cr  dup prime_sieve  0 swap  1 do    i prime? if      i digit_sum prime? if        i 3 .r        1+ dup 10 mod 0= if cr else space then      then    then  loop  cr . ." additive primes found." cr ; 500 print_additive_primesbye`
Output:
```Additive primes less than 500:
2   3   5   7  11  23  29  41  43  47
61  67  83  89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229
241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449
461 463 467 487
```

## FreeBASIC

As with the other special primes tasks, use one of the primality testing algorithms as an include.

`#include "isprime.bas" function digsum( n as uinteger ) as uinteger    dim as uinteger s    while n        s+=n mod 10        n\=10    wend    return send function dim as uinteger s print "Prime","Digit Sum"for i as uinteger = 2 to 499    if isprime(i) then        s = digsum(i)        if isprime(s) then            print i, s        end if    end ifnext i`
Output:
```Prime         Digit Sum
2             2
3             3
5             5
7             7
11            2
23            5
29            11
41            5
43            7
47            11
61            7
67            13
83            11
89            17
101           2
113           5
131           5
137           11
139           13
151           7
157           13
173           11
179           17
191           11
193           13
197           17
199           19
223           7
227           11
229           13
241           7
263           11
269           17
281           11
283           13
311           5
313           7
317           11
331           7
337           13
353           11
359           17
373           13
379           19
397           19
401           5
409           13
421           7
443           11
449           17
461           11
463           13
467           17
487           19```

## Go

`package main import "fmt" func isPrime(n int) bool {    switch {    case n < 2:        return false    case n%2 == 0:        return n == 2    case n%3 == 0:        return n == 3    default:        d := 5        for d*d <= n {            if n%d == 0 {                return false            }            d += 2            if n%d == 0 {                return false            }            d += 4        }        return true    }} func sumDigits(n int) int {    sum := 0    for n > 0 {        sum += n % 10        n /= 10    }    return sum} func main() {    fmt.Println("Additive primes less than 500:")    i := 2    count := 0    for {        if isPrime(i) && isPrime(sumDigits(i)) {            count++            fmt.Printf("%3d  ", i)            if count%10 == 0 {                fmt.Println()            }        }        if i > 2 {            i += 2        } else {            i++        }        if i > 499 {            break        }    }    fmt.Printf("\n\n%d additive primes found.\n", count)}`
Output:
```Additive primes less than 500:
2    3    5    7   11   23   29   41   43   47
61   67   83   89  101  113  131  137  139  151
157  173  179  191  193  197  199  223  227  229
241  263  269  281  283  311  313  317  331  337
353  359  373  379  397  401  409  421  443  449
461  463  467  487

```

## Java

`public class additivePrimes {     public static void main(String[] args) {        int additive_primes = 0;        for (int i = 2; i < 500; i++) {            if(isPrime(i) && isPrime(digitSum(i))){                additive_primes++;                System.out.print(i + " ");            }        }        System.out.print("\nFound " + additive_primes + " additive primes less than 500");    }     static boolean isPrime(int n) {        int counter = 1;        if (n < 2 || (n != 2 && n % 2 == 0) || (n != 3 && n % 3 == 0)) {            return false;        }        while (counter * 6 - 1 <= Math.sqrt(n)) {            if (n % (counter * 6 - 1) == 0 || n % (counter * 6 + 1) == 0) {                return false;            } else {                counter++;            }        }        return true;    }     static int digitSum(int n) {        int sum = 0;        while (n > 0) {            sum += n % 10;            n /= 10;        }        return sum;    }} `
Output:
```2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487
Found 54 additive primes less than 500```

## jq

Works with: jq

Works with gojq, the Go implementation of jq

Preliminaries

`def is_prime:  . as \$n  | if (\$n < 2)         then false    elif (\$n % 2 == 0)  then \$n == 2    elif (\$n % 3 == 0)  then \$n == 3    elif (\$n % 5 == 0)  then \$n == 5    elif (\$n % 7 == 0)  then \$n == 7    elif (\$n % 11 == 0) then \$n == 11    elif (\$n % 13 == 0) then \$n == 13    elif (\$n % 17 == 0) then \$n == 17    elif (\$n % 19 == 0) then \$n == 19    else {i:23}    | until( (.i * .i) > \$n or (\$n % .i == 0); .i += 2)    | .i * .i > \$n    end; # Emit an array of primes less than `.`def primes:  if . < 2 then []  else [2] + [range(3; .; 2) | select(is_prime)]  end; def add(s): reduce s as \$x (null; . + \$x); def sumdigits: add(tostring | explode[] | [.] | implode | tonumber); # Pretty-printingdef nwise(\$n):  def n: if length <= \$n then . else .[0:\$n] , (.[\$n:] | n) end;  n; def lpad(\$len): tostring | (\$len - length) as \$l | (" " * \$l)[:\$l] + .; `

` # Input: a number n# Output: an array of additive primes less than ndef additive_primes:  primes  | . as \$primes  | reduce .[] as \$p (null;      ( \$p | sumdigits ) as \$sum      | if ((\$primes | bsearch(\$sum)) > -1)        then . + [\$p]        else .        end ); "Erdős primes under 500:",(500 | additive_primes | ((nwise(10) | map(lpad(4)) | join(" ")),   "\n\(length) additive primes found.")) `
Output:
```Erdős primes under 500:
2    3    5    7   11   23   29   41   43   47
61   67   83   89  101  113  131  137  139  151
157  173  179  191  193  197  199  223  227  229
241  263  269  281  283  311  313  317  331  337
353  359  373  379  397  401  409  421  443  449
461  463  467  487

```

## Julia

`using Primes let    p = primesmask(500)    println("Additive primes under 500:")    pcount = 0    for i in 2:499        if p[i] && p[sum(digits(i))]            pcount += 1            print(lpad(i, 4), pcount % 20 == 0 ? "\n" : "")        end    end    println("\n\n\$pcount additive primes found.")end `
Output:
```Erdős primes under 500:
2   3   5   7  11  23  29  41  43  47  61  67  83  89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449 461 463 467 487

```

## Lua

This task uses `primegen` from: Extensible_prime_generator#Lua

`function sumdigits(n)  local sum = 0  while n > 0 do    sum = sum + n % 10    n = math.floor(n/10)  end  return sumend primegen:generate(nil, 500)aprimes = primegen:filter(function(n) return primegen.tbd(sumdigits(n)) end)print(table.concat(aprimes, " "))print("Count:", #aprimes)`
Output:
```2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487
Count:  54```

## Mathematica/Wolfram Language

`ClearAll[AdditivePrimeQ]AdditivePrimeQ[n_Integer] := PrimeQ[n] \[And] PrimeQ[Total[IntegerDigits[n]]]Select[Range[500], AdditivePrimeQ]`
Output:
`{2,3,5,7,11,23,29,41,43,47,61,67,83,89,101,113,131,137,139,151,157,173,179,191,193,197,199,223,227,229,241,263,269,281,283,311,313,317,331,337,353,359,373,379,397,401,409,421,443,449,461,463,467,487}`

## Nim

`import math, strutils const N = 499 # Sieve of Erathostenes.var composite: array[2..N, bool]  # Initialized to false, ie. prime. for n in 2..sqrt(N.toFloat).int:  if not composite[n]:    for k in countup(n * n, N, n):      composite[k] = true  func digitSum(n: Positive): Natural =  ## Compute sum of digits.  var n = n.int  while n != 0:    result += n mod 10    n = n div 10  echo "Additive primes less than 500:"var count = 0for n in 2..N:  if not composite[n] and not composite[digitSum(n)]:    inc count    stdout.write (\$n).align(3)    stdout.write if count mod 10 == 0: '\n' else: ' 'echo() echo "\nNumber of additive primes found: ", count`
Output:
```Additive primes less than 500:
2   3   5   7  11  23  29  41  43  47
61  67  83  89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229
241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449
461 463 467 487

Number of additive primes found: 54```

## Pari/GP

This is a good task for demonstrating several different ways to approach a simple problem.

`hasPrimeDigitsum(n)=isprime(sumdigits(n)); \\ see A028834 in the OEIS v1 = select(isprime, select(hasPrimeDigitsum, [1..499]));v2 = select(hasPrimeDigitsum, select(isprime, [1..499]));v3 = select(hasPrimeDigitsum, primes([1, 499])); s=0; forprime(p=2,499, if(hasPrimeDigitsum(p), s++)); s;[#v1, #v2, #v3, s]`
Output:
`%1 = [54, 54, 54, 54]`

## Perl

Library: ntheory
`use strict;use warnings;use ntheory 'is_prime';use List::Util <sum max>; sub pp {    my \$format = ('%' . (my \$cw = 1+length max @_) . 'd') x @_;    my \$width  = ".{@{[\$cw * int 60/\$cw]}}";    (sprintf(\$format, @_)) =~ s/(\$width)/\$1\n/gr;} my(\$limit, @ap) = 500;is_prime(\$_) and is_prime(sum(split '',\$_)) and push @ap, \$_ for 1..\$limit; print @ap . " additive primes < \$limit:\n" . pp(@ap);`
Output:
```54 additive primes < 500:
2   3   5   7  11  23  29  41  43  47  61  67  83  89 101
113 131 137 139 151 157 173 179 191 193 197 199 223 227 229
241 263 269 281 283 311 313 317 331 337 353 359 373 379 397
401 409 421 443 449 461 463 467 487```

## Phix

```function additive(integer p) return is_prime(sum(sq_sub(sprint(p),'0'))) end function
string r = join(shorten(apply(res,sprint),"",6))
```
Output:
```54 additive primes found: 2 3 5 7 11 23 ... 443 449 461 463 467 487
```

## PL/M

`100H: /* FIND ADDITIVE PRIMES - PRIMES WHOSE DIGIT SUM IS ALSO PRIME */     DECLARE CR LITERALLY '0DH';    DECLARE LF LITERALLY '0AH';     BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */       DECLARE FN BYTE, ARG ADDRESS;       GOTO 5;    END BDOS;    PRINT\$CHAR:   PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;    PRINT\$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;    PRINT\$NL:     PROCEDURE; CALL PRINT\$STRING( .( CR, LF, '\$' ) ); END;    PRINT\$NUMBER: PROCEDURE( N, WIDTH );       DECLARE N ADDRESS, WIDTH BYTE;       DECLARE V ADDRESS, N\$STR( 6 ) BYTE, ( N\$POS, W ) BYTE;       V = N; W = WIDTH + 1;       N\$STR( W ) = '\$';       N\$STR( W := W - 1 ) = '0' + ( V MOD 10 );       DO WHILE( W > 0 );          W = W - 1;          V = V / 10;          IF V = 0 THEN N\$STR( W ) = ' ';                   ELSE N\$STR( W ) = '0' + ( V MOD 10 );       END;       CALL PRINT\$STRING( .N\$STR( W + 1 ) );    END PRINT\$NUMBER;     DECLARE MAX\$PRIME LITERALLY '501';    DECLARE FALSE     LITERALLY '0';    DECLARE TRUE      LITERALLY '1';    DECLARE PRIME( MAX\$PRIME ) BYTE; /* ELEMENT 0 IS UNUSED */    DECLARE ( A\$COUNT, I, J ) ADDRESS;    /* SIEVE THE PRIMES UP TO MAX\$PRIME */    PRIME( 1 ) = FALSE; PRIME( 2 ) = TRUE;    DO I = 3 TO LAST( PRIME ) BY 2; PRIME( I ) = TRUE;  END;    DO I = 4 TO LAST( PRIME ) BY 2; PRIME( I ) = FALSE; END;    DO I = 3 TO LAST( PRIME ) / 2 BY 2;       IF PRIME( I ) THEN DO;          DO J = I * I TO LAST( PRIME ) BY I; PRIME( J ) = FALSE; END;       END;    END;    /* FIND THE PRIMES THAT ARE ADDATIVE PRIMES */    A\$COUNT = 0;    DO I = 1 TO LAST( PRIME );       IF PRIME( I ) THEN DO;          DECLARE D\$SUM BYTE, V ADDRESS;          V     = I;          D\$SUM = 0;          DO WHILE V > 0;             D\$SUM = D\$SUM + ( V MOD 10 );             V     = V / 10;          END;          IF PRIME( D\$SUM ) THEN DO;             CALL PRINT\$NUMBER( I, 4 );             A\$COUNT = A\$COUNT + 1;             IF A\$COUNT MOD 12 = 0 THEN CALL PRINT\$NL;          END;       END;    END;    CALL PRINT\$NL;    CALL PRINT\$NUMBER( A\$COUNT, 4 );    CALL PRINT\$STRING( .' ADDITIVE PRIMES FOUND BELOW\$' );    CALL PRINT\$NUMBER( LAST( PRIME ), 4 );    CALL PRINT\$NL;EOF `
Output:
```   2   3   5   7  11  23  29  41  43  47  61  67
83  89 101 113 131 137 139 151 157 173 179 191
193 197 199 223 227 229 241 263 269 281 283 311
313 317 331 337 353 359 373 379 397 401 409 421
443 449 461 463 467 487
54 ADDITIVE PRIMES FOUND BELOW 500
```

## Processing

`IntList primes = new IntList(); void setup() {  sieve(500);  int count = 0;  for (int i = 2; i < 500; i++) {    if (primes.hasValue(i) && primes.hasValue(sumDigits(i))) {      print(i + " ");      count++;    }  }  println();  print("Number of additive primes less than 500: " + count);} int sumDigits(int n) {  int sum = 0;  for (int i = 0; i <= floor(log(n) / log(10)); i++) {    sum += floor(n / pow(10, i)) % 10;  }  return sum;} void sieve(int max) {  for (int i = 2; i <= max; i++) {    primes.append(i);  }  for (int i = 0; i < primes.size(); i++) {    for (int j = i + 1; j < primes.size(); j++) {      if (primes.get(j) % primes.get(i) == 0) {        primes.remove(j);        j--;      }    }  }}`
Output:
```2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487
Number of additive primes less than 500: 54```

## PureBasic

`#MAX=500Global Dim P.b(#MAX) : FillMemory(@P(),#MAX,1,#PB_Byte)If OpenConsole()=0 : End 1 : EndIfFor n=2 To Sqr(#MAX)+1 : If P(n) : m=n*n : While m<=#MAX : P(m)=0 : m+n : Wend : EndIf : Next Procedure.i qsum(v.i)  While v : qs+v%10 : v/10 : Wend  ProcedureReturn qsEndProcedure For i=2 To #MAX  If P(i) And P(qsum(i)) : c+1 : Print(RSet(Str(i),5)) : If c%10=0 : PrintN("") : EndIf : EndIfNextPrintN(~"\n\n"+Str(c)+" additive primes below 500.")Input()`
Output:
```    2    3    5    7   11   23   29   41   43   47
61   67   83   89  101  113  131  137  139  151
157  173  179  191  193  197  199  223  227  229
241  263  269  281  283  311  313  317  331  337
353  359  373  379  397  401  409  421  443  449
461  463  467  487

## Python

`def is_prime(n: int) -> bool:    if n <= 3:        return n > 1    if n % 2 == 0 or n % 3 == 0:        return False    i = 5    while i ** 2 <= n:        if n % i == 0 or n % (i + 2) == 0:            return False        i += 6    return True def digit_sum(n: int) -> int:    sum = 0    while n > 0:        sum += n % 10        n //= 10    return sum def main() -> None:    additive_primes = 0    for i in range(2, 500):        if is_prime(i) and is_prime(digit_sum(i)):            additive_primes += 1            print(i, end=" ")    print(f"\nFound {additive_primes} additive primes less than 500") if __name__ == "__main__":    main()`
Output:
```2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487
Found 54 additive primes less than 500```

## Quackery

`eratosthenes` and `isprime` are defined at Sieve of Eratosthenes#Quackery.

`digitsum` is defined at Sum digits of an integer#Quackery.

`  500 eratosthenes   []  500 times    [ i^ isprime if        [ i^ 10 digitsum           isprime if            [ i^ join ] ] ]   dup echo cr cr  size echo say " additive primes found."`
Output:
```[ 2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487 ]

## Raku

`unit sub MAIN (\$limit = 500);say "{+\$_} additive primes < \$limit:\n{\$_».fmt("%" ~ \$limit.chars ~ "d").batch(10).join("\n")}",    with ^\$limit .grep: { .is-prime and .comb.sum.is-prime }`
Output:
```54 additive primes < 500:
2   3   5   7  11  23  29  41  43  47
61  67  83  89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229
241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449
461 463 467 487```

## REXX

`/*REXX program counts/displays the number of additive primes under a specified number N.*/parse arg n cols .                               /*get optional number of primes to find*/if    n=='' |    n==","  then    n= 500          /*Not specified?   Then assume default.*/if cols=='' | cols==","  then cols=  10          /* "      "          "     "       "   */call genP n                                      /*generate all primes under  N.        */w= 10                                            /*width of a number in any column.     */                                     title= " additive primes that are  < "     commas(n)if cols>0  then say ' index │'center(title,  1 + cols*(w+1) )if cols>0  then say '───────┼'center(""   ,  1 + cols*(w+1), '─')found= 0;                  idx= 1                /*initialize # of additive primes & IDX*/\$=                                               /*a list of additive primes  (so far). */       do j=1  for #;      p= @.j                /*obtain the  Jth  prime.              */       _= sumDigs(p);      if \!._  then iterate /*is sum of J's digs a prime? No, skip.*/       /* ◄■■■■■■■■ a filter. */       found= found + 1                          /*bump the count of additive primes.   */       if cols<0                    then iterate /*Build the list  (to be shown later)? */       c= commas(p)                              /*maybe add commas to the number.      */       \$= \$  right(c, max(w, length(c) ) )       /*add additive prime──►list, allow big#*/       if found//cols\==0           then iterate /*have we populated a line of output?  */       say center(idx, 7)'│'  substr(\$, 2);  \$=  /*display what we have so far  (cols). */       idx= idx + cols                           /*bump the  index  count for the output*/       end   /*j*/ if \$\==''  then say center(idx, 7)"│"  substr(\$, 2)  /*possible display residual output.*/if cols>0  then say '───────┴'center(""   ,  1 + cols*(w+1), '─')saysay 'found '      commas(found)      titleexit 0                                           /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/commas:  parse arg ?; do jc=length(?)-3  to 1  by -3; ?=insert(',', ?, jc); end;  return ?sumDigs: parse arg x 1 s 2;  do k=2  for length(x)-1; s= s + substr(x,k,1); end;  return s/*──────────────────────────────────────────────────────────────────────────────────────*/genP: parse arg n;           @.1= 2;  @.2= 3;  @.3= 5;  @.4= 7;  @.5= 11;  @.6= 13                    !.= 0;   !.2= 1;  !.3= 1;  !.5= 1;  !.7= 1;  !.11= 1;  !.13= 1                           #= 6;  sq.#= @.# ** 2 /*the number of primes;  prime squared.*/        do [email protected].#+2  by 2  for max(0, n%[email protected].#%2-1)       /*find odd primes from here on. */        parse var  j   ''  -1  _                 /*obtain the last digit of the  J  var.*/        if     _==5  then iterate;  if j// 3==0  then iterate  /*J ÷ by 5?   J ÷ by  3? */        if j// 7==0  then iterate;  if j//11==0  then iterate  /*" "  " 7?   " "  " 11? */                                                 /* [↓]  divide by the primes.   ___    */              do k=6  while sq.k<=j              /*divide  J  by other primes ≤ √ J     */              if j//@.k==0  then iterate j       /*÷ by prev. prime?  ¬prime     ___    */              end   /*k*/                        /* [↑]   only divide up to     √ J     */        #= # + 1;    @.#= j;  sq.#= j*j;  !.j= 1 /*bump prime count; assign prime & flag*/        end   /*j*/;                      return`
output   when using the default inputs:
``` index │                                        additive primes that are  <  500
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
1   │          2          3          5          7         11         23         29         41         43         47
11   │         61         67         83         89        101        113        131        137        139        151
21   │        157        173        179        191        193        197        199        223        227        229
31   │        241        263        269        281        283        311        313        317        331        337
41   │        353        359        373        379        397        401        409        421        443        449
51   │        461        463        467        487
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────

found  54  additive primes that are  <  500
```

## Ring

` load "stdlib.ring" see "working..." + nlsee "Additive primes are:" + nl row = 0limit = 500 for n = 1 to limit    num = 0    if isprime(n)        strn = string(n)       for m = 1 to len(strn)           num = num + number(strn[m])       next       if isprime(num)          row = row + 1          see "" + n + " "          if row%10 = 0             see nl          ok       ok    oknext see nl + "found " + row + " additive primes." + nlsee "done..." + nl `
Output:
```working...
2 3 5 7 11 23 29 41 43 47
61 67 83 89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229
241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449
461 463 467 487
done...
```

## Ruby

`require "prime" additive_primes = Enumerator.new do |y|  Prime.each {|prime| y << prime if prime.digits.sum.prime?}end N = 500res = additive_primes.take_while{|n| n < N}.to_aputs res.join(" ")puts "\n#{res.size} additive primes below #{N}." `
Output:
```2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151 157 173 179 191 193 197 199 223 227 229 241 263 269 281 283 311 313 317 331 337 353 359 373 379 397 401 409 421 443 449 461 463 467 487

```

## Seed7

`\$ include "seed7_05.s7i"; const func boolean: isPrime (in integer: number) is func  result    var boolean: prime is FALSE;  local    var integer: upTo is 0;    var integer: testNum is 3;  begin    if number = 2 then      prime := TRUE;    elsif odd(number) and number > 2 then      upTo := sqrt(number);      while number rem testNum <> 0 and testNum <= upTo do        testNum +:= 2;      end while;      prime := testNum > upTo;    end if;  end func; const func integer: digitSum (in var integer: number) is func  result    var integer: sum is 0;  begin    while number > 0 do      sum +:= number rem 10;      number := number div 10;    end while;  end func; const proc: main is func  local    var integer: n is 0;    var integer: count is 0;  begin    for n range 2 to 499 do      if isPrime(n) and isPrime(digitSum(n)) then        write(n lpad 3 <& " ");        incr(count);        if count rem 9 = 0 then          writeln;        end if;      end if;    end for;    writeln("\nFound " <& count <& " additive primes < 500.");  end func;`
Output:
```  2   3   5   7  11  23  29  41  43
47  61  67  83  89 101 113 131 137
139 151 157 173 179 191 193 197 199
223 227 229 241 263 269 281 283 311
313 317 331 337 353 359 373 379 397
401 409 421 443 449 461 463 467 487

Found 54 additive primes < 500.
```

## Sidef

`func additive_primes(upto, base = 10) {    upto.primes.grep { .sumdigits(base).is_prime }} additive_primes(500).each_slice(10, {|*a|    a.map { '%3s' % _ }.join(' ').say})`
Output:
```  2   3   5   7  11  23  29  41  43  47
61  67  83  89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229
241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449
461 463 467 487
```

## Swift

`import Foundation func isPrime(_ n: Int) -> Bool {    if n < 2 {        return false    }    if n % 2 == 0 {        return n == 2    }    if n % 3 == 0 {        return n == 3    }    var p = 5    while p * p <= n {        if n % p == 0 {            return false        }        p += 2        if n % p == 0 {            return false        }        p += 4    }    return true} func digitSum(_ num: Int) -> Int {    var sum = 0    var n = num    while n > 0 {        sum += n % 10        n /= 10    }    return sum} let limit = 500print("Additive primes less than \(limit):")var count = 0for n in 1..<limit {    if isPrime(digitSum(n)) && isPrime(n) {        count += 1        print(String(format: "%3d", n), terminator: count % 10 == 0 ? "\n" : " ")    }}print("\n\(count) additive primes found.")`
Output:
```Additive primes less than 500:
2   3   5   7  11  23  29  41  43  47
61  67  83  89 101 113 131 137 139 151
157 173 179 191 193 197 199 223 227 229
241 263 269 281 283 311 313 317 331 337
353 359 373 379 397 401 409 421 443 449
461 463 467 487
```

## Wren

Library: Wren-math
Library: Wren-fmt
`import "/math" for Intimport "/fmt" for Fmt var sumDigits = Fn.new { |n|    var sum = 0    while (n > 0) {        sum = sum + (n % 10)        n = (n/10).floor    }    return sum} System.print("Additive primes less than 500:")var primes = Int.primeSieve(499)var count = 0for (p in primes) {    if (Int.isPrime(sumDigits.call(p))) {        count = count + 1        Fmt.write("\$3d  ", p)        if (count % 10 == 0) System.print()    }}System.print("\n\n%(count) additive primes found.")`
Output:
```Additive primes less than 500:
2    3    5    7   11   23   29   41   43   47
61   67   83   89  101  113  131  137  139  151
157  173  179  191  193  197  199  223  227  229
241  263  269  281  283  311  313  317  331  337
353  359  373  379  397  401  409  421  443  449
461  463  467  487

```

## XPL0

`func IsPrime(N);        \Return 'true' if N is a prime numberint  N, I;[if N <= 1 then return false;for I:= 2 to sqrt(N) do    if rem(N/I) = 0 then return false;return true;]; func SumDigits(N);      \Return the sum of the digits in Nint     N, Sum;[Sum:= 0;repeat  N:= N/10;        Sum:= Sum + rem(0);until   N=0;return Sum;]; int Count, N;[Count:= 0;for N:= 0 to 500-1 do    if IsPrime(N) & IsPrime(SumDigits(N)) then        [IntOut(0, N);        Count:= Count+1;        if rem(Count/10) = 0 then CrLf(0) else ChOut(0, 9\tab\);        ];CrLf(0);IntOut(0, Count);Text(0, " additive primes found below 500.");]`
Output:
```2       3       5       7       11      23      29      41      43      47
61      67      83      89      101     113     131     137     139     151
157     173     179     191     193     197     199     223     227     229
241     263     269     281     283     311     313     317     331     337
353     359     373     379     397     401     409     421     443     449
461     463     467     487
54 additive primes found below 500.
```