Інша послідовність, черговий виклик. *

Визначення

Наочний pв цій послідовності, давайте назвемо його A, якщо для кожної цифри dв pдесятковому розкладанні «s, ви замінюєте dз dкопіями dі отримане число до сих пір прем'єром; нулі заборонені.

Наприклад, 11тривіально в цій послідовності (це, до речі, перше число). Наступним у послідовності є 31, тому що 3331також є простим; то 53тому 55555333, що також є простим і так далі.

Виклик

Враховуючи вхід n, повернення A(n), тобто цей nелемент у цій послідовності.

Приклади

Ось перші 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тощо, коли використовується нульова індексація.

Правила

• Ви можете вибрати нульову або одноосновну індексацію; вкажіть, будь ласка, у своїй відповіді.
• Замість того, щоб повернути лише цей nелемент, ви можете вибрати повернути перші 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.

Ерік Аутгольфер врятував байт. Використання ṗзамість цього εpдозволить зберегти ще один байт, але це робить програму настільки повільною, що в рази більше, ніж для n = 2.

05AB1E , 14 13 байт

-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Ạµ#

Спробуйте в Інтернеті!

Містер Xcoder: -1 байт (все логічно)

Ерік Аутгольфер: -2 байти (один рядок замість двох)

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

Редагувати: спочатку надіслали відповідь, яка містила цифри з 0 у десятковому поданні, що конкретно не дозволено.

Мова Вольфрама (Mathematica) , 100 байт

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

Спробуйте в Інтернеті!

Джонатан Фрех врятував 3 байти

і -7 байт від JungHwan Min

-15 байт від Мартіна Ендера

також завдяки Дженні Маті

Аліса , 72 70 66 62 56 байт

Дякуємо Лео за збереження 5 байт.

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

Спробуйте в Інтернеті!

Використовує вхід на основі 1.

Пояснення

Найменший трюк з гольфу тут (хоча він заощаджує лише пару байтів) - це те, що я використовую тест на первинність, який дає 0композитний n для nнекомпозитний n . Таким чином, нам не доведеться використовувати результат безпосередньо в умовному режимі, але ми можемо передати його прямо в наступну частину, яка перевіряє, чи вхід не містить нулів.

/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 байт

• Завдяки 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))

Спробуйте в Інтернеті!

Python 2 , 195 179 167 140 138 136 135 134 байт

• Збережено 27 байт завдяки ovs ; використовуючи xrangeзамість range, обходячи таким чином a MemoryErrorі ущільнюючи просту функцію; поліпшення підрахунку цілих чисел.
• Збережено два байти; використання двійкової труби або операцій |для збереження байтів or.
• Збережено два байти; інвертування простірної функції та проведення подальших логічних маніпуляцій.
• Збережено байт; використовуючи ~-замість того, 0**щоб інвертувати існування нуля в j, &після чого справжнє булеве значення ізолює булеву властивість цього значення.
• Збережено байт завдяки Лінні ; гольф ~-A&B&C(еквівалентно (not A) and B and C) з A, B, Cбулями 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

Спробуйте в Інтернеті! (1-індексований)

Пояснення

Визначає головну функцію, fяка приймає цілий індекс, nі за замовчуванням встановлене значення j, поточну кандидатуру послідовності (закликається 9покращити продуктивність, зберігаючи розмір програми) та функцію просте перевірки.
Поки nзначення не дорівнює нулю, nзапис -ої послідовності ще не знайдено. Таким чином j, збільшується і nзменшується на один iff j- це число, яке задовольняє необхідним властивостям.
Коли цикл закінчується, jвідбувається n-та запис послідовності і таким чином друкується.

Pyth , 21 байт

.f&.AKjZT&P_ss*VK`ZP_

Спробуйте тут!

Досить тривалим, оскільки Pyth не має вбудованого десяткового розширення .

• Візьміть перші N натуральних чисел ( .f), які:
  • У всіх цифр truthy ( .AKjZT) та ( &) ...
  • Векторизоване множення їх рядкового представлення на їхні цифри ( *VK`Z), об'єднані та перетворені на ціле число ( ss), є простими ( P_) та ( &) ...
  • Це самі праймери ( P_).

Perl 6 , 51 байт

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

Спробуйте в Інтернеті!

• grep {...}, 2..*фільтрує нескінченну послідовність натуральних чисел, починаючи з 2, використовуючи функцію предиката між дужками. (...)[$_]індексує у цей відфільтрований список, використовуючи аргумент функції $_.
• !/0/ фільтрує числа, що містять нульову цифру.
• S:g/./{$/ x $/}/ копіює кожну цифру в десятковому розширенні тестового числа.
• is-prime $_ & S:g/./{$/ x $/}/викликає вбудовану is-primeфункцію з і-переходом $_, тестовим номером та номером, що виникає в результаті повторення її цифр. Функція повернеться істиною, якщо обидва члени і-з'єднання є простими.

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

І, нарешті, головний Do ... У той час як дієслово, з його прикметною, здавалося б, неминучою табличкою, яка виникає через те, що нам потрібно використовувати список для зберігання нашого прогресу, який вимагає як "поточного прем'єра", так і "знайдених поки що" реєстрів , оскільки наш лівий аргумент вже прийнятий для збереження умови зупинки, тобто n. Це означає, що ми повинні використовувати безліч дорогоцінних байтів для простого завдання вказівки аргументів ( [і ]) та розпакування нашого списку 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.

Спробуйте в Інтернеті!