Extra primes: Difference between revisions

 

;Definition

*   [[:Category:Prime Numbers]]

<br><br>

 

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

As the digits can only be 2, 3, 5 or 7 (see the Wren sample) we can easily generate the candidates for the sequence.

% find extra primes - numbers whose digits are prime and whose %

% digit sum is prime %

end for_d1

end

{{out}}

<pre>

 

=={{header|APL}}==

pd←0 2 3 5 7

ds←↓⍉(∧⌿ds∊pd)/ds←10(⊥⍣¯1)1↓⍳⍵

}2

(sieve[ns]∧sieve[ss])/ns

 

{{out}}

 

2 3 5 7 23 27 223 227 333 337 353 373 377 533 553 557 577 733 737 757

773 777 2223 2227 2333 2353 2357 2377 2533 2537 2557 2573 2577

2737 2753 2757 2773 2777 3233 3253 3257 3277 3323 3523 3527 3727

5233 5237 5257 5273 5277 5323 5327 5527 5723 5727 7237 7253 7257

 

=={{header|AWK}}==

# syntax: GAWK -f EXTRA_PRIMES.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

 

=={{header|BASIC}}==

15 FOR I=0 TO 4: READ D(I): NEXT

20 FOR I=2 TO SQR(7777)

120 NEXT

130 NEXT

 

{{out}}

 

=={{header|C}}==

#include <stdbool.h>

#include <stdio.h>

unsigned int extra_primes[last];

printf("Extra primes under %'u:\n", limit1);

++n;

if (p < limit1)

printf("%'u: %'u\n", n-i, extra_primes[(n-i) % last]);

return 0;

 

{{out}}

 

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

#include <iostream>

 

unsigned int extra_primes[last];

std::cout << "Extra primes under " << limit1 << ":\n";

++n;

if (p < limit1)

std::cout << n-i << ": " << extra_primes[(n-i) % last] << '\n';

return 0;

 

{{out}}

 

=={{header|Cowgol}}==

const MAXPRIME := 7777;

 

end loop;

i1 := i1 + 1;

 

{{out}}

7723

7727</pre>

 

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

===The Function===

This task uses [[Permutations/Derangements#F.23]]

// Extra Primes. Nigel Galloway: January 9th., 2021

let izXprime g=let rec fN n g=match n with 0L->isPrime64 g |_->if isPrime64(n%10L) then fN (n/10L) (n%10L+g) else false in fN g 0L

===The tasks===

; Extra primes below 10,000

primes64() |> Seq.filter izXprime |> Seq.takeWhile((>) 10000L) |> Seq.iteri(printfn "%3d->%d")

{{out}}

<pre>

</pre>

; Last 10 Extra primes below 1,000,000,000

primes64()|>Seq.takeWhile((>)1000000000L)|>Seq.rev|>Seq.filter izXprime|>Seq.take 10|>Seq.rev|>Seq.iter(printf "%d ");printfn ""

{{out}}

<pre>

</pre>

; Last 10 Extra primes below 10,000,000,000

primes64()|>Seq.skipWhile((>)7770000000L)|>Seq.takeWhile((>)7777777777L)|>List.ofSeq|>List.filter izXprime|>List.rev|>List.take 10|>List.rev|>List.iter(printf "%d ");printfn ""

{{out}}

<pre>

{{trans|Wren}}

{{works with|Factor|0.99 2020-08-14}}

sequences sequences.extras ;

 

[ sum prime? ] filter

[ digits>number ] [ prime? ] map-filter

{{out}}

<pre style="height: 45ex">

 

=={{header|Forth}}==

dup 2 < if drop false exit then

dup 2 mod 0= if 2 = exit then

dup 2 = if drop 1+ exit then

dup 3 = if drop 2 + exit then

10 / recurse 10 * 2 + ;

 

0

begin

while

repeat

 

begin

repeat

 

." Extra primes under 10000:" cr

 

{{out}}

7723

7727

</pre>

 

=={{header|FreeBASIC}}==

dim as uinteger p(0 to 4) = {0,2,3,5,7}, d3, d2, d1, d0, pd1, pd2, pd3, pd0

 

next d1

next d2

{{out}}

<pre>

7723

7727</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import "fmt"

}

}

 

