Program, który znajdzie następną liczbę pierwszą

15

Wprowadzenie:


Przypadkowo zepsułeś upływ czasu za pomocą urządzenia stworzonego dla zabawy, które okazało się maszyną czasu. W rezultacie zostałeś zepchnięty do dalekiej przyszłości. Zdałeś sobie sprawę, że obliczenia, moc obliczeniowa i ogólnie komputery zostały rozwinięte w ogromnej ilości, a dokładniej w nieskończonej ilości . Więc weź sobie komputer z nieskończoną pamięcią i mocą obliczeniową. Nie masz pojęcia, jak może mieć nieskończoną pamięć i nieskończoną moc przetwarzania, ale akceptujesz ją i wracasz do teraźniejszości.

Wyzwanie:


Słyszałeś, że osoba, która odkryła największą liczbę pierwszą, 2^74,207,281 − 1otrzymała 100 000 $. Postanawiasz stworzyć program, który znajdzie następną liczbę pierwszą, ponieważ chcesz odzyskać pieniądze wydane na komputer. Tworzysz taki, który pobiera liczbę wejściową i znajduje następną liczbę pierwszą, albo przez bruteforcing, albo dowolną inną metodą.

Wyjaśnienia: Masz hipotetyczną maszynę z nieskończoną pamięcią i mocą obliczeniową. Twój program NIE MOŻE być ograniczony (np. Int # C # może przechowywać od -2,147,483,648do 2,147,483,647), więc twój program musi być w stanie przechowywać i pracować z dowolną liczbą dowolnej wielkości. Masz nieskończone zasoby, więc nie przejmuj się, jeśli zabraknie ci pamięci, jeśli na to pozwolisz.

Przykład I / O: Dane
wejściowe: obecnie największa odkryta liczba pierwsza z 22 338 618 cyframi.
Wyjście: Dokładnie następna liczba pierwsza

Oczywiście nie musisz udowadniać, że działa, ponieważ obliczenie na maszynie fizycznej zajęłoby mnóstwo czasu. Ale jeśli przeniosłeś swój program na hipotetyczną maszynę z nieskończoną mocą obliczeniową / pamięcią, powinien natychmiast obliczyć.


Znalezienie następnej liczby pierwszej i sprawdzenie, czy liczba jest liczbą pierwszą, to dwie zupełnie różne rzeczy

P. Ktinos
źródło
1
Czy to musi być kolejna liczba pierwsza ? Wiele algorytmów wyszukiwania liczb pierwszych dla dużych liczb pierwszych przeszukuje tylko określone typy liczb i dlatego czasami
pomija
10
Myślę, że powinieneś dodać kilka poważnych przypadków testowych.
FlipTack
3
Twój program NIE MOŻE być ograniczony ”, ale na podstawie przykładu podejrzewam, że każdy istniejący język liczy się jako ograniczony, jeśli nie pasuje do innego powodu niż użycie skończonego typu do adresowania pamięci.
Peter Taylor
1
Możliwy duplikat Czy ta liczba jest liczbą pierwszą?
Post Rock Garf Hunter
2
@ mbomb007 dlaczego? Wszystkie odpowiedzi oprócz wbudowanych widać tylko dodatkowe opakowanie.
Post Rock Garf Hunter

Odpowiedzi:

22

Mathematica, 9 bajtów

NextPrime
Greg Martin
źródło
... Czy to naprawdę działa?
wizzwizz4
12
Oczywiście Mathematica zawsze ma wbudowaną
funkcję
@ wizzwizz4, oczywiście, wypróbuj online!
Pavel
8

Python 3 , 45 bajtów

f=lambda n,k=1,m=1:m%k*k>n or-~f(n,k+1,m*k*k)

Wypróbuj online!

Dennis
źródło
3
Wierzę, że to ukryte twierdzenie Wilsona. kjest równy końcowemu wynikowi, mzawiera (k-1)!^2. Od (k-1)! = -1 mod k zachowuje się tylko wtedy, gdy k jest liczbą pierwszą, mamy (k-1)! (K-1)! = 1 mod k, który pomnożony przez k będzie sam k. Obliczasz kwadrat, aby pozbyć się jedynego wyjątku (k-1)! = 0 mod k dla kompozytu k, co występuje dla k = 4. Prawidłowo?
lub
Tak to jest poprawne.
Dennis
To rzucaRecursionError: maximum recursion depth exceeded in comparisonf(1000)
2017
5
@ovs Pytanie mówi, że mamy nieskończoną pamięć. Dlatego możemy założyć nieskończenie wysoki limit głębokości rekurencji, a więc nie martwić się RecursionError.
FlipTack,
6

Python 2, 78 77 76 74 bajty

def f(n):
 while 1:
    n+=1
    if[i for i in range(1,n)if n%i<1]==[1]:return n

-1 bajt dzięki @KritixiLithos
-1 bajt dzięki @FlipTack
-2 bajty dzięki @ElPedro

ovs
źródło
n%i<1jest krótszy niżn%i==0
Kritixi Lithos
Po tym nie potrzebujesz już spacji if.
FlipTack
Myślę, że masz na myśli<1
Jonathan Allan,
Myślę, że możesz użyć tabulacji zamiast 2 spacji dla wcięć drugiego poziomu, ale w tej chwili nie mogę przetestować.
ElPedro
1
@ElPedro ma rację. Możesz zmienić 2 spacje przed n+=1i ifna tabulatory i zapisać 2 bajty
5

Galaretka , 2 bajty

Æn

Wypróbuj online!

To domyślnie pobiera dane wejściowe z i zgodnie z instrukcją generuje najbliższą liczbę pierwszą ściśle większą niż z.

Steenbergh
źródło
4

Bash + coreutils, 52 bajty

for((n=$1,n++;`factor $n|wc -w`-2;n++)){ :;};echo $n

Wypróbuj online!

Dokumentacja bash i współczynnik nie określają maksymalnej wartości całkowitej, którą mogą obsłużyć (chociaż w praktyce każda implementacja ma maksymalną wartość całkowitą). Przypuszczalnie w GNU przyszłości na twoich nieskończenie dużych maszynach, bash i factor będą miały nielimitowane liczby całkowite.

Mitchell Spector
źródło
W rzeczywistości dokumenty określają fakt, że jeśli zbudowany bez GNU MP, obsługiwana jest tylko pojedyncza precyzja.
Dani_l
1
@Dani_l Cóż, pozycja man dla bash mówi tylko: „Ocena jest przeprowadzana w liczbach całkowitych o stałej szerokości bez sprawdzania przepełnienia, chociaż dzielenie przez 0 jest uwięzione i oznaczone jako błąd”. Nie określa szerokości. (Jak pamiętam, standardowe implementacje bash na moich komputerach używają 64-bitowych liczb całkowitych ze znakiem, ale nie mogę teraz sprawdzić.) Co do faktów, to z pewnością zostanie zaktualizowane: przyszłe komputery OP z nieskończonymi zasobami będą miały czynnik skompilowany z gnu_up, aby uzyskać nieograniczoną precyzję :).
Mitchell Spector
3

