每个具有偶数位数的回文可以被11整除，因此11是唯一具有偶数位数的[回文素数]。- 大卫·沃瑟曼，OEIS

今天，在进行回文素数计算时，我的程序跳过了偶数位数（11除外）的数字，这是我在进行研究之前以手动方式学习的。您的任务：创建一个程序或函数，当给定整数输入N时，该程序或函数在Stephen's Palindromic Sequence™中输出第N个项。

斯蒂芬的回文序列™

Stephen的Palindromic Sequence™从11开始，再到回文的 半素数可被11整除。基本上，如果11不“计数”，则所有的半素数都是素数。有利的是，此列表包含具有偶数个数字的数字！好极了。并且，由于它们已经是质数，所以将跳过许多具有奇数个数字的数字。

序列的开始：

1   : 11
2   : 22
3   : 33
4   : 55
5   : 77
6   : 121
7   : 737
8   : 979
9   : 1111
10  : 1441
11  : 1661
12  : 1991
13  : 3113
14  : 3223
15  : 3443
16  : 3883
17  : 7117
18  : 7447
19  : 7997
20  : 9119
21  : 9229
22  : 9449
23  : 10901

_{^{*尽管1331（11 ^ 3）和类似内容符合此顺序的精神，但它们不符合规则。}}

更长的测试用例：

26  : 91619
31  : 103301
41  : 139931
51  : 173371
61  : 305503
71  : 355553
81  : 395593
91  : 725527
101 : 772277
127 : 997799
128 : 1099901
141 : 3190913
151 : 3739373
161 : 7589857
171 : 9460649
200 : 11744711
528 : 39988993

输入值

整数N，> =1。如果在回答中指定，则可以使用索引为0的N（一定要调整测试用例）。允许尾随换行符。

输出量

Stephen's Palindromic Sequence™中的第N个术语。允许尾随换行符。

规则

• 您的程序/函数只能接受N个输入。例如，您的程序无法从OEIS获取序列（也称为标准漏洞）。
• 您必须能够打印最多六位数字的输出（N = 127）。时间不是一个因素-但是，如果您的程序/功能很快变得非常长，则必须证明该算法有效。如果您的语言自然允许更长的输出，则可以让它自然扩展到最大限制，也可以将其限制为十位数，以您喜欢的为准。超出限制的输出/终止无关紧要，只要它看起来不是有效的输出即可。
• 与无效输入无关的程序/功能功能。

果冻，18 13字节

ṬÆẸש11ŒḂµ#ṛ®

由于某些原因，尽管这样做完全一样，但它比我最初的版本要慢得多。

在线尝试！

N = 127

dennis-home:~$ time jelly eun 'ṬÆẸש11ŒḂµ#ṛ®' <<< 127
997799

real    1m43.745s
user    1m43.676s
sys     0m0.113s

怎么运行的

ṬÆẸש11ŒḂµ#ṛ®  Main link. No arguments.

         µ     Combine all links to the left into a chain.
          #    Read an integer n from STDIN and call the chain monadically, with
               argument k = 0, 1, 2, ... until n values of k result in a truthy
               output. Return the array of all matching values of k.
Ṭ                Untruth; yield [0, 0, 0, ..., 1] (k-1 zeroes followed by a 1) or
                 [] if k = 0.
 ÆẸ              Unexponents; consider the resulting array as exponents of the
                 sequence of primes and yield the corresponding integer. For k = 0,
                 this yields 1. For k > 0, it yields the k-th prime.
   ש11          Multiply the result by 11 and copy the product to the register.
       ŒḂ        Test if the product is a palindrome.
           ṛ®  Replace the resulting array with the integer in the register.

Python 2中，76 73 72 70 69 68字节

n=input();c=k=m=11
while n:m*=k/c;k+=c;n-=`k`==`k`[::~m%k-c]
print k

感谢@WheatWizard高尔夫球了3个字节！

感谢@ØrjanJohansen打高尔夫球1个字节！

感谢@xnor和@ØrjanJohansen为68个字节铺平了道路！

输入为0索引。在线尝试！或验证前31个测试用例。

