쿠바 프라이스


20

자연수 주어지면 번째 쿠바 소수를 반환합니다 .

쿠바 프라임

쿠바 소수는 형태의 소수입니다

=엑스와이엑스와이

여기서 및 또는와이>0x=1+yx=2+y

세부

  • 가장 적합한 방식으로 0 또는 1 기반 색인을 사용할 수 있습니다.
  • 인덱스 n 또는 첫 번째 n 소수를 제공 하면 n 번째 소수를 증가하는 순서로 반환하거나 소수를 증가하는 순서로 생성하는 무한 목록 / 생성자를 반환 할 수 있습니다.nn

테스트 사례

처음 몇 용어는 다음과 같습니다.

(#1-13)   7, 13, 19, 37, 61, 109, 127, 193, 271, 331, 397, 433, 547,
(#14-24) 631, 769, 919, 1201, 1453, 1657, 1801, 1951, 2029, 2269, 2437,
(#25-34) 2791, 3169, 3469, 3571, 3889, 4219, 4447, 4801, 5167, 5419,
(#35-43) 6211, 7057, 7351, 8269, 9241, 10093, 10267, 11719, 12097,
(#44-52) 12289, 13267, 13669, 13873, 16651, 18253, 19441, 19927, 20173

OEIS에서 더 많은 용어를 찾을 수 있습니다 . xheer x=1+y 또는 x=2+y 에 따라 두 개의 시퀀스로 나뉩니다 . A002407A002648


2
정렬되지 않은 첫 n 개의 소수를 반환 할 수 있습니까?
J42161217

아니요, 소수는 순서대로 증가해야합니다.
flawr

답변:


23

자바 스크립트 (V8) , 54 바이트

쿠바 소수를 영원히 인쇄하는 전체 프로그램.

for(x=0;;){for(k=N=~(3/4*++x*x);N%++k;);~k||print(-N)}

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

NB : 프린터에 무한 종이가없는 한, 브라우저 콘솔이 실행을 시도하지 않는 경우, print()다른 의미를 가질 수있다.


자바 스크립트 (ES6),  63 61 60  59 바이트

n 번째 쿠바 소수 (1 인덱스)를 리턴합니다 .

f=(n,x)=>(p=k=>N%++k?p(k):n-=!~k)(N=~(3/4*x*x))?f(n,-~x):-N

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

방법?

쿠바 프라임은 다음과 같은 형식의 프라임이라는 사실을 기반으로합니다.

pn=3n24+1,n3

위의 공식은 다음과 같이 쓸 수 있습니다.

pn={3n2+14 if n is odd3n2+44 if n is even

또는 y>0 :

p2y+1=3(2y+1)2+14=3y2+3y+1
p2y+2=3(2y+2)2+44=3y2+6y+4

이것은 x3y3xyx=y+1x=y+2는 각각.


7

05AB1E , 16 12 9 바이트

무한 목록을 생성합니다. Kevin Cruijssen의 Arnaulds 공식 포트로
4 바이트를 절약했습니다 . Grimy 덕분에 3 바이트 더 절약

∞n3*4÷>ʒp

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

설명

∞          # on the list of infinite positive integers
 n3*4÷>    # calculate (3*N^2)//4+1 for each
       ʒp  # and filter to only keep primes

"당신은 당신의 설명에 오타를 만들었 의 사본을 넣어 N^2+3스택에 있어야한다" 3*N^2. 또한 왜 )대신에 ¯? 입력하기가 쉽기 때문에? 그리고 어떤 이유로 나는 NnN‚3*¬sO‚1 바이트가 더 짧을 수 있다고 생각하지만 그것을 보지 못했습니다. 약간의 등가 바이트 대안은 Nn3*DN3*+‚입니다. 그러나 나는 아마도 거기에없는 것들을보고있을 것입니다 ..;) 멋진 답변, 그래서 +1.
Kevin Cruijssen

1
나는 실제로 내 대답을 05AB1E로 이식하려고 시도했지만 비참하게 실패했습니다. : D
Arnauld

1
실제로 무한 목록을 생성하는 것이 더 편리합니다. ∞n3 * 4 ÷> ʒp 인
Grimmy

1
좋아, 나는 모순되는 사양에 익숙하지 않다. :-)
WGroleau

6
@WGroleau 나는 당신이 전문적으로 소프트웨어를 개발 한 적이 없다고 가정합니다. 자신과 모순 되지 않는 사양을 얻을 때 더 걱정 입니다.
MikeTheLiar

7

R , 75 73 바이트

n=scan()
while(F<n)F=F+any(!(((T<-T+1)*1:4-1)/3)^.5%%1)*all(T%%(3:T-1))
T

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

-2 바이트 *대신 &(다른 우선 순위)를 사용하면 대괄호를 제거 할 수 있음을 알았습니다 .

n쿠바 소수 (1 색인)를 출력합니다 .

쿠바 소수는 일부 n에 대해 =1+2 또는 4=1+2 , 즉 n = 이라는 사실을 사용합니다 (OEIS에서 제공).=에이1에이=1또는에이=4의 정수입니다.

트릭 더 소수의 형식이 될 수 없다는 것이다 2=1+2 또는 =1+2 (*), 우리가 수식을 선택하여 2 바이트를 저장할 수 있도록 { 1 , 2 , 3 , 4 } ( ) 대신 { 1 , 4 } ( ).에이{1,2,,4}1:4에이{1,4}c(1,4)

코드의 약간 ungolfed 버전 :

# F and T are implicitly initialized at 0 and 1
# F is number of Cuban primes found so far
# T is number currently being tested for being a Cuban prime
n = scan()                       # input
while(F<n){
  T = T+1                        # increment T 
  F = F +                        # increment F if
    (!all(((T*1:4-1)/3)^.5 %% 1) # there is an integer of the form sqrt(((T*a)-1)/3)
     & all(T%%(3:T-1)))          # and T is prime (not divisible by any number between 2 and T-1)
  }
T                                # output T

(*) 소수는 =1+2 형식 수 없으며 , 그렇지 않으면 1=(2) 으로 나눌 수 있습니다 .

=22=1+2=2케이+12=4+12케이(케이+1), hence =2+6케이(케이+1) and would be even.


what about avoiding a loop by using an upper bound on the nth Cuban prime?
Xi'an

@Xi'an I thought about that, but couldn't come up with such a bound. Do you have one?
Robin Ryder

5

Wolfram Language (Mathematica), 66 65 56 bytes

(f=1+⌊3#/4#⌋&;For[n=i=0,i<#,PrimeQ@f@++n&&i++];f@n)&

Try it online!

  • J42161217 -1 by using ⌊ ⌋ instead of Floor[ ]

  • attinat

    • -1 by using ⌊3#/4#⌋ instead of ⌊3#^2/4⌋
    • -8 for For[n=i=0,i<#,PrimeQ@f@++n&&i++] instead of n=2;i=#;While[i>0,i-=Boole@PrimeQ@f@++n]

1
65 bytes. Welcome to ppcg. Nice first answer! +1
J42161217

Thanks! (Long time lurker.) I couldn't quite parse your existing answer so I wrote my own and it came out a little shorter. I might do a Python one too.
speedstyle


@attinat I thought Arnauld's formula only worked for n>2 so I didn't start with 0 - although as in your example it works for all n (because it starts 1 1 4 7 13 ... so the primes are 7 13 ...)
speedstyle

3

Java 8, 94 88 86 84 bytes

v->{for(int i=3,n,x;;System.out.print(x<1?++n+" ":""))for(x=n=i*i++*3/4;~n%x--<0;);}

-6 bytes by using the Java prime-checker of @SaraJ, so make sure to upvote her!
-2 bytes thanks to @OlivierGrégoire. Since the first number we check is 7, we can drop the trailing %n from Sara's prime-checker, which is to terminate the loop for n=1.
-2 bytes thanks to @OlivierGrégoire by porting @Arnauld's answer.

Outputs space-delimited indefinitely.

Try it online.

Explanation (of the old 86 bytes version): TODO: Update explanation

Uses the formula of @Arnauld's JavaScript answer: pn=3n24+1,n3.

v->{                     // Method with empty unused parameter and no return-type
  for(int i=3,           //  Loop-integer, starting at 3
          n,x            //  Temp integers
      ;                  //  Loop indefinitely:
      ;                  //    After every iteration:
       System.out.print( //     Print:
        n==x?            //      If `n` equals `x`, which means `n` is a prime:
         n+" "           //       Print `n` with a space delimiter
        :                //      Else:
         ""))            //       Print nothing
    for(n=i*i++*3/4+1,   //   Set `n` to `(3*i^2)//4+1
                         //   (and increase `i` by 1 afterwards with `i++`)
        x=1;             //   Set `x` to 1
        n%++x            //   Loop as long as `n` modulo `x+1`
                         //   (after we've first increased `x` by 1 with `++x`)
             >0;);}      //   is not 0 yet
                         //   (if `n` is equal to `x`, it means it's a prime)

I don't really think it's feasible, but another way of finding the cuban primes uses this formula: v->{for(int n=7,i=3,p,x,d,r=0;;i+=++r%2*3,n+=i,System.out.print(x>1?x+" ":""))for(x=n,d=1;++d<n;x=x%d<1?0:n);}, maybe someone can use this to golf? I couldn't.
Olivier Grégoire

1
@OlivierGrégoire You can golf yours a bit more by removing the unused ,p and changing i+=++r%2*3,n+=i to n+=i+=++r%2*3, but then I'll still end up at 106 bytes. Using Java 11's String#repeat with prime-regex is 105 bytes: v->{for(int n=7,i=3,r=0;;n+=i+=++r%2*3)if(!"x".repeat(n).matches(".?|(..+?)\\1+"))System.out.println(n);}.
Kevin Cruijssen

Yeah, I guessed it wasn't much golfable despite my (now obvious) mistakes. Thanks for giving it a ride ;)
Olivier Grégoire

@OlivierGrégoire Maybe also good to know for you, but there is apparently a shorter prime-check loop in Java. See my edit and SaraJ's prime-check answer.
Kevin Cruijssen

I might be wrong, but the last %n isn't required, is it?
Olivier Grégoire




1

공백 , 180 바이트

[S S S T    S N
_Push_2][S N
S _Duplicate][N
S S N
_Create_Label_OUTER_LOOP][S N
N
_Discard_top_stack][S S S T N
_Push_1][T  S S S _Add][S N
S _Duplicate][S N
S _Duplicate][T S S N
_Multiply][S S S T  T   N
_Push_3][T  S S N
_Multiply][S S S T  S S N
_Push_4][T  S T S _Integer_divide][S S S T  N
_Push_1][T  S S S _Add][S S S T N
_Push_1][S N
S _Duplicate_1][N
S S S N
_Create_Label_INNER_LOOP][S N
N
_Discard_top_stack][S S S T N
_Push_1][T  S S S _Add][S N
S _Duplicate][S N
S _Duplicate][S T   S S T   T   N
_Copy_0-based_3rd][T    S S T   _Subtract][N
T   S T N
_Jump_to_Label_PRINT_if_0][S T  S S T   S N
_Copy_0-based_2nd][S N
T   _Swap_top_two][T    S T T   _Modulo][S N
S _Duplicate][N
T   S S S N
_Jump_to_Label_FALSE_if_0][N
S N
S N
_Jump_to_Label_INNER_LOOP][N
S S T   N
_Create_Label_PRINT][T  N
S T _Print_as_integer][S S S T  S T S N
_Push_10_(newline)][T   N
S S _Print_as_character][S N
S _Duplicate][N
S S S S N
_Create_Label_FALSE][S N
N
_Discard_top_stack][S N
N
_Discard_top_stack][N
S N
N
_Jump_to_Label_OUTER_LOOP]

문자 S(공백), T(탭) 및 N(줄 바꾸기)가 강조 표시로만 추가되었습니다.
[..._some_action]설명으로 만 추가되었습니다.

줄 바꿈으로 무한정 출력합니다.

온라인으로 시도하십시오 (원시 공백, 탭 및 줄 바꾸기 만).

의사 코드의 설명 :

내 Java 8 답변의 포트는 @Arnauld 의 JavaScript 답변 의 공식을 사용합니다 .=24+1,.

Integer i = 2
Start OUTER_LOOP:
  i = i + 1
  Integer n = i*i*3//4+1
  Integer x = 1
  Start INNER_LOOP:
    x = x + 1
    If(x == n):
      Call function PRINT
    If(n % x == 0):
      Go to next iteration of OUTER_LOOP
    Go to next iteration of INNER_LOOP

function PRINT:
  Print integer n
  Print character '\n'
  Go to next iteration of OUTER_LOOP

1

파이썬 (3) , 110 (108) 102 바이트

Mathematica 답변과 비슷한 방법 (예 : 이 골프 프라임 검사기를isPrime(1+⌊¾n²⌋) else n++ 사용 하고 익명의 무한 생성기를 반환

from itertools import*
(x for x in map(lambda n:1+3*n**2//4,count(2)) if all(x%j for j in range(2,x)))

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

  • mypetlion -2 익명의 생성자가 명명 된 것보다 더 많이 허용되기 때문에
  • -6 시작하여 count2에서 +1 그래서 것을 and x>1빌려 주요 검사기 I에서 불필요 -7

변수로 들어가는 대답은 일반적으로 유효한 "출력"형식으로 간주되지 않습니다. 결과가 표준 출력으로 출력되거나 함수에 의해 리턴되도록 답변을 재 작업 할 수 있습니까?
mypetlion

1
익명 함수가 허용되고 도전이 명시 적으로 무한 생성기를 허용하므로을 제거했습니다 g=. 와 함께 TIO에 대한 빠른 비주얼을 허용했기 때문에 처음에는 포함 시켰습니다 print(next(g) for i in range(52)).
스피드 스타일



1

파이썬 3 , 83 바이트

쿠바 프라임을 영원히 인쇄합니다.

P=k=1
while 1:P*=k*k;x=k;k+=1;P%k>0==((x/3)**.5%1)*((x/3+.25)**.5%1-.5)and print(k)

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

주요 생성기를 기반으로 합니다 . 모든 소수에 대해 정수 y가 존재하는지 여부를 확인합니다.엑스=1+와이 또는 엑스=2+와이.

=(1+와이)와이(1+와이)와이=1+와이+와이2와이=12±14+1

=(2+와이)와이(1+와이)와이=4+6와이+와이2와이=1±1
우리는 단지 관심 여부 와이 정수 솔루션을 가지고 있으므로 무시할 수 있습니다. ±1.


1

펄 6 , 33 31 바이트

Grimy 덕분에 -2 바이트

{grep &is-prime,1+|¾*$++²xx*}

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

쿠바 소수의 게으른 무한 목록을 반환하는 익명 코드 블록. 이것은 사용 Arnauld의 공식을 다음, 쿠바 수 소수를 생성하기 위해 &is-prime그들을 필터링.

설명:

{                           }  # Anonymous code block
 grep &is-prime,               # Filter the primes from
                         xx*   # The infinite list
                   ¾*          # Of three quarters
                     $++²      # Of an increasing number squared
                1+|            # Add one by ORing with 1

1
1+0+|그냥있을 수 있습니다1+|
Grimmy


0

APL (NARS), 98 자, 196 바이트

r←h w;y;c;v
r←c←y←0⋄→4
→3×⍳∼0πv←1+3×y×1+y+←1⋄r←v⋄→0×⍳w≤c+←1
→2×⍳∼0πv+←3×y+1⋄c+←1⋄r←v
→2×⍳w>c

들여 쓰기 :

r←h w;y;c;v
r←c←y←0⋄→4
    →3×⍳∼0πv←1+3×y×1+y+←1⋄r←v⋄→0×⍳w≤c+←1
    →2×⍳∼0πv+←3×y+1⋄c+←1⋄r←v
    →2×⍳w>c

테스트:

  h ¨1..20
7 13 19 37 61 109 127 193 271 331 397 433 547 631 769 919 1201 1453 1657 1801 
  h 1000
25789873
  h 10000
4765143511

다음을 기반으로합니다. 만약 y가 N이면 쿠바 프라임은

S1=1+3y(y+1)

다음으로 가능한 쿠바 프라임은

S2=3(y+1)+S1
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.