Một trình tự khác, một thách thức khác. *

Định nghĩa

Một số nguyên tố pnằm trong chuỗi này, hãy gọi nó A, iff cho mỗi chữ số dtrong phần pmở rộng thập phân của số, bạn thay thế dbằng các dbản sao củad và số nguyên kết quả vẫn là số nguyên tố; số không được phép.

Ví dụ, 11là tầm thường trong chuỗi này (đó là số đầu tiên, tình cờ). Tiếp theo trong chuỗi là 31, bởi vì 3331cũng là số nguyên tố; sau đó 53bởi vì 55555333cũng là nguyên tố, và như vậy.

Thử thách

Đưa ra một đầu vào n, trả lại A(n), tức làn mục thứ trong chuỗi này.

Ví dụ

Dưới đây là 20 điều khoản đầu tiên để bạn bắt đầu. Đây là A057628 trên OEIS.

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

Điều này có nghĩa là A(0) = 11,A(1) = 31 v.v., khi sử dụng lập chỉ mục bằng không.

Quy tắc

• Bạn có thể chọn lập chỉ mục không hoặc một dựa trên; vui lòng ghi rõ trong câu trả lời của bạn.
• Thay vì chỉ trả về nphần tử thứ, thay vào đó bạn có thể chọn trả về các nđiều khoản đầu tiên .
• Bạn có thể giả định rằng đầu vào / đầu ra sẽ không lớn hơn định dạng số nguyên gốc của ngôn ngữ của bạn; tuy nhiên, số nguyên tố lặp lại có thể lớn hơn định dạng gốc của ngôn ngữ của bạn, do đó sẽ cần phải được tính.
• Ví dụ, 1871số cuối cùng của các ví dụ, có một số nguyên tố tương ứng 18888888877777771, lớn hơn một chút so với INT32 tiêu chuẩn.
• Hoặc là một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Đầu ra có thể là bàn điều khiển, được trả về từ một chức năng, được hiển thị trong cửa sổ bật lên cảnh báo, v.v.
• Lỗ hổng tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

* Để công bằng, tôi đã đưa ra một vài điều khoản đầu tiên của chuỗi chỉ chơi xung quanh với một số số, và sau đó đến OEIS để lấy phần còn lại của chuỗi.

Husk , 15 byte

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

Hãy thử trực tuyến!

!                 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.

Erik Outgolfer đã lưu một byte. Sử dụng ṗthay vì εpsẽ tiết kiệm một byte khác, nhưng điều đó làm cho chương trình chậm đến mức nhân với n = 2.

05AB1E , 14 13 byte

-1 byte nhờ Emigna !

µNSÐPŠ×JpNpPĀ½

Hãy thử trực tuyến!

Giải trình

µ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

Thạch , 18 14 byte

ÆPaDxDḌÆPaDẠµ#

Hãy thử trực tuyến!

Ông Xcoder: -1 Byte (logic tất cả)

Erik the Outgolfer: -2 Byte (một dòng thay vì hai)

HyperNeutrino: -1 Byte (trả về n phần tử đầu tiên của chuỗi)

Giải trình

Æ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

Chỉnh sửa: ban đầu đã gửi một câu trả lời bao gồm các số có 0 trong biểu diễn thập phân của nó, đặc biệt không được phép.

Ngôn ngữ Wolfram (Mathicala) , 100 byte

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

Hãy thử trực tuyến!

Jonathan Frech đã lưu 3 byte

và -7 byte từ JungHwan Min

-15 byte từ Martin Ender

cũng cảm ơn Jenny Mathy

Alice , 72 70 66 62 56 byte

Cảm ơn Leo vì đã tiết kiệm 5 byte.

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

Hãy thử trực tuyến!

Sử dụng đầu vào dựa trên 1.

Giải trình

Bí quyết chơi golf thú vị nhất ở đây (mặc dù nó chỉ tiết kiệm một vài byte) là tôi đang sử dụng một kiểm tra tính nguyên tố mang đến cho 0cho composite n cho ncho người không hợp n . Theo cách đó, chúng ta không phải sử dụng kết quả trực tiếp trong một điều kiện, nhưng chúng ta có thể chuyển thẳng sang phần tiếp theo để kiểm tra xem đầu vào không chứa bất kỳ số không nào.

/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.

