View source for Strange unique prime triplets

{{Draft task|Prime Numbers}}

Primes &nbsp; '''n, &nbsp; m,''' &nbsp; and &nbsp; '''p''' &nbsp; are &nbsp; ''strange unique primes'' &nbsp;  if &nbsp; '''n, &nbsp; m,''' &nbsp; and &nbsp; '''p''' &nbsp; are unique and their sum &nbsp; &nbsp; '''n&nbsp;+&nbsp;m&nbsp;+&nbsp;p''' &nbsp; &nbsp; is also prime. Assume '''n''' < '''m''' < '''p'''.


;Task:
:* &nbsp; Find all triplets of strange unique primes in which &nbsp; '''n, &nbsp; m,''' &nbsp; and &nbsp; '''p''' &nbsp; are all less than &nbsp; '''30'''.
:* &nbsp; (stretch goal) &nbsp; Show the <u>count</u> (only) of all the triplets of strange unique primes in which &nbsp; &nbsp;&nbsp;'''n,&nbsp;m,'''&nbsp;and&nbsp;'''p'''&nbsp; &nbsp; are all less than &nbsp; '''1,000'''.
<br><br>

=={{header|11l}}==
{{trans|Python}}

<syntaxhighlight lang="11l">F primes_upto(limit)
   V is_prime = [0B] * 2 [+] [1B] * (limit - 1)
   L(n) 0 .< Int(limit ^ 0.5 + 1.5)
      I is_prime[n]
         L(i) (n * n .< limit + 1).step(n)
            is_prime[i] = 0B
   R enumerate(is_prime).filter((i, prime) -> prime).map((i, prime) -> i)

F strange_triplets(Int mx = 30)
   [(Int, Int, Int)] r
   V primes = Array(primes_upto(mx))
   V primes3 = Set(primes_upto(3 * mx))
   L(n) primes
      V i = L.index
      L(m) primes[i + 1 ..]
         V j = L.index + i + 1
         L(p) primes[j + 1 ..]
            I n + m + p C primes3
               r.append((n, m, p))
   R r

L(n, m, p) strange_triplets()
   print(‘#2: #2+#2+#2 = #.’.format(L.index + 1, n, m, p, n + m + p))

V mx = 1'000
print("\nIf n, m, p < #. finds #.".format(mx, strange_triplets(mx).len))</syntaxhighlight>

{{out}}
<pre>
 1:  3+ 5+11 = 19
 2:  3+ 5+23 = 31
 3:  3+ 5+29 = 37
 4:  3+ 7+13 = 23
 5:  3+ 7+19 = 29
 6:  3+11+17 = 31
 7:  3+11+23 = 37
 8:  3+11+29 = 43
 9:  3+17+23 = 43
10:  5+ 7+11 = 23
11:  5+ 7+17 = 29
12:  5+ 7+19 = 31
13:  5+ 7+29 = 41
14:  5+11+13 = 29
15:  5+13+19 = 37
16:  5+13+23 = 41
17:  5+13+29 = 47
18:  5+17+19 = 41
19:  5+19+23 = 47
20:  5+19+29 = 53
21:  7+11+13 = 31
22:  7+11+19 = 37
23:  7+11+23 = 41
24:  7+11+29 = 47
25:  7+13+17 = 37
26:  7+13+23 = 43
27:  7+17+19 = 43
28:  7+17+23 = 47
29:  7+17+29 = 53
30:  7+23+29 = 59
31: 11+13+17 = 41
32: 11+13+19 = 43
33: 11+13+23 = 47
34: 11+13+29 = 53
35: 11+17+19 = 47
36: 11+19+23 = 53
37: 11+19+29 = 59
38: 13+17+23 = 53
39: 13+17+29 = 59
40: 13+19+29 = 61
41: 17+19+23 = 59
42: 19+23+29 = 71

If n, m, p < 1000 finds 241580
</pre>

=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"

PROC Main()
  DEFINE MAXPRIME="29"
  DEFINE MAX="99"
  BYTE ARRAY primes(MAX+1)
  BYTE n,m,p,c
  INT count=[0]

  Put(125) PutE() ;clear the screen
  Sieve(primes,MAX+1)
  c=0
  FOR n=2 TO MAXPRIME-2
  DO
    IF primes(n) THEN
      FOR m=n+1 TO MAXPRIME-1
      DO
        IF primes(m) THEN
          FOR p=m+1 TO MAXPRIME
          DO
            IF primes(p)=1 AND primes(n+m+p)=1 THEN
              PrintF("%I+%I+%I=%I ",n,m,p,n+m+p)
              count==+1 c==+1
              IF c=3 THEN
                c=0 PutE()
              FI
            FI
          OD
        FI
      OD
    FI
  OD
  PrintF("%EThere are %I prime triplets",count)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Strange_unique_prime_triplets.png Screenshot from Atari 8-bit computer]
<pre>
3+5+11=19 3+5+23=31 3+5+29=37
3+7+13=23 3+7+19=29 3+11+17=31
3+11+23=37 3+11+29=43 3+17+23=43
5+7+11=23 5+7+17=29 5+7+19=31
5+7+29=41 5+11+13=29 5+13+19=37
5+13+23=41 5+13+29=47 5+17+19=41
5+19+23=47 5+19+29=53 7+11+13=31
7+11+19=37 7+11+23=41 7+11+29=47
7+13+17=37 7+13+23=43 7+17+19=43
7+17+23=47 7+17+29=53 7+23+29=59
11+13+17=41 11+13+19=43 11+13+23=47
11+13+29=53 11+17+19=47 11+19+23=53
11+19+29=59 13+17+23=53 13+17+29=59
13+19+29=61 17+19+23=59 19+23+29=71

There are 42 prime triplets
</pre>

=={{header|ALGOL 68}}==
{{Trans|Algol W}} which is based on {{Trans|Wren}}
{{libheader|ALGOL 68-primes}}
<syntaxhighlight lang="algol68">BEGIN # find some strange unique primes - triplets of primes n, m, p        #
      # where n + m + p is also prime and n =/= m =/= p                     #
    # we need to find the strange unique prime triplets below 1000          #
    # so the maximum triplet sum could be roughly 3000                      #
    INT max number = 1000;
    # sieve the primes to the maximum reuired prime #
    PR read "primes.incl.a68" PR
    []BOOL prime = PRIMESIEVE ( max number * 3 );
    # we need to find the strange unique prime triplets below 1000          #
    INT s count := 0, c30 := 0;
    # 2 cannot be one of the primes as the sum would be even otherwise      #
    FOR n FROM 3 BY 2 TO max number - 5 DO
        IF prime[ n ] THEN
            FOR m FROM n + 2 BY 2 TO max number- 3 DO
                IF prime[ m ] THEN
                    FOR p FROM m + 2 BY 2 TO max number DO
                        IF prime[ p ] THEN
                            IF INT s = n + m + p;
                               prime[ s ]
                            THEN
                                # have 3 unique primes whose sum is prime   #
                                s count +:= 1;
                                IF p <= 30 AND m <= 30 AND n <= 30 THEN
                                    c30 +:= 1;
                                    print( ( whole( c30, -3 ), ": "
                                           , whole( n,   -3 ), " + "
                                           , whole( m,   -3 ), " + "
                                           , whole( p,   -3 ), " = "
                                           , whole( s,   -3 ), newline
                                           )
                                         )
                                FI
                            FI
                        FI
                    OD # p #
                FI
            OD # m #
        FI
    OD # n # ;
    print( ( "Found ", whole( c30,     -6 ), " strange unique prime triplets up to   30", newline ) );
    print( ( "Found ", whole( s count, -6 ), " strange unique prime triplets up to 1000", newline ) )
END</syntaxhighlight>
{{out}}
<pre>
  1:   3 +   5 +  11 =  19
  2:   3 +   5 +  23 =  31
  3:   3 +   5 +  29 =  37
  4:   3 +   7 +  13 =  23
  5:   3 +   7 +  19 =  29
  6:   3 +  11 +  17 =  31
  7:   3 +  11 +  23 =  37
  8:   3 +  11 +  29 =  43
  9:   3 +  17 +  23 =  43
 10:   5 +   7 +  11 =  23
 11:   5 +   7 +  17 =  29
 12:   5 +   7 +  19 =  31
 13:   5 +   7 +  29 =  41
 14:   5 +  11 +  13 =  29
 15:   5 +  13 +  19 =  37
 16:   5 +  13 +  23 =  41
 17:   5 +  13 +  29 =  47
 18:   5 +  17 +  19 =  41
 19:   5 +  19 +  23 =  47
 20:   5 +  19 +  29 =  53
 21:   7 +  11 +  13 =  31
 22:   7 +  11 +  19 =  37
 23:   7 +  11 +  23 =  41
 24:   7 +  11 +  29 =  47
 25:   7 +  13 +  17 =  37
 26:   7 +  13 +  23 =  43
 27:   7 +  17 +  19 =  43
 28:   7 +  17 +  23 =  47
 29:   7 +  17 +  29 =  53
 30:   7 +  23 +  29 =  59
 31:  11 +  13 +  17 =  41
 32:  11 +  13 +  19 =  43
 33:  11 +  13 +  23 =  47
 34:  11 +  13 +  29 =  53
 35:  11 +  17 +  19 =  47
 36:  11 +  19 +  23 =  53
 37:  11 +  19 +  29 =  59
 38:  13 +  17 +  23 =  53
 39:  13 +  17 +  29 =  59
 40:  13 +  19 +  29 =  61
 41:  17 +  19 +  23 =  59
 42:  19 +  23 +  29 =  71
Found     42 strange unique prime triplets up to   30
Found 241580 strange unique prime triplets up to 1000
</pre>

=={{header|ALGOL W}}==
Based on {{Trans|Wren}}
<syntaxhighlight lang="algolw">begin % find some strange unique primes - triplets of primes n, m, p %
      % where n + m + p is also prime and n =/= m =/= p              %
    % 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 ;
    % we need to find the strange unique prime triplets below 1000 %
    integer MAX_PRIME;
    MAX_PRIME := 1000;
    begin
        % the sum of the triplets could be (roughly) 3 x the largest prime %
        logical array p ( 1 :: MAX_PRIME * 3 );
        integer sCount, c30;
        % construct a sieve of primes up to MAX_PRIME * 3                  %
        Eratosthenes( p, MAX_PRIME * 3 );
        % count the strange prime triplets whose members are < 1000 and    %
        % whose sum is prime                                               %
        sCount := c30 := 0;
        % 2 cannot be one of the primes as the sum would be even otherwise %
        for n := 3 step 2 until MAX_PRIME - 5 do begin
            if p( n ) then begin
                for m := n + 2 step 2 until MAX_PRIME - 3 do begin
                    if p( m ) then begin
                        for l := m + 2 step 2 until MAX_PRIME do begin
                            if p( l ) then begin
                                integer s;
                                s := n + m + l;
                                if p( s ) then begin
                                    sCount := sCount + 1;
                                    if l <= 30 and m <= 30 and n <= 30 then begin
                                        c30 := c30 + 1;
                                        write( i_w := 3, s_w := 0, c30, ": ", n, " + ", m, " + ", l, " = ", s )
                                    end if_l_m_n_le_30
                                end if_p_s
                            end if_p_l
                        end for_l
                    end if_p_m
                end for_m
            end if_p_n
        end for_n ;
        write( i_w := 3, s_w := 0, "Found ", c30,    " strange unique prime triplets up to   30" );
        write( i_w := 3, s_w := 0, "Found ", sCount, " strange unique prime triplets up to 1000" );
    end