{{out}}

35: 7723

36: 7727

</pre>

 

=={{header|J}}==

 

{{out}}

 

 

=={{header|Java}}==

{{trans|Go}}

private static int nextPrimeDigitNumber(int n) {

if (n == 0) {

System.out.println();

}

{{out}}

<pre>Extra primes under 10000:

36: 7727</pre>

 

=={{header|Julia}}==

 

function extraprimes(maxlen)

 

extraprimes(4)

<pre>

2

=={{header|Kotlin}}==

{{trans|Java}}

return if (n == 0) {

2

}

println()

{{out}}

<pre>Extra primes under 10000:

35: 7723

36: 7727</pre>

 

=={{header|MAD}}==

BOOLEAN PRIME

DIMENSION PRIME(7777)

X CONTINUE

 

 

{{out}}

7723

7727</pre>

 

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

 

{{out}}

 

=={{header|Phix}}==

Minor reworking of [[Numbers_with_prime_digits_whose_sum_is_13#iterative|Numbers_with_prime_digits_whose_sum_is_13#Phix#iterative]]

{{out}}

<pre>

 

=={{header|Python}}==

from functools import reduce

 

for n in takewhile(lambda n: n < 10000, extra_primes()):

print(n)

 

{{out}}

7723

7727</pre>

 

=={{header|Raku}}==

For the time being, (Doctor?), I'm going to assume that the task is really "Sequence of primes with every digit a prime and the sum of the digits a prime". Outputting my own take on a reasonable display of results, compact and easily doable but exercising it a bit.

 

flat (2..*).map: { flat ([X~] (2, 3, 5, 7) xx $_) X~ (3, 7) };

 

put 'Terms < 10,000: '.fmt('%34s'), @ppp[^(@ppp.first: * > 1e4, :k)];

put '991st through 1000th: '.fmt('%34s'), @ppp[990 .. 999];

{{out}}

<pre> Terms < 10,000: 2 3 5 7 23 223 227 337 353 373 557 577 733 757 773 2333 2357 2377 2557 2753 2777 3253 3257 3323 3527 3727 5233 5237 5273 5323 5527 7237 7253 7523 7723 7727

 

If the limit is negative,&nbsp; the list of primes found isn't shown,&nbsp; but the count of primes found is always shown.

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

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

end /*while*/; return r

/*──────────────────────────────────────────────────────────────────────────────────────*/

high= max(9 * digits(), iSqrt(hi) ) /*enough primes for sums & primality ÷ */

parse var j '' -1 _ /*obtain the last digit of the J var.*/

/* [↓] divide by the primes. ___ */

if j//@.k == 0 then iterate j /*÷ by prev. prime? ¬prime ___ */

end /*k*/ /* [↑] only divide up to √ J */

end /*j*/

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

 

 

=={{header|Ring}}==

load "stdlib.ring"

 

return 0

ok

Output:

<pre>

</pre>

 

=={{header|Ruby}}==

{{trans|Java}}

if n == 0 then

return 2

end

end

{{out}}

<pre>Extra primes under 10000:

 

=={{header|Rust}}==

// primal = "0.3"

 

}

 

if n == 0 {

return 2;

}

 

let mut sum = 0;

while n > 0 {

let mut extra_primes = vec![0; last];

println!("Extra primes under {}:", limit1);

p = next_prime_digit_number(p);

n += 1;

if p < limit1 {

println!("{}: {}", n - i, extra_primes[(n - i) % last]);

}

 

{{out}}

9057: 777777577

9058: 777777773

</pre>

 

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

 

var digits = [2, 3, 5, 7] // the only digits which are primes

Fmt.print("$2d: $4d", count, cand[0])

}

 

{{out}}

 

=={{header|XPL0}}==

int N, I;

[if N <= 1 then return false;

[IntOut(0, P); CrLf(0)];

];

 

{{out}}