Python 2 , 130 byte

• Cảm ơn ArBo cho giải pháp ngắn hơn bốn byte này.

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))

Hãy thử trực tuyến!

Con trăn 2 , 195 179 167 140 138 136 135 134 byte

• Đã lưu 27 byte nhờ vào ovs ; sử dụng xrangethay vì range, do đó phá vỡ một MemoryErrorvà nén chức năng chính; cải thiện việc đếm chỉ số nguyên.
• Đã lưu hai byte; sử dụng ống nhị phân hoặc các hoạt động |để lưu byte qua or.
• Đã lưu hai byte; đảo ngược hàm nguyên tố và thực hiện một số thao tác logic hơn nữa.
• Đã lưu một byte; sử dụng ~-thay vì 0**đảo ngược sự tồn tại của số 0 trongj , &theo sau là một boolean thực sự cô lập thuộc tính boolean của giá trị này.
• Đã lưu một byte nhờ Lynn ; chơi golf ~-A&B&C(tương đương (not A) and B and C) với A, B, Cviệc được booleans A<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

Hãy thử trực tuyến!(1 chỉ mục)

Giải trình

Xác định một hàm chính fcó chỉ số nguyên nvà giá trị được đặt mặc định j, chuỗi trình tự hiện tại (bắt đầu 9để cải thiện hiệu suất trong khi giữ kích thước chương trình) và chức năng kiểm tra chính.
Miễn nlà khác không, mục nthứ tự -th chưa được tìm thấy. Do đó jđược tăng lên và nđược giảm bởi một iff jlà một số thỏa mãn các thuộc tính cần thiết.
Khi vòng lặp kết thúc, jlà mục nthứ tự -th và do đó được in.

Bình thường , 21 byte

.f&.AKjZT&P_ss*VK`ZP_

Hãy thử nó ở đây!

Khá dài vì Pyth không có bản mở rộng thập phân .

• Lấy N đầu tiên số nguyên dương ( .f), rằng:
  • Có tất cả các chữ số trung thực (.AKjZT ) và ( &) ...
  • Phép nhân vectơ của biểu diễn chuỗi của chúng với các chữ số ( *VK`Z), được nối với nhau và được chuyển đổi thành một số nguyên ( ss) là số nguyên tố ()P_ ) và (& ) ...
  • Đó là số nguyên tố ( P_).

Perl 6 , 51 byte

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

Hãy thử trực tuyến!

• grep {...}, 2..* lọc chuỗi vô hạn các số tự nhiên bắt đầu từ 2 bằng cách sử dụng hàm vị ngữ giữa các dấu ngoặc. (...)[$_]lập chỉ mục vào danh sách được lọc này bằng cách sử dụng đối số của hàm$_ .
• !/0/ lọc ra các số có chứa một chữ số không.
• S:g/./{$/ x $/}/ sao chép từng chữ số trong phần mở rộng thập phân của số kiểm tra.
• is-prime $_ & S:g/./{$/ x $/}/gọi is-primehàm tích hợp với một hàm và $_số, số kiểm tra và số kết quả từ việc sao chép các chữ số của nó. Hàm sẽ trả về true nếu cả hai thành viên của hàm và là số nguyên tố.

J, 81 byte

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

Đây là một trong những tình huống mà tôi chưa tìm thấy giải pháp J tốt.

Tuy nhiên, tôi đăng bài này với hy vọng học được điều gì đó mới.

fcho chúng tôi biết nếu một số đã cho là "số nguyên tố lặp lại". Nó bị hỏng như sau:

[: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

Và cuối cùng là Do ... Trong khi động từ, với cái nồi hơi khó hiểu, dường như không thể tránh khỏi, xuất phát từ thực tế là chúng ta cần sử dụng một danh sách để lưu trữ tiến trình của chúng ta, đòi hỏi cả hai thanh ghi "hiện tại" và "tìm thấy cho đến nay" , vì đối số bên trái của chúng tôi đã được sử dụng để lưu trữ điều kiện dừng, nghĩa là , n. Điều này có nghĩa là chúng ta phải sử dụng nhiều byte quý cho nhiệm vụ đơn giản là chỉ định args ( [và ]) và giải nén danh sách 2 phần tử của chúng ta ( {.và {:):

[:{.                                                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.

Hãy thử trực tuyến!