Другая последовательность, другая проблема. *

Определение

Простое pв этой последовательности, давайте назовем его A, если для каждой цифры dв pдесятичном разложении в России вы заменяете 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и т.д., при использовании нулевой индексации.

правила

• Вы можете выбрать индексирование на основе нуля или единицы; пожалуйста, укажите в своем ответе какой.
• Вместо того, чтобы возвращать только 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 байт

-1 байт благодаря Emigna !

µ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 байт (все логично)

Эрик Outgolfer: -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 в десятичном представлении, что специально не допускается.

Wolfram Language (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для не композитного п . Таким образом, нам не нужно использовать результат непосредственно в условном выражении, но мы можем передать его прямо следующей части, которая проверяет, что входные данные не содержат нулей.

/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, таким образом, обхода 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уменьшается на единицу, если jэто число, которое удовлетворяет требуемым свойствам.
Когда цикл заканчивается, jпроисходит nзапись -ой последовательности и, таким образом, печатается.

Pyth , 21 байт

.f&.AKjZT&P_ss*VK`ZP_

Попробуй это здесь!

Довольно длинный, так как Pyth не имеет встроенного десятичного расширения .

• Возьмем первые N натуральных чисел ( .f), которые:
  • Есть все цифры правда ( .AKjZT) и ( &) ...
  • Векторизованное умножение их строкового представления на их digits ( *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функцию с соединением «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

И, наконец, главный 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.

Попробуйте онлайн!