Additive primes: Difference between revisions

{{trans|Python}}

I a == 2

R 1B

additive_primes++

print(i, end' ‘ ’)

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */

/* program additivePrime64.s */

.include "../includeARM64.inc"

<pre>

Prime : 2

</pre>

=={{header|Ada}}==

procedure Additive_Primes is

Put (" additive primes.");

New_Line;

{{out}}

<pre>Additive primes <500:

=={{header|ALGOL 68}}==

{{libheader|ALGOL 68-primes}}

# sieve the primes to max prime #

PR read "primes.incl.a68" PR

OD;

print( ( newline, "Found ", whole( additive count, 0 ), " additive primes below ", whole( UPB prime + 1, 0 ), newline ) )

{{out}}

<pre>

=={{header|ALGOL W}}==

% sets p( 1 :: n ) to a sieve of primes up to n %

procedure Eratosthenes ( logical array p( * ) ; integer value n ) ;

write( i_w := 1, s_w := 0, "Found ", aCount, " additive primes below ", MAX_NUMBER )

end

{{out}}

<pre>

=={{header|APL}}==

{{out}}

=={{header|AppleScript}}==

script o

property numberList : {missing value}

-- Task code:

{{output}}

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI */

/* program additivePrime.s */

.include "../affichage.inc"

<pre>

Prime : 2

=={{header|Arturo}}==

loop split.every:10 additives 'a ->

print map a => [pad to :string & 4]

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f ADDITIVE_PRIMES.AWK

BEGIN {

return(sum)

}

{{out}}

<pre>

=={{header|BASIC}}==

20 DIM P(E): P(0)=-1: P(1)=-1

30 FOR I=2 TO SQR(E)

90 IF NOT P(S) THEN N=N+1: PRINT I,

100 NEXT

{{out}}

<pre> 2 3 5 7 11

54 additive primes found below 500</pre>

==={{header|Applesoft BASIC}}===

1 F = E - 1:L = LEN ( STR$ (F)) + 1: FOR I = 2 TO L:S$ = S$ + CHR$ (32): NEXT I: DIM P(E):P(0) = - 1:P(1) = - 1: FOR I = 2 TO SQR (F): IF NOT P(I) THEN FOR J = I * 2 TO E STEP I:P(J) = - 1: NEXT J

2 NEXT I: FOR I = B TO F: IF NOT P(I) THEN GOSUB 4

4 S = 0: IF I THEN FOR J = I TO 0 STEP 0:J1 = INT (J / 10):S = S + (J - J1 * 10):J = J1: NEXT J

5 IF NOT P(S) THEN N = N + 1: PRINT RIGHT$ (S$ + STR$ (I),L);

<pre>

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

=={{header|BASIC256}}==

for i = 2 to 499

if isprime(i) then

end while

return s

=={{header|BCPL}}==

manifest $( limit = 500 $)

$)

writef("*N*NFound %N additive primes < %N.*N", num, limit)

{{out}}

<pre> 2 3 5 7 11 23 29 41 43 47

=={{header|C}}==

#include <stdbool.h>

#include <stdio.h>

return 0;

}/* main */

{{out}}

<pre>

=={{header|C++}}==

#include <iostream>

}

std::cout << '\n' << count << " additive primes found.\n";

{{out}}

=={{header|CLU}}==

% Returns an array [1..max] marking the primes

sieve = proc (max: int) returns (array[bool])

stream$putl(po, "\nFound " || int$unparse(count) ||

" additive primes < " || int$unparse(max))

{{out}}

<pre> 2 3 5 7 11 23 29 41 43 47

=={{header|COBOL}}==

PROGRAM-ID. ADDITIVE-PRIMES.

SIEVE-INNER-LOOP.

{{out}}

<pre> 2 3 5 7 11 23 29 41 43 47

=={{header|Common Lisp}}==