end.</syntaxhighlight>
{{out}}
<pre>
  1:   3 +   5 +  11 =  19
  2:   3 +   5 +  23 =  31
  3:   3 +   5 +  29 =  37
  4:   3 +   7 +  13 =  23
  5:   3 +   7 +  19 =  29
  6:   3 +  11 +  17 =  31
  7:   3 +  11 +  23 =  37
  8:   3 +  11 +  29 =  43
  9:   3 +  17 +  23 =  43
 10:   5 +   7 +  11 =  23
 11:   5 +   7 +  17 =  29
 12:   5 +   7 +  19 =  31
 13:   5 +   7 +  29 =  41
 14:   5 +  11 +  13 =  29
 15:   5 +  13 +  19 =  37
 16:   5 +  13 +  23 =  41
 17:   5 +  13 +  29 =  47
 18:   5 +  17 +  19 =  41
 19:   5 +  19 +  23 =  47
 20:   5 +  19 +  29 =  53
 21:   7 +  11 +  13 =  31
 22:   7 +  11 +  19 =  37
 23:   7 +  11 +  23 =  41
 24:   7 +  11 +  29 =  47
 25:   7 +  13 +  17 =  37
 26:   7 +  13 +  23 =  43
 27:   7 +  17 +  19 =  43
 28:   7 +  17 +  23 =  47
 29:   7 +  17 +  29 =  53
 30:   7 +  23 +  29 =  59
 31:  11 +  13 +  17 =  41
 32:  11 +  13 +  19 =  43
 33:  11 +  13 +  23 =  47
 34:  11 +  13 +  29 =  53
 35:  11 +  17 +  19 =  47
 36:  11 +  19 +  23 =  53
 37:  11 +  19 +  29 =  59
 38:  13 +  17 +  23 =  53
 39:  13 +  17 +  29 =  59
 40:  13 +  19 +  29 =  61
 41:  17 +  19 +  23 =  59
 42:  19 +  23 +  29 =  71
Found  42 strange unique prime triplets up to   30
Found 241580 strange unique prime triplets up to 1000
</pre>

=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f STRANGE_UNIQUE_PRIME_TRIPLETS.AWK
# converted from Go
BEGIN {
    main(29,1)
    main(999,0)
    exit(0)
}
function main(n,show,  count,i,j,k,s) {
    for (i=3; i<=n-4; i+=2) {
      if (is_prime(i)) {
        for (j=i+2; j<=n-2; j+=2) {
          if (is_prime(j)) {
            for (k=j+2; k<=n; k+=2) {
              if (is_prime(k)) {
                s = i + j + k
                if (is_prime(s)) {
                  count++
                  if (show == 1) {
                    printf("%2d + %2d + %2d = %d\n",i,j,k,s)
                  }
                }
              }
            }
          }
        }
      }
    }
    printf("Unique prime triples 2-%d which sum to a prime: %'d\n\n",n,count)
}
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)
}
</syntaxhighlight>
{{out}}
<pre>
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71
Unique prime triples 2-29 which sum to a prime: 42

Unique prime triples 2-999 which sum to a prime: 241,580
</pre>

=={{header|C}}==
<syntaxhighlight lang="c">#include <stdbool.h>
#include <stdio.h>
#include <string.h>

#define LIMIT 3000

void init_sieve(unsigned char sieve[], int limit) {
    int i, j;

    for (i = 0; i < limit; i++) {
        sieve[i] = 1;
    }
    sieve[0] = 0;
    sieve[1] = 0;

    for (i = 2; i < limit; i++) {
        if (sieve[i]) {
            for (j = i + i; j < limit; j += i) {
                sieve[j] = 0;
            }
        }
    }
}

void strange_unique_prime_triplets(unsigned char sieve[], int limit, bool verbose) {
    int count = 0, sum;
    int i, j, k, n, p;
    int pi, pj, pk;

    n = 0;
    for (i = 0; i < limit; i++) {
        if (sieve[i]) {
            n++;
        }
    }

    if (verbose) {
        printf("Strange unique prime triplets < %d:\n", limit);
    }

    for (i = 0; i + 2 < n; i++) {
        pi = 2;
        p = i;
        while (p > 0) {
            pi++;
            if (sieve[pi]) {
                p--;
            }
        }

        for (j = i + 1; j + 1 < n; j++) {
            pj = pi;
            p = j - i;
            while (p > 0) {
                pj++;
                if (sieve[pj]) {
                    p--;
                }
            }

            for (k = j + 1; k < n; k++) {
                pk = pj;
                p = k - j;
                while (p > 0) {
                    pk++;
                    if (sieve[pk]) {
                        p--;
                    }
                }

                sum = pi + pj + pk;
                if (sum < LIMIT && sieve[sum]) {
                    count++;
                    if (verbose) {
                        printf("%2d + %2d + %2d = %d\n", pi, pj, pk, sum);
                    }
                }
            }
        }
    }

    printf("Count of strange unique prime triplets < %d is %d.\n\n", limit, count);
}

int main() {
    unsigned char sieve[LIMIT];

    init_sieve(sieve, LIMIT);

    strange_unique_prime_triplets(sieve, 30, true);
    strange_unique_prime_triplets(sieve, 1000, false);

    return 0;
}</syntaxhighlight>
{{out}}
<pre>Strange unique prime triplets < 30:
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71
Count of strange unique prime triplets < 30 is 42.

Count of strange unique prime triplets < 1000 is 241580.</pre>

=={{header|C#|CSharp}}==
Just for fun, <30 sorted by sum, instead of order generated.  One might think one should include the sieve generation time, but it is orders of magnitude smaller than the permute/sum time for these relatively low numbers.
<syntaxhighlight lang="csharp">using System; using System.Collections.Generic; using static System.Console; using System.Linq; using DT = System.DateTime;

class Program { static void Main(string[] args) { string s;
  foreach (int lmt in new int[]{ 90, 300, 3000, 30000, 111000 }) {
    var pr = PG.Primes(lmt).Skip(1).ToList(); DT st = DT.Now;
    int d, f = 0; var r = new List<string>();
    int i = -1, m, h = (m = lmt / 3), j, k, pra, prab;
    while (i < 0) i = pr.IndexOf(h--); k = (j = i - 1) - 1;
    for (int a = 0; a <= k; a++) { pra = pr[a];
    for (int b = a + 1; b <= j; b++) { prab = pra + pr[b]; 
    for (int c = b + 1; c <= i; c++) {
      if (PG.flags[d = prab + pr[c]]) continue; f++;
      if (lmt < 100) r.Add(string.Format("{3,5} = {0,2} + {1,2} + {2,2}", pra, pr[b], pr[c], d)); } } }
    s = "s.u.p.t.s under "; r.Sort(); if (r.Count > 0) WriteLine("{0}{1}:\n{2}", s, m, string.Join("\n", r));
    if (lmt > 100) WriteLine("Count of {0}{1,6:n0}: {2,13:n0}  {3} sec", s, m, f, (DT.Now - st).ToString().Substring(6)); } } }

class PG { public static bool[] flags;
  public static IEnumerable<int> Primes(int lim) {
  flags = new bool[lim + 1]; int j = 2;
  for (int d = 3, sq = 4; sq <= lim; j++, sq += d += 2)
    if (!flags[j]) { yield return j;
      for (int k = sq; k <= lim; k += j) flags[k] = true; }
  for (; j <= lim; j++) if (!flags[j]) yield return j; } }</syntaxhighlight>
{{out}}
Timings from tio.run 
<pre>s.u.p.t.s under 30:
   19 =  3 +  5 + 11
   23 =  3 +  7 + 13
   23 =  5 +  7 + 11
   29 =  3 +  7 + 19
   29 =  5 +  7 + 17
   29 =  5 + 11 + 13
   31 =  3 +  5 + 23
   31 =  3 + 11 + 17
   31 =  5 +  7 + 19
   31 =  7 + 11 + 13
   37 =  3 +  5 + 29
   37 =  3 + 11 + 23
   37 =  5 + 13 + 19
   37 =  7 + 11 + 19
   37 =  7 + 13 + 17
   41 =  5 +  7 + 29
   41 =  5 + 13 + 23
   41 =  5 + 17 + 19
   41 =  7 + 11 + 23
   41 = 11 + 13 + 17
   43 =  3 + 11 + 29
   43 =  3 + 17 + 23
   43 =  7 + 13 + 23
   43 =  7 + 17 + 19
   43 = 11 + 13 + 19
   47 =  5 + 13 + 29
   47 =  5 + 19 + 23
   47 =  7 + 11 + 29
   47 =  7 + 17 + 23
   47 = 11 + 13 + 23
   47 = 11 + 17 + 19
   53 =  5 + 19 + 29
   53 =  7 + 17 + 29
   53 = 11 + 13 + 29
   53 = 11 + 19 + 23
   53 = 13 + 17 + 23
   59 =  7 + 23 + 29
   59 = 11 + 19 + 29
   59 = 13 + 17 + 29
   59 = 17 + 19 + 23
   61 = 13 + 19 + 29
   71 = 19 + 23 + 29
Count of s.u.p.t.s under    100:           891  00.0000243 sec
Count of s.u.p.t.s under  1,000:       241,580  00.0054753 sec
Count of s.u.p.t.s under 10,000:    74,588,542  01.8159964 sec
Count of s.u.p.t.s under 37,000: 2,141,379,201  55.0369689 sec
</pre>

=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <iomanip>
#include <iostream>
#include <vector>

std::vector<bool> prime_sieve(size_t limit) {
    std::vector<bool> sieve(limit, true);
    if (limit > 0)
        sieve[0] = false;
    if (limit > 1)
        sieve[1] = false;
    for (size_t i = 4; i < limit; i += 2)
        sieve[i] = false;
    for (size_t p = 3; ; p += 2) {
        size_t q = p * p;
        if (q >= limit)
            break;
        if (sieve[p]) {
            size_t inc = 2 * p;
            for (; q < limit; q += inc)
                sieve[q] = false;
        }
    }
    return sieve;
}

void strange_unique_prime_triplets(int limit, bool verbose) {
    std::vector<bool> sieve = prime_sieve(limit * 3);
    std::vector<int> primes;
    for (int p = 3; p < limit; p += 2) {
        if (sieve[p])
            primes.push_back(p);
    }
    size_t n = primes.size();
    size_t count = 0;
    if (verbose)
        std::cout << "Strange unique prime triplets < " << limit << ":\n";
    for (size_t i = 0; i + 2 < n; ++i) {
        for (size_t j = i + 1; j + 1 < n; ++j) {
            for (size_t k = j + 1; k < n; ++k) {
                int sum = primes[i] + primes[j] + primes[k];
                if (sieve[sum]) {
                    ++count;
                    if (verbose) {
                        std::cout << std::setw(2) << primes[i] << " + "
                                  << std::setw(2) << primes[j] << " + "
                                  << std::setw(2) << primes[k] << " = " << sum
                                  << '\n';
                    }
                }
            }
        }
    }
    std::cout << "\nCount of strange unique prime triplets < " << limit
              << " is " << count << ".\n";
}

int main() {
    strange_unique_prime_triplets(30, true);
    strange_unique_prime_triplets(1000, false);
    return 0;
}</syntaxhighlight>

{{out}}
<pre>
Strange unique prime triplets < 30:
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71

Count of strange unique prime triplets < 30 is 42.

Count of strange unique prime triplets < 1000 is 241580.
</pre>

=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|Go}}
<syntaxhighlight lang="delphi">
program Strange_primes;