Maxima, 10 bajtów

next_prime

Funkcja zwraca najmniejszą liczbę pierwszą większą niż argument.

rahnema1
źródło
3

Brachylog , 2 bajty

<ṗ

Wypróbuj online!

Wyjaśnienie

(?) <   (.)      Input < Output
      ṗ (.)      Output is prime
                 (Implicit labelization of the Output at the end of the predicate)
Fatalizować
źródło
3

Python z sympią, 28 bajtów

import sympy
sympy.nextprime

sympy.nextprimeto funkcja, która robi to, co mówi na puszce. Działa dla wszystkich pływaków.

repl.it


Pyton, 66 59 bajtów

-4 bajty dzięki Lynn (użycie -~)
-3 bajty dzięki FlipTack (użycie andi or, pozwalając ...==1na przełączenie do ...-1warunku).

f=lambda n:sum(-~n%-~i<1for i in range(n))-1and f(n+1)or-~n

repl.it

Funkcja rekurencyjna, która się liczy n momentu znalezienia liczby pierwszej, poprzez sprawdzenie, że istnieje tylko jedna liczba, n-1która dzieli ją (tj. 1). Działa dla wszystkich liczb całkowitych, podnosi błąd dla liczb zmiennoprzecinkowych.

Działa na 2.7.8 i 3.5.2, nie działa na 3.3.3 (błąd składniowy z powodu braku miejsca między ==1i else)

