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

number of unsexy primes is 48627

last 10 unsexy primes: 999853 999863 999883 999907 999917 999931 999961 999979 999983 1000003

</pre>

 

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

 

 

 

groups :: Int -> Result -> Result

 

main :: IO ()

printf "Number of unsexy primes: %d\n Last 10: %s\n\n" (length unsexy) (show $ drop (length unsexy - 10) unsexy)

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

{{out}}

<pre>

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

</pre>

 

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

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

It seems so, not a proove.

 

uses

 

const

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

Number of unsexy primes is 48627

Last 10 unsexy primes: [999853,999863,999883,999907,999917,999931,999961,999979,999983,1000003]

</pre>

 

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

load "stdlib.ring"

 

 

see "Sexy prime pairs under 100:" + nl + nl

for m = n + 1 to len(primes)

if primes[m] - primes[n] = 6

 

see "Sexy prime triplets under 100:" + nl +nl

for x = m + 1 to len(primes)

bool1 = (primes[m] - primes[n] = 6)

 

see "Sexy prime quadruplets under 100:" + nl + nl

for y = m + 1 to len(primes)

bool1 = (primes[m] - primes[n] = 6)

 

see "Sexy prime quintuplets under 100:" + nl + nl

for z = y + 1 to len(primes)

bool1 = (primes[m] - primes[n] = 6)

next

next

Output:

<pre>

 

(5 11 17 23 29)

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