另一个顺序，另一个挑战。*

定义

素数p是这个序列中的一个，我们称它为A，如果十进制扩展中的每个数字都d为p，则替换d为的d副本，d结果整数仍为素数；不允许为零。

例如，11在此序列中琐碎是（顺便说一下，它是第一个数字）。序列中的下一个是31，因为3331它也是素数。那么53因为55555333也是素数，依此类推。

挑战

给定一个input n，return A(n)，即n此序列中的第一个项目。

例子

这是让您入门的前20个学期。这是OEIS上的A057628。

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.

Outgolfer的Erik保存了一个字节。使用ṗ代替代替ε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字节（逻辑全）

Erik the 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语言（Mathematica），100字节

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

在线尝试！

Jonathan Frech保存了3个字节

和郑焕敏的-7个字节

马丁·恩德的-15个字节

也要感谢珍妮·马西（Jenny Mathy）

爱丽丝，72 70 66 62 56字节

感谢Leo节省了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字节

• 由于ovs节省了27个字节；使用xrange代替range，从而绕开a MemoryError并压缩素函数；改善整数索引计数。
• 保存了两个字节；使用二进制管道或操作|来保存字节or。
• 保存了两个字节；反转素函数并进行进一步的逻辑处理。
• 保存一个字节；使用~-而不是0**反转in中零的存在j，&后跟一个真正的布尔值，将隔离此值的布尔值属性。
• 感谢Lynn节省了一个字节；打高尔夫球~-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-th序列条目并因此打印。

Pyth，21个字节

.f&.AKjZT&P_ss*VK`ZP_

在这里尝试！

相当长，因为Pyth没有内置十进制扩展。

• 取前N个正整数（.f），即：
  • 所有数字均为真（.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带有和号$_，测试号以及复制其数字所得的数字的内置函数。如果and-junction的两个成员均为素数，则该函数将返回true。

J，81个字节

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

这是这些情形之一的，我还没有找到一个很好的解决方案Ĵ。

不过，我发布此文章是希望学习新的东西。

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 ...而动词带有令人讨厌的，似乎不可避免的样板，这是由于我们需要使用列表来存储我们的进度这一事实而产生的，它既需要“当前素数”又要“找到到目前为止” ，因为我们已经使用了left参数来存储停止条件，即n。这意味着我们必须使用许多宝贵的字节来完成指定args（[和]）并解包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.

在线尝试！