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

 

If n, m, p < 1000 finds 241580

</pre>

 

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

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

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

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

INT s count := 0, c30 := 0;

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>

Found 241580 strange unique prime triplets up to 1000

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

74588542

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

Count of strange unique prime triplets < 1000: 241580

</pre>

 

=={{header|Go}}==

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

Same as 'basic' version.

 

=={{header|Java}}==

 

public class StrangeUniquePrimeTriplets {

return sieve;

}

 

{{out}}

 

Count of strange unique prime triplets < 1000 is 241580.

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

224.940756 seconds (35 allocations: 218.156 KiB)

</pre>

 

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

 

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

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

 

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

 

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

done...

 

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

Count of strange unique prime triplets < 30 is 42.

Count of strange unique prime triplets < 1000 is 241580.

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

===Basic===

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

 

var strangePrimes = Fn.new { |n, countOnly|

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.

 

var max = 1000

strangePrimes.call(29, false)

var c = strangePrimes.call(999, true)

 

{{out}}

Same as 'basic' version.