10001th prime: Difference between revisions

The APPROXIMATESIEVESIZEFOR operator uses this to find a rough value for size of sieve needed to contain the required number of primes.

{{libheader|ALGOL 68-primes}}

PR read "primes.incl.a68" PR

# construct a sieve of primes that should be large enough to contain 10001 primes #

FI

OD

{{out}}

<pre>

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f 10001TH_PRIME.AWK

# converted from FreeBASIC

return(1)

}

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|BASIC256}}===

if v < 2 then return False

if v mod 2 = 0 then return v = 2

 

print prime(10001)

 

==={{header|PureBasic}}===

If v <= 1 : ProcedureReturn #False

ElseIf v < 4 : ProcedureReturn #True

n = prime(10001)

PrintN(Str(n))

 

==={{header|Yabasic}}===

if v < 2 then return False : fi

if mod(v, 2) = 0 then return v = 2 : fi

 

print prime(10001)

 

 

=={{header|C}}==

#include<stdlib.h>

 

printf( "%d\n", prime(10001) );

return 0;

{{out}}<pre>104743</pre>

 

===Sieve vs Trial Division===

Comparing performance of the one-at-a-time trial division method vs the sieve of Eratosthenes method. About ten times faster for the sieve. It may appear that the sieve may be off by one, <code>pr[10000]</code> but since the array is zero based, it's the 10001st value.

 

static bool isprime(uint p ) { if ((p & 1) == 0) return p == 2;

t = pr[10000]; sw.Stop();

Console.Write(" {0:n0} {1} μs {2:0.000} times faster", t,

{{out|Output @ Tio.run}}

<pre>One-at-a-time trial division vs sieve of Eratosthenes

 

===Alternative Trial Division Method===

namespace p10001 // 1 second 10001 104743

{ class Program // rextester.com/ZBEPGE34760

Console.Write("{0} {1}", n-1, p-1);

Console.ReadKey();

{{out}}

<pre>104743</pre>

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

{{libheader|Primesieve}}

#include <locale>

 

std::cout.imbue(std::locale(""));

std::cout << "The 10,001st prime is " << primesieve::nth_prime(10001) << ".\n";

 

{{out}}

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

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

// 10001st prime. Nigel Galloway: November 22nd., 2021

printfn $"%d{Seq.item 10000 (primes32())}"

{{out}}

<pre>

</pre>

=={{header|Factor}}==

 

{{out}}

<pre>

 

=={{header|Fermat}}==

Prime(10001);

{{out}}<pre>104743</pre>

 

=={{header|FreeBASIC}}==

#include "isprime.bas"

function prime( n as uinteger ) as ulongint

 

print prime(10001)

{{out}}<pre>104743</pre>

 

=={{header|Frink}}==

{{out}}

<pre>

 

=={{header|GW-BASIC}}==

20 P = 3

30 WHILE PN < 10001

170 IF I*I<=P THEN GOTO 150

180 Q = 1

{{out}}<pre>104743</pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Println(final)

}

{{out}}<pre>104743</pre>

 

=={{header|J}}==

{{out}}

<pre>104743</pre>

=={{header|Java}}==

Uses the PrimeGenerator class from [[Extensible prime generator#Java]].

public static void main(String[] args) {

System.out.printf("The 10,001st prime is %,d.\n", nthPrime(10001));

return prime;

}

 

{{out}}

 

See [[Erdős-primes#jq]] for a suitable definition of `is_prime` as used here.

def primes: 2, (range(3; infinite; 2) | select(is_prime));

 

# The task

# jq uses an index-origin of 1 and so:

{{out}}

<pre>

 

=={{header|Julia}}==

 

julia> prime(10001)

104743

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

 

{{out}}<pre>

 

=={{header|PARI/GP}}==

{{out}}<pre>%1 = 104743</pre>

 

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

# or if for some reason you want the answer quickly

use ntheory 'nth_prime';

{{out}}

<pre>104743

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">js</span> <span style="color: #0000FF;">?</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10001</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|Picat}}==

println(nth_prime(10001)),

 

prime(Num).

next_prime2(Num, P) :-

 

{{out}}

=={{header|Python}}==

===Trial Division Method===

 

def isPrime(n):

 

if __name__ == '__main__':

{{out}}

<pre>104743</pre>

 

===Alternative Trial Division Method===

while n<=max: # 78081 994271 45 seconds

f=0; j=2; s = int(p**0.5) # rextester.com/AAOHQ6342

p+=1

print(n-1,p-1)

{{out}}

<pre>10001 104743 7 seconds</pre>

=={{header|QB64}}==

===Trial Division Method===

While n <= max ' 10001 104743 0.35 seconds

f=0: j=2

p=p+1

Wend

{{out}}

<pre>10001 104743 0.35 seconds</pre>

 

===More Efficient TD Method===

'Original version: 10001 104743 .21875

'This version: 10001 104743 .109375

p=p+1

Wend

{{out}}

<pre>10001 104743 0.11 seconds</pre>

 

=={{header|R}}==

{{out}}

<pre>104743</pre>

 

=={{header|Racket}}==

(require math/number-theory)

; Index starts at 0, (nth-prime 0) is 2

{{out}}

<pre>104743</pre>

 

=={{header|Raku}}==

{{out}}

<pre>104743</pre>

 

=={{header|REXX}}==

Parse Version v

Say v

End

End

{{out}}

<pre>H:\>rexx prime10001

 

=={{header|Ring}}==

load "stdlib.ring"

see "working..." + nl

 

see "" + num + nl + "done..." + nl

{{out}}

<pre>

 

=={{header|Ruby}}==

{{out}}

<pre>104743

</pre>

=={{header|Rust}}==

// primal = "0.3"

 

let p = primal::StreamingSieve::nth_prime(10001);

println!("The 10001st prime is {}.", p);

 

{{out}}

 

=={{header|Sidef}}==

{{out}}

<pre>

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "./fmt" for Fmt

 

var limit = (n.log * n * 1.2).floor // should be enough

var primes = Int.primeSieve(limit)

 

{{out}}

 

=={{header|XPL0}}==

int N, I;

[for I:= 3 to sqrt(N) do

];

IntOut(0, N);

 

{{out}}