문제

목표는 -1을 n으로 나눌 수 있도록 제목이 n 번째 소수를 찾는 것입니다.

설명

다음은 질문을 이해하기위한 예 입니다. 반드시 해결해야하는 것은 아닙니다. 그것은 단지 질문을 설명하는 방법으로

입력으로 3을 주면 먼저 모든 소수를 살펴볼 것입니다.

 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 ...

그런 다음 소수-1을 n으로 나눌 수 있도록 소수를 선택합니다 (이 경우 3)

 7 13 19 31 37 43 61 67 73 79 97 103 107 109 127 ...

그런 다음이 순서에서 n 번째 항을 선택합니다

3을 입력하면 19 를 출력합니다

노트

우리는 이것을 시퀀스 {1, n + 1, 2n + 1, 3n + 1 ... kn + 1}에서 n 번째 소수라고 생각할 수 있습니다. 여기서 k는 자연수입니다.

테스트 사례

  1 --> 2
  2 --> 5
  3 --> 19
  4 --> 29
100 --> 39301
123 --> 102337

05AB1E , 9 8 바이트

05AB1E는 CP-1252 인코딩을 사용합니다.

Osable 덕분에 바이트 절약

µN¹*>Dp½

온라인으로 사용해보십시오!

설명

µ          # for N in [1 ...] loop until counter == input
 N¹*>      # N*input+1 (generate multiples of input and increment)
     D     # duplicate
      p½   # if prime, increase counter
           # implicitly output last prime

파이썬 2, 58 바이트

n=N=input();m=k=1
while N:m*=k*k;k+=1;N-=m%k>~-k%n
print k

매스 매 티카, 48 바이트