Jonathan Allan
źródło
(n+1)%(i+1)jest -~n%-~i, jak sądzę.
Lynn
Dzieje się tak, dzięki ... Próbowałem zrobić krótszy, używając twierdzenia Wilsona.
Jonathan Allan
Czy zwarcie and/ ordziała, takie jak f=lambda n:sum(-~n%-~i<1for i in range(n))==1and-~n or f(n+1)?
FlipTack,
W rzeczywistości to ^ można f=lambda n:sum(-~n%-~i<1for i in range(n))-1and f(n+1)or-~n
grać w
@FlipTack Pierwotnie ich unikałem, aby mógł przejść przez zero, ale zadziała - to trzy bajtowe zapisywanie!
Jonathan Allan
2

Python, 114 83 bajtów

def g(b):
 while 1:
  b+=1
  for i in range(2,b):
   if b%i<1:break
  else:return b

Bez wbudowanych, jeśli istnieją.

-30 przez usunięcie białych znaków i -1 przez zmianę b%i==0nab%i<1

sagiksp
źródło
3
Nie znajdziesz następnej 1
liczby
Zakłada się teraz, że b> 2
sagiksp
Nie możesz po prostu stworzyć własnych zasad ... musisz postępować zgodnie ze specyfikacją wyzwania. Nigdzie nie jest powiedziane, że możesz przyjąć granice wejścia.
FlipTack
Nawet przy takim założeniu nie udaje się to w przypadku wszystkich wartościowanych danych wejściowych.
FlipTack
Jestem idiotą, źle to odczytałem. Naprawione. @FlipTack
sagiksp
2

Perl 6 , 25 bajtów

{first *.is-prime,$_^..*}

Jak to działa

{                       }  # A lambda.
                  $_ ..*   # Range from the lambda argument to infinity,
                    ^      # not including the start point.
 first           ,         # Iterate the range and return the first number which
       *.is-prime          # is prime.

Perl 6 , 32 bajty

{first {all $_ X%2..^$_},$_^..*}

Z nieefektywnymi niestandardowymi testami pierwotności.

Jak to działa

Struktura zewnętrzna jest taka sama jak powyżej, ale predykat przekazany do first(aby zdecydować, czy dana liczba jest liczbą pierwszą), jest teraz:

{               }  # A lambda.
     $_            # Lambda argument (number to be tested).
          2..^$_   # Range from 2 to the argument, excluding the end-point.
        X          # Cartesian product of the two,
         %         # with the modulo operator applied to each pair.
 all               # Return True if all the modulo results are truthy (i.e. non-0).
smls
źródło
Miałem nadzieję, że dostanę coś krótszego z Perlem 5, ale ciężko jest pokonać wbudowany .is-prime;)
Zaid
2

Pyke, 8 7 bajtów

~p#Q>)h

Wypróbuj tutaj!

4 bajty, niekonkurujące

(Interpreter zaktualizowany od opublikowania wyzwania)

~p<h

Wypróbuj tutaj!

~p   -   primes_iterator()
  <  -  filter(^, input() < i)
   h - ^[0]
