Triplet of three numbers: Difference between revisions

Line 8:

<~~lang~~ 11l>V n = 6000

<syntaxhighlight lang="11l">V n = 6000

V p = [0B] * 6000

Line 20:

L.continue

E

print(f:‘{i:4}: {i - 1:4} {i + 3:4} {i + 5:4}’)</~~lang~~>

print(f:‘{i:4}: {i - 1:4} {i + 3:4} {i + 5:4}’)</syntaxhighlight>

Line 74:

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

<~~lang~~ ~~Action~~!>INCLUDE "H6:SIEVE.ACT"

<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"

PROC Main()

Line 91:

OD

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

RETURN</~~lang~~>

RETURN</syntaxhighlight>

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

Line 107:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>with Ada.Text_Io;

<syntaxhighlight lang="ada">with Ada.Text_Io;

procedure Triplets is

Line 151:

end if;

end loop;

end Triplets;</~~lang~~>

end Triplets;</syntaxhighlight>

<pre>

Line 204:

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

<~~lang~~ algol68>BEGIN # find numbers n where n-1, n+3 and n+5 are prime #

<syntaxhighlight lang="algol68">BEGIN # find numbers n where n-1, n+3 and n+5 are prime #

# sieve the primes up to the maximum number for the task #

PR read "primes.incl.a68" PR

Line 221:

OD;

print( ( newline, "Found ", TOSTRING n count, " triplets", newline ) )

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 241:

=={{header|Arturo}}==

<~~lang~~ rebol>lst: select 3..6000 'x

<syntaxhighlight lang="rebol">lst: select 3..6000 'x

-> all? @[prime? x-1 prime? x+3 prime? x+5]

loop split.every: 10 lst 'a ->

print map a => [pad to :string & 5]</~~lang~~>

print map a => [pad to :string & 5]</syntaxhighlight>

Line 256:

=={{header|AWK}}==

# syntax: GAWK -f TRIPLET_OF_THREE_NUMBERS.AWK

BEGIN {

Line 283:

return(1)

}

</syntaxhighlight>

</lang>

<pre>

Line 338:

=={{header|BASIC}}==

<~~lang~~ basic>10 DEFINT A-Z: N=6000

<syntaxhighlight lang="basic">10 DEFINT A-Z: N=6000

20 DIM P(N+5)

30 FOR I=2 TO SQR(N)

Line 346:

70 IF P(I-1) OR P(I+3) OR P(I+5) GOTO 90

80 PRINT USING "####,: ####, ####, ####,";I;I-1;I+3;I+5

90 NEXT</~~lang~~>

90 NEXT</syntaxhighlight>

<pre style='height:50ex'> 8: 7 11 13

Line 398:

=={{header|BASIC256}}==

N = 6000

dim p(N+6)

Line 418:

next i

end

</syntaxhighlight>

</lang>

<pre>

Line 425:

=={{header|BCPL}}==

<~~lang~~ bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

manifest $( limit = 6000 $)

Line 451:

writef("%I4: %I4, %I4, %I4*N", i, i-1, i+3, i+5)

freevec(prime)

$)</~~lang~~>

$)</syntaxhighlight>

<pre style='height:50ex'> 8: 7, 11, 13

Line 501:

=={{header|C}}==

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

#include <stdlib.h>

#include <string.h>

Line 536:

free(p);

return 0;

}</~~lang~~>

}</syntaxhighlight>

<pre style='height:50ex'> 8: 7, 11, 13

Line 587:

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

<~~lang~~ cpp>#include <iostream>

<syntaxhighlight lang="cpp">#include <iostream>

#include <vector>

Line 624:

return 0;

}</~~lang~~>

}</syntaxhighlight>

<pre> 8: 7, 11, 13

Line 675:

=={{header|C#|CSharp}}==

How about some upper limits above 6000?

<~~lang~~ csharp>using System; using System.Collections.Generic; using System.Linq;

<syntaxhighlight lang="csharp">using System; using System.Collections.Generic; using System.Linq;

using T3 = System.Tuple<int, int, int>; using static System.Console;

class Program { static void Main() {

Line 696:

for (int k = s, i = j << 1; k < l; k += i) f[k] = true; }

for (; j < l; lllj = llj, llj = lj, lj = j, j += 2)

if (isPrT(lllj, lj, j)) yield return new T3(lllj, lj, j); } }</~~lang~~>

if (isPrT(lllj, lj, j)) yield return new T3(lllj, lj, j); } }</syntaxhighlight>

<pre style='height:50ex'> "N": Prime Triplet Adjacent (to previous)

Line 754:

=={{header|CLU}}==

<~~lang~~ clu>LIMIT = 6000

<syntaxhighlight lang="clu">LIMIT = 6000

isqrt = proc (s: int) returns (int)

Line 799:

end

end start_up</~~lang~~>

end start_up</syntaxhighlight>

<pre style='height:50ex;'> 8: 7, 11, 13

Line 849:

=={{header|Comal}}==

<~~lang~~ comal>0010 lim#:=6000

<syntaxhighlight lang="comal">0010 lim#:=6000

0020 DIM prime#(lim#)

0030 FOR i#:=2 TO lim# DO prime#(i#):=TRUE

Line 860:

0100 ENDIF

0110 ENDFOR i#

0120 END</~~lang~~>

0120 END</syntaxhighlight>

<pre style='height:50ex;'> 8: 7, 11, 13

Line 910:

=={{header|Cowgol}}==

<~~lang~~ cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

const LIMIT := 6000;

Line 946:

end if;

i := i + 1;

end loop;</~~lang~~>

end loop;</syntaxhighlight>

<pre style='height:50ex'>8: 7, 11, 13

Line 997:

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

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

<~~lang~~ fsharp>

// Prime triplets: Nigel Galloway. May 18th., 2021

primes32()|>Seq.takeWhile((>)6000)|>Seq.filter(fun n->isPrime(n+4)&&isPrime(n+6))|>Seq.iter((+)1>>printf "%d "); printfn ""

</syntaxhighlight>

</lang>

<pre>

Line 1,008:

=={{header|Factor}}==

<~~lang~~ factor>USING: combinators formatting grouping kernel math math.primes

<syntaxhighlight lang="factor">USING: combinators formatting grouping kernel math math.primes

math.statistics sequences ;

Line 1,018:

"..., %4d, [%4d], __, __, %4d, __, %4d, ...\n" printf ;

6000 4,2-gaps [ first3 [ dup 1 + ] 2dip triplet. ] each</~~lang~~>

6000 4,2-gaps [ first3 [ dup 1 + ] 2dip triplet. ] each</syntaxhighlight>

Line 1,071:

=={{header|Forth}}==

<~~lang~~ forth>: prime? ( n -- ? ) here + c@ 0= ;

<syntaxhighlight lang="forth">: prime? ( n -- ? ) here + c@ 0= ;

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

Line 1,114:

6000 main

bye</~~lang~~>

bye</syntaxhighlight>

Line 1,171:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>

Dim As Integer N = 6000

Dim As Integer p(N)

Line 1,190:

Next i

Sleep

</syntaxhighlight>

</lang>

<pre>

8: 7 11 13

Line 1,244:

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 1,268:

}

fmt.Printf("\n%d such numbers found.\n", len(numbers))

}</~~lang~~>

}</syntaxhighlight>

Line 1,324:

=={{header|J}}==

<~~lang~~ j>triplet=: (1 *./@p: _1 3 5+])"0

<syntaxhighlight lang="j">triplet=: (1 *./@p: _1 3 5+])"0

echo (0 _1 3 5+])"0 (triplet#]) i.6000

exit ''</~~lang~~>

exit ''</syntaxhighlight>

<pre style='height:50ex'> 8 7 11 13

Line 1,379:

'''Works with gojq, the Go implementation of jq'''