背景

回想一下，威尔逊定理指出，对于所有整数p> 1，

意思是（p-1）！当且仅当p为质数时，+ 1才能被p整除。

如果P> 1是不素，它是复合材料; 令q为p的最小素数。显然，q≤p / q。有两种情况：

• 如果q = p / q，则有p =q²。

  如果q = 2，（p-1）！= 3！= 6，所以（p-1）！等于2模 p。

  如果p / q = q> 2，那么 2q <p。这样，q和2q都在1，…p-1之间，其乘积是p-1的阶乘，因此2p =2q²= q·2q除（p-1）！均匀地

• 如果q <p / q，q和p / q都在1，…，p-1之间，那么p = q·p / q除（p-1）！均匀地

加起来，

对于所有整数p> 1。

现在，对于所有整数同余以及所有整数a，b和c，以下成立。

当a = -1，b = 11且c = -1时，我们遵循

并且，由于21和-23为全模44和-1和11P-1是一致的模11P，我们在下面的结论。

对于p的所有可能值，结果（ 11，21，或11P - 1）将落入在范围0，...，11P - 1，所以这些值匹配那些将Python的返回%操作。

怎么运行的

将输入保存到n之后，将c，k和m初始化为11。在程序的其余部分，c将保持不变。由于下一行出现c的次数为三，分配c的成本仅为两个字节，因此节省了一个字节。使用上一段中p的含义，可以将k视为11p；最初，k = 11 = 11·1！。m代替11·（p-1）！; 最初，m = 11 = 11·0！。ķ和m将满足关系m = 11·（k / 11）！每时每刻。

n代表我们必须找到的“斯蒂芬回文数”。由于最初k = 11，我们可以逐字输出k，而无需进一步计算。但是，当n为正数时，我们进入while循环。在循环开始乘以米通过K / C = P，然后加入11至ķ，从而递增p。如果k是序列的成员，则从n中减去1并重新开始。一旦n达到0，我们就在所需索引处找到了序列成员，并跳出了循环，然后输出的最后一个值。 k

表达方式

`k`==`k`[::~m%k-c]

执行实际测试，并从n中减去其结果（对于序列成员为True / 1，否则为0 / False）。如前所见，〜米％K =（-m - 1）％K =（-11·（对- 1）！ - 1）％11P等于10，如果p是素数，21如果P = 4，和11P - 1如果p> 4是复合的，则> 43。因此，减去c = 11之后，我们剩下-1作为素数 p否则大于9的正整数。

对于素数p，​`k`[::-1]给我们k的字符串表示形式，其数字顺序相反，因此将其与​`k`​检查k是否为回文式进行比较。如果满足，则满足所有条件，并且k是序列成员。但是，如果p不是质数，则大范围步长和k将始终具有一个以上位数的事实意味着​`k`[::-1]不能具有与相同数量的位数​`k`​，更不用说等于它了。

Brachylog，17个字节

:I{11|ṗ×₁₁≜.↔}ᶠ⁽t

在线尝试！

这是1索引的。

说明

:I{          }ᶠ⁽t    Find the Input'th result of the following:
   11                  Output = 11
     |                 Or
          ≜.           Output is an integer…
      ṗ×₁₁             …which is the result of multiplying a prime by 11…
           .↔          …and Output reversed is still the Output

这个答案有两个实现：

• 我需要解决以下事实：⁽如果没有要传递的输入，则传递给元谓词（带有）的上标将不起作用（这就是为什么我必须添加:I）。
• 我需要添加一个元谓词以获得N谓词的th结果（这将避免使用ᶠ⁽t和，例如ⁿ⁽）。

实现这两个更改将使答案为14个字节。

Mathematica，65 60字节