niebieski
źródło
Dlaczego drugi nie konkuruje? Nie rozumiem wystarczająco
theonlygusti
@theonlygusti: Zazwyczaj jedynym uzasadnionym powodem oznaczenia zgłoszenia jako niekonkurującego w tym miejscu (w przeciwieństwie do jego całkowitego braku) jest to, że naprawiłeś błąd lub dodałeś funkcję w języku, w którym napisany jest program, i to pomogło ci w wyzwaniu . (
@theonlygusti wyjaśnione
Blue
1

J, 4 bajty

4&p:

Prosty wbudowany do następnej liczby pierwszej.

Conor O'Brien
źródło
1

05AB1E , 16 13 bajtów (Emigna @ -3 bajty)

2•7£?ÿ•o[>Dp#

Wypróbuj online!

2•7£?ÿ•o        # Push current largest prime.
        [   #    # Until true..
         >Dp    # Increment by 1, store, check primality.
                # After infinite loop, implicitly return next prime.
Urna Magicznej Ośmiornicy
źródło
Nie [>Dp#działałoby?
Emigna
Nadal możesz wyciąć 8 dodatkowych bajtów, ponieważ program powinien zająć liczbę pierwszą jako dane wejściowe i wyjściowe następnej liczby pierwszej.
Emigna
@Emigna to pytanie jest duplikatem.
Magic Octopus Urn
To prawdopodobne, że tak.
Emigna
1

Perl, 30 bajtów (29 +1 za -p):

(1x++$_)=~/^(11+?)\1+$/&&redo

Stosowanie

Wprowadź liczbę po naciśnięciu klawisza Return (wprowadź 12345 w przykładzie poniżej, wyjścia 12347):

$ perl -pe '(1x++$_)=~/^(11+?)\1+$/&&redo'
12345
12347

Jak to działa

  • Zdefiniuj ciąg znaków o 1długości ++$_, gdzie$_ początkowo jest wartością wejściową
  • Wyrażenie regularne sprawdza, czy łańcuch 1s nie jest liczbą pierwszą (wyjaśniono tutaj ).
  • Jeśli długość łańcucha nie jest liczbą pierwszą, sprawdzanie jest ponownie oceniane dla następnej liczby całkowitej (++$_ )
  • Jeśli długość łańcucha jest liczbą pierwszą, niejawna whilepętla kończy działanie i-p wyświetla wartość$_
  • Uwaga: nie ma potrzeby obsługi przypadku krawędzi "1"o długości 1, ponieważ nigdy nie będzie on używany dla wartości mniejszych niż 1, zgodnie ze specyfikacją.
Zaid
źródło
1

Java 7, 373 343 334 303 268 bajtów

import java.math.*;class M{public static void main(String[]a){BigInteger n,i,o,r=new BigInteger(a[0]);for(r=r.add(o=r.ONE);;r=r.add(o)){for(n=r,i=o.add(o);i.compareTo(n)<0;n=n.mod(i).compareTo(o)<0?r.ZERO:n,i=i.add(o));if(n.compareTo(o)>0)break;}System.out.print(r);}}

-75 bajtów dzięki @Poke

Nie golfowany:

import java.math.*;
class M{
  public static void main(String[] a){
    BigInteger n,
               i,
               o,
               r = new BigInteger(a[0]);
    for(r = r.add(o = r.ONE); ; r = r.add(o)){
      for(n = r, i = o.add(o); i.compareTo(n) < 0; n = n.mod(i).compareTo(o)< 0
                                                        ? r.ZERO
                                                        : n,
                                                   i = i.add(o));
      if(n.compareTo(o) > 0){
        break;
      }
    }
    System.out.print(r);
  }
}

Wypróbuj tutaj.

Niektóre przykładowe wejścia / wyjścia:

7 -> 11
1609 -> 1613
104723 -> 104729
Kevin Cruijssen
źródło
@Poke Grałem w golfa o kolejne 31 bajtów, dodając staticpole i metodę p, ale usuwając metodę ci pparametr.
Kevin Cruijssen
0

QBIC , 34 bajty

:{a=a+1[2,a/2|~a%b=0|b=a]]~a<b|_Xa

Na podstawie tego testera pierwotności QBIC . Wyjaśnienie:

:{a=a+1    Read 'a' from the command line, start an infinite loop 
           and at the start of each iteration increment 'a'
[2,a/2|    FOR b = 2, b <= a/2, b++
~a%b=0|    IF b cleanly divides a, we're no prime
b=a]]      so, break out of the FOR loop ( ]] = End if, NEXT )
~a<b|      If the FOR loop completed without breaking
_Xa        then quit, printing the currently tested (prime) number
           The second IF and the DO-loop are implicitly closed by QBIC.
Steenbergh
źródło
0

JavaScript (ES7), 61 bajtów

a=>{for(;a++;){for(c=0,b=2;b<a;b++)a%b||c++;if(!c)return a;}}

Stosowanie

f=a=>{for(;a++;){for(c=0,b=2;b<a;b++)a%b||c++;if(!c)return a;}}
f(2)

Wynik

3
Łukasz
źródło
Fajnie, ale nie sądzę, że to zadziała, ponieważ sam JavaScript (nie komputer) straci precyzję już po 2 ^ 53.
ETHproductions
Masz rację, ale nie sądzę, aby tego limitu można było uniknąć, nawet jeśli podzielimy liczbę na części po 32 bity w tablicy, ponieważ ostatecznie liczba musi zostać przetworzona jako całość. Jeśli masz pomysł, jak to rozwiązać, daj mi znać.
Łukasz
1
Istnieją biblioteki JS dla matematyki o dowolnej precyzji - w pewnym momencie nawet ją zbudowałem - więc jestem pewien, że to możliwe.
Spróbuję
Zrobiłem trochę google, i wydaje się interesujące. Ja też spróbuję.
Łukasz
0

MATL, 3 bajty

_Yq 

Funkcja Yqzwraca następną liczbę pierwszą bezwzględnej wartości wejścia, jeśli dane wejściowe są ujemne, więc domyślnie przechwytujemy dane wejściowe, negujemy je ( _) i szukamy następnej liczby pierwszej za pomocą Yq.

Wypróbuj online!

Suever
źródło
0

Haskell, 42 46 43 bajty

f n=[i|i<-[n..],all((>0).rem i)[2..i-1]]!!1

zwykły kod brutalnej siły.

Oczywiście znajduje to następną najmniejszą liczbę pierwszą pon . Nie ma największej liczby pierwszej.

Działa dla n > 0 .

edycja: Zakłada się, że njest liczbą pierwszą. Dzięki radom @Laikoni w komentarzach .

Will Ness
źródło
Możesz zapisać bajt, zastępując head[...]go [...]!!0. Myślę jednak, że można założyć, że njest liczbą pierwszą, więc możesz użyć [n..]zamiast, [n+1..]a następnie wziąć drugi element [...]!!1.
Laikoni
0

SimpleTemplate, 132 bajty

Algorytm jest okropny, ponieważ muszę zrobić własny kod, aby sprawdzić, czy liczba jest liczbą pierwszą, czy nie.
Okazało się to okropne, ale działa.

{@setY argv.0}{@setX 1}{@whileX}{@setX}{@set+T Y,-1}{@for_ from2 toT}{@ifY is multiple_}{@incX}{@/}{@/}{@ifX}{@incY}{@/}{@/}{@echoY}

Pobiera liczbę jako pierwszy argument, wyświetlając wynik.


Nie golfowany:

{@set number argv.0}
{@set remainder 1}
{@while remainder}
    {@set remainder 0}
    {@set+ tmp number, -1}
    {@for divisor from 2 to tmp}
        {@if number is multiple divisor}
            {@inc by 1 remainder}
        {@/}
    {@/}
    {@if remainder}
        {@inc by 1 number}
    {@/}
{@/}
{@echo number}

Wszelkie wskazówki, jak usunąć to ostatnie @if?

Ismael Miguel
źródło
0

Lua, 876 bajtów

function I(a)a.s=a.s:gsub("(%d)(9*)$",function(n,k)return tostring(tonumber(n)+1)..("0"):rep(#k)end)end function D(a)a.s=a.s:gsub("(%d)(0*)$",function(n,k)return tostring(tonumber(n)-1)..("9"):rep(#k)end):gsub("^0+(%d)","%1")end function m(a,b)local A=K(a)local B=K(b)while V(0,B)do D(A)D(B)end return A end function M(a,b)local A=K(a)local B=K(b)while V(m(B,1),A)do A=m(A,B)end return A end function l(n)return#n.s end function p(a)local A=K(a)local i=K(2)while V(i,A)do if V(M(A,i),1)then return false end I(i)end return true end function V(b,a)A=K(a)B=K(b)if l(A)>l(B)then return true end if l(B)>l(A)then return false end for i=1,l(A)do c=A.s:sub(i,i)j=B.s:sub(i,i)if c>j then return true elseif c<j then return false end end return false end function K(n)if(type(n)=='table')then return{s=n.s}end return{s=tostring(n)}end P=K(io.read("*n"))repeat I(P)until p(P)print(P.s)

Lua, w przeciwieństwie do niektórych innych języków, ma maksymalną liczbę całkowitą. Gdy liczba staje się większa niż 2 32 , rzeczy przestają działać poprawnie, a Lua próbuje oszacować zamiast dokładnych wartości.

W związku z tym musiałem zaimplementować nową metodę przechowywania liczb, w szczególności zapisałem je jako ciągi Base10, ponieważ Lua nie ma limitu wielkości Ciągów, innego niż rozmiar pamięci.

Wydaje mi się, że ta odpowiedź jest o wiele bardziej zgodna z duchem pytania, ponieważ sama w sobie musi implementować liczby całkowite precyzji, a także test podstawowy.

Wyjaśniono

-- String Math
_num = {}

_num.__index = _num

-- Increase a by one.
-- This works by grabbing ([0-9])999...$ from the string.
-- Then, increases the first digit in that match, and changes all the nines to zero.
-- "13", only the "3" is matched, and it increases to 1.
-- "19", firstly the 1 is turned to a 2, and then the 9 is changed to a 0.
-- "9" however, the 9 is the last digit matched, so it changes to "10"
function _num.inc(a)
    a.str = a.str:gsub("(%d)(9*)$",function(num,nines)
            return tostring(tonumber(num)+1)..("0"):rep(#nines)
        end)
end


-- Decrease a by one
-- Much like inc, however, uses ([0-9])0...$ instead.
-- Decrements ([0-9]) by one and sets 0... to 9...
-- "13" only the "3" is matched, and it decreases by one.
-- "10", the "1" is matched by the ([0-9]), and the 0 is matched by the 0..., which gives 09, which is clipped to 9.
function _num.dec(a)
    a.str = a.str:gsub("(%d)(0*)$",function(num,zeros)
        return tostring(tonumber(num)-1)..("9"):rep(#zeros)
    end)         :gsub("^0+(%d)","%1")
end

-- Adds a and b
-- Makes A and B, so that the original values aren't modified.
-- B is then decremented until it hits 0, and A is incremented.
-- A is then returned.
function _num.__add(a,b)
    local A = str_num(a)
    local B = str_num(b)
    while B > 0 do
        A:inc()
        B:dec()
    end
    return A
end

-- Subs b from a
-- Works just like Addition, yet Dec's A instead of Incs.
function _num.__sub(a,b)
    local A = str_num(a)
    local B = str_num(b)
    while B > 0 do
        A:dec()
        B:dec()
    end
    return A
end

-- A % B
-- Makes A and B from a and b
-- Constantly subtracts B from A until A is less than B
function _num.__mod(a,b)
    local A = str_num(a)
    local B = str_num(b)
    while A >= B do
        A = A - B
    end
    return A
end

-- #a
-- Useful for golfiness
function _num.__len(n)
    return #n.str
end

-- Primacy Testing
-- Generates A from a and i from 2.
-- Whilst i is less than A, i is incremented by one, and if A % i == 0, then it's not a prime, and we return false.
-- Once that finishes, we return true.
function _num.isprime(a)
    local A = str_num(a)
    local i = str_num(2)
    while i < A do
        if A%i < 1 then
            return false
        end
        i:inc()
    end
    return true
end

-- b < a
-- A and B are generated from a and b
-- Fristly, if the length of A and B aren't equal, then that result is output.
-- Otherwise, each character is searched from left to right, the moment they are unequal, the difference is output.
-- If all the characters match, then it's equal. Return false.
function _num.__lt(b,a)
    A=str_num(a)
    B=str_num(b)
    if #A > #B then
        return true
    end
    if #B > #A then
        return false
    end
    for i=1, #A.str do
        As = A.str:sub(i,i)
        Bs = B.str:sub(i,i)
        if As > Bs then
            return true
        elseif As < Bs then
            return false
        end
    end
    return false
end


-- b <= a
-- Same as b < a, but returns true on equality.
function _num.__le(b,a)
    A=str_num(a)
    B=str_num(b)
    if #A > #B then
        return true
    end
    if #B > #A then
        return false
    end
    for i=1, #A.str do
        As = A.str:sub(i,i)
        Bs = B.str:sub(i,i)
        if As > Bs then
            return true
        elseif As < Bs then
            return false
        end
    end
    return true
end

-- Just straight up returns it's string component. Endlessly faster than the int equivalent, mostly because it never is anything _but_ the string form.
function _num.__tostring(a)
    return a.str
end

-- Just set up the metatable...
function str_num(n)
    if(type(n)=='table')then
        return setmetatable({str = n.str}, _num)
    end
    return setmetatable({str = tostring(n)}, _num)
end

-- Generate a new str_num from STDIN
Prime = str_num(io.read("*n"))

-- This is handy, because it will call Prime:inc() atleast once, and stop at the next prime number it finds.
-- Basically, if it weren't for all that overhead of making the math possible, that's all this would be.
repeat
    Prime:inc()
until Prime:isprime()
print(Prime)

Chociaż powyższe używa Metatables, zamiast zwykłych funkcji, takich jak rzeczywista odpowiedź, która okazała się mniejsza.

ATaco
źródło
0

Rubinowy, 28 + 6 = 34 bajty

Używa -rprimeflagi.

f=->i{i+=1;i.prime??i :f[i]}

Wersja nierekurencyjna dla 31 + 6 = 37 bajtów:

->i{i+=1;i+=1 while i.prime?;i}
Wartość tuszu
źródło
0

Python + primefac , 34 32 bajty

Nie tak krótki jak używanie sympy(inna odpowiedź już tego używa), ale wciąż jest dość krótki i jest znacznie szybszy.

import primefac as p
p.nextprime

Wypróbuj online

Wprowadzanie 2**2000zakończeń zajmuje kilka sekund.

mbomb007
źródło