<~~lang~~ jq>def is_prime:

<syntaxhighlight lang="jq">def is_prime:

if . == 2 then true

else

Line 1,390:

end ;

range(3;6000) | select( all( .-1, .+3, .+5; is_prime))</~~lang~~>

range(3;6000) | select( all( .-1, .+3, .+5; is_prime))</syntaxhighlight>

<pre>

Line 1,403:

=={{header|Julia}}==

<~~lang~~ julia>using Primes

<syntaxhighlight lang="julia">using Primes

makesprimetriplet(n) = all(isprime, [n - 1, n + 3, n + 5])

println(" N Prime Triplet\n--------------------------")

foreach(n -> println(rpad(n, 6), [n - 1, n + 3, n + 5]), filter(makesprimetriplet, 2:6005))

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

N Prime Triplet

Line 1,461:

=={{header|Ksh}}==

<~~lang~~ ksh>

#!/bin/ksh

Line 1,511:

IFS=${oldIFS}

unset arr

done</~~lang~~>

done</syntaxhighlight>

{{out}}<pre>

8: 7,11,13

Line 1,561:

=={{header|MAD}}==

<~~lang~~ ~~MAD~~> NORMAL MODE IS INTEGER

<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER

BOOLEAN PRIME

DIMENSION PRIME(6005)

Line 1,585:

VECTOR VALUES FMT = $I4,3H =,3(I5)*$

END OF PROGRAM </~~lang~~>

END OF PROGRAM </syntaxhighlight>

<pre style='height:50ex'> 8 = 7 11 13

Line 1,635:

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

