또 다른 순서, 또 다른 도전. *

정의

대표적인는 p이 순서에, 현실을 부르 자 A모든 숫자에 IFF에, d에 p당신은 대체의 진수 확장 d과 d사본 d및 결과 정수는 여전히 소수; 0은 허용되지 않습니다.

예를 들어, 11이 순서는 사소합니다 (실수로 첫 번째 숫자 임). 시퀀스에서 다음 은 또한 프라임 31이므로 3331; 다음 53있기는 55555333등등도 소수합니다.

도전

입력이 주어지면 nreturn A(n), 즉 n이 순서 의 th 항목이 주어 집니다.

예

다음은 시작하기위한 첫 20 개의 용어입니다. 이다 A057628 OEIS합니다.

11, 31, 53, 131, 149, 223, 283, 311, 313, 331, 397, 463, 641, 691, 937, 941, 1439, 1511, 1741, 1871

이 수단은 A(0) = 11, A(1) = 31등, 제로 인덱스를 사용하는 경우.

규칙

• 0 또는 1 기반 색인을 선택할 수 있습니다. 답을 지정하십시오.
• nth 요소 만 반환하는 대신 첫 번째 n항 을 반환하도록 선택할 수 있습니다 .
• 입력 / 출력이 언어의 기본 정수 형식보다 크지 않다고 가정 할 수 있습니다. 그러나 반복되는 자릿수 는 해당 언어의 기본 형식보다 클 수 있으므로이를 고려해야합니다.
• 예를 들어, 예제 1871의 마지막 수인에 해당하는 소수는 18888888877777771표준 INT32보다 약간 더 큽니다.
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 콘솔로 출력하거나, 함수에서 반환하거나, 경고 팝업에 표시하는 등
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

* 공정하게, 나는 몇 개의 숫자를 가지고 놀면서 시퀀스의 처음 몇 용어를 생각해 냈고 나머지 시퀀스를 얻기 위해 OEIS로 갔다.

껍질 , 15 바이트

!fo§&öεpd´ṘΠdİp

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

!                 Index into
             İp     the list of primes
 f                    for which:
            d            the digits of p
  o§&                      satisfy both:
     öεpd´Ṙ                  repeated "themselves" times, they form a prime.
           Π                 they are all nonzero.

Outgolfer 에릭은 바이트를 절약했습니다. ṗ대신 εp바이트를 사용 하면 다른 바이트를 절약 할 수 있지만 n = 2 인 경우에도 프로그램 속도가 너무 느려집니다.

05AB1E , 14 13 바이트

Emigna 덕분에 -1 바이트 !

µNSÐPŠ×JpNpPĀ½

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

설명

µNSÐPŠ×JpNpPĀ½
µ              # Do until the input is reached...
 N              # Push the iteration counter
  S             # Split it to its digits
   Ð            # And push two copies of it to the stack
    P           # Get the digital product of the counter
     Š          # And place it two places down the stack
      ×J        # Repeat each digit by itself and join it back to a number
        p       # Check for primality on that result
         Np     # And on the original counter as well
           PĀ   # Create the product and truthify the result
                # Implicit: If it is true increment the input number

젤리 , 18 14 바이트

ÆPaDxDḌÆPaDẠµ#

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

Mr. Xcoder : -1 바이트 (논리적 전부)

아웃 골퍼 에릭 : -2 바이트 (2 줄 대신 1 줄)

HyperNeutrino : -1 바이트 (시퀀스의 처음 n 개 요소 반환)

설명

ÆPaDxDḌÆPaDẠµ#     First Link
ÆP                Is prime?
  a               logical and
   D              convert number to list of digits
    xD            repeat each digit as many times as it's value
      Ḍ           convert to an integer
       ÆP         is prime?
         a        logical and
          D       list of digits
           Ạ      logical all
            µ     the following link as a monad
             #    Do this until n matches are found and return them all

편집 : 원래 10 진수로 0을 포함하는 숫자가 포함 된 답변을 제출했습니다.

Wolfram Language (Mathematica) , 100 바이트

