Başka bir dizi, başka bir zorluk. *

Tanım

Bir asal pbu dizide olduğu, diyelim Aher rakam için IFF, diçinde pdeğiştirmek, 'in ondalık genişlemesi dile dkopyaları dve elde edilen tamsayı hala asal olduğu; sıfırlara izin verilmez.

Örneğin, 11bu sırayla önemsizdir (tesadüfen ilk sayıdır). Sırada bir sonraki 31, çünkü 3331aynı zamanda asal; o zaman 53çünkü 55555333aynı zamanda asal, vb.

Meydan okuma

Bir girdi verildiğinde n, geri dönüş A(n), yani nbu dizideki th öğesi.

Örnekler

İşte başlamanız için ilk 20 terim. Bu OEIS'de A057628 .

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

Bu A(0) = 11, A(1) = 31sıfır indeksleme kullanırken, vb. Anlamına gelir.

kurallar

• Sıfır veya tek tabanlı indekslemeyi seçebilirsiniz; Lütfen cevabınızda hangisi olduğunu belirtiniz.
• Yalnızca nth öğesini döndürmek yerine, ilk nterimleri döndürmeyi seçebilirsiniz .
• Giriş / çıktının dilinizin yerel tam sayı biçiminden daha büyük olmayacağını varsayabilirsiniz; ancak, yinelenen basamaklı asal , dilinizin yerel biçiminden daha büyük olabilir , bu nedenle hesaba katılması gerekir.
• Örneğin 1871, örneklerin son sayısı, 18888888877777771standart INT32'den biraz daha büyük olan karşılık gelen bir prime sahiptir .
• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine döndürebilirsiniz.
• Çıktı konsola olabilir, bir işlevden döndürülebilir, uyarı açılır penceresinde görüntülenebilir vb.
• Standart boşluklar yasaktır.
• Bu kod golfüdür, bu nedenle her zamanki golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

* Adil olmak gerekirse, dizinin ilk birkaç terimini sadece bazı sayılarla oynadım ve sonra dizinin geri kalanını almak için OEIS'e gittim.

Kabuk , 15 bayt

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

Çevrimiçi deneyin!

!                 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 Erik bir bayt kurtardı. ṗBunun yerine kullanmak εpbaşka bir bayt kaydeder, ancak bu program n = 2 için bile zamanımızı çok yavaşlatır.

05AB1E , 14 13 bayt

Emigna sayesinde -1 bayt !

µNSÐPŠ×JpNpPĀ½

Çevrimiçi deneyin!

açıklama

µ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

Jöle , 18 14 bayt

ÆPaDxDḌÆPaDẠµ#

Çevrimiçi deneyin!

Bay Xcoder: -1 Bayt (mantıklı hepsi)

Outgolfer Erik: -2 Bayt (iki yerine bir satır)

HyperNeutrino: -1 Bayt (dizinin ilk n öğesini döndürür)

açıklama

Æ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

Düzenleme: Başlangıçta ondalık gösterimde 0 olan ve özellikle izin verilmeyen sayılar içeren bir yanıt gönderdi.

Wolfram Dili (Mathematica) , 100 bayt

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

Çevrimiçi deneyin!

Jonathan Frech 3 bayt kurtardı

ve JungHwan Min'den -7 bayt

Martin Ender'den -15 bayt

ayrıca Jenny Mathy sayesinde

Alice , 72 70 66 62 56 bayt

Leo'ya 5 bayt kaydettiği için teşekkürler.

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

Çevrimiçi deneyin!

1 tabanlı giriş kullanır.

açıklama

Etkileyicisi golf hüner burada (sadece bayt bir çift kaydeder bile) ben veren bir asallık testi kullanılarak olmam 0kompozit için n için nolmayan kompozit için n . Bu şekilde, sonucu doğrudan bir koşullu olarak kullanmak zorunda değiliz, ancak doğrudan girdinin sıfır içermediğini kontrol eden bir sonraki bölüme aktarabiliriz.

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