{$APPTYPE CONSOLE}

uses
  System.SysUtils;

function IsPrime(n: Integer): Boolean;
begin
  if n < 2 then
    exit(false);

  if n mod 2 = 0 then
    exit(n = 2);

  if n mod 3 = 0 then
    exit(n = 3);

  var d := 5;
  while d * d <= n do
  begin
    if n mod d = 0 then
      exit(false);

    inc(d, 2);

    if n mod d = 0 then
      exit(false);

    inc(d, 4);
  end;
  Result := true;
end;

function Commatize(value: Integer): string;
begin
  Result := FloatToStrF(value, ffNumber, 10, 0);
end;

function StrangePrimes(n: Integer; countOnly: Boolean): Integer;
begin
  var c := 0;
  var f := '%2d: %2d + %2d + %2d = %2d'#10;
  var s: Integer := 0;

  var i := 3;
  while i <= n - 4 do
  begin
    if IsPrime(i) then
    begin
      var j := i + 2;
      while j <= n - 2 do
      begin
        if IsPrime(j) then
        begin
          var k := j + 2;
          while k <= n do
          begin
            if IsPrime(k) then
            begin
              s := i + j + k;
              if IsPrime(s) then
              begin
                inc(c);
                if not countOnly then
                  write(format(f, [c, i, j, k, s]));
              end;
            end;
            inc(k, 2);
          end;
        end;
        inc(j, 2);
      end;
    end;
    inc(i, 2);
  end;
  Result := c;
end;

begin
  Writeln('Unique prime triples under 30 which sum to a prime:');
  strangePrimes(29, false);
  var cs := commatize(strangePrimes(999, true));
  writeln('There are ', cs, ' unique prime triples under 1,000 which sum to a prime.');
  readln;
end.</syntaxhighlight>