Nest[#+1//.i_/;!PrimeQ@FromDigits[##&@@#~Table~#&/@(l=IntegerDigits@i)]||Min@l<1:>NextPrime@i&,1,#]&

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

Jonathan Frech가 3 바이트를 절약했습니다

JungHwan Min의 -7 바이트

Martin Ender에서 -15 바이트

Jenny Mathy 덕분에

Alice , 72 70 66 62 56 바이트

5 바이트를 절약 해 준 Leo에게 감사합니다.

/.\&wh...tz~F0/*$\W.tzt$W?K/ o
\i/&.,a:.$K;d&\FR/K.!w.a%

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

1 기반 입력을 사용합니다.

설명

산뜻한 골프 트릭 여기에 (그것은 단지 바이트의 몇 가지를 저장하더라도이) 내가 제공하는 소수성 테스트를 사용하고 있다는 점이다 0컴포지트 N 에 대한 n비 합성을위한 N을 . 이렇게하면 결과를 조건부에서 직접 사용할 필요는 없지만 입력에 0이 없는지 확인하는 다음 부분으로 바로 전달할 수 있습니다.

/i\       Read all input in Ordinal mode (the usual way to read decimal input).
&w        Push the current IP position onto the return address stack (RAS)
          n times. This effectively begins our main loop. We will return
          here after each number we've checked, but whenever we come across
          a repeated digit prime (RDP), we will pop one copy of the address
          from the RAS, so that the loops ends once we've found n RDPs.

h.        Increment our main loop iterator X (initially an implicit zero on
          the empty stack) and duplicate it.
.         Make another copy.
.tz       Drop all factors less than X. This gives X for prime X and 1 for
          non-prime X.
~F        Check whether X divides this value. Of course, X divides X so this
          gives X for non-composite X. But X doesn't divide 1 (unless X is 1),
          so we get 0 for composite X. Call this Y.
0         Push a 0.
\         Switch to Ordinal mode.
F         Implicitly convert both to string and check whether Y contains 0.
$/K       If it does, return to the w. Either way, switch back to Cardinal mode.
          Note that the only numbers that get to this point are 1 and prime
          numbers which don't contain 0. It's fine that we let 1 through here,
          because we'll use a proper primality test for the digit-expanded
          version later on.
.!        Store a copy of X on the tape. Let's call the copy that remains on
          the stack Z, which we're now decomposing into digits while expanding
          them.
w         Push the current IP position to the RAS. This marks the beginning
          of an inner loop over the digits of Z.

  .a%       Duplicate Z and retrieve its last digit D by taking Z % 10.
  \./       Duplicate D (in Ordinal mode but that doesn't matter).
  &.        Duplicate D, D times. So we end up with D+1 copies of D.
  ,         Pop the top D and pull up the Dth stack element, which is Z.
  a:        Discard the last digit by taking Z / 10.
  .$K       If Z is zero now, skip the K and end the inner loop, otherwise
            repeat the inner loop.
;         Discard the 0 (what used to be Z).
          We now have D copies of each digit D on the stack, but the digits
          were processed in reverse order, so the last digit is at the bottom.
d&        Repeat the next command once for each stack element.
\*        Concatenate in Ordinal mode. This joins all the digits on the
          stack into a single string.
R         Reverse that string. This is the digit-expanded version of X.
/         Switch back to Cardinal mode.
W         Pop the inner loop's return address from the RAS. We could have done
          this right after the most recent K, but putting it here helps lining
          up the two Ordinal sections in the program layout.
.tzt      Is the digit-expanded number a prime?
$W        If so, we've found an RDP. Pop one copy of the main loop address 
          from the RAS.
g         Recover the current value of X from the top left grid cell.
K         Jump back to the w if any copies of the return address are left 
          on the RAS. Otherwise, we leave the main loop.
/o        Implicitly convert the result to a string and print it in
          Ordinal mode.
          The IP will then bounce off the top right corner and start
          travelling through the program in reverse. Whatever it does
          on the way back is utter nonsense, but it will eventually get
          back to the division (:). The top of the stack will be zero
          at that point and therefore the division terminates the program.

파이썬 2 , 130 바이트

• 이 4 바이트 더 짧은 솔루션에 대해 ArBo 에게 감사드립니다 .

f=lambda n,c=9:n and f(n-(('0'in`c`)<p(c)*p(int("".join(d*int(d)for d in`c`)))),c+1)or~-c
p=lambda n:all(n%m for m in xrange(2,n))

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

파이썬 (2) , 195 (179) 167 140 138 136 135 134 바이트

• ovs 덕분에 27 바이트 절약 ; xrange대신에를 사용하여 rangea를 우회 MemoryError하고 주요 함수를 압축하는 단계; 정수 인덱스 카운팅 개선.
• 2 바이트를 절약했습니다. 바이너리 파이프 또는 연산 |을 사용하여 바이트를 절약합니다 or.
• 2 바이트를 절약했습니다. 프라임 함수를 반전시키고 추가 로직 조작을 수행합니다.
• 바이트를 저장했습니다. true boolean이 뒤에 오는 것처럼 in in 0의 존재를 반전시키기 위해 ~-대신 사용 하면이 값의 boolean 속성이 분리됩니다.0**j&
• Lynn 덕분에 바이트를 절약했습니다 . 부울이있는 골프 ~-A&B&C(와 동일 (not A) and B and C) .A, B, CA<B==C

def f(n,j=9,p=lambda n:all(n%j for j in xrange(2,n))):
 while n:j+=1;n-=("0"in`j`)<p(j)==p(int("".join(d*int(d)for d in`j`)))
 print j

온라인으로 사용해보십시오! (1 인덱스)

설명

f정수 인덱스를 받는 기본 함수 n및 기본 설정 값 j, 현재 시퀀스 후보 ( 9프로그램 크기를 유지하면서 성능을 향상시키기 위해 초기화 됨) 및 프라임 검사 기능을 정의합니다.
만큼 n비 제로는 n번째 순서 항목은 아직 찾을 수 없습니다. 따라서 필요한 특성을 만족하는 숫자 인 iff만큼 j증가하고 n감소 j합니다.
루프가 종료되면, j는 IS n번째 시퀀스 엔트리 따라서 인쇄.

Pyth , 21 바이트

.f&.AKjZT&P_ss*VK`ZP_

여기 사용해보십시오!

Pyth에는 10 진 확장 기능이 내장되어 있지 않기 때문에 다소 길다 .

• 첫 번째 N 양의 정수 ( .f)를 사용하십시오.
  • 모든 숫자를 진지하게 ( .AKjZT) 및 ( &) ...
  • 문자열 표현에 숫자 ( *VK`Z)를 곱하고 함께 결합하여 정수 ( ss) 로 변환 한 벡터화 된 곱셈 은 소수 ( P_) 및 ( &) ...
  • 그 자체가 소수입니다 ( P_).

펄 6 , 51 바이트

{(grep {!/0/&is-prime $_&S:g/./{$/x$/}/},2..*)[$_]}

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

• grep {...}, 2..*중괄호 사이의 술어 함수를 사용하여 2부터 시작하여 무한한 자연수 시퀀스를 필터링합니다. (...)[$_]함수의 argument를 사용하여이 필터링 된 목록으로 색인합니다 $_.
• !/0/ 숫자가 0 인 숫자를 필터링합니다.
• S:g/./{$/ x $/}/ 테스트 번호의 10 진수 확장에서 각 숫자를 복제합니다.
• is-prime $_ & S:g/./{$/ x $/}/is-primeand-junction $_, 테스트 번호 및 숫자 복제 결과로 내장 함수를 호출합니다 . and-junction의 멤버가 모두 소수이면 함수는 true를 반환합니다.

J, 81 바이트

f=.[:1&p:(*@(*/)*x:@#~)&.(10&#.inv)
[:{.(4&p:@{.@]([,]+f@[){:@])^:([>{:@])^:_&2 0

이것은 아직 좋은 J 솔루션을 찾지 못한 상황 중 하나입니다 .

그럼에도 불구하고, 나는 새로운 것을 배우기 위해 이것을 게시합니다.

f주어진 숫자가 "반복 숫자 소수"인지 알려줍니다. 다음과 같이 분류됩니다.

[:1&p:                               is the following a prime?
      (*@                            the signum of...
         (*/)                        the product of the digits
             *                       times...
              x:@                    force extended precision of...
                 #~)                 self-duplicated digits
                    &.               "Under": perform this, then perform its inverse at the end
                      (10&#.inv)     convert to a list of digits

그리고 마지막으로 할 일 ... 동사는 성가신 것처럼 피할 수없는 것처럼 보일 것입니다. 이것은 진행 상황을 저장하기 위해 목록을 사용해야한다는 사실에서 발생합니다. "현재 프라임"과 "지금까지 발견 된"레지스터 , 우리의 왼쪽 인수는 이미 정지 조건을 저장하기 위해 사용 n됩니다. 즉, args ( [및 ]) 를 지정 하고 2 개의 요소 목록 ( {.및 {:)을 푸는 간단한 작업을 위해서는 많은 소중한 바이트를 사용해야합니다 .

[:{.                                                take the first element of the final result, of the following Do... While:
    (4&p:@                                          the next prime after...
          {.@                                       the first element of...
             ]                                      the right arg 
                       {:@])                        the last (2nd) elm of the arg...
              ([,]+f@[)                             those two now become the left and right args to this verb...
               [,                                   left arg appended to...
                 ]+                                 right arg plus...
                   f@[                              f of the left arg...
                             ^:(      )^:_          keep doing all that while...
                                [>                  the left is bigger than...
                                  {:@]              the last elm of the right arg
                                          &2 0      seed the process with 2 0, ie,
                                                    the first prime, and 0 rdps found so far.

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