View source for Sum of square and cube digits of an integer are primes

{{Draft task}}

;Task:
Find and show here all positive integers '''n''' less than '''100''' where:
* the sum of the digits of the square of '''n''' is prime; and
* the sum of the digits of the cube of '''n''' is also prime.
<br>
;Example:
'''16''' satisfies the task descrption because 16 x 16 = 256 has a digit sum of 13 which is prime and
16 x 16 x 16 = 4096 has a digit sum of 19 which is also prime.
<br><br>

=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<lang algol68>BEGIN # find numbers where the digit sums of the square and cube are prtime #
    INT max number = 99; # maximum number to consider #
    PR read "primes.incl.a68" PR
    []BOOL prime = PRIMESIEVE ( INT d sum := 9; # calculate the largest possible digit sum #
                                INT n     := max number * max number * max number;
                                WHILE ( n OVERAB 10 ) > 0 DO
                                    d sum +:= 9
                                OD;
                                d sum
                              );
    # returns the sum of the digits of n #
    OP  DIGITSUM = ( INT n )INT:
        BEGIN
            INT v      := ABS n;
            INT result := v MOD 10;
            WHILE ( v OVERAB 10 ) > 0 DO
                result +:= v MOD 10
            OD;
            result
        END # DIGITSUM # ;
    FOR i TO max number DO
        INT i2 = i * i;
        IF prime[ DIGITSUM i2 ] THEN
            IF prime[ DIGITSUM ( i * i2 ) ] THEN
                print( ( " ", whole( i, 0 ) ) )
            FI
        FI
    OD
END</lang>
{{out}}
<pre>
 16 17 25 28 34 37 47 52 64
</pre>

=={{header|APL}}==
<lang apl>(⊢(/⍨)∧/∘((2=0+.=⍳|⊢)∘(+/⍎¨∘⍕)¨*∘2 3)¨)⍳100</lang>
{{out}}
<pre>16 17 25 28 34 37 47 52 64</pre>

=={{header|BQN}}==
<lang bqn># 'Library' functions from BQNCrate
Digits ← 10 {⌽𝕗|⌊∘÷⟜𝕗⍟(↕1+·⌊𝕗⋆⁼1⌈⊢)}
Prime ← 2=·+´0=(1+↕)⊸|

(∧˝∘⍉∘((Prime +´∘Digits)¨⋆⌜⟜2‿3))⊸/↕100</lang>
{{out}}
<pre>⟨ 16 17 25 28 34 37 47 52 64 ⟩</pre>

=={{header|CLU}}==
<lang clu>digit_sum = proc (n: int) returns (int)
    sum: int := 0
    while n>0 do
        sum := sum + n // 10
        n := n / 10
    end
    return(sum)
end digit_sum

% The numbers tested for primality are very small,
% so this simple test suffices.
prime = proc (n: int) returns (bool)
    if n<2 then return(false) end
    d: int := 2
    while d*d <= n do
        if n//d=0 then return(false) end
        d := d+1
    end
    return(true)
end prime

accept = proc (n: int) returns (bool)
    return(prime(digit_sum(n**2)) cand prime(digit_sum(n**3)))
end accept

start_up = proc ()
    po: stream := stream$primary_output()
    for i: int in int$from_to(1, 99) do
        if accept(i) then
            stream$puts(po, int$unparse(i) || " ")
        end
    end
end start_up</lang>
{{out}}
<pre>16 17 25 28 34 37 47 52 64</pre>