(defun sum-of-digits (n)

"Return the sum of the digits of a number"

{{out}}<pre>(dotimes (i 500) (when (additive-primep i) (princ i) (princ " ")))

=={{header|Crystal}}==

# Uses P3 Prime Generator (PG) and its Prime Generator Sequence (PGS).

addprimes.each_with_index { |n, idx| printf "%*d ", maxdigits, n; print "\n" if idx % 10 == 9 } # more efficient

puts "\n#{addprimes.size} additive primes below #{nn}."

{{out}}

<pre> 2 3 5 7 11 23 29 41 43 47

=={{header|Draco}}==

word max, p, c;

max := dim(prime,1)-1;

writeln();

writeln("There are ", n, " additive primes below ", MAX)

{{out}}

<pre> 2 3 5 7 11 23 29 41 43 47 61 67 83 89 101 113 131 137 139 151

=={{header|Erlang}}==

main(_) ->

AddPrimes = [N || N <- lists:seq(2,500), isprime(N) andalso isprime(digitsum(N))],

digitsum(0, S) -> S;

digitsum(N, S) -> digitsum(N div 10, S + N rem 10).

{{Out}}

<pre>

=={{header|F_Sharp|F#}}==

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]

// Additive Primes. Nigel Galloway: March 22nd., 2021

let 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 ""

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

prettyprint sequences ;

499 primes-upto [ sum-digits prime? ] filter

[ 9 group simple-table. nl ]

{{out}}

<pre>

=={{header|Fermat}}==

digsum := 0;

while n>0 do

fi od;

{{out}}<pre>

Additive primes below 500 are

=={{header|Forth}}==

{{works with|Gforth}}

: notprime! ( n -- ) here + 1 swap c! ;

500 print_additive_primes

{{out}}

=={{header|FreeBASIC}}==

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

function digsum( n as uinteger ) as uinteger

end if

end if

{{out}}

<pre style="height:16em">Prime Digit Sum

then go through the list, sum digits and check for prime

Program AdditivePrimes;

Const max_number = 500;

writeln(counter,' additive primes found.');

End.

{{out}}

<pre>

=={{header|Frink}}==

println[formatTable[columnize[vals, 10]]]

{{out}}

<pre>

=={{header|Go}}==

import "fmt"

}

fmt.Printf("\n\n%d additive primes found.\n", count)

{{out}}

=={{header|J}}==

=={{header|Java}}==

public static void main(String[] args) {

}

}

{{out}}

'''Preliminaries'''

. as $n

| if ($n < 2) then false

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

'''The task'''

# Input: a number n

# Output: an array of additive primes less than n

| ((nwise(10) | map(lpad(4)) | join(" ")),

"\n\(length) additive primes found."))

{{out}}

<pre>

=={{header|Haskell}}==

Naive solution which doesn't rely on advanced number theoretic libraries.

-- infinite list of primes

-- test for an additive prime

isAdditivePrime n = isPrime n && (isPrime . sum . digits) n

The task

=={{header|Julia}}==

let

println("\n\n$pcount additive primes found.")

end

<pre>

Erdős primes under 500:

=={{header|Kotlin}}==

{{trans|Python}}

if (n <= 3) return n > 1

if (n % 2 == 0 || n % 3 == 0) return false

}

println("\nFound $additivePrimes additive primes less than 500")

{{out}}

<pre>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

=={{header|Ksh}}==

# Prime numbers for which the sum of their decimal digits are also primes

_isprime ${digsum} ; (( $? )) && printf "%4d " ${i}

done

{{out}}

<pre> 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 </pre>

=={{header|langur}}==

{{works with|langur|0.10}}

val .sumDigits = f fold f{+}, s2n toString .i

writeln $"\n\n\.count; additive primes found.\n"

{{out}}

=={{header|Lua}}==

This task uses <code>primegen</code> from: [[Extensible_prime_generator#Lua]]

local sum = 0

while n > 0 do

aprimes = primegen:filter(function(n) return primegen.tbd(sumdigits(n)) end)

print(table.concat(aprimes, " "))

{{out}}

<pre>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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

AdditivePrimeQ[n_Integer] := PrimeQ[n] \[And] PrimeQ[Total[IntegerDigits[n]]]

{{out}}

<pre>{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}</pre>

=={{header|Modula-2}}==

FROM InOut IMPORT WriteString, WriteCard, WriteLn;

WriteString('.');

WriteLn();

{{out}}

<pre> 2 3 5 7 11 23 29 41 43 47

=={{header|Nim}}==

const N = 499

echo()

{{out}}

=={{header|Pari/GP}}==

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

v1 = select(isprime, select(hasPrimeDigitsum, [1..499]));

s=0; forprime(p=2,499, if(hasPrimeDigitsum(p), s++)); s;

{{out}}

<pre>%1 = [54, 54, 54, 54]</pre>

=={{header|Pascal}}==

{{works with|Free Pascal}}{{works with|Delphi}} checking isPrime(sum of digits) before testimg isprime(num) improves speed.<br>Tried to speed up calculation of sum of digits.

{$IFDEF FPC}

{$MODE DELPHI}{$CODEALIGN proc=16}

writeln(cnt, ' additive primes found.');

END.

{{out}}

<pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use ntheory 'is_prime';

is_prime($_) and is_prime(sum(split '',$_)) and push @ap, $_ for 1..$limit;

{{out}}

<pre>54 additive primes < 500:

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">additive</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">)))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">500</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">),</span><span style="color: #000000;">additive</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d additive primes found: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">))})</span>

{{out}}

<pre>

=={{header|Phixmonti}}==

by Galileo, 05/2022 #/

"Additive primes found: " print print

{{out}}

<pre>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 Additive primes found: 54

=={{header|Picat}}==

PCount = 0,

foreach (I in 2..499)

sum_digits(N) = S =>

S = sum([ord(C)-ord('0') : C in to_string(N)]).

