Sexy primes: Difference between revisions

::*Note that 1000033 '''SHOULD NOT''' be counted in the pair count. It is sexy, but not in a pair within the limit. However, it also '''SHOULD NOT''' be listed in the unsexy primes since it is sexy.

<br><br>

 

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

5 11 17 23 29,

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

See [https://rosettacode.org/wiki/Sexy_primes#Pascal Pascal].

 

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

import java.util.ArrayList;

import java.util.List;

 

}

 

{{out}}

The last 10 unsexy primes:

[999853], [999863], [999883], [999907], [999917], [999931], [999961], [999979], [999983], [1000003]

</pre>

 

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

1 quintuplets, ending with: (5 11 17 23 29)

48627 unsexy, ending with: 999853 999863 999883 999907 999917 999931 999961 999979 999983 1000003</pre>

 

=={{header|Nim}}==

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

for p in countup(3, sqrt(Lim.toFloat).int, 2): # Ignore even numbers.

if not composite[p]:

composite[k] = true

 

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

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

999983

1000003

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

var printHelper = Fn.new { |cat, le, lim, max|

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

 

{{out}}

The last 10 are:

[999853, 999863, 999883, 999907, 999917, 999931, 999961, 999979, 999983, 1000003]

</pre>

 

 

[[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%">