=={{header|COBOL}}==
<lang cobol>       IDENTIFICATION DIVISION.
       PROGRAM-ID. SQUARE-CUBE-DIGITS-PRIME.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 NUMBER-SEARCH-VARS.
          03 CAND             PIC 9(6).
          03 SQUARE           PIC 9(6).
          03 CUBE             PIC 9(6).
          
       01 SUM-DIGITS-VARS.
          03 SUM-NUM          PIC 9(6).
          03 DIGITS           PIC 9 OCCURS 6 TIMES INDEXED BY D
                              REDEFINES SUM-NUM.
          03 SUM              PIC 99.
       
       01 PRIME-TEST-VARS.
          03 DIVISOR          PIC 99.
          03 DIV-TEST         PIC 99V9999.
          03 FILLER           REDEFINES DIV-TEST.
             05 FILLER        PIC 99.
             05 FILLER        PIC 9999.
                88 DIVISIBLE  VALUE ZERO.
          03 PRIME-FLAG       PIC X.
             88 PRIME         VALUE '*'.
       
       01 OUT-FMT             PIC Z9.
       
       PROCEDURE DIVISION.
       BEGIN.
           PERFORM CHECK-NUMBER VARYING CAND FROM 1 BY 1
           UNTIL CAND IS EQUAL TO 100.
           STOP RUN.
       
       CHECK-NUMBER.
           MULTIPLY CAND BY CAND GIVING SQUARE.
           MULTIPLY CAND BY SQUARE GIVING CUBE.
           MOVE SQUARE TO SUM-NUM.
           PERFORM SUM-DIGITS.
           PERFORM PRIME-TEST.
           IF PRIME,
               MOVE CUBE TO SUM-NUM,
               PERFORM SUM-DIGITS,
               PERFORM PRIME-TEST,
               IF PRIME,
                   MOVE CAND TO OUT-FMT,
                   DISPLAY OUT-FMT.
           
       SUM-DIGITS.
           MOVE ZERO TO SUM.
           PERFORM SUM-DIGIT VARYING D FROM 1 BY 1
           UNTIL D IS GREATER THAN 6.
           
       SUM-DIGIT.
           ADD DIGITS(D) TO SUM.
       
       PRIME-TEST.
           MOVE '*' TO PRIME-FLAG.
           PERFORM CHECK-DIVISOR VARYING DIVISOR FROM 2 BY 1
           UNTIL NOT PRIME, OR DIVISOR IS EQUAL TO SUM.
       
       CHECK-DIVISOR.
           DIVIDE SUM BY DIVISOR GIVING DIV-TEST.
           IF DIVISIBLE, MOVE SPACE TO PRIME-FLAG.</lang>
{{out}}
<pre>16
17
25
28
34
37
47
52
64</pre>

=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<lang fsharp>
// Sum of square and cube digits of an integer are primes. Nigel Galloway: December 22nd., 2021
let rec fN g=function 0->g |n->fN(g+n%10)(n/10)
[1..99]|>List.filter(fun g->isPrime(fN 0 (g*g)) && isPrime(fN 0 (g*g*g)))|>List.iter(printf "%d "); printfn ""
</lang>
{{out}}
<pre>
16 17 25 28 34 37 47 52 64
</pre>

=={{header|FreeBASIC}}==
<lang freebasic>
function digsum(byval n as uinteger, b as const uinteger) as uinteger
    'digital sum of n in base b
    dim as integer s
    while n
        s+=n mod b
        n\=b
    wend
    return s
end function

function isprime(n as const uinteger) as boolean
    if n<2 then return false
    if n<4 then return true
    if n mod 2 = 0 then return false
    dim as uinteger i = 3
    while i*i<=n
        if n mod i = 0 then return false
        i+=2
    wend
    return true
end function

for n as uinteger = 1 to 99
    if isprime(digsum(n^3,10)) andalso isprime(digsum(n^2,10)) then print n;"   ";
next n</lang>
{{out}}<pre>16   17   25   28   34   37   47   52   64</pre>

=={{header|Haskell}}==
<lang haskell>import Data.Bifunctor (first)
import Data.Numbers.Primes (isPrime)

p :: Int -> Bool
p =
  ((&&) . primeDigitSum . (^ 2))
    <*> (primeDigitSum . (^ 3))


--------------------------- TEST -------------------------
main :: IO ()
main = print $ filter p [2 .. 99]


------------------------- GENERIC ------------------------
primeDigitSum :: Int -> Bool
primeDigitSum = isPrime . digitSum 10

digitSum :: Int -> Int -> Int
digitSum base = go
  where
    go 0 = 0
    go n = uncurry (+) (first go $ quotRem n base)</lang>
{{Out}}
<pre>[16,17,25,28,34,37,47,52,64]</pre>