n=NextPrime;11Nest[n@#//.x_/;!PalindromeQ[11x]:>n@x&,1,#-1]&

使用素数直接迭代，NextPrime并检查素数11倍是否是回文。达到N = 528。结果528和529 相隔超过2 ^16个质数，此时//.将无法尝试足够数量的替换。

Python 2中，111 107 103 102 101 100 91 90 89字节

丹尼斯在这里殴打我，所以去看看他的答案。

这个答案是零索引

n=input()
r=1
while n:r+=1;c=`r*11`;n-=all(r%x for x in range(2,r))*c==c[::-1]
print r*11

在线尝试！

数学迷节省了一个字节

说明

首先，我们接受输入并将其设置为n还创建一个新变量r=1。我们将计算r搜寻素数和11的乘积回文。n直到达到0。

所以我们开始一个循环：

while n:

我们要做的第一件事是增量 r

r+=1

我们还预定义了一个变量c作为字符串的表示形式r*11

c=`r*11`

现在，n如果要找到这样一个数字，我们要减少。我们将简单地r*11从中减去一个布尔值，表示是否适合该模式r。如果是，False我们将减去零，如果是True，它将减去1。

要计算布尔值，我们要做：

all(r%x for x in range(2,r))*c==c[::-1]

第一部分all将确定是否r为质数。我们将结果乘以cif r为素数将是空字符串，c如果r为comp则将为""空字符串。然后，我们将c[::-1]其与的反向进行比较c。如果r是素数c是回文，则将是True，如果其中任何一个失败，则整个结果将为假。

当n为零时，我们简单地说print c。

83个字节

这是一个较短的递归解决方案，但不幸的是不符合规范，因为它以太快的速度达到了python的递归上限。

f=lambda n,r=1:n and f(n-all(r%x*(`r*11`==`r*11`[::-1])for x in range(2,r)),r+1)+11

在线尝试！

05AB1E，15个字节

0索引。

11Iµ11N*DÂQNp*½

在线尝试！

说明

11               # initialize stack with 11
  Iµ             # loop over N in [1 ... inf] until counter equals input
    11N*         # multiply N by 11
        D        # duplicate
         ÂQ      # check if the copy equals its reverse
           Np    # check if N is prime
             *   # multiply the results of the checks together
              ½  # if 1, increase counter

Haskell，94 90字节

h#n|n<2=0|mod n h<1=1+h#div n h|j<-h+1=j#n
([n|n<-[0,11..],(==)=<<reverse$show n,3>2#n]!!)

在线尝试！用法示例：([n|n<-[0,11..],(==)=<<reverse$show n,3>2#n]!!) 127。

[0,11..]构造无限列表[0,11,22,33, ...]（使序列1索引需要零）。对于n此列表中的每一个，我们都检查n==(read.reverse.show)n，即是否n是回文。3>2#n检查是否n最多有两个素数除数。因为n总是被11整除，所以我们没有得到任何素数，只有半素数。

编辑：感谢ØrjanJohansen打高尔夫球4个字节！

PHP，82字节

for(;$d<$argn;$i>1||($p=11*$n)!=strrev($p)?:$d++)for($i=++$n;--$i&&$n%$i;);echo$p;

在线尝试！

公理，105字节

g(n)==(i:=c:=1;repeat(c=n=>break;i:=i+1;if(prime? i)then(x:=(11*i)::String;x=reverse(x)=>(c:=c+1)));i*11)

高尔夫，测试代码和结果

f(n)==
   i:=c:=1
   repeat
      c=n=>break
      i:=i+1
      if(prime? i)then(x:=(11*i)::String;x=reverse(x)=>(c:=c+1))
   i*11


(5) -> [[i,g(i)]  for i in 1..23]
   (5)
   [[1,11], [2,22], [3,33], [4,55], [5,77], [6,121], [7,737], [8,979],
    [9,1111], [10,1441], [11,1661], [12,1991], [13,3113], [14,3223], [15,3443],
    [16,3883], [17,7117], [18,7447], [19,7997], [20,9119], [21,9229],
    [22,9449], [23,10901]]
                                          Type: List List PositiveInteger
(6) -> [[i,g(i)]  for i in [26,31,41,101,151,200]]
   (6)
   [[26,91619], [31,103301], [41,139931], [101,772277], [151,3739373],
    [200,11744711]]

在这里g（700）= 92511529，所以限制将是> 700；ww（1000）= 703999307但使用nextPrime（）