• Bu dört baytlık daha kısa çözüm için ArBo'ya teşekkürler .

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

Çevrimiçi deneyin!

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

• Ovs sayesinde 27 bayt tasarruf ; asal fonksiyonun xrangeyerine kullanmak range, böylece a'yı MemoryErrorsıkıştırmak ve sıkıştırmak; tamsayı dizin sayımının iyileştirilmesi.
• İki bayt kaydedildi; |bayt kaydetmek için ikili boru veya işlemleri kullanarak or.
• İki bayt kaydedildi; asal fonksiyonun ters çevrilmesi ve daha fazla mantık manipülasyonu yapılması.
• Bir bayt kaydedildi; sıfır değerinin varlığını tersine çevirmek ~-yerine kullanmak , bunu gerçek bir boolean izler ve bu değerin boolean özelliğini yalıtır.0**j&
• Lynn sayesinde bir bayt kurtardı ; boolean olmak ile golf ~-A&B&C(eşdeğer (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

Çevrimiçi deneyin! (1 endeksli)

açıklama

fBir tamsayı dizini alan bir ana işlevi nve varsayılan olarak ayarlanmış bir değeri j, geçerli dizi kandilini ( 9program boyutunu korurken performansı artırmak için başlatılan) ve prime kontrol işlevini tanımlar . Sıfırdan farklı
olduğu sürece -th sekans girişi henüz bulunmaz. Böylece artırılır ve bir iff azaltılır , gerekli özellikleri karşılayan bir sayıdır. Döngüsü sona erdikten sonra, bir inci dizisi giriş ve böylece basılmış.nnjnj
jn

Pyth , 21 bayt

.f&.AKjZT&P_ss*VK`ZP_

Burada deneyin!

Pyth'in yerine ondalık bir genişleme yerleşik değildir .

• İlk N pozitif tamsayıyı ( .f) alın :
  • Tüm rakamları doğru ( .AKjZT) ve ( &) yapın ...
  • Dize temsillerinin basamakları ( *VK`Z) ile vektörize çarpımı , birleştirilmiş ve bir tamsayıya ( ss) dönüştürülen asal ( P_) ve ( &) ...
  • Bu asal olanların kendisidir ( P_).

Perl 6 , 51 bayt

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

Çevrimiçi deneyin!

• grep {...}, 2..*kaşlı ayraçlar arasındaki yüklem işlevini kullanarak 2'den başlayan sonsuz doğal sayı dizisini filtreler. (...)[$_]işlevin bağımsız değişkenini kullanarak bu filtrelenmiş listeye dizinler $_.
• !/0/ sıfır basamağı içeren sayıları filtreler.
• S:g/./{$/ x $/}/ test numarasının ondalık genişlemesindeki her basamağı çoğaltır.
• is-prime $_ & S:g/./{$/ x $/}/yerleşik is-primeişlevi $_, test numarası ve rakamlarının çoğaltılmasından kaynaklanan sayı ile birleşim yeri olarak çağırır . Ve kavşağın her iki üyesi de asalsa işlev true döndürecektir.

J, 81 bayt

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

Bu, henüz iyi bir J çözümü bulamadığım durumlardan biri .

Yine de, bunu yeni bir şey öğrenme umuduyla gönderiyorum.

fbize verilen bir sayının "tekrarlanan basamaklı asal" olup olmadığını söyler. Aşağıdaki şekilde parçalanır:

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

Ve nihayet ana Do ... Sinir bozucu, görünüşte kaçınılmaz olan kaynatma plakası ile, hem "mevcut ana" hem de "şimdiye kadar bulunan" kayıtlarını gerektiren ilerlememizi saklamak için bir liste kullanmamız gerektiğinden ortaya çıkıyor. , sol argümanımız zaten durdurma koşulunu saklamak için alınmış olduğundan, yani n. Bu, argümanları belirtmek ( [ve ]) ve 2 element listemizi ( {.ve {:) açmak için çok değerli bayt kullanmamız gerektiği anlamına gelir :

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

Çevrimiçi deneyin!