10001th prime

From Rosetta Code
10001th prime is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task


Find and show on this page the 10001st prime number.

11l 

V k = 10001
V n = k * 17
V primes = [1B] * n
primes[0] = primes[1] = 0B

L(i) 2 .. Int(sqrt(n))
   I !primes[i]
      L.continue
   L(j) (i * i .< n).step(i)
      primes[j] = 0B

L(i) 0 .< n
   I primes[i]
      I k == 1
         print(i)
         L.break
      k--
Output:
104743

ALGOL 68

Chebyshev showed that the limit of pi( n ) / ( n / ln(n) ) as n approaches infinity is 1 ( pi( n ) is the number of primes up to n ).
The APPROXIMATESIEVESIZEFOR operator uses this to find a rough value for size of sieve needed to contain the required number of primes.

Library: ALGOL 68-primes
BEGIN # find the 10001st prime #
    PR read "primes.incl.a68" PR
    # construct a sieve of primes that should be large enough to contain 10001 primes #
    INT required prime = 10 001;
    []BOOL prime = PRIMESIEVE APPROXIMATESIEVESIZEFOR required prime;
    INT p count := 1;
    FOR n FROM 3 BY 2 WHILE p count < required prime DO
        IF prime[ n ] THEN
            p count +:= 1;
            IF p count = required prime THEN
                print( ( "Prime ", whole( required prime, 0 ), " is ", whole( n, 0 ) ) )
            FI
        FI
    OD
END
Output:
Prime 10001 is 104743

Arturo 

primes: select 2..110000 => prime?
print primes\[10000]
Output:
104743

AWK

Converted from FreeBASIC

# syntax: GAWK -f 10001TH_PRIME.AWK

BEGIN {
    printf("%s\n",main(10001))
    exit(0)
}
function main(n,  p,pn) {
    if (n == 1) { return(2) }
    p = 3
    pn = 1
    while (pn < n) {
      if (is_prime(p)) {
        pn++
      }
      p += 2
    }
    return(p-2)
}
function is_prime(n,  d) {
    d = 5
    if (n < 2) { return(0) }
    if (n % 2 == 0) { return(n == 2) }
    if (n % 3 == 0) { return(n == 3) }
    while (d*d <= n) {
      if (n % d == 0) { return(0) }
      d += 2
      if (n % d == 0) { return(0) }
      d += 4
    }
    return(1)
}

Idiomatic

# awk -f 10001prime.awk

# n: odd number and n>8
function IsOddPrime(n,	i,limit) {
 limit = int(sqrt(n))
 for (i=3;i <= limit;i+=2)
  if (n%i==0) return 0
 return 1
}

# pos: positive
function PrimePosition(pos,	prime){
 pos -= ( (pos==1) ? prime=2 : prime=3 ) - 1
 while (pos)
  if (IsOddPrime(prime+=2)) pos--
 return prime
}

BEGIN { print PrimePosition(10001) }
Output:
104743

BASIC

BASIC256 

function isPrime(v)
	if v < 2 then return False
	if v mod 2 = 0 then return v = 2
	if v mod 3 = 0 then return v = 3
	d = 5
	while d * d <= v
		if v mod d = 0 then return False else d += 2
	end while
	return True
end function

function prime(n)
	if n=1 then return 2
	p = 3
	pn = 1
	while pn < n
		if isPrime(p) then pn += 1
		p += 2
	end while
	return p-2
end function

print prime(10001)
end

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4

The GW-BASIC solution works without any changes.

FreeBASIC 

#include "isprime.bas"
function prime( n as uinteger ) as ulongint
    if n=1 then return 2
    dim as integer p=3, pn=1
    while pn<n
        if isprime(p) then pn + = 1
        p += 2
    wend
    return p-2
end function

print prime(10001)
Output:
104743

Gambas 

'Use "isprime.bas"

Public Sub Main()

  Print prime(10001)
  
End

Function prime(n As Integer) As Long 

  If n = 1 Then Return 2 
  Dim p As Integer = 3, pn As Integer = 1 
  While pn < n 
    If isPrime(p) Then pn += 1 
    p += 2 
  Wend 
  Return p - 2 
  
End Function
Output:
104743

GW-BASIC