=={{header|J}}==
<lang j>((1*./@p:[:+/@|:10#.^:_1^&2 3)"0#]) i.100</lang>
{{out}}
<pre>16 17 25 28 34 37 47 52 64</pre>

=={{header|Julia}}==
<lang julia>using Primes

is_sqcubsumprime(n) = isprime(sum(digits(n*n))) && isprime(sum(digits(n*n*n)))
println(filter(is_sqcubsumprime, 1:100)) # [16, 17, 25, 28, 34, 37, 47, 52, 64]
</lang>

=={{header|Perl}}==
{{libheader|ntheory}}
<lang perl>#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Sum_of_square_and_cube_digits_of_an_integer_are_primes
use warnings;
use ntheory qw( is_prime vecsum );

my @results = grep
  is_prime( vecsum( split //, $_ ** 2 ) ) &&
  is_prime( vecsum( split //, $_ ** 3 ) ), 1 .. 100;
print "@results\n";</lang>
{{out}}
<pre>
16 17 25 28 34 37 47 52 64
</pre>

=={{header|Phix}}==
<!--<lang Phix>(phixonline)-->
 <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
 <span style="color: #008080;">function</span> <span style="color: #000000;">ipsd</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</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: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</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: #008080;">function</span> <span style="color: #000000;">scdp</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #000000;">ipsd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">*</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ipsd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">*</span><span style="color: #000000;">n</span><span style="color: #0000FF;">*</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
 <span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">99</span><span style="color: #0000FF;">),</span><span style="color: #000000;">scdp</span><span style="color: #0000FF;">))</span>
<!--</lang>-->
{{out}}
<pre>
{16,17,25,28,34,37,47,52,64}
</pre>

=={{header|Raku}}==
<lang perl6>say ^100 .grep: { .².comb.sum.is-prime && .³.comb.sum.is-prime }</lang>
{{out}}
<pre>(16 17 25 28 34 37 47 52 64)</pre>

=={{header|Ring}}==
<lang ring>
load "stdlib.ring"
see "working..." +nl

limit = 100

for n = 1 to limit
    sums = 0
    sumc = 0
    sps = string(pow(n,2))
    spc = string(pow(n,3))
    for m = 1 to len(sps)
        sums = sums + sps[m]
    next
    for p = 1 to len(spc)
        sumc = sumc + spc[p]
    next
    if isprime(sums) and isprime(sumc)
       see "" + n + " "
    ok
next
  
see nl + "done..." + nl
</lang>
{{out}}
<pre>
working...
16 17 25 28 34 37 47 52 64 
done...
</pre>

=={{header|TinyBASIC}}==
This can only go up to 31 because 32^3 is too big to fit in a signed 16-bit int.
<lang tinybasic>REM      N, the number to be tested
REM      D, the digital sum of its square or cube
REM      T, temporary variable
REM      Z, did D test as prime or not

    LET N = 1
 10 LET T = N*N*N
    GOSUB 20
    GOSUB 30
    IF Z = 0 THEN GOTO 11
    LET T = N*N
    GOSUB 20
    GOSUB 30
    IF Z = 0 THEN GOTO 11
    PRINT N
 11 IF N = 31 THEN END
    LET N = N + 1
    GOTO 10
 20 LET D = 0
 21 IF T = 0 THEN RETURN
    LET D = D + (T-(T/10)*10)
    LET T = T/10
    GOTO 21
 30 LET Z = 0
    IF D < 2 THEN RETURN
    LET Z = 1
    IF D < 4 THEN RETURN
    LET Z = 0
    IF (D/2)*2 = D THEN RETURN
    LET T = 1
 31 LET T = T + 2
    IF T*T>D THEN GOTO 32
    IF (D/T)*T=D THEN RETURN
    GOTO 31
 32 LET Z = 1
    RETURN</lang>
{{out}}<pre>
16
17
25
28</pre>

=={{header|Wren}}==
{{libheader|Wren-math}}
<lang ecmascript>import "./math" for Int

for (i in 1..99) {
    if (Int.isPrime(Int.digitSum(i*i)) && Int.isPrime(Int.digitSum(i*i*i))) System.write("%(i) ")
}
System.print()</lang>

{{out}}
<pre>
16 17 25 28 34 37 47 52 64 
</pre>

=={{header|XPL0}}==
<lang XPL0>func IsPrime(N);        \Return 'true' if N is prime
int  N, I;
[if N <= 2 then return N = 2;
if (N&1) = 0 then \even >2\ return false;
for I:= 3 to sqrt(N) do
    [if rem(N/I) = 0 then return false;
    I:= I+1;
    ];
return true;
];

func SumDigits(N);      \Return the sum of digits in N
int  N, Sum;
[Sum:= 0;
while N do
    [N:= N/10;
    Sum:= Sum + rem(0);
    ];
return Sum;
];

int N;
[for N:= 0 to 100-1 do
    if IsPrime(SumDigits(N*N)) & IsPrime(SumDigits(N*N*N)) then
        [IntOut(0, N);  ChOut(0, ^ )];
]</lang>

{{out}}
<pre>
16 17 25 28 34 37 47 52 64 
</pre>