Urutan lain, tantangan lain. *

Definisi

Perdana pberada dalam urutan ini, sebut saja A, jika untuk setiap digit ddalam pekspansi desimal, Anda ganti ddengan dsalinan ddan bilangan bulat yang dihasilkan masih prima; nol tidak diizinkan.

Sebagai contoh, 11sepele dalam urutan ini (ini adalah angka pertama, kebetulan). Berikutnya dalam urutan adalah 31, karena 3331juga prima; maka 53karena 55555333juga prima, dan sebagainya.

Tantangan

Diberikan input n, kembali A(n), yaitu nitem th dalam urutan ini.

Contohnya

Berikut adalah 20 istilah pertama untuk membantu Anda memulai. Ini adalah A057628 pada OEIS.

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

Ini berarti A(0) = 11,, A(1) = 31dll., Ketika menggunakan nol pengindeksan.

Aturan

• Anda dapat memilih pengindeksan berbasis nol atau satu; tolong jelaskan di jawaban Anda yang mana.
• Alih-alih mengembalikan nelemen ke - th, Anda dapat memilih untuk mengembalikan nistilah yang pertama .
• Anda dapat mengasumsikan bahwa input / output tidak akan lebih besar dari format integer asli bahasa Anda; namun, prime digit yang diulang mungkin lebih besar dari format asli bahasa Anda, sehingga perlu dipertanggungjawabkan.
• Sebagai contoh,, 1871jumlah terakhir dari contoh, memiliki bilangan prima yang sesuai 18888888877777771, yang sedikit lebih besar dari INT32 standar.
• Program lengkap atau fungsi dapat diterima. Jika suatu fungsi, Anda dapat mengembalikan output daripada mencetaknya.
• Output bisa ke konsol, dikembalikan dari fungsi, ditampilkan dalam sembulan peringatan, dll.
• Celah standar dilarang.
• Ini adalah kode-golf sehingga semua aturan golf biasa berlaku, dan kode terpendek (dalam byte) menang.

* Agar adil, saya telah menemukan beberapa syarat pertama dari urutan yang hanya bermain-main dengan beberapa angka, dan kemudian pergi ke OEIS untuk mendapatkan sisa urutan.

Sekam , 15 byte

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

Cobalah online!

!                 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 the Outgolfer menyimpan satu byte. Menggunakan ṗalih-alih εpakan menghemat byte lain, tetapi itu membuat program sangat lambat bahkan untuk n = 2.

05AB1E , 14 13 byte

-1 byte terima kasih kepada Emigna !

µNSÐPŠ×JpNpPĀ½

Cobalah online!

Penjelasan

µ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

Jelly , 18 14 byte

ÆPaDxDḌÆPaDẠµ#

Cobalah online!

Tn. Xcoder: -1 Byte (logis semua)

Erik the Outgolfer: -2 Bytes (satu baris, bukan dua)

HyperNeutrino: -1 Byte (mengembalikan elemen urutan pertama)

Penjelasan

Æ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

Sunting: semula mengirim jawaban yang menyertakan angka 0 dalam representasi desimalnya yang secara khusus tidak diizinkan.

Bahasa Wolfram (Mathematica) , 100 byte

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

Cobalah online!

Jonathan Frech menyimpan 3 byte

dan -7 byte dari JungHwan Min

-15 byte dari Martin Ender

juga terima kasih kepada Jenny Mathy

Alice , 72 70 66 62 56 byte

Terima kasih kepada Leo karena telah menghemat 5 byte.

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

Cobalah online!

Menggunakan input berbasis 1.

Penjelasan

The golf trik rapi di sini (meskipun itu hanya menghemat beberapa byte) adalah bahwa saya menggunakan tes primality yang memberikan 0untuk komposit n untuk nuntuk non-komposit n . Dengan begitu, kita tidak harus menggunakan hasilnya secara langsung dalam kondisi, tetapi kita bisa meneruskannya langsung ke bagian berikutnya yang memeriksa bahwa input tidak mengandung nol.