Select[Array[Prime,(n=#)^3],Mod[#-1,n]==0&][[n]]&

이름이없는 함수는 단일 인수를 사용합니다 n. 첫 번째 n^3소수 목록을 생성하고 1 modulo에 해당하는 소수를 선택한 n다음 n결과 의 th 요소 를 가져옵니다 . 입력 123에서 몇 초 안에 실행됩니다.

가장 먼저, 항상 단 한 번의 전성기가 있다면 그것은 현재 알려진 아니에요 n^3소수, 즉 합동 1 개 모듈이다 n훨씬 덜, n그들 중. 그러나 알고리즘은 일반화 된 Riemann 가설을n 가정하여 (적어도 큰 경우 ) 올바른 것으로 입증 될 수 있습니다 !

하스켈, 59 47 바이트

f n=[p|p<-[1,n+1..],all((<2).gcd p)[2..p-1]]!!n

사용 예 : f 4-> 29.

작동 방식 :

[p|p<-[1,n+1..]                     ]    -- make a list of all multiples of n+1
                                         -- (including 1, as indexing is 0-based)
           ,all((<2).gcd p)[2..p-1]      -- and keep the primes
                              !!n       -- take the nth element

편집 : 나누기 테스트를 제거하고 처음에 여러 개만 보아 12 바이트 동안 @Damien에게 감사드립니다.

젤리 , 9 바이트

‘ÆP>%ð#Ṫ‘

온라인으로 사용해보십시오!

작동 원리

‘ÆP>%ð#Ṫ‘  Main link. Argument: n

     ð#    Call the dyadic chain to the left with right argument n and left
           argument k = n, n+1, n+2, ... until n of them return 1.
‘          Increment; yield k+1.
 ÆP        Test k+1 for primality, yielding 1 or 0.
    %      Compute k%n.
   >       Compare the results to both sides, yielding 1 if and only if k+1 is
           prime and k is divisible by n.
       Ṫ   Tail; extract the last k.
        ‘  Increment; yield k+1.

자바 7, 106 바이트

int c(int n){for(int z=1,i=2,j,x;;i++){x=i;for(j=2;j<x;x=x%j++<1?0:x);if(x>1&(i-1)%n<1&&z++==n)return i;}}

언 골프 드 :

int c(int n){
  for(int z = 1, i = 2, j, x; ; i++){
    x = i;
    for(j = 2; j < x; x = x % j++ < 1
                           ? 0
                           : x);
    if(x > 1 & (i-1) % n < 1 && z++ == n){
      return i;
    }
  }
}

테스트 코드 :

여기에서 시도하십시오 (마지막 테스트 사례로 인해 시간 제한이 초과 되었습니다)

class M{
  static int c(int n){for(int z=1,i=2,j,x;;i++){x=i;for(j=2;j<x;x=x%j++<1?0:x);if(x>1&(i-1)%n<1&&z++==n)return i;}}

  public static void main(String[] a){
    System.out.println(c(1));
    System.out.println(c(2));
    System.out.println(c(3));
    System.out.println(c(4));
    System.out.println(c(100));
    System.out.println(c(123));
  }
}

산출:

2
5
19
29
39301
102337

Nasm 679 바이트 (Intelion Intel 386 CPU 120 바이트)

isPrime1:  
push ebp
mov ebp,dword[esp+ 8]
mov ecx,2
mov eax,ebp
cmp ebp,1
ja .1
.n: xor eax,eax
jmp short .z
.1: xor edx,edx
cmp ecx,eax
jae .3
div ecx
or edx,edx
jz .n
mov ecx,3
mov eax,ebp
.2: xor edx,edx
cmp ecx,eax
jae .3
mov eax,ebp
div ecx
or edx,edx
jz .n
inc ecx
inc ecx
jmp short .2
.3: xor eax,eax
inc eax
.z: pop   ebp
ret 4
Np:  
push esi
push edi
mov esi,dword[esp+ 12]
xor edi,edi
or esi,esi
ja .0
.e: xor eax,eax
jmp short .z
.0: inc esi
jz .e
push esi
call isPrime1
add edi,eax
dec esi
cmp edi,dword[esp+ 12]
jae .1
add esi,dword[esp+ 12]
jc .e
jmp short .0
.1: mov eax,esi
inc eax
.z: pop edi
pop esi
ret 4

이것은 ungolfed 하나이며 결과

;0k,4ra,8Pp
isPrime1: 
          push    ebp
          mov     ebp,  dword[esp+  8]
          mov     ecx,  2
          mov     eax,  ebp
          cmp     ebp,  1
          ja      .1
.n:       xor     eax,  eax
          jmp     short  .z
.1:       xor     edx,  edx
          cmp     ecx,  eax
          jae     .3
          div     ecx
          or      edx,  edx
          jz      .n
          mov     ecx,  3
          mov     eax,  ebp
.2:       xor     edx,  edx
          cmp     ecx,  eax
          jae     .3
          mov     eax,  ebp
          div     ecx
          or      edx,  edx
          jz      .n
          inc     ecx
          inc     ecx
          jmp     short  .2
.3:       xor     eax,  eax
          inc     eax
.z:       
          pop     ebp
          ret     4

; {1, n+1, 2n+1, 3n+1 }
; argomento w, return il w-esimo primo nella successione di sopra
;0j,4i,8ra,12P
Np:       
          push    esi
          push    edi
          mov     esi,  dword[esp+  12]
          xor     edi,  edi
          or      esi,  esi
          ja      .0
.e:       xor     eax,  eax
          jmp     short  .z
.0:       inc     esi
          jz      .e
          push    esi
          call    isPrime1
          add     edi,  eax
          dec     esi
          cmp     edi,  dword[esp+  12]
          jae     .1
          add     esi,  dword[esp+  12]
          jc      .e
          jmp     short  .0
.1:       mov     eax,  esi
          inc     eax
.z:       
          pop     edi
          pop     esi
          ret     4

00000975  55                push ebp
00000976  8B6C2408          mov ebp,[esp+0x8]
0000097A  B902000000        mov ecx,0x2
0000097F  89E8              mov eax,ebp
00000981  81FD01000000      cmp ebp,0x1
00000987  7704              ja 0x98d
00000989  31C0              xor eax,eax
0000098B  EB28              jmp short 0x9b5
0000098D  31D2              xor edx,edx
0000098F  39C1              cmp ecx,eax
00000991  731F              jnc 0x9b2
00000993  F7F1              div ecx
00000995  09D2              or edx,edx
00000997  74F0              jz 0x989
00000999  B903000000        mov ecx,0x3
0000099E  89E8              mov eax,ebp
000009A0  31D2              xor edx,edx
000009A2  39C1              cmp ecx,eax
000009A4  730C              jnc 0x9b2
000009A6  89E8              mov eax,ebp
000009A8  F7F1              div ecx
000009AA  09D2              or edx,edx
000009AC  74DB              jz 0x989
000009AE  41                inc ecx
000009AF  41                inc ecx
000009B0  EBEE              jmp short 0x9a0
000009B2  31C0              xor eax,eax
000009B4  40                inc eax
000009B5  5D                pop ebp
000009B6  C20400            ret 0x4
68

000009B9  56                push esi
000009BA  57                push edi
000009BB  8B74240C          mov esi,[esp+0xc]
000009BF  31FF              xor edi,edi
000009C1  09F6              or esi,esi
000009C3  7704              ja 0x9c9
000009C5  31C0              xor eax,eax
000009C7  EB1D              jmp short 0x9e6
000009C9  46                inc esi
000009CA  74F9              jz 0x9c5
000009CC  56                push esi
000009CD  E8A3FFFFFF        call 0x975
000009D2  01C7              add edi,eax
000009D4  4E                dec esi
000009D5  3B7C240C          cmp edi,[esp+0xc]
000009D9  7308              jnc 0x9e3
000009DB  0374240C          add esi,[esp+0xc]
000009DF  72E4              jc 0x9c5
000009E1  EBE6              jmp short 0x9c9
000009E3  89F0              mov eax,esi
000009E5  40                inc eax
000009E6  5F                pop edi
000009E7  5E                pop esi
000009E8  C20400            ret 0x4
000009EB  90                nop
120


[0, 0] [1, 2] [2, 5] [3, 19] [4, 29] [5, 71] [6, 43] [7, 211] [8, 193] [9, 271] [1
0, 191] [11, 661] [12, 277] [13, 937] [14, 463] [15, 691] [16, 769] [17, 1531] [18
, 613] [19, 2357] [20, 1021] [21, 1723] [22, 1409] [23, 3313] [24, 1609] [25, 3701
] [26, 2029] [27, 3187] [28, 2437] [29, 6961] [30, 1741] [31, 7193] [32, 3617] [33
, 4951] [34, 3877] [35, 7001] [36, 3169] [37, 10657] [38, 6271] [39, 7879] [40, 55
21] [41, 13613] [42, 3823] [43, 15137] [44, 7349] [45, 9091] [46, 7499] [47, 18049
] [48, 6529] [49, 18229] [50, 7151] [51, 13159] [52, 10141] [53, 26501] [54, 7669]
 [55, 19801] [56, 11593] [57, 18127] [58, 13109] [59, 32569] [60, 8221] [61, 34649
] [62, 17981] [63, 21799] [64, 16001] [65, 28081] [66, 10429] [67, 39799] [68, 193
81] [69, 29947] [70, 14771] [71, 47713] [72, 16417] [73, 51539] [74, 25013] [75, 2
9101] [76, 26449] [77, 50051] [78, 16927] [79, 54037] [80, 23761] [81, 41149] [82,
 31489] [83, 68891] [84, 19237] [85, 51341] [86, 33713] [87, 45589] [88, 34057] [8
9, 84551] [90, 19531] [91, 64793] [92, 42689] [93, 54499] [94, 41737] [95, 76001]
[96, 27457] [97, 97583] [98, 40867] [99, 66529] [100, 39301] [101, 110899] [102, 2
9989] [103, 116803] [104, 49297] [105, 51871] [106, 56711] [107, 126047] [108, 385
57] [109, 133853] [110, 42901] [111, 76369] [112, 53089] [113, 142607] [114, 40129
] [115, 109481] [116, 63337] [117, 83071] [118, 67733] [119, 112337] [120, 41281]
[121, 152219] [122, 70639] [123, 102337]

실제로 13 바이트

골프 제안을 환영합니다! 온라인으로 사용해보십시오!

;╗`PD╜@%Y`╓NP

언 골핑

         Implicit input n.
;╗       Save a copy of n to register 0.
`...`╓   Push first n values where f(x) is truthy, starting with f(0).
  PD       Get the x-th prime - 1.
  ╜@%      Push (x_p - 1) % n.
  Y        If x_p-1 is divisible by n, return 1. Else, return 0.
NP       Get the n-th prime where n_p-1 is divisible by n.
         Implicit return.

공통 리스프, 162 바이트

(defun s(n)(do((b 2(loop for a from(1+ b)when(loop for f from 2 to(1- a)never(=(mod a f)0))return a))(a 0)(d))((= a n)d)(when(=(mod(1- b)n)0)(incf a)(setf d b))))

용법:

* (s 100)

39301

언 골프 드 :

(defun prime-search (n)
  (do ((prime 2 (loop for next from (1+ prime) when
                 (loop for factor from 2 to (1- next) never
                      (= (mod next factor) 0)) return next))
       (count 0) (works))
      ((= count n) works)
    (when (= (mod (1- prime) n) 0)
      (incf count)
      (setf works prime))))

이러한 loop구조 중 일부 는 아마도 do루프 로 단축 될 수 있지만 이것이 내가 지금 얻은 것입니다.

MATL , 12 바이트

1i:"`_YqtqG\

온라인으로 사용해보십시오!

(입력의 123경우 온라인 컴파일러에서 시간 초과되지만 오프라인으로 작동합니다.)

설명

1          % Push 1
i:         % Input n and push [1 2 ... n]
"          % For each (that is, do the following n times)
  `        %   Do...while
    _Yq    %     Next prime
    tq     %     Duplicate, subtract 1
    G      %     Push n again
    \      %     Modulo
           %   End (implicit). Exit loop if top of stack is 0; else next iteration
           % End (implicit)
           % Display (implicit)

Perl, 77 76 + 1 = 77 바이트

for($p=2;@a<$_;$p++){push@a,$p if(1 x$p)!~/^(11+?)\1+$/&&($p%$_<2)}say$a[-1]

소수 테스트 정규 표현식을 사용하여 소수인지 결정 $p하고 입력을 1 mod와 일치하는지 확인하십시오 (2 미만의 음이 아닌 정수는 0과 1이지만 소수이면 0이 될 수 없으므로 소수 여야 함) 1은 1 바이트를 초과합니다 ==1).

매스 매 티카 44 바이트

   Pick[x=Table[i #+1,{i,# #}],PrimeQ/@x][[#]]&

매우 빠릅니다. "참고"의 아이디어를 사용합니다.

% /@ {1, 2, 3, 4, 100, 123} // Timing

산출

{0.0156001, {2, 5, 19, 29, 39301, 102337}}

펄 6 ,  46 39  37 바이트

->\n{(2..*).grep({.is-prime&&($_-1)%%n})[n-1]}

->\n{(1,n+1...*).grep(*.is-prime)[n-1]}

{(1,$_+1...*).grep(*.is-prime)[$_-1]}

자바 8, 84 바이트

골프

(n)->{for(int s=n,i=1;;i+=n)for(int j=2;i%j>0&j<i;)if(++j==i&&--s<1)return n>1?i:2;}

언 골프

(n) -> { 
for (int s = n,      // Counting down to find our nth prime.
    i = 1;           // Counting up for each multiple of n, plus 1.
    ;                // No end condition specified for outer for loop.
    i += n)          // Add n to i every iteration.
for (int j = 2;      // Inner for loop for naive primality check.
     i % j > 0)      // Keep looping while i is not divisible by j 
                     // (and implicitly while j is less than i).
     if(++j==i       // Increment j. If j has reached i, we've found a prime
     &&              // Short-circutting logical AND, so that we only decrement s if a prime is found
     --s < 1)        // If we've found our nth prime...
     return n>1?i:2; // Return it. Or 2 if n=1, because otherwise it returns 3.
}

설명

몇 가지 다른 답변에서 영감을 얻은 솔루션. 함수는 단일 int를 기대하는 람다입니다.

는 n>1?i:2I = 1 N의 경우를 고려하는 더 나은 방법을 알아낼 수 없었기 때문에 싼 해킹입니다.

또한이 솔루션은 Ideone에서 시간 초과되지만 모든 테스트 사례에 대해 테스트되었습니다. 몇 바이트를 면도하기 위해 j<i내부 루프에서 명시 적 검사를 수행했기 때문에 시간이 초과되었습니다 . 와 (첫 번째 반복) i%j>0의 경우를 제외하고는 ...에 의해 대부분 암시됩니다 . 이 경우 j는 오버플로 될 때까지 루프가 실행됩니다 (가정). 그런 다음 나중에 모든 반복에 잘 작동합니다.i=1j=2

시간이 초과되지 않는 버전은 몇 바이트 더 길다면 여기를 참조하십시오!

라켓 109 바이트

(let p((j 2)(k 0))(cond[(= 0(modulo(- j 1)n))(if(= k(- n 1))j(p(next-prime j)(+ 1 k)))][(p(next-prime j)k)]))

언 골프 드 :

(define (f n)
  (let loop ((j 2)
             (k 0))
    (cond
      [(= 0 (modulo (sub1 j) n))
       (if (= k (sub1 n)) 
           j
           (loop (next-prime j) (add1 k)))]
      [else (loop (next-prime j) k)]  )))

테스트 :

(f 1)
(f 2)
(f 3)
(f 4)
(f 100)
(f 123)

산출:

2
5
19
29
39301
102337

루비 64 바이트

require'prime';f=->(n){t=n;Prime.find{|x|(x-1)%n==0&&(t-=1)==0}}

다음과 같이 호출됩니다.

f.call(100)
# 39301

또한이 명령 줄 앱은 다음과 같이 작동합니다.

n=t=ARGV[0].to_i;p Prime.find{|x|(x-1)%n==0&&(t-=1)==0}

이렇게 불렀다

ruby -rprime find_golf_prime.rb 100

그러나 문자 수를 계산하는 방법을 잘 모르겠습니다. 언어 이름을 무시할 수는 있지만 -rprime스크립트 이름 앞에 및 공백 을 포함해야 하므로 63에서 약간 짧습니다. . .

R, 72 바이트

n=scan();q=j=0;while(q<n){j=j+1;q=q+1*(numbers::isPrime(j)&!(j-1)%%n)};j

매우 비효율적이고 느리지 만 작동합니다. stdin에서 입력을 읽은 다음 패키지 의 isPrime함수 를 사용 numbers하여 소수를 찾습니다. 나머지는 prime - 1로 나눌 수 있는지 확인 하고 n있습니다.

자바 스크립트 (ES6), 65 바이트

f=(n,i=n,j=1)=>i?f(n,i-!/^(..+?)\1+$/.test('.'.repeat(j+=n)),j):j

정규식 원시성 테스터를 사용합니다. 왜냐하면 a) 8 바이트가 짧고 b) 재귀 적 접근 방식보다 재귀가 적기 때문입니다.

공리 64 바이트

f(n)==(n<0 or n>150=>0;[i*n+1 for i in 0..2000|prime?(i*n+1)].n)

누군가 Axiom 스트림을 사용하여 위의 글을 쓰는 방법을 알고 있습니까? ... 몇 가지 예

-> f(i)  for i in 1..150
   Compiling function f with type PositiveInteger -> NonNegativeInteger


   [2, 5, 19, 29, 71, 43, 211, 193, 271, 191, 661, 277, 937, 463, 691, 769,
    1531, 613, 2357, 1021, 1723, 1409, 3313, 1609, 3701, 2029, 3187, 2437,
    6961, 1741, 7193, 3617, 4951, 3877, 7001, 3169, 10657, 6271, 7879, 5521,
    13613, 3823, 15137, 7349, 9091, 7499, 18049, 6529, 18229, 7151, 13159,
    10141, 26501, 7669, 19801, 11593, 18127, 13109, 32569, 8221, 34649, 17981,
    21799, 16001, 28081, 10429, 39799, 19381, 29947, 14771, 47713, 16417,
    51539, 25013, 29101, 26449, 50051, 16927, 54037, 23761, 41149, 31489,
    68891, 19237, 51341, 33713, 45589, 34057, 84551, 19531, 64793, 42689,
    54499, 41737, 76001, 27457, 97583, 40867, 66529, 39301, 110899, 29989,
    116803, 49297, 51871, 56711, 126047, 38557, 133853, 42901, 76369, 53089,
    142607, 40129, 109481, 63337, 83071, 67733, 112337, 41281, 152219, 70639,
    102337, 75641, 126001, 42589, 176531, 85121, 107071, 62791, 187069, 55837,
    152419, 94873, 104761, 92753, 203857, 62929, 226571, 72661, 144103, 99401,
    193051, 69697, 168781, 112859, 133183, 111149, 250619, 60601]

유형 : Tuple NonNegativeInteger