<~~lang~~ ~~Mathematica~~>Select[Range[5999], PrimeQ[# - 1] && PrimeQ[# + 3] && PrimeQ[# + 5] &]</~~lang~~>

<syntaxhighlight lang="mathematica">Select[Range[5999], PrimeQ[# - 1] && PrimeQ[# + 3] && PrimeQ[# + 5] &]</syntaxhighlight>

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import strformat

<syntaxhighlight lang="nim">import strformat

const

Line 1,666:

inc count

echo &"\nFound {count} triplets for n < {N+1}."</~~lang~~>

echo &"\nFound {count} triplets for n < {N+1}."</syntaxhighlight>

Line 1,721:

=={{header|Perl}}==

<~~lang~~ perl>#!/usr/bin/perl

<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict;

Line 1,728:

is_prime($_ - 4) and printf "%5d" x 4 . "\n", $_ - 3, $_ - 4, $_, $_ + 2

for @{ twin_primes( 6000 ) };</~~lang~~>

for @{ twin_primes( 6000 ) };</syntaxhighlight>

<pre>

Line 1,780:

=={{header|Phix}}==

function trio(integer n) return sum(apply({n-1,n+3,n+5},is_prime))=3 end function

sequence res = filter(tagset(6000),trio)

printf(1,"%d found: %V\n",{length(res),shorten(res,"",5)})

(assumes you can add {-1,3,5} to each number in your head easily enough)

Line 1,792:

=={{header|PL/M}}==

<~~lang~~ plm>100H:

<syntaxhighlight lang="plm">100H:

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

Line 1,852:

END;

CALL EXIT;

EOF</~~lang~~>

EOF</syntaxhighlight>

<pre style='height:50ex'>8: 7, 11, 13

Line 1,904:

=={{header|Python}}==

<~~lang~~ python>

#!/usr/bin/python3

Line 1,921:

else:

print(i, ': ', i-1, ' ', i+3, ' ', i+5)

</syntaxhighlight>

</lang>

<pre>

Similar a la entrada de FreeBASIC.

Line 1,928:

=={{header|Quackery}}==

<~~lang~~ ~~Quackery~~> [ 1 swap times [ i 1+ * ] ] is ! ( n --> n )

<syntaxhighlight lang="quackery"> [ 1 swap times [ i 1+ * ] ] is ! ( n --> n )

[ dup 2 < iff

Line 1,943:

else drop ]

echo</~~lang~~>

echo</syntaxhighlight>

Line 1,953:

A weird combination of [[Cousin primes]] and [[Twin primes]] that are siblings, but known by their neighbor.... I shall dub these Alabama primes.

<lang ~~perl6~~>say "{.[0]+1}: ",$_ for grep *.all.is-prime, ^6000 .race.map: { $_-1, $_+3, $_+5 };</~~lang~~>

<syntaxhighlight lang="raku" line>say "{.[0]+1}: ",$_ for grep *.all.is-prime, ^6000 .race.map: { $_-1, $_+3, $_+5 };</syntaxhighlight>

<pre>8: (7 11 13)

Line 2,003:

=={{header|REXX}}==

<~~lang~~ rexx>/*REXX pgm finds prime triplets: n-1, n+3, n+5 are primes, and n < some specified #.*/

<syntaxhighlight lang="rexx">/*REXX pgm finds prime triplets: n-1, n+3, n+5 are primes, and n < some specified #.*/

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

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

Line 2,047:

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

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

end /*j*/; return</~~lang~~>

end /*j*/; return</syntaxhighlight>

<pre>

Line 2,070:

=={{header|Ring}}==

<~~lang~~ ring>

load "stdlib.ring"

see "working..." + nl

Line 2,092:

see "Found " + row + " prime triplets" + nl

see "done..." + nl

</syntaxhighlight>

</lang>

<pre>

Line 2,149:

=={{header|Seed7}}==

<~~lang~~ seed7>$ include "seed7_05.s7i";

<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

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

Line 2,183:

end for;

writeln("\nFound " <& count <& " triplets for n < 6000.");

end func;</~~lang~~>

end func;</syntaxhighlight>

<pre>

Line 2,239:

=={{header|Sidef}}==

<~~lang~~ ruby>^6000 -> grep {|n| [-1, 3, 5].all {|k| n + k -> is_prime } }.say</~~lang~~>

<syntaxhighlight lang="ruby">^6000 -> grep {|n| [-1, 3, 5].all {|k| n + k -> is_prime } }.say</syntaxhighlight>

<pre>

Line 2,248:

=={{header|True BASIC}}==

<~~lang~~ basic>

LET n = 6000

Line 2,270:

NEXT i

END

</syntaxhighlight>

</lang>

<pre>

Line 2,278:

=={{header|Vlang}}==

<~~lang~~ vlang>import math

<syntaxhighlight lang="vlang">import math

const n = 6000

Line 2,299:

}

}</~~lang~~>

}</syntaxhighlight>

<pre>

Similar to Go

Line 2,307:

<~~lang~~ ecmascript>import "/math" for Int

<syntaxhighlight lang="ecmascript">import "/math" for Int

import "/fmt" for Fmt

Line 2,319:

}

for (n in numbers) Fmt.print("$,6d => $,6d", n, [n-1, n+3, n+5])

System.print("\nFound %(numbers.count) such numbers.")</~~lang~~>

System.print("\nFound %(numbers.count) such numbers.")</syntaxhighlight>

Line 2,375:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>func IsPrime(N); \Return 'true' if N is prime

<syntaxhighlight lang="xpl0">func IsPrime(N); \Return 'true' if N is prime

int N, I;

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

Line 2,401:

Text(0, " prime triplets found below 6000.

");

]</~~lang~~>

]</syntaxhighlight>

Line 2,420:

=={{header|Yabasic}}==

<~~lang~~ ~~Yabasic~~>// Rosetta Code problem: http://rosettacode.org/wiki/Triplet_of_three_numbers

<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Triplet_of_three_numbers

// by Galileo, 04/2022

Line 2,436:

for i = 3 to N

if not (p(i-1) or p(i+3) or p(i+5)) print i, ": ", i-1, " ", i+3, " ", i+5

next</~~lang~~>

next</syntaxhighlight>

<pre>8: 7 11 13