Sexy primes: Difference between revisions

{{trans|Python}}

 

F get_primes(limit)

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

print("\nThere are #. unsexy primes ending with ...".format(unsexy.len))

L(usx) unsexy[(len)-10..]

 

{{out}}

 

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

% find some sexy primes - primes that differ from another prime by 6 %

% implements the sieve of Eratosthenes %

showPrimes( 1, unsexy, 10, "unsexy primes", MAX_SEXY )

end

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f SEXY_PRIMES.AWK

BEGIN {

s[key] = str

}

{{out}}

<pre>

=={{header|C}}==

Similar approach to the Go entry but only stores the arrays that need to be printed out.

#include <stdlib.h>

#include <string.h>

free(sv);

return 0;

 

{{out}}

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

{{libheader|Boost}}

#include <iostream>

#include <vector>

cout << '\n';

return 0;

 

Contents of prime_sieve.hpp:

#define PRIME_SIEVE_HPP

 

}

 

 

{{out}}

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

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

// Sexy primes. Nigel Galloway: October 2nd., 2018

let n=pCache |> Seq.takeWhile(fun n->n<1000035) |> Seq.filter(fun n->(not (isPrime(n+6)) && (not isPrime(n-6))))) |> Array.ofSeq

printfn "There are %d sexy prime quintuplets all components of which are less than 1,000,035. The last 5 are:" nigel.Length

Array.skip (nigel.Length-5) nigel |> Array.iter(fun n->printf "(%d,%d,%d,%d,%d) " (n-24) (n-18) (n-12) (n-6) n); printfn ""

{{out}}

<pre>

 

=={{header|Factor}}==

literals locals make math math.primes math.ranges prettyprint qw

sequences tools.memory.private ;

: main ( -- ) 2 5 [a,b] [ show-tuplets ] each show-unsexy ;

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

If ValorEval < 2 Then Return False

If ValorEval Mod 2 = 0 Then Return ValorEval = 2

Next I

Print Chr(8); " "

{{out}}

<pre> 78500 primes less than 1000035

 

=={{header|Go}}==

 

import "fmt"

le, n, verb = printHelper("unsexy primes", len(unsexy), lim, 10)

fmt.Printf("The last %d %s:\n %v\n\n", n, verb, unsexy[le-n:])

 

{{out}}

=={{header|Haskell}}==

Uses Library primes. https://hackage.haskell.org/package/primes (wheel sieve).

import Data.Numbers.Primes (isPrime, primes)

 

where (pairs, triplets, quads, quins, unsexy) = foldr groups ([], [], [], [], []) $ takeWhile (< 1000035) primes

lastFive xs = show $ drop (length xs - 5) xs

{{out}}

<pre>

</pre>

Slight variation which only holds on to the display results. Does not perform any better than above though. Both run ~ 250ms.

import Control.Lens (makeLenses, over, (^.), to, view)

import Data.Numbers.Primes (isPrime, primes)

collectGroups = foldl collect initialGroups . takeWhile (< 1000035)

display :: Show a => [a] -> String

 

=={{header|J}}==

NB. The 1 _1 p: ... logic here allows the input value to

NB. be included in the list in the case it itself is prime

us =. p (] #~ 1 +:/@:p: +/)~ (+,-) pd NB. Unsexy numbers