/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

• Terima kasih kepada ArBo untuk solusi empat byte yang lebih pendek ini.

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

Cobalah online!

Python 2 , 195 179 167 140 138 136 135 134 byte

• Disimpan 27 byte berkat ovs ; menggunakan xrangealih-alih range, dengan demikian menghindari MemoryErrordan memadatkan fungsi utama; meningkatkan penghitungan indeks bilangan bulat.
• Disimpan dua byte; menggunakan pipa biner atau operasi |untuk menghemat byte or.
• Disimpan dua byte; membalik fungsi utama dan melakukan manipulasi logika lebih lanjut.
• Disimpan satu byte; menggunakan ~-alih-alih 0**untuk membalikkan keberadaan nol dalam j, seperti& diikuti oleh boolean sejati mengisolasi properti boolean nilai ini.
• Menyimpan satu byte berkat Lynn ; bermain golf ~-A&B&C(setara dengan (not A) and B and C) dengan A, B, Cmenjadi boolean 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

Cobalah online! (1-diindeks)

Penjelasan

Menentukan fungsi utama fyang mengambil dalam indeks integer n,, dan secara default nilai yang ditetapkan j, urutan saat ini canditate (diinisiasi 9untuk meningkatkan kinerja sambil menjaga ukuran program) dan fungsi pengecekan utama.
Selama ntidak nol, nentri urutan ke-3 belum ditemukan. Jadi jbertambah dan ndikurangi oleh satu jika if jadalah angka yang memenuhi properti yang diperlukan.
Ketika loop berakhir, jadalah nentri urutan ke - 4 dan dengan demikian dicetak.

Pyth , 21 byte

.f&.AKjZT&P_ss*VK`ZP_

Coba di sini!

Agak panjang karena Pyth tidak memiliki ekspansi Desimal bawaan .

• Ambil bilangan bulat positif N pertama (.f ), yang:
  • Apakah semua digit benar ( .AKjZT), dan (& ) ...
  • Perkalian vektor dari representasi string mereka dengan digit mereka ( *VK`Z), bergabung bersama dan dikonversi ke integer ( ss) adalah prime ( P_), dan (& ) ...
  • Itu bilangan prima sendiri ( P_).

Perl 6 , 51 byte

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

Cobalah online!

• grep {...}, 2..*memfilter urutan tak terbatas bilangan asli mulai dari 2 menggunakan fungsi predikat antara kawat gigi. (...)[$_]indeks ke dalam daftar yang difilter ini menggunakan argumen fungsi $_.
• !/0/ memfilter angka yang mengandung angka nol.
• S:g/./{$/ x $/}/ mereplikasi setiap digit dalam ekspansi desimal nomor tes.
• is-prime $_ & S:g/./{$/ x $/}/memanggil is-primefungsi bawaan dengan dan-junction $_, nomor tes, dan nomor yang dihasilkan dari mereplikasi digitnya. Fungsi akan mengembalikan true jika kedua anggota dan-junction adalah prima.

J, 81 byte

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

Ini adalah salah satu situasi di mana saya belum menemukan solusi yang baik.

Meskipun demikian, saya memposting ini dengan harapan mempelajari sesuatu yang baru.

fmemberi tahu kami jika angka yang diberikan adalah "prime digit berulang". Itu rusak sebagai berikut:

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

Dan akhirnya kata kunci Do ... While, dengan kata kerja yang sulit, yang tampaknya tidak dapat dihindari, yang muncul dari kenyataan bahwa kita perlu menggunakan daftar untuk menyimpan kemajuan kita, yang membutuhkan register "prima saat ini" dan "yang ditemukan sejauh ini" , karena argumen kiri kami sudah diambil untuk menyimpan kondisi berhenti, yaitu n,. Ini berarti bahwa kita harus menggunakan banyak byte berharga untuk tugas sederhana menentukan args ( [dan ]) dan membongkar daftar elemen 2 kita ( {.dan {:):

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

Cobalah online!