=={{header|F_Sharp|F#}}==
This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>
<syntaxhighlight lang="fsharp">
// Strange unique prime triplets. Nigel Galloway: March 12th., 2021
let sP n=let N=primes32()|>Seq.takeWhile((>)n)|>Array.ofSeq
         seq{for n in 0..N.Length-1 do for i in n+1..N.Length-1 do for g in i+1..N.Length-1->(N.[n],N.[i],N.[g])}|>Seq.filter(fun(n,i,g)->isPrime(n+i+g))
sP 30|>Seq.iteri(fun n(i,g,l)->printfn "%2d: %2d+%2d+%2d=%2d")
printfn "%d" (Seq.length(sP 1000))
printfn "%d" (Seq.length(sP 10000))
</syntaxhighlight>
{{out}}
<pre>
241580
74588542
</pre>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: formatting io kernel math math.combinatorics math.primes
sequences tools.memory.private ;

: .triplet ( seq -- ) "%2d+%2d+%2d = %d\n" vprintf ;

: strange ( n -- )
    primes-upto 3
    [ dup sum dup prime? [ suffix .triplet ] [ 2drop ] if ]
    each-combination ;

: count-strange ( n -- count )
    0 swap primes-upto 3
    [ sum prime? [ 1 + ] when ] each-combination ;

30 strange
1,000 count-strange commas nl
"Found %s strange prime triplets with n, m, p < 1,000.\n" printf</syntaxhighlight>
{{out}}
<pre>
 3+ 5+11 = 19
 3+ 5+23 = 31
 3+ 5+29 = 37
 3+ 7+13 = 23
 3+ 7+19 = 29
 3+11+17 = 31
 3+11+23 = 37
 3+11+29 = 43
 3+17+23 = 43
 5+ 7+11 = 23
 5+ 7+17 = 29
 5+ 7+19 = 31
 5+ 7+29 = 41
 5+11+13 = 29
 5+13+19 = 37
 5+13+23 = 41
 5+13+29 = 47
 5+17+19 = 41
 5+19+23 = 47
 5+19+29 = 53
 7+11+13 = 31
 7+11+19 = 37
 7+11+23 = 41
 7+11+29 = 47
 7+13+17 = 37
 7+13+23 = 43
 7+17+19 = 43
 7+17+23 = 47
 7+17+29 = 53
 7+23+29 = 59
11+13+17 = 41
11+13+19 = 43
11+13+23 = 47
11+13+29 = 53
11+17+19 = 47
11+19+23 = 53
11+19+29 = 59
13+17+23 = 53
13+17+29 = 59
13+19+29 = 61
17+19+23 = 59
19+23+29 = 71

Found 241,580 strange prime triplets with n, m, p < 1,000.
</pre>

=={{header|Fermat}}==
<syntaxhighlight lang="fermat">Function IsSUPT(n,m,p) = 
    if Isprime(n) and Isprime(m) and Isprime(p) and Isprime(n+m+p) then 1 else 0 fi.

for n=3 to 19 do 
    for m=n+2 to 23 do 
        for p=m+2 to 29 do 
            if IsSUPT(n,m,p) then !!(n,m,p) fi;
        od;
    od;
od</syntaxhighlight>
I'll leave the stretch goal for someone else.

=={{header|FreeBASIC}}==
Use the function at [[Primality by trial division#FreeBASIC]] as an include; I can't be bothered reproducing it here.
<syntaxhighlight lang="freebasic">#include"isprime.bas"

dim as uinteger c = 0

for p as uinteger = 3 to 997
    if not isprime(p) then continue for
    for m as uinteger = p + 1 to 998
        if not isprime(m) then continue for
        for n as uinteger = m + 1 to 999
            if not isprime(n) then continue for
            if isprime(p + n + m) then
                c = c + 1
                if n < 30 then print p;" + ";m;" + ";n;" = "; p + m + n
            end if
        next n
    next m
next p

print "There are ";c;" triples below 1000."</syntaxhighlight>
{{out}}<pre>3 + 5 + 11 = 19
3 + 5 + 23 = 31
3 + 5 + 29 = 37
3 + 7 + 13 = 23
3 + 7 + 19 = 29
3 + 11 + 17 = 31
3 + 11 + 23 = 37
3 + 11 + 29 = 43
3 + 17 + 23 = 43
5 + 7 + 11 = 23
5 + 7 + 17 = 29
5 + 7 + 19 = 31
5 + 7 + 29 = 41
5 + 11 + 13 = 29
5 + 13 + 19 = 37
5 + 13 + 23 = 41
5 + 13 + 29 = 47
5 + 17 + 19 = 41
5 + 19 + 23 = 47
5 + 19 + 29 = 53
7 + 11 + 13 = 31
7 + 11 + 19 = 37
7 + 11 + 23 = 41
7 + 11 + 29 = 47
7 + 13 + 17 = 37
7 + 13 + 23 = 43
7 + 17 + 19 = 43
7 + 17 + 23 = 47
7 + 17 + 29 = 53
7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71
There are 241580 triples below 1000.</pre>

=={{header|Forth}}==
{{works with|Gforth}}
<syntaxhighlight lang="forth">: prime? ( n -- ? ) here + c@ 0= ;
: notprime! ( n -- ) here + 1 swap c! ;

: prime_sieve ( n -- )
  here over erase
  0 notprime!
  1 notprime!
  dup 4 > if
    dup 4 do i notprime! 2 +loop
  then
  3
  begin
    2dup dup * >
  while
    dup prime? if
      2dup dup * do
        i notprime!
      dup 2* +loop
    then
    2 +
  repeat
  2drop ;

: print_strange_unique_prime_triplets ( n -- )
  dup 8 < if drop exit then
  dup 3 * prime_sieve
  dup 4 - 3 do
    i prime? if
      dup 2 - i 2 + do
        i prime? if
          dup i 2 + do
            i prime? if
              i j k + + dup prime? if
                k 2 .r ."  + " j 2 .r ."  + " i 2 .r ."  = " 2 .r cr
              else
                drop
              then
            then
          2 +loop
        then
      2 +loop
    then
  2 +loop drop ;

: count_strange_unique_prime_triplets ( n -- n )
  dup 8 < if drop 0 exit then
  dup 3 * prime_sieve
  0 swap
  dup 4 - 3 do
    i prime? if
      dup 2 - i 2 + do
        i prime? if
          dup i 2 + do
            i prime? if
              i j k + + prime? if
                swap 1+ swap
              then
            then
          2 +loop
        then
      2 +loop
    then
  2 +loop drop ;

." Strange unique prime triplets < 30:" cr
30 print_strange_unique_prime_triplets

." Count of strange unique prime triplets < 1000: "
1000 count_strange_unique_prime_triplets . cr
bye</syntaxhighlight>

{{out}}
<pre>
Strange unique prime triplets < 30:
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71
Count of strange unique prime triplets < 1000: 241580 
</pre>

=={{header|Fōrmulæ}}==

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation &mdash;i.e. XML, JSON&mdash; they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its [https://formulae.org website], However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In '''[https://formulae.org/?example=Strange_unique_prime_triplets this]''' page you can see the program(s) related to this task and their results.

=={{header|Go}}==
===Basic===
{{trans|Wren}}
<syntaxhighlight lang="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 commatize(n int) string {
    s := fmt.Sprintf("%d", n)
    if n < 0 {
        s = s[1:]
    }
    le := len(s)
    for i := le - 3; i >= 1; i -= 3 {
        s = s[0:i] + "," + s[i:]
    }
    if n >= 0 {
        return s
    }
    return "-" + s
}

func strangePrimes(n int, countOnly bool) int {
    c := 0
    f := "%2d: %2d + %2d + %2d = %2d\n"
    var s int

    for i := 3; i <= n-4; i += 2 {
        if isPrime(i) {
            for j := i + 2; j <= n-2; j += 2 {
                if isPrime(j) {
                    for k := j + 2; k <= n; k += 2 {
                        if isPrime(k) {
                            s = i + j + k
                            if isPrime(s) {
                                c++
                                if !countOnly {
                                    fmt.Printf(f, c, i, j, k, s)
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return c
}

func main() {
    fmt.Println("Unique prime triples under 30 which sum to a prime:")
    strangePrimes(29, false)
    cs := commatize(strangePrimes(999, true))
    fmt.Printf("\nThere are %s unique prime triples under 1,000 which sum to a prime.\n", cs)
}</syntaxhighlight>

{{out}}
<pre>
Unique prime triples under 30 which sum to a prime:
 1:  3 +  5 + 11 = 19
 2:  3 +  5 + 23 = 31
 3:  3 +  5 + 29 = 37
 4:  3 +  7 + 13 = 23
 5:  3 +  7 + 19 = 29
 6:  3 + 11 + 17 = 31
 7:  3 + 11 + 23 = 37
 8:  3 + 11 + 29 = 43
 9:  3 + 17 + 23 = 43
10:  5 +  7 + 11 = 23
11:  5 +  7 + 17 = 29
12:  5 +  7 + 19 = 31
13:  5 +  7 + 29 = 41
14:  5 + 11 + 13 = 29
15:  5 + 13 + 19 = 37
16:  5 + 13 + 23 = 41
17:  5 + 13 + 29 = 47
18:  5 + 17 + 19 = 41
19:  5 + 19 + 23 = 47
20:  5 + 19 + 29 = 53
21:  7 + 11 + 13 = 31
22:  7 + 11 + 19 = 37
23:  7 + 11 + 23 = 41
24:  7 + 11 + 29 = 47
25:  7 + 13 + 17 = 37
26:  7 + 13 + 23 = 43
27:  7 + 17 + 19 = 43
28:  7 + 17 + 23 = 47
29:  7 + 17 + 29 = 53
30:  7 + 23 + 29 = 59
31: 11 + 13 + 17 = 41
32: 11 + 13 + 19 = 43
33: 11 + 13 + 23 = 47
34: 11 + 13 + 29 = 53
35: 11 + 17 + 19 = 47
36: 11 + 19 + 23 = 53
37: 11 + 19 + 29 = 59
38: 13 + 17 + 23 = 53
39: 13 + 17 + 29 = 59
40: 13 + 19 + 29 = 61
41: 17 + 19 + 23 = 59
42: 19 + 23 + 29 = 71

There are 241,580 unique prime triples under 1,000 which sum to a prime.
</pre>

===Faster===
{{trans|Wren}}
<syntaxhighlight lang="go">package main

import "fmt"

var sieved []bool
var p = []int{2}

func sieve(limit int) []bool {
    limit++
    // True denotes composite, false denotes prime.
    c := make([]bool, limit) // all false by default
    c[0] = true
    c[1] = true
    // no need to bother with even numbers over 2 for this task
    p := 3 // Start from 3.
    for {
        p2 := p * p
        if p2 >= limit {
            break
        }
        for i := p2; i < limit; i += 2 * p {
            c[i] = true
        }
        for {
            p += 2
            if !c[p] {
                break
            }
        }
    }
    return c
}

func commatize(n int) string {
    s := fmt.Sprintf("%d", n)
    if n < 0 {
        s = s[1:]
    }
    le := len(s)
    for i := le - 3; i >= 1; i -= 3 {
        s = s[0:i] + "," + s[i:]
    }
    if n >= 0 {
        return s
    }
    return "-" + s
}

func strangePrimes(n int, countOnly bool) int {
    c := 0
    f := "%2d: %2d + %2d + %2d = %2d\n"
    var r, s int
    m := 0
    for ; m < len(p) && p[m] <= n; m++ { 
    }
    for i := 1; i < m-2; i++ {
        for j := i + 1; j < m-1; j++ {
            r = p[i] + p[j]
            for k := j + 1; k < m; k++ {
                s = r + p[k]
                if !sieved[s] {
                    c++
                    if !countOnly {
                        fmt.Printf(f, c, p[i], p[j], p[k], s)
                    }
                }
            }
        }
    }
    return c
}

func main() {
    const max = 1000
    sieved = sieve(3*max)
    for i := 3; i <= max; i += 2 {
        if !sieved[i] {
            p = append(p, i)
        }
    }
    fmt.Println("Unique prime triples under 30 which sum to a prime:")
    strangePrimes(29, false)
    cs := commatize(strangePrimes(999, true))
    fmt.Printf("\nThere are %s unique prime triples under 1,000 which sum to a prime.\n", cs)
}</syntaxhighlight>

{{out}}
Same as 'basic' version.

=={{header|Java}}==
<syntaxhighlight lang="java">import java.util.*;

public class StrangeUniquePrimeTriplets {
    public static void main(String[] args) {
        strangeUniquePrimeTriplets(30, true);
        strangeUniquePrimeTriplets(1000, false);
    }

    private static void strangeUniquePrimeTriplets(int limit, boolean verbose) {
        boolean[] sieve = primeSieve(limit * 3);
        List<Integer> primeList = new ArrayList<>();
        for (int p = 3; p < limit; p += 2) {
            if (sieve[p])
                primeList.add(p);
        }
        int n = primeList.size();
        // Convert object list to primitive array for performance
        int[] primes = new int[n];
        for (int i = 0; i < n; ++i)
            primes[i] = primeList.get(i);
        int count = 0;
        if (verbose)
            System.out.printf("Strange unique prime triplets < %d:\n", limit);
        for (int i = 0; i + 2 < n; ++i) {
            for (int j = i + 1; j + 1 < n; ++j) {
                int s = primes[i] + primes[j];
                for (int k = j + 1; k < n; ++k) {
                    int sum = s + primes[k];
                    if (sieve[sum]) {
                        ++count;
                        if (verbose)
                            System.out.printf("%2d + %2d + %2d = %2d\n", primes[i], primes[j], primes[k], sum);
                    }
                }
            }
        }
        System.out.printf("\nCount of strange unique prime triplets < %d is %d.\n", limit, count);
    }

    private static boolean[] primeSieve(int limit) {
        boolean[] sieve = new boolean[limit];
        Arrays.fill(sieve, true);
        if (limit > 0)
            sieve[0] = false;
        if (limit > 1)
            sieve[1] = false;
        for (int i = 4; i < limit; i += 2)
            sieve[i] = false;
        for (int p = 3; ; p += 2) {
            int q = p * p;
            if (q >= limit)
                break;
            if (sieve[p]) {
                int inc = 2 * p;
                for (; q < limit; q += inc)
                    sieve[q] = false;
            }
        }
        return sieve;
    }
}</syntaxhighlight>

{{out}}
<pre>
Strange unique prime triplets < 30:
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71

Count of strange unique prime triplets < 30 is 42.

Count of strange unique prime triplets < 1000 is 241580.
</pre>

=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''

See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
<syntaxhighlight lang="jq">def count(s): reduce s as $x (null; .+1);

def task($n):
  [2, (range(3;$n;2)|select(is_prime))] 
  | . as $p
  | range(0; length) as $i
  | range($i+1; length) as $j
  | range($j+1; length) as $k
  | [.[$i], .[$j], .[$k]] 
  | select( add| is_prime) ;

task(30),
"\nStretch goal: \(count(task(1000)))"</syntaxhighlight>
{{out}}
<pre>
[3,5,11]
[3,5,23]
[3,5,29]
[3,7,13]
[3,7,19]
[3,11,17]
[3,11,23]
[3,11,29]
[3,17,23]
[5,7,11]
[5,7,17]
[5,7,19]
[5,7,29]
[5,11,13]
[5,13,19]
[5,13,23]
[5,13,29]
[5,17,19]
[5,19,23]
[5,19,29]
[7,11,13]
[7,11,19]
[7,11,23]
[7,11,29]
[7,13,17]
[7,13,23]
[7,17,19]
[7,17,23]
[7,17,29]
[7,23,29]
[11,13,17]
[11,13,19]
[11,13,23]
[11,13,29]
[11,17,19]
[11,19,23]
[11,19,29]
[13,17,23]
[13,17,29]
[13,19,29]
[17,19,23]
[19,23,29]

Stretch goal: 241580
</pre>
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Primes

function prime_sum_prime_triplets_to(N, verbose=false)
    a = primes(3, N)
    prime_sieve_set = primesmask(1, N * 3)
    len, triplets, n = length(a), Dict{Tuple{Int64,Int64,Int64}, Int}(), 0
    for i in eachindex(a), j in i+1:len, k in j+1:len
        if prime_sieve_set[a[i] + a[j] + a[k]]
            verbose && (triplets[(a[i], a[j], a[k])] = 1)
            n += 1
        end
    end
    if verbose
        len = (length(string(N)) + 2) * 3
        println("\n", rpad("Triplet", len), "Sum\n", "-"^(len+3))
        for k in sort(collect(keys(triplets)), lt = (x, y) -> collect(x) < collect(y))
            println(rpad(k, len), sum(k))
        end
    end
    println("\n\n$n unique triplets of 3 primes between 2 and $N sum to a prime.")
    return triplets
end

prime_sum_prime_triplets_to(30, true)
prime_sum_prime_triplets_to(1000)
@time prime_sum_prime_triplets_to(10000)
@time prime_sum_prime_triplets_to(100000)
</syntaxhighlight>{{out}}
<pre>
Triplet     Sum
---------------
(3, 5, 11)  19
(3, 5, 23)  31
(3, 5, 29)  37
(3, 7, 13)  23
(3, 7, 19)  29
(3, 11, 17) 31
(3, 11, 23) 37
(3, 11, 29) 43
(3, 17, 23) 43
(5, 7, 11)  23
(5, 7, 17)  29
(5, 7, 19)  31
(5, 7, 29)  41
(5, 11, 13) 29
(5, 13, 19) 37
(5, 13, 23) 41
(5, 13, 29) 47
(5, 17, 19) 41
(5, 19, 23) 47
(5, 19, 29) 53
(7, 11, 13) 31
(7, 11, 19) 37
(7, 11, 23) 41
(7, 11, 29) 47
(7, 13, 17) 37
(7, 13, 23) 43
(7, 17, 19) 43
(7, 17, 23) 47
(7, 17, 29) 53
(7, 23, 29) 59
(11, 13, 17)41
(11, 13, 19)43
(11, 13, 23)47
(11, 13, 29)53
(11, 17, 19)47
(11, 19, 23)53
(11, 19, 29)59
(13, 17, 23)53
(13, 17, 29)59
(13, 19, 29)61
(17, 19, 23)59
(19, 23, 29)71


42 unique triplets of 3 primes between 2 and 30 sum to a prime.


241580 unique triplets of 3 primes between 2 and 1000 sum to a prime.


74588542 unique triplets of 3 primes between 2 and 10000 sum to a prime.
  0.509732 seconds (31 allocations: 25.938 KiB)


28694800655 unique triplets of 3 primes between 2 and 100000 sum to a prime.
224.940756 seconds (35 allocations: 218.156 KiB)
</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">p = Prime[Range@PrimePi[30]];
Select[Subsets[p, {3}], Total/*PrimeQ]

p = Prime[Range@PrimePi[1000]];
Length[Select[Subsets[p, {3}], Total/*PrimeQ]]</syntaxhighlight>
{{out}}
<pre>{{3,5,11},{3,5,23},{3,5,29},{3,7,13},{3,7,19},{3,11,17},{3,11,23},{3,11,29},{3,17,23},{5,7,11},{5,7,17},{5,7,19},{5,7,29},{5,11,13},{5,13,19},{5,13,23},{5,13,29},{5,17,19},{5,19,23},{5,19,29},{7,11,13},{7,11,19},{7,11,23},{7,11,29},{7,13,17},{7,13,23},{7,17,19},{7,17,23},{7,17,29},{7,23,29},{11,13,17},{11,13,19},{11,13,23},{11,13,29},{11,17,19},{11,19,23},{11,19,29},{13,17,23},{13,17,29},{13,19,29},{17,19,23},{19,23,29}}
241580</pre>

=={{header|Nim}}==
<syntaxhighlight lang="nim">import strformat, strutils, sugar

func isPrime(n: Positive): bool =
  if n < 2: return false
  if n mod 2 == 0: return n == 2
  if n mod 3 == 0: return n == 3
  var d = 5
  while d * d <= n:
    if n mod d == 0: return false
    inc d, 2
    if n mod d == 0: return false
    inc d, 4
  result = true


iterator triplets(primes: openArray[int]): (int, int, int) =
  ## Yield the triplets.
  for i in 0..primes.high-2:
    let n = primes[i]
    for j in (i+1)..primes.high-1:
      let m = primes[j]
      for k in (j+1)..primes.high:
        let p = primes[k]
        if (n + m + p).isPrime:
          yield (n, m, p)


const Primes30 = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
echo "List of strange unique prime triplets for n < m < p < 30:"
for (n, m, p) in Primes30.triplets():
  echo &"{n:2} + {m:2} + {p:2} = {n+m+p}"

echo()
const Primes1000 = collect(newSeq):
                     for n in 2..999:
                       if n.isPrime: n
var count = 0
for _ in Primes1000.triplets(): inc count
echo "Count of strange unique prime triplets for n < m < p < 1000: ", ($count).insertSep()</syntaxhighlight>

{{out}}
<pre>List of strange unique prime triplets for n < m < p < 30:
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71

Count of strange unique prime triplets for n < m < p < 1000: 241_580</pre>

=={{header|Pascal}}==
{{works with|Free Pascal}}
<syntaxhighlight lang="pascal">program PrimeTriplets;
//Free Pascal Compiler version 3.2.1 [2020/11/03] for x86_64fpc  3.2.1
{$IFDEF FPC}
  {$MODE DELPHI}
  {$Optimization ON,ALL}  
{$ELSE}
  {$APPTYPE CONSOLE}  
{$ENDIF}  
const
  MAXZAHL = 100000;// > 3
  MAXSUM  = 3*MAXZAHL;

  CountOfPrimes = trunc(MAXZAHL/(ln(MAXZAHL)-1.08))+100;
  
type
  tChkprimes = array[0..MAXSUM] of byte;//prime == 1 , nonprime == 0
var
  Chkprimes:tChkprimes;  
  primes : array[0..CountOfPrimes]of Uint32;//here starting with 3
  count,primeCount:NativeInt;
  
procedure InitPrimes;
//sieve of eratothenes
var
  i,j : NativeInt;
begin
  fillchar(Chkprimes,SizeOf(tChkprimes),#1);
  i := 2;
  j := 2*2;
  if j> MAXSUM then
      EXIT;
  repeat
    Chkprimes[j]:= 0;
    inc(j,i);
  until j> Maxsum;     
  
  For i := 3 to MAXSUM do
  Begin
    if Chkprimes[i] <>0 then
    Begin
      j := i*i;
      if j> MAXSUM then
        Break;
      repeat
        Chkprimes[j]:= 0;
        inc(j,2*i);
      until j> Maxsum;    
    end;
  end;      
 
  j := 0;
  For i := 3 to MAXZAHL do
    IF Chkprimes[i]<>0 then
    Begin
      primes[j] := i;
      inc(j);
    end;  
  primeCount := j-1;
  j :=CountOfPrimes -primeCount;
  
  IF j <0 then 
  begin
    writeln(' Need more space for primes ', -j);
    HALT(-243);
  end;
end;

function GetMaxPrimeIdx(lmt:NativeInt):NativeInt;
begin
  if lmt >= Maxzahl then
  Begin
    result := primecount;
    EXIT; 
  end;
  
  result := 0;
  while (result < primecount) AND (primes[result]<lmt) do
    inc(result);
  dec(result);  
end;

procedure Out_Check(lmt:nativeInt);
//simplest version
var
  i,j,k,s,pc:   NativeInt;
Begin
  pc:= GetMaxPrimeIdx(lmt);
  count := 0;
  For i := 0 to pc do
    For j := i+1 to pc do
      For k := j+1 to pc do
      Begin
        s := primes[i]+primes[j]+Primes[k];
        //if takes the longest time
        if ChkPrimes[s]<> 0 then
        begin
          inc(count);
          writeln(count:3,': ',primes[i],'+',primes[j],'+',primes[k],' = ',s);
        end;  
      end;  
  writeln;
end;

procedure Count_Check(pc:nativeInt);
// the power of many registers ( 64-Bit )
var
  cnt : Uint64;
  pPrimes : pUint32;
  pChkPrimes : ^tChkprimes;
  pi,pij,i,j,k:   NativeInt;
Begin
  cnt := 0;
  pPrimes := @primes[0];
  pChkPrimes := @Chkprimes[0];
  For i := 0 to pc do
  Begin
    pi := pPrimes[i];
    For j := i+1 to pc do
    begin
      pij := pi+pPrimes[j];
      For k := j+1 to pc do
        inc(cnt,pChkPrimes^[pij+pPrimes[k]]);
    end;  
  end;  
  count := cnt;
end;
  
procedure Check_Limit(lmt:NativeInt);
Begin
  If lmt>primes[primecount] then
    lmt := MaxZahl;
  write('Limit = ',lmt,' count: ');
  Count_Check(GetMaxPrimeIdx(lmt));
  writeln(count);
end;

BEGIN
  InitPrimes;
  Out_Check(30);
  Check_Limit(100);
  Check_Limit(1000);
  Check_Limit(10000);
//Check_Limit(MAXZAHL);  
END.</syntaxhighlight>
{{out}}
<pre>
  1: 3+5+11 = 19
  2: 3+5+23 = 31
  3: 3+5+29 = 37
  4: 3+7+13 = 23
  5: 3+7+19 = 29
  6: 3+11+17 = 31
  7: 3+11+23 = 37
  8: 3+11+29 = 43
  9: 3+17+23 = 43
 10: 5+7+11 = 23
 11: 5+7+17 = 29
 12: 5+7+19 = 31
 13: 5+7+29 = 41
 14: 5+11+13 = 29
 15: 5+13+19 = 37
 16: 5+13+23 = 41
 17: 5+13+29 = 47
 18: 5+17+19 = 41
 19: 5+19+23 = 47
 20: 5+19+29 = 53
 21: 7+11+13 = 31
 22: 7+11+19 = 37
 23: 7+11+23 = 41
 24: 7+11+29 = 47
 25: 7+13+17 = 37
 26: 7+13+23 = 43
 27: 7+17+19 = 43
 28: 7+17+23 = 47
 29: 7+17+29 = 53
 30: 7+23+29 = 59
 31: 11+13+17 = 41
 32: 11+13+19 = 43
 33: 11+13+23 = 47
 34: 11+13+29 = 53
 35: 11+17+19 = 47
 36: 11+19+23 = 53
 37: 11+19+29 = 59
 38: 13+17+23 = 53
 39: 13+17+29 = 59
 40: 13+19+29 = 61
 41: 17+19+23 = 59
 42: 19+23+29 = 71

Limit = 100 count: 891
Limit = 1000 count: 241580
Limit = 10000 count: 74588542
//real    0m0,142s
Limit = 100000 count: 28694800655
real    1m5,378s</pre>

=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl">use strict;
use warnings;
use List::Util 'sum';
use ntheory <primes is_prime>;
use Algorithm::Combinatorics 'combinations';

for my $n (30, 1000) {
    printf "Found %d strange unique prime triplets up to $n.\n",
        scalar grep { is_prime(sum @$_) } combinations(primes($n), 3);
}</syntaxhighlight>
{{out}}
<pre>Found 42 strange unique prime triplets up to 30.
Found 241580 strange unique prime triplets up to 1000.</pre>

=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
 <span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"0.8.4"</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">function</span> <span style="color: #000000;">create_sieve</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">limit</span><span style="color: #0000FF;">)</span>
     <span style="color: #004080;">sequence</span> <span style="color: #000000;">sieve</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">)</span>
     <span style="color: #000000;">sieve</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">4</span> <span style="color: #008080;">to</span> <span style="color: #000000;">limit</span> <span style="color: #008080;">by</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
         <span style="color: #000000;">sieve</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
     <span style="color: #008080;">for</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">=</span><span style="color: #000000;">3</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">))</span> <span style="color: #008080;">by</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
         <span style="color: #004080;">integer</span> <span style="color: #000000;">p2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">*</span><span style="color: #000000;">p</span>
         <span style="color: #008080;">if</span> <span style="color: #000000;">sieve</span><span style="color: #0000FF;">[</span><span style="color: #000000;">p2</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
             <span style="color: #008080;">for</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">p2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">limit</span> <span style="color: #008080;">by</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">*</span><span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
                 <span style="color: #000000;">sieve</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
             <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
     <span style="color: #008080;">return</span> <span style="color: #000000;">sieve</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
  
 <span style="color: #008080;">procedure</span> <span style="color: #000000;">strange_triplets</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">lim</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">bool</span> <span style="color: #000000;">bCountOnly</span><span style="color: #0000FF;">=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
     <span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">(),</span> <span style="color: #000000;">t1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">t0</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span>
     <span style="color: #004080;">sequence</span> <span style="color: #000000;">primes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lim</span><span style="color: #0000FF;">),</span>
              <span style="color: #000000;">sieve</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">create_sieve</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lim</span><span style="color: #0000FF;">*</span><span style="color: #000000;">3</span><span style="color: #0000FF;">),</span>
              <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
     <span style="color: #004080;">atom</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
     <span style="color: #000080;font-style:italic;">--
     -- It is not worth involving 2, ie primes[1],
     -- since (2 + any other two primes) is even,
     -- also we may as well leave space for {j,k},
     -- {k} in the two outer loops.
     -- Using a sieve on the inner test is over
     -- ten times faster than is_prime(), whereas
     -- using a separate table of primes for the
     -- two outer loops is about twice as fast as 
     -- scanning the sieve skipping falsies. Also
     -- interestingly, using nm = n+m is twice as
     -- fast as nmp = n+m+p.
     --</span>
     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
         <span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
         <span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
             <span style="color: #004080;">integer</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">],</span>
                     <span style="color: #000000;">nm</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">+</span><span style="color: #000000;">m</span>
             <span style="color: #008080;">for</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">j</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
                 <span style="color: #004080;">integer</span> <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">],</span>
                         <span style="color: #000000;">nmp</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">nm</span><span style="color: #0000FF;">+</span><span style="color: #000000;">p</span>
                 <span style="color: #008080;">if</span> <span style="color: #000000;">sieve</span><span style="color: #0000FF;">[</span><span style="color: #000000;">nmp</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
                     <span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
                     <span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #000000;">bCountOnly</span> <span style="color: #008080;">then</span>
                         <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%2d: %2d+%2d+%2d = %d"</span><span style="color: #0000FF;">,</span>
                                                  <span style="color: #0000FF;">{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span>  <span style="color: #000000;">m</span><span style="color: #0000FF;">,</span>  <span style="color: #000000;">p</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">nmp</span><span style="color: #0000FF;">}))</span>
                     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
                 <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
                 <span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()></span><span style="color: #000000;">t1</span> <span style="color: #008080;">then</span>
                     <span style="color: #7060A8;">progress</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Working... (%,d)\r"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">})</span>
                     <span style="color: #000000;">t1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()+</span><span style="color: #000000;">1</span>
                 <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
             <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
         <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
     <span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">progress</span><span style="color: #0000FF;">(</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
     <span style="color: #004080;">string</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bCountOnly</span><span style="color: #0000FF;">?</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">" (%s)"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)})</span>
                              <span style="color: #0000FF;">:</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">":\n%s"</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;">3</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"\n"</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 strange triplets &lt; %,d found%s\n\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lim</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">})</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
  
 <span style="color: #000000;">strange_triplets</span><span style="color: #0000FF;">(</span><span style="color: #000000;">30</span><span style="color: #0000FF;">,</span><span style="color: #004600;">false</span><span style="color: #0000FF;">)</span>
 <span style="color: #000000;">strange_triplets</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">)</span>
 <span style="color: #000000;">strange_triplets</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10000</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
42 strange triplets < 30 found:
 1:  3+ 5+11 = 19
 2:  3+ 5+23 = 31
 3:  3+ 5+29 = 37
...
40: 13+19+29 = 61
41: 17+19+23 = 59
42: 19+23+29 = 71

241,580 strange triplets < 1,000 found (0.0s)

74,588,542 strange triplets < 10,000 found (11.4s)
</pre>

=={{header|Prolog}}==
<syntaxhighlight lang="prolog">
primes(2, Limit):- 2 =< Limit.
primes(N, Limit):-
	between(3, Limit, N),
	N /\ 1 > 0,              % odd
	M is floor(sqrt(N)) - 1, % reverse 2*I+1
	Max is M div 2,
	forall(between(1, Max, I), N mod (2*I+1) > 0).

primeComb(N, List, Comb):-
	comb(N, List, Comb),
	sumlist(Comb, Sum),
	primes(Sum, inf).

comb(0, _, []).
comb(N, [X|T], [X|Comb]):-
	N > 0,
    N1 is N - 1,
    comb(N1, T, Comb).
comb(N, [_|T], Comb):-
    N > 0,
    comb(N, T, Comb).

tripletList(Limit, List, Len):-
	findall(N, primes(N, Limit), PrimeList),
	findall(Comb, primeComb(3, PrimeList, Comb), List),
	length(List, Len).

showList([]).
showList([[I, J, K]|TList]):-
	Sum is I + J + K,
	writef('%3r +%3r +%3r =%3r\n', [I, J, K, Sum]),
	showList(TList).

run([]).
run([Limit|TLimits]):-
	tripletList(Limit, List, Len),
	( Limit < 50
	  -> List1 = List
	  ; List1 = []
	),
	showList(List1),
	writef('number of prime Triplets up to%5r is%7r\n', [Limit, Len]),
	run(TLimits).
	
do:- run([30, 1000]).
</syntaxhighlight>
{{out}}
<pre>
?- do.
  3 +  5 + 11 = 19
  3 +  5 + 23 = 31
  3 +  5 + 29 = 37
       ...
 13 + 19 + 29 = 61
 17 + 19 + 23 = 59
 19 + 23 + 29 = 71
number of prime Triplets up to   30 is     42
number of prime Triplets up to 1000 is 241580
true.
</pre>

=={{header|Python}}==
Using [https://docs.sympy.org/latest/modules/ntheory.html#sympy.ntheory.generate.Sieve.primerange sympy.primerange].

<syntaxhighlight lang="python">from sympy import primerange

def strange_triplets(mx: int = 30) -> None:
    primes = list(primerange(0, mx))
    primes3 = set(primerange(0, 3 * mx))
    for i, n in enumerate(primes):
        for j, m in enumerate(primes[i + 1:], i + 1):
            for p in primes[j + 1:]:
                if n + m + p in primes3:
                    yield n, m, p

for c, (n, m, p) in enumerate(strange_triplets(), 1):
    print(f"{c:2}: {n:2}+{m:2}+{p:2} = {n + m + p}")

mx = 1_000
print(f"\nIf n, m, p < {mx:_} finds {sum(1 for _ in strange_triplets(mx)):_}")</syntaxhighlight>

{{out}}
<pre> 1:  3+ 5+11 = 19
 2:  3+ 5+23 = 31
 3:  3+ 5+29 = 37
 4:  3+ 7+13 = 23
 5:  3+ 7+19 = 29
 6:  3+11+17 = 31
 7:  3+11+23 = 37
 8:  3+11+29 = 43
 9:  3+17+23 = 43
10:  5+ 7+11 = 23
11:  5+ 7+17 = 29
12:  5+ 7+19 = 31
13:  5+ 7+29 = 41
14:  5+11+13 = 29
15:  5+13+19 = 37
16:  5+13+23 = 41
17:  5+13+29 = 47
18:  5+17+19 = 41
19:  5+19+23 = 47
20:  5+19+29 = 53
21:  7+11+13 = 31
22:  7+11+19 = 37
23:  7+11+23 = 41
24:  7+11+29 = 47
25:  7+13+17 = 37
26:  7+13+23 = 43
27:  7+17+19 = 43
28:  7+17+23 = 47
29:  7+17+29 = 53
30:  7+23+29 = 59
31: 11+13+17 = 41
32: 11+13+19 = 43
33: 11+13+23 = 47
34: 11+13+29 = 53
35: 11+17+19 = 47
36: 11+19+23 = 53
37: 11+19+29 = 59
38: 13+17+23 = 53
39: 13+17+29 = 59
40: 13+19+29 = 61
41: 17+19+23 = 59
42: 19+23+29 = 71

If n, m, p < 1_000 finds 241_580</pre>

=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line># 20210312 Raku programming solution

for 30, 1000 -> \k {
   given (2..k).grep(*.is-prime).combinations(3).grep(*.sum.is-prime) {
      say "Found ", +$_, " strange unique prime triplets up to ", k
   }
}</syntaxhighlight>
{{out}}
<pre>
Found 42 strange unique prime triplets up to 30
Found 241580 strange unique prime triplets up to 1000
</pre>

=={{header|REXX}}==
<syntaxhighlight lang="rexx">/*REXX program finds/lists triplet strange primes (<HI) where the triplets' sum is prime*/
parse arg hi .                                   /*obtain optional argument from the CL.*/
if hi=='' | hi==","  then hi= 30                 /*Not specified?  Then use the default.*/
tell= hi>0;            hi= abs(hi);  hi= hi - 1  /*use absolute value of  HI for limit. */
if tell>0  then say  'list of unique triplet strange primes whose sum is a prime.:'
call genP                                        /*build array of semaphores for primes.*/
finds= 0                                         /*# of triplet strange primes (so far).*/
say
   do     m=2+1  by 2  to hi;     if \!.m  then iterate      /*just use the odd primes. */
     do   n=m+2  by 2  to hi;     if \!.n  then iterate      /*  "   "   "   "     "    */
     mn= m + n                                               /*partial sum (deep loops).*/
       do p=n+2  by 2  to hi;     if \!.p  then iterate      /*just use the odd primes. */
       sum= mn + p                                           /*compute sum of 3 primes. */
       if \!.sum  then iterate                   /*Is the sum prime?   No, then skip it.*/
       finds= finds + 1                          /*bump # of triplet  "strange"  primes.*/
       if tell  then say right(m, w+9) right(n, w) right(p, w) ' sum to:'  right(sum, w+2)
       end   /*p*/
     end     /*n*/
   end       /*m*/
say
say 'Found '      commas(finds)      " unique triplet strange primes  < "   commas(hi+1) ,
                                     " which sum to a prime."
exit 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 ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
genP: !.= 0;                    w= length(hi)    /*semaphores for primes;  width of #'s.*/
      @.1=2;  @.2=3;  @.3=5;  @.4=7;  @.5=11     /*define some low primes.              */
      !.2=1;  !.3=1;  !.5=1;  !.7=1;  !.11=1     /*   "     "   "    "     semaphores.  */
                        #=5;     s.#= @.# **2    /*number of primes so far;     prime². */
                                                 /* [↓]  generate more  primes  ≤  high.*/
        do j=@.#+2  by 2  for hi*3%2             /*find odd primes from here on.        */
        parse var j '' -1 _; if     _==5  then iterate  /*J divisible by 5?  (right dig)*/
                             if j// 3==0  then iterate  /*"     "      " 3?             */
                             if j// 7==0  then iterate  /*"     "      " 7?             */
                                                 /* [↑]  the above five lines saves time*/
               do k=5  while s.k<=j              /* [↓]  divide by the known odd primes.*/
               if j // @.k == 0  then iterate j  /*Is  J ÷ X?  Then not prime.     ___  */
               end   /*k*/                       /* [↑]  only process numbers  ≤  √ J   */
        #= #+1;    @.#= j;    s.#= j*j;   !.j= 1 /*bump # of Ps; assign next P;  P²; P# */
        end          /*j*/;   return</syntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
list of unique triplet strange primes that sum to a prime:
prime generation took 0.02 seconds.

          3  5 11   sum to:    19
          3  5 23   sum to:    31
          3  5 29   sum to:    37
          3  7 13   sum to:    23
          3  7 19   sum to:    29
          3 11 17   sum to:    31
          3 11 23   sum to:    37
          3 11 29   sum to:    43
          3 17 23   sum to:    43
          5  7 11   sum to:    23
          5  7 17   sum to:    29
          5  7 19   sum to:    31
          5  7 29   sum to:    41
          5 11 13   sum to:    29
          5 13 19   sum to:    37
          5 13 23   sum to:    41
          5 13 29   sum to:    47
          5 17 19   sum to:    41
          5 19 23   sum to:    47
          5 19 29   sum to:    53
          7 11 13   sum to:    31
          7 11 19   sum to:    37
          7 11 23   sum to:    41
          7 11 29   sum to:    47
          7 13 17   sum to:    37
          7 13 23   sum to:    43
          7 17 19   sum to:    43
          7 17 23   sum to:    47
          7 17 29   sum to:    53
          7 23 29   sum to:    59
         11 13 17   sum to:    41
         11 13 19   sum to:    43
         11 13 23   sum to:    47
         11 13 29   sum to:    53
         11 17 19   sum to:    47
         11 19 23   sum to:    53
         11 19 29   sum to:    59
         13 17 23   sum to:    53
         13 17 29   sum to:    59
         13 19 29   sum to:    61
         17 19 23   sum to:    59
         19 23 29   sum to:    71

Found  42  unique triplet strange primes  <  30  which sum to a prime.
</pre>

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> -1000 </tt>}}
<pre>
Found  241,580  unique triplet strange primes  <  1,000  which sum to a prime.
</pre>

=={{header|Ring}}==
<syntaxhighlight lang="ring">
load "stdlib.ring"

num = 0
limit = 30

see "working..." + nl
see "the strange primes are:" + nl

for n = 1 to limit
    for m = n+1 to limit
        for p = m+1 to limit
            sum = n+m+p
            if isprime(sum) and isprime(n) and isprime(m) and isprime(p)
               num = num + 1
               see "" + num + ": " + n + "+" + m + "+" + p + " = " + sum + nl
            ok
        next
    next
next

see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
working...
the strange primes are:
1: 3+5+11 = 19
2: 3+5+23 = 31
3: 3+5+29 = 37
4: 3+7+13 = 23
5: 3+7+19 = 29
6: 3+11+17 = 31
7: 3+11+23 = 37
8: 3+11+29 = 43
9: 3+17+23 = 43
10: 5+7+11 = 23
11: 5+7+17 = 29
12: 5+7+19 = 31
13: 5+7+29 = 41
14: 5+11+13 = 29
15: 5+13+19 = 37
16: 5+13+23 = 41
17: 5+13+29 = 47
18: 5+17+19 = 41
19: 5+19+23 = 47
20: 5+19+29 = 53
21: 7+11+13 = 31
22: 7+11+19 = 37
23: 7+11+23 = 41
24: 7+11+29 = 47
25: 7+13+17 = 37
26: 7+13+23 = 43
27: 7+17+19 = 43
28: 7+17+23 = 47
29: 7+17+29 = 53
30: 7+23+29 = 59
31: 11+13+17 = 41
32: 11+13+19 = 43
33: 11+13+23 = 47
34: 11+13+29 = 53
35: 11+17+19 = 47
36: 11+19+23 = 53
37: 11+19+29 = 59
38: 13+17+23 = 53
39: 13+17+29 = 59
40: 13+19+29 = 61
41: 17+19+23 = 59
42: 19+23+29 = 71
done...

</pre>

=={{header|Rust}}==
<syntaxhighlight lang="rust">fn prime_sieve(limit: usize) -> Vec<bool> {
    let mut sieve = vec![true; limit];
    if limit > 0 {
        sieve[0] = false;
    }
    if limit > 1 {
        sieve[1] = false;
    }
    for i in (4..limit).step_by(2) {
        sieve[i] = false;
    }
    let mut p = 3;
    loop {
        let mut q = p * p;
        if q >= limit {
            break;
        }
        if sieve[p] {
            let inc = 2 * p;
            while q < limit {
                sieve[q] = false;
                q += inc;
            }
        }
        p += 2;
    }
    sieve
}

fn strange_unique_prime_triplets(limit: usize, verbose: bool) {
    if limit < 6 {
        return;
    }
    let mut primes = Vec::new();
    let sieve = prime_sieve(limit * 3);
    for p in (3..limit).step_by(2) {
        if sieve[p] {
            primes.push(p);
        }
    }
    if verbose {
        println!("Strange unique prime triplets < {}:", limit);
    }
    let mut count = 0;
    let n = primes.len();
    for i in 0..n - 2 {
        for j in i + 1..n - 1 {
            for k in j + 1..n {
                let sum = primes[i] + primes[j] + primes[k];
                if sieve[sum] {
                    count += 1;
                    if verbose {
                        println!(
                            "{:2} + {:2} + {:2} = {:2}",
                            primes[i], primes[j], primes[k], sum
                        );
                    }
                }
            }
        }
    }
    println!(
        "Count of strange unique prime triplets < {} is {}.",
        limit, count
    );
}

fn main() {
    strange_unique_prime_triplets(30, true);
    strange_unique_prime_triplets(1000, false);
}</syntaxhighlight>

{{out}}
<pre>
Strange unique prime triplets < 30:
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71
Count of strange unique prime triplets < 30 is 42.
Count of strange unique prime triplets < 1000 is 241580.
</pre>

=={{header|Scala}}==
Scala3 ready
<syntaxhighlight lang="scala">
val primeStream5 = LazyList.from(5, 6)
    .flatMap(n => Seq(n, n + 2))
    .filter(p => (5 to math.sqrt(p).floor.toInt by 6).forall(a => p % a > 0 && p % (a + 2) > 0))

val primes = LazyList(2, 3) ++ primeStream5

def isPrime(n: Int): Boolean = 
    if (n < 5) (n | 1) == 3
    else primes.takeWhile(_ <= math.sqrt(n)).forall(n % _ > 0)

def triplets(limit: Int): Iterator[Seq[Int]] = 
    primes.takeWhile(_ <= limit)
        .combinations{3}
        .filter(primeTriplet => isPrime(primeTriplet.sum))

@main def main: Unit = {
    for (list <- triplets(30)) {
        val Seq(k, l, m) = list
        println(f"$k%2d + $l%2d + $m%2d = ${list.sum}%2d")
    }

    for (limit <- Seq(30, 1000)) {
        val start = System.currentTimeMillis
        val num = triplets(limit).length
        val duration = System.currentTimeMillis - start
        println(f"number of prime triplets up to $limit%4d is $num%6d [time(ms): $duration%4d]")
    }
}
</syntaxhighlight>
{{out}}
<pre>
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71
number of prime triplets up to   30 is     42 [time(ms):    2]
number of prime triplets up to 1000 is 241580 [time(ms): 1271]
</pre>

=={{header|Sidef}}==
<syntaxhighlight lang="ruby">for n in (30, 1000) {
    var triplets = []
    combinations(n.primes, 3, {|*a|
        triplets << a if a.sum.is_prime
    })
    if (n == 30) {
        say "Unique prime triplets (p,q,r) <= #{n} such that p+q+r is prime:"
        triplets.slices(6).each{.join(' ').say}
    }
    printf("Found %d strange unique prime triplets up to %s.\n", triplets.len, n)
}</syntaxhighlight>
{{out}}
<pre>
Unique prime triplets (p,q,r) <= 30 such that p+q+r is prime:
[3, 5, 11] [3, 5, 23] [3, 5, 29] [3, 7, 13] [3, 7, 19] [3, 11, 17]
[3, 11, 23] [3, 11, 29] [3, 17, 23] [5, 7, 11] [5, 7, 17] [5, 7, 19]
[5, 7, 29] [5, 11, 13] [5, 13, 19] [5, 13, 23] [5, 13, 29] [5, 17, 19]
[5, 19, 23] [5, 19, 29] [7, 11, 13] [7, 11, 19] [7, 11, 23] [7, 11, 29]
[7, 13, 17] [7, 13, 23] [7, 17, 19] [7, 17, 23] [7, 17, 29] [7, 23, 29]
[11, 13, 17] [11, 13, 19] [11, 13, 23] [11, 13, 29] [11, 17, 19] [11, 19, 23]
[11, 19, 29] [13, 17, 23] [13, 17, 29] [13, 19, 29] [17, 19, 23] [19, 23, 29]
Found 42 strange unique prime triplets up to 30.
Found 241580 strange unique prime triplets up to 1000.
</pre>

=={{header|Swift}}==
<syntaxhighlight lang="swift">import Foundation

func primeSieve(limit: Int) -> [Bool] {
    guard limit > 0 else {
        return []
    }
    var sieve = Array(repeating: true, count: limit)
    sieve[0] = false
    if limit > 1 {
        sieve[1] = false
    }
    if limit > 4 {
        for i in stride(from: 4, to: limit, by: 2) {
            sieve[i] = false
        }
    }
    var p = 3
    while true {
        var q = p * p
        if q >= limit {
            break
        }
        if sieve[p] {
            let inc = 2 * p
            while q < limit {
                sieve[q] = false
                q += inc
            }
        }
        p += 2
    }
    return sieve
}

func strangeUniquePrimeTriplets(limit: Int, verbose: Bool) {
    guard limit > 5 else {
        return;
    }
    let sieve = primeSieve(limit: 3 * limit)
    var primes: [Int] = []
    for p in stride(from: 3, to: limit, by: 2) {
        if sieve[p] {
            primes.append(p)
        }
    }
    let n = primes.count
    var count = 0
    if verbose {
        print("Strange unique prime triplets < \(limit):")
    }
    for i in (0..<n - 2) {
        for j in (i + 1..<n - 1) {
            for k in (j + 1..<n) {
                let sum = primes[i] + primes[j] + primes[k]
                if sieve[sum] {
                    count += 1
                    if verbose {
                        print(String(format: "%2d + %2d + %2d = %2d",
                                     primes[i], primes[j], primes[k], sum))
                    }
                }
            }
        }
    }
    print("\nCount of strange unique prime triplets < \(limit) is \(count).")
}

strangeUniquePrimeTriplets(limit: 30, verbose: true)
strangeUniquePrimeTriplets(limit: 1000, verbose: false)</syntaxhighlight>

{{out}}
<pre>
Strange unique prime triplets < 30:
 3 +  5 + 11 = 19
 3 +  5 + 23 = 31
 3 +  5 + 29 = 37
 3 +  7 + 13 = 23
 3 +  7 + 19 = 29
 3 + 11 + 17 = 31
 3 + 11 + 23 = 37
 3 + 11 + 29 = 43
 3 + 17 + 23 = 43
 5 +  7 + 11 = 23
 5 +  7 + 17 = 29
 5 +  7 + 19 = 31
 5 +  7 + 29 = 41
 5 + 11 + 13 = 29
 5 + 13 + 19 = 37
 5 + 13 + 23 = 41
 5 + 13 + 29 = 47
 5 + 17 + 19 = 41
 5 + 19 + 23 = 47
 5 + 19 + 29 = 53
 7 + 11 + 13 = 31
 7 + 11 + 19 = 37
 7 + 11 + 23 = 41
 7 + 11 + 29 = 47
 7 + 13 + 17 = 37
 7 + 13 + 23 = 43
 7 + 17 + 19 = 43
 7 + 17 + 23 = 47
 7 + 17 + 29 = 53
 7 + 23 + 29 = 59
11 + 13 + 17 = 41
11 + 13 + 19 = 43
11 + 13 + 23 = 47
11 + 13 + 29 = 53
11 + 17 + 19 = 47
11 + 19 + 23 = 53
11 + 19 + 29 = 59
13 + 17 + 23 = 53
13 + 17 + 29 = 59
13 + 19 + 29 = 61
17 + 19 + 23 = 59
19 + 23 + 29 = 71

Count of strange unique prime triplets < 30 is 42.

Count of strange unique prime triplets < 1000 is 241580.
</pre>

=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Imports DT = System.DateTime

Module Module1

    Iterator Function Primes(lim As Integer) As IEnumerable(Of Integer)
        Dim flags(lim) As Boolean

        Dim j = 2

        Dim d = 3
        Dim sq = 4
        While sq <= lim
            If Not flags(j) Then
                Yield j
                For k = sq To lim Step j
                    flags(k) = True
                Next
            End If

            j += 1
            d += 2
            sq += d
        End While

        While j <= lim
            If Not flags(j) Then
                Yield j
            End If
            j += 1
        End While
    End Function

    Sub Main()
        For Each lmt In {90, 300, 3000, 30000, 111000}
            Dim pr = Primes(lmt).Skip(1).ToList()
            Dim st = DT.Now
            Dim f = 0
            Dim r As New List(Of String)
            Dim i = -1
            Dim m = lmt \ 3
            Dim h = m
            While i < 0
                i = pr.IndexOf(h)
                h -= 1
            End While
            Dim j = i - 1
            Dim k = j - 1
            For a = 0 To k
                Dim pra = pr(a)
                For b = a + 1 To j
                    Dim prab = pra + pr(b)
                    For c = b + 1 To i
                        Dim d = prab + pr(c)
                        If Not pr.Contains(d) Then
                            Continue For
                        End If
                        f += 1
                        If lmt < 100 Then
                            r.Add(String.Format("{3,5} = {0,2} + {1,2} + {2,2}", pra, pr(b), pr(c), d))
                        End If
                    Next
                Next
            Next
            Dim s = "s.u.p.t.s under "
            r.Sort()
            If r.Count > 0 Then
                Console.WriteLine("{0}{1}:" + vbNewLine + "{2}", s, m, String.Join(vbNewLine, r))
            End If
            If lmt > 100 Then
                Console.WriteLine("Count of {0}{1,6:n0}: {2,13:n0}  {3} sec", s, m, f, (DT.Now - st).ToString().Substring(6))
            End If
        Next
    End Sub

End Module</syntaxhighlight>
{{out}}
<pre>Same as C#</pre>

=={{header|Wren}}==
===Basic===
{{libheader|Wren-math}}
{{libheader|Wren-trait}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="ecmascript">import "/math" for Int
import "/trait" for Stepped
import "/fmt" for Fmt

var strangePrimes = Fn.new { |n, countOnly|
    var c = 0
    var s 
    for (i in Stepped.new(3..n-4, 2)) {
        if (Int.isPrime(i)) {
            for (j in Stepped.new(i+2..n-2, 2)) {
                if (Int.isPrime(j)) {
                    for (k in Stepped.new(j+2..n, 2)) {
                        if (Int.isPrime(k) && Int.isPrime(s = i + j + k)) {
                            c = c + 1
                            if (!countOnly) Fmt.print("$2d: $2d + $2d + $2d = $2d", c, i, j, k, s)
                        }
                    }
                }
            }
        }
    }
    return c
}

System.print("Unique prime triples under 30 which sum to a prime:")
strangePrimes.call(29, false)
var c = strangePrimes.call(999, true)
Fmt.print("\nThere are $,d unique prime triples under 1,000 which sum to a prime.", c)</syntaxhighlight>

{{out}}
<pre>
Unique prime triples under 30 which sum to a prime:
 1:  3 +  5 + 11 = 19
 2:  3 +  5 + 23 = 31
 3:  3 +  5 + 29 = 37
 4:  3 +  7 + 13 = 23
 5:  3 +  7 + 19 = 29
 6:  3 + 11 + 17 = 31
 7:  3 + 11 + 23 = 37
 8:  3 + 11 + 29 = 43
 9:  3 + 17 + 23 = 43
10:  5 +  7 + 11 = 23
11:  5 +  7 + 17 = 29
12:  5 +  7 + 19 = 31
13:  5 +  7 + 29 = 41
14:  5 + 11 + 13 = 29
15:  5 + 13 + 19 = 37
16:  5 + 13 + 23 = 41
17:  5 + 13 + 29 = 47
18:  5 + 17 + 19 = 41
19:  5 + 19 + 23 = 47
20:  5 + 19 + 29 = 53
21:  7 + 11 + 13 = 31
22:  7 + 11 + 19 = 37
23:  7 + 11 + 23 = 41
24:  7 + 11 + 29 = 47
25:  7 + 13 + 17 = 37
26:  7 + 13 + 23 = 43
27:  7 + 17 + 19 = 43
28:  7 + 17 + 23 = 47
29:  7 + 17 + 29 = 53
30:  7 + 23 + 29 = 59
31: 11 + 13 + 17 = 41
32: 11 + 13 + 19 = 43
33: 11 + 13 + 23 = 47
34: 11 + 13 + 29 = 53
35: 11 + 17 + 19 = 47
36: 11 + 19 + 23 = 53
37: 11 + 19 + 29 = 59
38: 13 + 17 + 23 = 53
39: 13 + 17 + 29 = 59
40: 13 + 19 + 29 = 61
41: 17 + 19 + 23 = 59
42: 19 + 23 + 29 = 71

There are 241,580 unique prime triples under 1,000 which sum to a prime.
</pre>

===Faster===
The following version uses a prime sieve and is about 17 times faster than the 'basic' version.
<syntaxhighlight lang="ecmascript">import "/math" for Int
import "/fmt" for Fmt

var max = 1000
var sieved = Int.primeSieve(3*max, false) // includes composites
var p = Int.primeSieve(max, true)         // primes only

var strangePrimes = Fn.new { |n, countOnly|
    var c = 0
    var m = 0
    while (m < p.count && p[m] <= n) m = m + 1
    var r
    var s
    for (i in 1...m-2) {
        for (j in i+1...m-1) {
            r = p[i] + p[j]
            for (k in j+1...m) {
                if (!sieved[s = r + p[k]]) {
                    c = c + 1
                    if (!countOnly) Fmt.print("$2d: $2d + $2d + $2d = $2d", c, p[i], p[j], p[k], s)
                }
            }
        }
    }
    return c
}

System.print("Unique prime triples under 30 which sum to a prime:")
strangePrimes.call(29, false)
var c = strangePrimes.call(999, true)
Fmt.print("\nThere are $,d unique prime triples under 1,000 which sum to a prime.", c)</syntaxhighlight>

{{out}}
Same as 'basic' version.

=={{header|XPL0}}==
<syntaxhighlight 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;
];      \IsPrime

int Primes, Cnt, P, M, N, S;
[Primes:= [2, 3, 5, 7, 11, 13, 17, 19, 23, 29];
Format(2, 0);
Cnt:= 0;
for P:= 2 to 9 do
    for M:= 1 to P-1 do
        for N:= 0 to M-1 do
            [S:= Primes(N) + Primes(M) + Primes(P);
            if IsPrime(S) then
                [Cnt:= Cnt+1;
                RlOut(0, float(Cnt));
                Text(0, ":  ");
                RlOut(0, float(Primes(N)));
                Text(0, " + ");
                RlOut(0, float(Primes(M)));
                Text(0, " + ");
                RlOut(0, float(Primes(P)));
                Text(0, "  =  ");
                RlOut(0, float(S));
                CrLf(0);
                ];
            ];
]</syntaxhighlight>

{{out}}
<pre>
 1:   3 +  5 + 11  =  19
 2:   5 +  7 + 11  =  23
 3:   3 +  7 + 13  =  23
 4:   5 + 11 + 13  =  29
 5:   7 + 11 + 13  =  31
 6:   5 +  7 + 17  =  29
 7:   3 + 11 + 17  =  31
 8:   7 + 13 + 17  =  37
 9:  11 + 13 + 17  =  41
10:   3 +  7 + 19  =  29
11:   5 +  7 + 19  =  31
12:   7 + 11 + 19  =  37
13:   5 + 13 + 19  =  37
14:  11 + 13 + 19  =  43
15:   5 + 17 + 19  =  41
16:   7 + 17 + 19  =  43
17:  11 + 17 + 19  =  47
18:   3 +  5 + 23  =  31
19:   3 + 11 + 23  =  37
20:   7 + 11 + 23  =  41
21:   5 + 13 + 23  =  41
22:   7 + 13 + 23  =  43
23:  11 + 13 + 23  =  47
24:   3 + 17 + 23  =  43
25:   7 + 17 + 23  =  47
26:  13 + 17 + 23  =  53
27:   5 + 19 + 23  =  47
28:  11 + 19 + 23  =  53
29:  17 + 19 + 23  =  59
30:   3 +  5 + 29  =  37
31:   5 +  7 + 29  =  41
32:   3 + 11 + 29  =  43
33:   7 + 11 + 29  =  47
34:   5 + 13 + 29  =  47
35:  11 + 13 + 29  =  53
36:   7 + 17 + 29  =  53
37:  13 + 17 + 29  =  59
38:   5 + 19 + 29  =  53
39:  11 + 19 + 29  =  59
40:  13 + 19 + 29  =  61
41:   7 + 23 + 29  =  59
42:  19 + 23 + 29  =  71
</pre>