Works with: BASICA
10 PN = 1
20 P = 3
30 WHILE PN < 10001
40 GOSUB 100
50 IF Q = 1 THEN PN = PN + 1
60 P = P + 2
70 WEND
80 PRINT P - 2
90 END
100 REM Tests if a number is prime
110 Q = 0
120 IF P = 2 THEN Q = 1: RETURN
130 IF P = 3 THEN Q = 1: RETURN
140 I = 1
150 I = I + 2
160 IF INT(P / I) * I = P THEN RETURN
170 IF I * I <= P THEN GOTO 150
180 Q = 1
190 RETURN
Output:
104743

PureBasic 

Procedure isPrime(v.i)
  If     v <= 1    : ProcedureReturn #False
  ElseIf v < 4     : ProcedureReturn #True
  ElseIf v % 2 = 0 : ProcedureReturn #False
  ElseIf v < 9     : ProcedureReturn #True
  ElseIf v % 3 = 0 : ProcedureReturn #False
  Else
    Protected r = Round(Sqr(v), #PB_Round_Down)
    Protected f = 5
    While f <= r
      If v % f = 0 Or v % (f + 2) = 0
        ProcedureReturn #False
      EndIf
      f + 6
    Wend
  EndIf
  ProcedureReturn #True
EndProcedure

Procedure prime(n.i)
  If n = 1 
    ProcedureReturn 2
  EndIf
  p.i = 3
  pn.i = 1
  While pn < n
    If isprime(p)
      pn + 1
    EndIf
    p + 2
  Wend
  ProcedureReturn p-2
EndProcedure

OpenConsole()
n = prime(10001)
PrintN(Str(n))
CloseConsole()

QB64

Trial Division Method

max=10001: n=1: p=0: t=Timer ' PRIMES.bas russian DANILIN
While n <= max ' 10001 104743 0.35 seconds
    f=0: j=2
    While f < 1
        If j >= p ^ 0.5 Then f=2
        If p Mod j = 0 Then f=1
        j=j+1
    Wend
    If f <> 1 Then n=n+1: ' Print n, p
    p=p+1
Wend
Print n-1, p-1, Timer-t
Output:
10001 104743 0.35 seconds

More Efficient TD Method

'JRace's results:
'Original version: 10001   104743  .21875
'This version:     10001   104743  .109375
max = 10001: n=1: p=0: t = Timer ' PRIMES.bas
While n <= max ' 10001 104743 0.35 seconds
    f = 0: j = 2
    pp = p^0.5 'NEW VAR: move exponentiation here, to outer loop
    While f < 1
        ' If j >= p ^ 0.5 Then f=2 'original line
        ' NOTE: p does not change in this loop,
        '      therefore p^0.5 doesn't change;
        '      moving p^0.5 to the outer loop will eliminate a lot of FP math)
        If j >= pp Then f=2 'new version with exponentiation relocated
        If p Mod j = 0 Then f=1
        j=j+1
    Wend
    If f <> 1 Then n=n+1: ' Print n, p
    p=p+1
Wend
Print n-1, p-1, Timer - t
Output:
10001 104743 0.11 seconds

True BASIC

Trial Division Method

Translation of: QB64
LET max = 10001
LET n = 1
LET p = 0
DO WHILE n <= max
   LET f = 0
   LET j = 2
   DO WHILE f < 1
      IF j >= p^0.5 THEN LET f = 2
      IF REMAINDER(p, j) = 0 THEN LET f = 1
      LET j = j+1
   LOOP
   IF f <> 1 THEN LET n = n+1
   LET p = p+1
LOOP
PRINT p-1
END
Output:
104743

Yabasic 

sub isPrime(v)
    if v < 2 then return False : fi
    if mod(v, 2) = 0 then return v = 2 : fi
    if mod(v, 3) = 0 then return v = 3 : fi
    d = 5
    while d * d <= v
        if mod(v, d) = 0 then return False else d = d + 2 : fi
    wend
    return True
end sub

sub prime(n)
    if n = 1 then return 2 : fi
    p = 3 
	pn = 1
    while pn<n
        if isPrime(p) then pn = pn + 1 : fi
        p = p + 2
    wend
    return p-2
end sub

print prime(10001)
end

bc 

a[0] = 2
a[o = 1] = 3
for (n = 5; o < 10000; n += 2) {
    for (i = 1; n % (p = a[i]) != 0; ++i) {
        if (p * p > n) {
            a[++o] = n
            break
        }
    }
}
a[o]
Output:
104743

C 

#include<stdio.h>
#include<stdlib.h>

int isprime( int p ) {
    int i;
    if(p==2) return 1;
    if(!(p%2)) return 0;
    for(i=3; i*i<=p; i+=2) {
       if(!(p%i)) return 0;
    }
    return 1;
}

int prime( int n ) {
    int p, pn=1;
    if(n==1) return 2;
    for(p=3;pn<n;p+=2) {
        if(isprime(p)) pn++;
    }
    return p-2;
}

int main(void) {
    printf( "%d\n", prime(10001) );
    return 0;
}
Output:
104743

C#

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, pr[10000] but since the array is zero based, it's the 10001st value. 

using System; class Program {

  static bool isprime(uint p ) { if ((p & 1) == 0) return p == 2;
    if ((p % 3) == 0) return p == 3;
    for (uint i = 5, d = 4; i * i <= p; i += (d = 6 - d))
      if (p % i == 0) return false; return true; }
 
  static uint prime(uint n) { uint p, d, pn;
    for (p = 5, d = 4, pn = 2; pn < n; p += (d = 6 - d))
      if (isprime(p)) pn++; return p - d; }

  static void Main(string[] args) {
    Console.WriteLine("One-at-a-time trial division vs sieve of Eratosthenes");
    var sw = System.Diagnostics.Stopwatch.StartNew();
    var t = prime(10001); sw.Stop(); double e1, e2;
    Console.Write("{0:n0} {1} ms", prime(10001),
      e1 = sw.Elapsed.TotalMilliseconds);
    sw.Restart(); uint n = 105000, i, j; var pr = new uint[10100];
    pr[0] = 2; pr[1] = 3; uint pc = 2, r, d, ii;
    var pl = new bool[n + 1]; r = (uint)Math.Sqrt(n);
    for (i = 9; i < n; i += 6) pl[i] = true;
    for (i = 5, d = 4; i <= r; i += (d = 6 - d)) if (!pl[i]) {
      pr[pc++] = i; for (j = i * i, ii = i << 1; j <= n; j += ii)
        pl[j] = true; }
    for ( ;i <= n; i += (d = 6 - d)) if (!pl[i]) pr[pc++] = i;
    t = pr[10000]; sw.Stop();
    Console.Write("  {0:n0} {1} μs  {2:0.000} times faster", t,
      (e2 = sw.Elapsed.TotalMilliseconds) * 1000.0, e1 / e2); } }
Output @ Tio.run:
One-at-a-time trial division vs sieve of Eratosthenes
104,743 3.8943 ms  104,743 357.9 μs  10.881 times faster

Alternative Trial Division Method

using System; using System.Text; // PRIME_numb.cs russian DANILIN
namespace p10001 // 1 second  10001  104743 
{ class Program // rextester.com/ZBEPGE34760
    { static void Main(string[] args)
        { int max=10001; int n=1; int p=1; int f; int j; long s;
            while (n <= max) 
            { f=0; j=2; s=Convert.ToInt32(Math.Pow(p,0.5));
                while (f < 1) 
                { if (j >= s) 
                    { f=2; } 
                  if (p % j == 0) { f=1; }
                  j++;
                }
                if (f != 1) { n++; } // Console.WriteLine("{0} {1}", n, p);
                p++;
            }
Console.Write("{0} {1}", n-1, p-1);
Console.ReadKey(); 
}}}
Output:
104743

C++

Library: Primesieve
#include <iostream>
#include <locale>

#include <primesieve.hpp>

int main() {
    std::cout.imbue(std::locale(""));
    std::cout << "The 10,001st prime is " << primesieve::nth_prime(10001) << ".\n";
}
Output:
The 10,001st prime is 104,743.

COBOL

Limit based on the fact that the nth prime is guaranteed to be less than n * (ln n + ln(ln n)). 

IDENTIFICATION DIVISION.
       PROGRAM-ID. 10001th_prime.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 n        PIC 9(3)    COMP.
       01 cnt      PIC 9(5)    COMP    VALUE 1.
       01 sieve.
           05 isp  PIC 9               VALUE 1 OCCURS 115000 TIMES 
                                       INDEXED BY i.
       01 out      PIC Z(10).

       PROCEDURE DIVISION.
           PERFORM VARYING n FROM 2 BY 1 UNTIL n * n > 115000
               SET i TO n

               IF isp(i) = 1
                   MULTIPLY n BY n GIVING i
                   PERFORM VARYING i FROM i BY n UNTIL i > 115000
                       SET isp(i) TO 0
                   END-PERFORM
           
           END-PERFORM

           SET i to 1
           
           PERFORM UNTIL cnt = 10001
               SET i UP BY 2
               ADD isp(i) TO cnt
           END-PERFORM

           MOVE i TO out
           DISPLAY FUNCTION TRIM (out)
           STOP RUN.
Output:
104743

Dart 

import 'dart:math';

bool isPrime(int n) {
  if (n <= 1) return false;
  if (n == 2) return true;
  for (int i = 2; i <= sqrt(n); ++i) {
    if (n % i == 0) return false;
  }
  return true;
}

int prime(int n) {
  int p, pn = 1;
  if (n == 1) return 2;
  for (p = 3; pn < n; p += 2) {
    if (isPrime(p)) pn++;
  }
  return p - 2;
}

void main() {
  print(prime(10001));
}
Output:
104743

Delphi

Works with: Delphi version 6.0
Library: none
function IsPrime(N: integer): boolean;
{Fast, optimised prime test}
var I,Stop: integer;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
     begin
     I:=5;
     Stop:=Trunc(sqrt(N));
     Result:=False;
     while I<=Stop do
           begin
           if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
           Inc(I,6);
           end;
     Result:=True;
     end;
end;


function Find10001thPrime: integer;
{Return the 10,001th prime number}
var Count: integer;
begin
Count:=1;
Result:= 3;
while true do
	begin
	if IsPrime(Result) then Count:= Count+1;
	if Count=10001 then exit;
	Inc(Result,2);
	end;
end;
Output:
10,001th Prime= 104,743

D

Translation of: C
import std.stdio;

int isprime( int p ) {
    int i;
	
    if(p==2) return 1;

    if(!(p%2)) return 0;
	
    for(i=3; i*i<=p; i+=2) {
       if(!(p%i)) return 0;
    }
	
    return 1;
}

int prime( int n ) {
	
    if(n==1) return 2;
	
    int p, pn=1;
	
    for(p=3;pn<n;p+=2) {
        if(isprime(p)) pn++;
    }
	
    return p-2;
}

void main()
{
	writeln(prime(10_001));
}
Output:
104743

Erlang 

-module(task_10001th_prime).

-export([main/0]).

% 2 and 3 are both primes, so we start searching at 5
main() -> search(5, 2, 2).

search(N, Inc, Count) when Count < 10_001 ->
    case is_prime(N) of
        true -> search(N + Inc, 6 - Inc, Count + 1);
        false -> search(N + Inc, 6 - Inc, Count)
    end;
search(N, Inc, _) -> N - 6 + Inc.

is_prime(P) -> is_prime(P, 5, 2).

is_prime(N, P, _) when P * P > N -> true;
is_prime(N, P, _) when N rem P =:= 0 -> false;
is_prime(N, P, Inc) -> is_prime(N, P + Inc, 6 - Inc).
Output:
 timer:tc(task_10001th_prime, main, []).
{68615,104743}

EasyLang 

fastfunc isprim num .
   if num mod 2 = 0 and num > 2
      return 0
   .
   i = 3
   while i <= sqrt num
      if num mod i = 0
         return 0
      .
      i += 2
   .
   return 1
.
i = 2
repeat
   if isprim i = 1
      nprim += 1
   .
   until nprim = 10001
   i += 1
.
print i
Output:
104743

F#

This task uses Extensible Prime Generator (F#) 

// 10001st prime. Nigel Galloway: November 22nd., 2021
printfn $"%d{Seq.item 10000 (primes32())}"
Output:
104743

Factor 

USING: math math.primes prettyprint ;

2 10,000 [ next-prime ] times .
Output:
104743

Fermat 

Prime(10001);
Output:
104743

Frink 

nth[primes[], 10001-1]
Output:
104743

FutureBasic 

local fn IsPrime( n as NSUInteger ) as BOOL
  BOOL       isPrime = YES
  NSUInteger i
  
  if n < 2        then exit fn = NO
  if n = 2        then exit fn = YES
  if n mod 2 == 0 then exit fn = NO
  for i = 3 to int(n^.5) step 2
    if n mod i == 0 then exit fn = NO
  next
end fn = isPrime


local fn Prime( n as NSUInteger ) as long
  long p = 3, pn = 1
  
  if n = 1 then exit fn = 2
  while ( pn < n )
    if fn IsPrime( p ) then pn++
    p += 2
  wend
  p -= 2
end fn = p

print fn Prime(10001)

HandleEvents
Output:
104743

Go 

package main

import "fmt"

func isPrime(n int) bool {
    if n == 1 {
        return false
    }
    i := 2
    for i*i <= n {
        if n%i == 0 {
            return false
        }
        i++
    }
    return true
}

func main() {
    var final, pNum int

    for i := 1; pNum < 10001; i++ {
        if isPrime(i) {
            pNum++
        }
        final = i
    }
    fmt.Println(final)
}
Output:
104743

J 

p:10000      NB. the index starts at 0; p:0 = 2
Output:
104743

Java

Uses the PrimeGenerator class from Extensible prime generator#Java. 

public class NthPrime {
    public static void main(String[] args) {
        System.out.printf("The 10,001st prime is %,d.\n", nthPrime(10001));
    }

    private static int nthPrime(int n) {
        assert n > 0;
        PrimeGenerator primeGen = new PrimeGenerator(10000, 100000);
        int prime = primeGen.nextPrime();
        while (--n > 0)
            prime = primeGen.nextPrime();
        return prime;
    }
}
Output:
The 10,001st prime is 104,743.


JavaScript

Prime 10001 from Russia jdoodle.com/h/2V1 

var max = 10001, n=1, p=1; var f,j,s  
while (n <= max) 
{ f=0; j=2; s = parseInt(Math.pow(p, 0.5))
   while (f < 1)
      { if (j >= s) f=2  
        if ( p % j == 0 ) f=1  
        j++
      }
   if (f != 1) n++ // { document.write(n +" "+ p +"<br>") }
   p++
}
document.write("<br>"+ (n-1) +" "+ (p-1) +"<br>" )
Output:
10001 104743

jq

Works with: jq

Works with gojq, the Go implementation of jq

A solution without any pre-determined numbers or guesses.

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

# Output: a stream of the primes
def primes: 2, (range(3; infinite; 2) | select(is_prime));

# The task
# jq uses an index-origin of 1 and so:
nth(10000; primes)
Output:
104743

Julia 

julia> using Primes

julia> prime(10001)
104743

Mathematica / Wolfram Language 

Prime[10001]
Output:


104743


Maxima 

primes_first_n(n) := (
           if n<=1 then
               []
           else (
               L : [2],
               for i:2 thru n do (
                   L : append(L, [next_prime(last(L))])
               ),
               L
           )
       )$
last(primes_first_n(10001));
Output:


104743

MiniScript 

isPrime = function(n)
	s = floor(n ^ 0.5)
	for i in range(2, s)
		if n % i == 0 then return false
	end for
	return true
end function

tt = time
c = 2
p = 2
lastPrime = 2
while c < 10001
	p += 1
	if isPrime(p) then 
		c += 1
	end if
end while
print p
Output:
104743

Nim 

func isPrime(n: Positive): bool =
  ## Return true if "n" is prime.
  ## Assume n >= 5 and n not multiple of 2 and 3.
  var d = 5
  var step = 2
  while d * d <= n:
    if n mod d == 0:
      return false
    inc d, step
    step = 6 - step
  result = true

iterator primes(): tuple[rank, value: int] =
  ## Yield the primes preceded by their rank in the sequence.
  yield (1, 2)
  yield (2, 3)
  var idx = 2
  var n = 5
  var step = 2
  while true:
    if n.isPrime:
      inc idx
      yield (idx, n)
    inc n, step
    step = 6 - step

for (i, n) in primes():
  if i == 10001:
    echo "10001st prime: ", n
    break
Output:
10001st prime: 104743

OCaml

Using the function seq_primes from Extensible prime generator#OCaml: 

let () =
  seq_primes |> Seq.drop 10000 |> Seq.take 1 |> Seq.iter (Printf.printf "%u\n")
Output:
104743

PARI/GP 

prime(10001)
Output:
%1 = 104743

Pascal

Free Pascal 

Program nth_prime;

Function nthprime(x : uint32): uint32;
Var primes : array Of uint32;
  i,pr,count : uint32;
  found : boolean;
Begin
  setlength(primes, x);
  primes[1] := 2;
  count := 1;
  i := 3;
  Repeat
    found := FALSE;
    pr := 0;
    Repeat
      inc(pr);
      found := i Mod primes[pr] = 0;
    Until (primes[pr]*primes[pr] > i) Or found;
    If Not found Then
      Begin
        inc(count);
        primes[count] := i;
      End;
    inc(i,2);
  Until count = x;
  nthprime := primes[x];
End;

Begin
  writeln(nthprime(10001));
End.
Output:
104743

Perl

Library: ntheory
use strict;
use warnings;
use feature 'say';

# the lengthy wait increases the delight in finally seeing the answer
my($n,$c) = (1,0);
while () {
    $c++ if (1 x ++$n) !~ /^(11+)\1+$/;
    $c == 10_001 and say $n and last;
}

# or if for some reason you want the answer quickly
use ntheory 'nth_prime';
say nth_prime(10_001);
Output:
104743
104743

Phix 

with js ?get_prime(10001)
Output:
104743

Picat 

go ?=>
  println(nth_prime(10001)),

  % faster but probably considered cheating
  nth(10001,primes(200000),P),
  println(P).

nth_prime(Choosen) = P =>
   nth_prime(1,0,Choosen, P).

nth_prime(Num, Choosen, Choosen, Num) :-
  prime(Num).
nth_prime(Num, Ix, Choosen, P) :-
   Ix < Choosen,
   next_prime(Num, P2),
   nth_prime(P2, Ix+1, Choosen, P).

next_prime(Num, P) :-
  next_prime2(Num+1, P).
next_prime2(Num, Num) :-
  prime(Num).
next_prime2(Num, P) :-
   next_prime2(Num+1,P).
Output:
104743
104743

Prolog

for swi-prolog 

isPrime(2).                 % prime generator
isPrime(N):-
	between(3, inf, N),
	N /\ 1 > 0,             % odd
	M is floor(sqrt(N)) - 1, % reverse 2*I+1
	Max is M div 2,
	forall(between(1, Max, I), N mod (2*I+1) > 0).

do:- Index is 10001,
	findnsols(Index, N, isPrime(N), PrimeList),!,
	last(PrimeList, PrimeAtIndex),
	format('prime(~d) is ~d', [Index, PrimeAtIndex]), nl.
Output:
?- do.
prime(10001) is 104743
true.

Python

Trial Division Method

#!/usr/bin/python

def isPrime(n):
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False        
    return True

def prime(n: int) -> int:
    if n == 1:
        return 2
    p = 3
    pn = 1
    while pn < n:
        if isPrime(p):
            pn += 1
        p += 2
    return p-2

if __name__ == '__main__':
    print(prime(10001))
Output:
104743

Alternative Trial Division Method

import time; max=10001; n=1; p=1; # PRIME_numb.py russian DANILIN 
while n<=max: # 78081 994271 45 seconds
    f=0; j=2; s = int(p**0.5) # rextester.com/AAOHQ6342
    while f < 1:
        if j >= s:
            f=2
        if p % j == 0:
            f=1
        j+=1
    if f != 1:
        n+=1;
        #print(n,p);
    p+=1
print(n-1,p-1)
print(time.perf_counter())
Output:
10001 104743 7 seconds

Quackery

The 10001st prime number is the 10000th odd prime number.

prime is defined at Miller–Rabin primality test#Quackery. 

  1 10000 times [ 2 + dup prime until ] echo
Output:
104743

R 

library(primes)
nth_prime(10001)
Output:
104743

Racket 

#lang racket
(require math/number-theory)
; Index starts at 0, (nth-prime 0) is 2
(nth-prime 10000)
Output:
104743

Raku 

say (^∞).grep( &is-prime )[10000]
Output:
104743

REXX

The task has no stretch goal, nevertheless I will try one: showing primes higher in de sequence.

Trial division

/* REXX */
Parse Version v
Say v
Call Time 'R'
z=1
p.0=3
p.1=2
p.2=3
p.3=5
Do n=5 By 2 Until z=10001
  If right(n,1)=5 Then Iterate
  Do i=2 To p.0 Until b**2>n
    b=p.i
    If n//b=0 Then Leave
    End
  If b**2>n Then Do
    z=p.0+1
    p.z=n
    p.0=z
    End
  End
Say z n time('E')
Output:
H:\>rexx prime10001
REXX-ooRexx_5.0.0(MT)_64-bit 6.05 8 Sep 2020
10001 104743 0.219000

H:\>regina prime10001
REXX-Regina_3.9.4(MT) 5.00 25 Oct 2021
10001 104743 .615000

Finding the 100001th prime number:

REXX-ooRexx_5.0.0(MT)_64-bit 6.05 23 Dec 2022
100001 1299721 11.989000

REXX-Regina_3.9.6(MT) 5.00 29 Apr 2024
100001 1299721 19.117000

Libraries

REXX does not have an 'include' facility nor 'arbitrary precision' mathematical functions out of the box. In previous REXX entries it was custom the have all needed routines or procedures copied into the program. Newer entries redirect to
Libraries and
Pre processor and Include clause.
At the end of each entry you'll find several 'Include' clauses, showing the libraries that the program needs (cf '#include', 'import', 'uses' or '::requires').

Sieve

As some other REXX entries suggest, using a sieve is faster, but requires memory to store the primes. Consider following program, based on the property 'nth prime < n*(ln(n)+ln(ln(n)))'. 

/* REXX */
Parse Version v
Say v
glob. = ''
Call Time 'R'
Call Primes(105000)
n = 10001
Say glob.prime.n n time('E')
Exit

Primes:
/* Prime numbers */
procedure expose glob.
arg x
/* Validity */
if \ Whole(x) then
   return 'X'
if x < 1 then
   return 'X'
/* Fast values */
if x = 1 then do
   glob.prime.0 = 0
   return 0
end
if x < 101 then do
   p = '2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 999'
   do n = 1 to Words(p)
      w = Word(p,n)
      if w > x then do
         n = n-1
         leave
      end
      glob.prime.n = w
   end
   glob.prime.0 = n
   return n
end
/* Wheeled sieve of Eratosthenes */
do i = 3 by 2 to x while i*i <= x
   if glob.priem.i = '' then do
      do j = i*3 by i+i to x
         glob.priem.j = 0
      end
   end
end
/* Save results */
n = 1; glob.prime.1 = 2
do i = 3 by 2 to x
   if glob.priem.i = '' then do
      n = n+1; glob.prime.n = i
   end
end
glob.prime.0 = n
return n

include Numbers
Output:
As required by the task:
REXX-ooRexx_5.0.0(MT)_64-bit 6.05 23 Dec 2022
104743 10001 0.047000
REXX-Regina_3.9.6(MT) 5.00 29 Apr 2024
104743 10001 0.027000

And for some higher entries in the sequence:
REXX-ooRexx_5.0.0(MT)_64-bit 6.05 23 Dec 2022
1299721 100001 0.829000
REXX-Regina_3.9.6(MT) 5.00 29 Apr 2024
1299721 100001 0.469000

REXX-ooRexx_5.0.0(MT)_64-bit 6.05 23 Dec 2022
15485867 1000001 13.938000
REXX-Regina_3.9.6(MT) 5.00 29 Apr 2024
15485867 1000001 7.726000

REXX-ooRexx_5.0.0(MT)_64-bit 6.05 23 Dec 2022
86028157 5000001 89.021000
REXX-Regina_3.9.6(MT) 5.00 29 Apr 2024
86028157 5000001 81.339000

The last example, finding all primes in the range 2-87M (more than 5M primes!), took > 10GB memory on my 16GB machine, pushing it to the max. But without using the sieve solution, the last two examples would have taken hours.

Ring 

load "stdlib.ring"
see "working..." + nl
num = 0 pr = 0 limit = 10001

while true
      num++
      if isprime(num) pr++ ok
      if pr = limit exit ok
end

see "" + num + nl + "done..." + nl
Output:
working...
The 10001th prime is: 104743
done...

RPL

Works with: HP version 49
« 2
  1 10000 START NEXTPRIME NEXT
» 'TASK' STO
Output:
1: 104743

Ruby 

require "prime"
puts  Prime.lazy.drop(10_000).next
Output:
104743

Rust 

// [dependencies]
// primal = "0.3"

fn main() {
    let p = primal::StreamingSieve::nth_prime(10001);
    println!("The 10001st prime is {}.", p);
}
Output:
The 10001st prime is 104743.

Scala

Scala3 ready 

object Prime10001 extends App {

  val oddPrimes: LazyList[Int] = 3 #:: LazyList.from(5, 2)
        .filter(p => oddPrimes.takeWhile(_ <= math.sqrt(p)).forall(p % _ > 0))
  val primes = 2 #:: oddPrimes
  
  val index = 10_001
  println(s"prime($index): " + primes.drop(index - 1).take(1).head)
}
Output:
prime(10001): 104743

Sidef 

say 10001.prime
Output:
104743

Wren

Library: Wren-math
Library: Wren-fmt
import "./math" for Int
import "./fmt" for Fmt

var n = 10001
var limit = (n.log * n * 1.2).floor  // should be enough
var primes = Int.primeSieve(limit)
Fmt.print("The $,r prime is $,d.", n, primes[n-1])
Output:
The 10,001st prime is 104,743.

x86 Assembly

Using the Sieve of Eratosthenes and n * (ln n + ln(ln n)) as the upper limit for finding the nth prime. 

section .data
    primes times 14375 db 255   ;N * (ln N + ln(ln N)) bits, rounded up

section .text
    global main

main:
    mov     ebx, 1          ;array index for outer loop
    xor     ecx, ecx        ;counter

sieve_outer:
    inc     ebx             ;increase index
    mov     eax, ebx        ;copy to eax for squaring
    mul     ebx             ;square
    cmp     eax, 115000     ;check if square is > limit    
    jg      find10001st     ;if it is, sieve is done
    bt      [primes], ebx   ;check if ebx is no prime
    jnc     sieve_outer     ;if no prime, try next number
    inc     ecx             ;else increase counter

sieve_inner:
    btr     [primes], eax   ;set multiple to not prime
    add     eax, ebx        ;next multiple
    cmp     eax, 115000     ;check if multiple is < limit
    jl      sieve_inner     ;if it is, continue with inner loop
    jmp     sieve_outer     ;if not, continue with outer loop

find10001st:
    inc     ebx             ;increase array index
    bt      [primes], ebx   ;is it prime?
    adc     ecx, 0          ;if yes, increase ecx
    cmp     ecx, 10001      ;check if counter arrived at 10001
    jl      find10001st     ;if not, continue
                            ;done, result in ebx
Output:
104743

XPL0 

func IsPrime(N); \Return 'true' if odd N > 2 is prime
int  N, I;
[for I:= 3 to sqrt(N) do
    [if rem(N/I) = 0 then return false;
    I:= I+1;
    ];
return true;
];

int C, N;
[C:= 1;         \count 2 as first prime
N:= 3;
loop    [if IsPrime(N) then
            [C:= C+1;
            if C = 10001 then quit;
            ];
        N:= N+2;
        ];
IntOut(0, N);
]
Output:
104743


Zig 

const std = @import("std");
const stdout = @import("std").io.getStdOut().writer();

const limit = 10001;

fn isPrime(x: usize) bool {
    if (x % 2 == 0) return false;

    var i: usize = 3;
    while (i * i <= x) : (i += 2) {
        if (x % i == 0) return false;
    }
    return true;
}

pub fn main() !void {
    var cnt: usize = 0;
    var last: usize = 0;
    var n: usize = 1;

    while (cnt < limit) : (n += 1) {
        if (isPrime(n)) {
            cnt += 1;
            last = n;
        }
    }
    try stdout.print("{d}st prime number is: {d}\n", .{ limit, last });
}
Output:
10001st prime number is: 104743
Retrieved from "https://rosettacode.org/wiki/10001th_prime?oldid=367610"