Strange unique prime triplets: Difference between revisions

{{trans|Python}}

 

V is_prime = [0B] * 2 [+] [1B] * (limit - 1)

L(n) 0 .< Int(limit ^ 0.5 + 1.5)

 

V mx = 1'000

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Sieve of Eratosthenes}}

 

PROC Main()

OD

PrintF("%EThere are %I prime triplets",count)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Strange_unique_prime_triplets.png Screenshot from Atari 8-bit computer]

{{Trans|Algol W}} which is based on {{Trans|Wren}}

{{libheader|ALGOL 68-primes}}

# where n + m + p is also prime and n =/= m =/= p #

# we need to find the strange unique prime triplets below 1000 #

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

{{out}}

<pre>

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

Based on {{Trans|Wren}}

% where n + m + p is also prime and n =/= m =/= p %

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

write( i_w := 3, s_w := 0, "Found ", sCount, " strange unique prime triplets up to 1000" );

end

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f STRANGE_UNIQUE_PRIME_TRIPLETS.AWK

# converted from Go

return(1)

}

{{out}}

<pre>

 

=={{header|C}}==

#include <stdio.h>

#include <string.h>

 

return 0;

{{out}}

<pre>Strange unique prime triplets < 30:

=={{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.

 

class Program { static void Main(string[] args) { string s;

if (!flags[j]) { yield return j;

for (int k = sq; k <= lim; k += j) flags[k] = true; }

{{out}}

Timings from tio.run

 

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

#include <iostream>

#include <vector>

strange_unique_prime_triplets(1000, false);

return 0;

 

{{out}}

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Strange_primes;

 

writeln('There are ', cs, ' unique prime triples under 1,000 which sum to a prime.');

readln;

 

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

This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>

// Strange unique prime triplets. Nigel Galloway: March 12th., 2021

let sP n=let N=primes32()|>Seq.takeWhile((>)n)|>Array.ofSeq

printfn "%d" (Seq.length(sP 1000))

printfn "%d" (Seq.length(sP 10000))

{{out}}

<pre>

</pre>

=={{header|Factor}}==

sequences tools.memory.private ;

 

30 strange

1,000 count-strange commas nl

{{out}}

<pre>

 

=={{header|Fermat}}==

if Isprime(n) and Isprime(m) and Isprime(p) and Isprime(n+m+p) then 1 else 0 fi.

 

od;

od;

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.

 

dim as uinteger c = 0

next p

 

{{out}}<pre>3 + 5 + 11 = 19

3 + 5 + 23 = 31

=={{header|Forth}}==

{{works with|Gforth}}

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

 

." Count of strange unique prime triplets < 1000: "

1000 count_strange_unique_prime_triplets . cr

 

{{out}}

===Basic===

{{trans|Wren}}

 

import "fmt"

cs := commatize(strangePrimes(999, true))

fmt.Printf("\nThere are %s unique prime triples under 1,000 which sum to a prime.\n", cs)

 

{{out}}

===Faster===

{{trans|Wren}}

 

import "fmt"

cs := commatize(strangePrimes(999, true))

fmt.Printf("\nThere are %s unique prime triples under 1,000 which sum to a prime.\n", cs)

 

{{out}}

 

=={{header|Java}}==

 

public class StrangeUniquePrimeTriplets {

return sieve;

}

 

{{out}}

 

See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.

 

def task($n):

 

task(30),

{{out}}

<pre>

</pre>

=={{header|Julia}}==

 

function prime_sum_prime_triplets_to(N, verbose=false)

@time prime_sum_prime_triplets_to(10000)

@time prime_sum_prime_triplets_to(100000)

<pre>

Triplet Sum

 

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

Select[Subsets[p, {3}], Total/*PrimeQ]

 

p = Prime[Range@PrimePi[1000]];

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

 

=={{header|Nim}}==

 

func isPrime(n: Positive): bool =

var count = 0

for _ in Primes1000.triplets(): inc count

 

{{out}}

=={{header|Pascal}}==

{{works with|Free Pascal}}

//Free Pascal Compiler version 3.2.1 [2020/11/03] for x86_64fpc 3.2.1

{$IFDEF FPC}

Check_Limit(10000);

//Check_Limit(MAXZAHL);

{{out}}

<pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use List::Util 'sum';

printf "Found %d strange unique prime triplets up to $n.\n",

scalar grep { is_prime(sum @$_) } combinations(primes($n), 3);

{{out}}

<pre>Found 42 strange unique prime triplets up to 30.

 

=={{header|Phix}}==

<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: #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>

{{out}}

<pre>

Using [https://docs.sympy.org/latest/modules/ntheory.html#sympy.ntheory.generate.Sieve.primerange sympy.primerange].

 

 

def strange_triplets(mx: int = 30) -> None:

 

mx = 1_000

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

 

for 30, 1000 -> \k {

say "Found ", +$_, " strange unique prime triplets up to ", k

}

{{out}}

<pre>

 

=={{header|REXX}}==

parse arg hi . /*obtain optional argument from the CL.*/

if hi=='' | hi=="," then hi= 30 /*Not specified? Then use the default.*/

end /*k*/ /* [↑] only process numbers ≤ √ J */

#= #+1; @.#= j; s.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */

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

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

 

see "done..." + nl

{{out}}

<pre>

 

=={{header|Rust}}==

let mut sieve = vec![true; limit];

if limit > 0 {

strange_unique_prime_triplets(30, true);

strange_unique_prime_triplets(1000, false);

 

{{out}}

 

=={{header|Sidef}}==

var triplets = []

combinations(n.primes, 3, {|*a|

}

printf("Found %d strange unique prime triplets up to %s.\n", triplets.len, n)

{{out}}

<pre>

 

=={{header|Swift}}==

 

func primeSieve(limit: Int) -> [Bool] {

 

strangeUniquePrimeTriplets(limit: 30, verbose: true)

 

{{out}}

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>Same as C#</pre>

{{libheader|Wren-trait}}

{{libheader|Wren-fmt}}

import "/trait" for Stepped

import "/fmt" for Fmt

strangePrimes.call(29, false)

var c = strangePrimes.call(999, true)

 

{{out}}

===Faster===

The following version uses a prime sieve and is about 17 times faster than the 'basic' version.

import "/fmt" for Fmt

 

strangePrimes.call(29, false)

var c = strangePrimes.call(999, true)

 

{{out}}

 

=={{header|XPL0}}==

int N, I;

[if N <= 2 then return N = 2;

];

];

 

{{out}}