( (# ; _10&{.) us ) , (#&.> g) ,. l

 

{{out}}

(;:'Group Count Examples') , (;:'Unsexy Pairs Triplets Quadruplets Quintuplets') ,. r

+-----------+-----+----------------------------------------------------------------------+

+-----------+-----+----------------------------------------------------------------------+

|Quintuplets|1 |5 11 17 23 29 |

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.List;

 

}

 

{{out}}

 

=={{header|Julia}}==

using Primes

 

end

 

There are:

16386 twins,

=={{header|Kotlin}}==

{{trans|Go}}

 

fun sieve(lim: Int): BooleanArray {

var (nu, verbu) = printHelper("unsexy primes", unsexy.size, lim, 10)

System.out.printf("The last %d %s:\n %s\n\n", nu, verbu, unsexy.takeLast(nu))

 

{{output}}

 

=={{header|Lua}}==

 

-- FUNCS:

end

local unsexy = primes:filter(function(v) return not (v>=N or sieve[v-6] or sieve[v+6]) end)

{{out}}

<pre>16386 pairs, ending with: (999371 999377) (999431 999437) (999721 999727) (999763 999769) (999953 999959)

 

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

AllSublengths[l_List] := If[Length[l] > 2,

Catenate[Partition[l, #, 1] & /@ Range[2, Length[l]]]

sel // Column

 

{{out}}

<pre>16386

This Nim version uses Kotlin algorithm with several differences. In particular, we have chosen to store only the first term of groups as others can be retrieved by computation. But it complicates somewhat the printing of results.

 

 

const Lim = 1_000_035

printResult(Quadruplets, quads, 5)

printResult(Quintuplets, quints, 5)

 

{{out}}

37907606 unsexy primes // = 50847538-2*6849047+758163-1

It seems so, not a proove.

 

uses

writeln(unsexyprimes,' unsexy primes');

OutLastUnsexy(10);

{{Output}}

<pre>

{{libheader|ntheory}}

We will use the prime iterator and primality test from the <code>ntheory</code> module.

 

sub tuple_tail {

 

print "Number of unsexy primes less than $cmax: ". comma(scalar @{$primes{unsexy}}) . "\n";

{{out}}

<pre>Total primes less than 1,000,035: 78,500

The cluster sieve becomes more efficient as the number of terms increases. See for example [[oeis:a213646|OEIS Prime 11-tuplets]].

 

 

# ... identical helper functions

} $max-1;

 

 

=={{header|Phix}}==

<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: #008080;">end</span> <span style="color: #008080;">for</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: #000000;">fmt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">results</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

is_prime(N),

!.

 

main:-

 

Module for finding prime numbers up to some limit:

:- dynamic is_prime/1.

 

cross_out(S, N, P):-

Q is S + 2 * P,

 

{{out}}

 

=={{header|PureBasic}}==

EnableExplicit

 

put(c1,"unsexy primes ending with ...",t1$)

 

{{out}}

<pre>16386 pairs ending with ...

=={{header|Python}}==

===Imperative Style===

def primes2(limit=LIMIT):

if limit < 2: return []

print(f'\nThere are {len(unsexy)} unsexy primes ending with ...')

for usx in unsexy[-10:]:

 

{{out}}

{{trans|FSharp}}

This task uses [[Extensible_prime_generator#210-wheel_postponed_incremental_sieve]]

#Functional Sexy Primes. Nigel Galloway: October 5th., 2018

from itertools import *

print ("There are",len(unsexy),"unsexy primes less than 1,000,035. The last 10 are:")

for g in islice(unsexy,max(len(unsexy)-10,0),len(unsexy)): print(g)

{{out}}

<pre>

{{works with|Rakudo|2018.08}}

 

my $sieve = Math::Primesieve.new;

 

}

 

{{out}}

<pre>Total primes less than 1,000,035: 78,500

 

=={{header|REXX}}==

parse arg N endU end2 end3 end4 end5 . /*obtain optional argument from the CL.*/

if N=='' | N=="," then N= 1000035 - 1 /*Not specified? Then use the default.*/

q=p-18; if \x.q then iterate

v=p-24; if \x.v then iterate; x5=x5 v'~'q"~"t'~' || b"~"p

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

 

=={{header|Ring}}==

{{Improve|Ring|Does not even ''attempt'' to fulfil the task requirements and has no explanation as to why not}}

load "stdlib.ring"

 

next

next

Output:

<pre>

 

=={{header|Ruby}}==

require 'prime'

 

unsexy.last(10).each {|item| print prime_array[item], " "}

print "\n\n", Time.now - start, " seconds"

 

Output:

 

=={{header|Rust}}==

// primal = "0.2"

// circular-queue = "0.2.5"

.collect::<Vec<String>>()

.join(", ")

 

{{out}}

 

=={{header|Scala}}==

but one practical solution would be to use the Shapeless library for this purpose; here we only use built-in Scala packages. */

 

 

}

{{out}}

<pre>

 

=={{header|Sidef}}==

var primes = limit.primes

 

var unsexy_primes = primes.grep {|p| is_prime(p+6) || is_prime(p-6) -> not }

say "...total number of unsexy primes = #{unsexy_primes.len.commify}"

{{out}}

<pre>

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

import "/math" for Int

unwrap.call(printHelper.call("unsexy primes", unsexy.count, lim, 10))

 

{{out}}

 

=={{header|XPL0}}==

int N, I;

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

[IntOut(0, Unsexy(I)); if I then Text(0, ", ")];

CrLf(0);

 

{{out}}

 

[[Extensible prime generator#zkl]] could be used instead.

const N=1_000_035, M=N+24; // M allows prime group to span N, eg N=100, (97,103)

const OVR=6; // 6 if prime group can NOT span N, else 0

println("Number of %s less than %,d is %,d".fmt(s,N,ps.len()));

println("The last %d %s:\n %s\n".fmt(n, (n>1 and "are" or "is"), gs));

{{out}}

<pre style="font-size:80%">