{{out}}

=={{header|PicoLisp}}==

(let D 0

(or

(inc 'C) ) )

(prinl)

{{out}}

<pre>

=={{header|PILOT}}==

:c=0

:max=500

:i=j

J (i>0):*digit

{{out}}

<pre style='height:50ex;'>2

The PL/I include file "pg.inc" can be found on the [[Polyglot:PL/I and PL/M]] page.

Note the use of text in column 81 onwards to hide the PL/I specifics from the PL/M compiler.

additive_primes_100H: procedure options (main);

CALL PRNL;

{{out}}

<pre>

=={{header|Processing}}==

void setup() {

}

}

{{out}}

<pre>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

=={{header|PureBasic}}==

Global Dim P.b(#MAX) : FillMemory(@P(),#MAX,1,#PB_Byte)

If OpenConsole()=0 : End 1 : EndIf

Next

PrintN(~"\n\n"+Str(c)+" additive primes below 500.")

{{out}}

<pre> 2 3 5 7 11 23 29 41 43 47

=={{header|Python}}==

if n <= 3:

return n > 1

if __name__ == "__main__":

{{out}}

<pre>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

<code>digitsum</code> is defined at [[Sum digits of an integer#Quackery]].

[]

[ i^ join ] ] ]

dup echo cr cr

{{out}}

=={{header|Racket}}==

(require math/number-theory)

(define additive-primes<500 (filter additive-prime? (range 1 500)))

(printf "There are ~a additive primes < 500~%" (length additive-primes<500))

{{out}}

=={{header|Raku}}==

say "{+$_} additive primes < $limit:\n{$_».fmt("%" ~ $limit.chars ~ "d").batch(10).join("\n")}",

{{out}}

<pre>54 additive primes < 500:

=={{header|Red}}==

cross-sum: function [n][out: 0 foreach m form n [out: out + to-integer to-string m]]

additive-primes: function [n][collect [foreach p ps: primes n [if find ps cross-sum p [keep p]]]]

]

== 54

Uses <code>primes</code> defined in https://rosettacode.org/wiki/Sieve_of_Eratosthenes#Red.

=={{header|REXX}}==

parse arg n cols . /*get optional number of primes to find*/

if n=='' | n=="," then n= 500 /*Not specified? Then assume default.*/

end /*k*/ /* [↑] only divide up to √ J */

#= # + 1; @.#= j; sq.#= j*j; !.j= 1 /*bump prime count; assign prime & flag*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see nl + "found " + row + " additive primes." + nl

see "done..." + nl

{{out}}

<pre>

</pre>

=={{header|Ruby}}==

additive_primes = Prime.lazy.select{|prime| prime.digits.sum.prime? }

puts res.join(" ")

puts "\n#{res.size} additive primes below #{N}."

{{out}}

<pre>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

===Flat implementation===

let limit = 500;

let column_w = limit.to_string().len() + 1;

}

println!("\n---\nFound {count} additive primes less than {limit}");

{{out}}

<pre>

primal implements the sieve of Eratosthenes with optimizations (10+ times faster for large limits)

// primal = "0.3.0"

.count();

println!("\n---\nFound {count} additive primes less than {limit}");

{{out}}

<pre>

=={{header|Sage}}==

limit = 500

additivePrimes = list(filter(lambda x: x > 0,

list(map(str,list(primes(1,limit))))))))

print(f"{additivePrimes}\nFound {len(additivePrimes)} additive primes less than {limit}")

{{out}}

<pre>

</pre>

=={{header|Seed7}}==

const func boolean: isPrime (in integer: number) is func

end for;

writeln("\nFound " <& count <& " additive primes < 500.");

{{out}}

<pre>

=={{header|Sidef}}==

upto.primes.grep { .sumdigits(base).is_prime }

}

additive_primes(500).each_slice(10, {|*a|

a.map { '%3s' % _ }.join(' ').say

{{out}}

<pre>

=={{header|TSE SAL}}==

INTEGER PROC FNMathGetSquareRootI( INTEGER xI )

END

{{out}} <pre>

=={{header|Swift}}==

func isPrime(_ n: Int) -> Bool {

}

}

{{out}}

a@ = a@ / 10

loop

{{Out}}

<pre>Prime Digit Sum

=={{header|Vlang}}==

{{trans|go}}

if n < 2 {

return false

}

println("\n\n$count additive primes found.")

{{out}}

=={{header|VTL-2}}==

20 :1)=1

30 P=2

330 ?=N

340 ?=" additive primes below ";

{{out}}

<pre>2 3 5 7 11 23 29 41 43 47

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

}

}

{{out}}

=={{header|XPL0}}==

int N, I;

[if N <= 1 then return false;

Text(0, " additive primes found below 500.

");

{{out}}

=={{header|Yabasic}}==

// by Galileo, 06/2022

next

{{out}}

<pre>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