序列

每个人都知道唯一的偶数是2。呜呜 但是，也有一定的连号n，其中，当串联n-1，就成为一个素数。

对于初学者来说，1不在列表中，因为10它不是素数。与2（21）和3（32）类似。但是，4之所以起作用是因为它43是质数，因此它是序列中的第一个数字a(1) = 4。下一个有效的数字（6（65）和8（87）都不起作用）是10，因为它109是素数a(2) = 10。然后我们再跳过一堆，直到22因为2221是素数，所以a(3) = 22。等等。

显然，此序列中的所有项都是偶数，因为n与之连接的任何奇数都n-1将变为偶数（如3变成32），而该数将永远不是素数。

这是OEIS上的序列A054211。

挑战

给定一个n适合此序列某处的输入数字（即，n与n-1质数连接），输出其在此序列中的位置。您可以选择0或1索引，但请在提交时说明。

规则

• 可以假定输入和输出适合您语言的本机整数类型。
• 输入和输出可以任何方便的格式给出。
• 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
• 如果可能，请提供一个在线测试环境的链接，以便其他人可以尝试您的代码！
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此所有常见的高​​尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

例子

以下示例为1索引。

n = 4
1

n = 100
11

n = 420
51

果冻， 8  7 字节

ḊżṖVÆPS

单调链接，它获取序列成员并返回其在序列中的索引。

在线尝试！

怎么样？

ḊżṖVÆPS - Link: number, n
Ḋ       - dequeue (implicit range) = [ 2   , 3   , 4   ,... ,              n         ]
  Ṗ     - pop (implicit range)     = [   1 ,   2 ,   3 ,... ,                  n-1   ]
 ż      - zip                      = [[2,1],[3,2],[4,3],... ,             [n , n-1]  ]
   V    - evaluate as Jelly code   = [ 21  , 32  , 43  ,... ,         int("n"+"n-1") ]
    ÆP  - is prime? (vectorises)   = [  0  ,  0  ,  1  ,... , isPrime(int("n"+"n-1"))]
      S - sum

Haskell，80 75 70字节

Laikoni节省了5个字节

p x=all((>0).mod x)[2..x-1]
g n=sum[1|x<-[4..n],p$read$show=<<[x,x-1]]

在线尝试！

果冻，12，10，8个字节

;’VÆPµ€S

在线尝试！

感谢@ nmjmcman101，节省了1-2个字节，感谢@Dennis，节省了2个字节！

说明：

     µ€   # For N in range(input()):
;         #   Concatenate N with...
 ’        #   N-1
  V       #   And convert that back into an integer
   ÆP     #   Is this number prime?
       S  # Sum that list 

05AB1E，9 8 7字节

码

ƒNN<«pO

使用05AB1E编码。在线尝试！

说明

ƒ          # For N in [0 .. input]..
 NN<«      #   Push n and n-1 concatenated
     p     #   Check for primality
      O    #   Sum the entire stack (which is the number of successes)

外壳，13 11 10字节

1索引解决方案：

#ȯṗdS¤+d←ḣ

在线尝试！

取消高尔夫/解释

         ḣ -- in the range [1..N]
#          -- count the number where the following predicate is true
        ←  --   decrement number,
    S  d   --   create lists of digits of number and decremented 
     ¤+    --   concatenate,
   d       --   interpret it as number and
 ȯṗ        --   check if it's a prime number

感谢@Zgarb提供-3字节！

Python 2，87个字节

-2个字节，感谢@officialaimm。1个索引。

lambda n:sum(all(z%v for v in range(2,z))for i in range(4,n+1)for z in[int(`i`+`i-1`)])

测试套件。

Pyth，12个字节

smP_s+`d`tdS

在线尝试！或验证所有测试用例。

怎么样？

smP_s+`d`tdSQ  -> Full Program. Takes input from Standard Input. Q means evaluated input
                  and is implicit at the end.

 m         SQ  -> Map over the Inclusive Range: [1...Q], with the current value d.
    s+`d`td    -> Concatenate: d, the current item and: td, the current item decremented. 
                  Convert to int.
  P_           -> Prime?
s              -> Sum, counts the occurrences of True.

Japt，15 14 12 11 9 8字节

1个索引。

ÇsiZÄÃèj

试试吧

Ç            :Map each Z in the range [0,input)
 s           :  Convert to string
  i          :    Prepend
   ZÄ        :    Z+1
     Ã       :End map
      è      :Count
       j     :  Primes

Röda，73个字节

{seq 3,_|slide 2|parseInteger`$_2$_1`|{|i|[1]if seq 2,i-1|[i%_!=0]}_|sum}

在线尝试！

1个索引。它使用流来进行输入和输出。

说明：

{
seq 3,_| /* Create a stream of numbers from 3 to input */
slide 2| /* Duplicate every number except the first and the last
            to create (n-1,n) pairs */
parseInteger`$_2$_1`| /* Concatenate n and n-1 and convert to integer */
{|i| /* For every i in the stream: */
    [1]if seq 2,i-1|[i%_!=0] /* Push 1 if i is a prime
                                (not divisible by smaller numbers) */
}_|
sum /* Return the sum of numbers in the stream */
}

Pyth，14个字节

lfP_Tms+`d`tdS

在线尝试！

说明

              Q    # Implicit input
             S     # 1-indexed range
     m             # For d in range [1, Q]...
      s+`d`td      # Concatenate d and d - 1
 fP_T              # Filter on primes
l                  # Return the length of the list

Perl 6、45字节

{first :k,$_,grep {is-prime $_~.pred},1..∞}

在线尝试！

该grep生产合格的数字序列，接下来我们来看看该键（:k在中）（即指数）first数，等于输入参数列表$_。

C，99 94字节

1个索引。编写素数测试非常麻烦，但是计算字节毕竟是字节。

如果我们允许一些非常脆弱的东西，那么在我的机器上进行编译而无需使用GCC 7.1.1进行优化，以下94个字节就可以工作（感谢@Conor O'Brien）

i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}n=c;}

否则，这些更健壮的99字节就可以完成工作

i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}return c;}

完整的程序，更具可读性：

i,c,m,k;
f(n){
    c=i=1;
    for(;++i<n;c+=m==k){
        for(k=m=1;m*=10,m<i;);
        for(m=i*m+i-1;++k<m&&m%k;);
    }
    return c;
}

int main(int argc, char *argv[])
{
    printf("%d\n", f(atoi(argv[1])));
    return 0;
}

JavaScript（ES6）， 49 48  47字节

1个索引。受引擎的调用堆栈大小限制。

f=n=>n&&f(n-2)+(p=n=>n%--x?p(n):x<2)(x=n+[--n])

在线尝试！

Mathematica，77个字节

Position[Select[Range@#,PrimeQ@FromDigits[Join@@IntegerDigits/@{#,#-1}]&],#]&

QBIC，25个字节

[:|p=p-µa*z^_l!a$|+a-1}?p

说明

[:|     FOR a = 1 to <n>
p=p-    Decrement p (the counter) by
µ       -1 if the following is prime, or 0 if not
        For the concatenating, we multiply 'a' by 10^LENGTH(a), then add a-1$┘p
        Example 8, len(8) = 1, 8*10^1 = 80, add 8-1=7, isPrime(87) = 0
a*z^_l!a$|+a-1
}       Close the FOR loop - this also terminates the prime-test
?p      Print p, the 0-based index in the sequence.

这使用了一些相当复杂的数学事物，并加上了正确的转换字符串。制作版本帽子仅进行基于字符串的连接要多一个字节：

[:|A=!a$+!a-1$┘p=p-µ!A!}?p

PHP，203字节

<?php $n=($a=$argv[1]).($a-1);$p=[2];$r=0;for($b=2;$b<=$n;$b++){$x=0;if(!in_array($b,$p)){foreach($p as $v)if(!($x=$b%$v))break;if($x)$p[]=$b;}}for($b=1;$b<=$a;$b++)if(in_array($b.($b-1),$p))$r++;die $r;

在线尝试！

使用基于1的索引进行输出。TIO链接具有代码的可读版本。

Ruby，42 + 9 = 51字节

使用-rprime -n标志。1个索引。

通过计算等于或低于满足条件的输入的所有数字（或更确切地说，满足n-1条件的所有数字）来工作。由于保证了输入是按顺序排列的，因此不存在来自随机输入的错误风险，例如7不会“成为素数”。

p (?3..$_).count{|i|eval(i.next+i).prime?}

在线尝试！

红宝石，62字节

->g{(1..g).count{|r|(2...x=eval([r,r-1]*'')).none?{|w|x%w<1}}}

在线尝试！

1索引

Python 2，85个字节

1索引

lambda n:sum(all(z%v for v in range(2,z))for i in range(3,n)for z in[int(`i+1`+`i`)])

测试

改善Xcoder先生的答案

Java 8，108字节

n->{for(long r=0,q=1,z,i;;){for(z=new Long(q+""+~-q++),i=2;i<z;z=z%i++<1?0:z);if(z>1)r++;if(q==n)return r;}}

0索引

说明：

在线尝试。

n->{                             // Method with integer parameter and long return-type
  for(long r=0,                  //  Result-long, starting at 0
      q=1,                       //  Loop integer, starting at 1
      z,i;                       //  Temp integers
      ;){                        //  Loop indefinitely
    for(z=new Long(q+""+~-q++),  //   Set z to `q` concatted with `q-1`
        i=2;i<z;z=z%i++<1?0:z);  //   Determine if `z` is a prime,
      if(z>1)                    //   and if it indeed is:
        r++;                     //    Increase the result-long by 1
      if(q==n)                   //   If `q` is now equal to the input integer
        return r;}}              //    Return the result

Stax，10 个字节

1-索引

Äm▬á┌╕|°φ♦

运行和调试它 解释

Rxr\{$e|pm|+         #Full program, unpacked, implicit input  (Example (4))
R                    #Create [1 to input] range  (ex [1,2,3,4] )             
 x                   #Copy value from x register (ex (4) )
  r                  #Create [0 to input-1] range (ex [0,1,2,3)
   \                 #Create array pair using the range arrays (ex [[1,0],[2,1],[3,2],[4,3]])
    {    m           #Map block
     $e|p            #To string, eval string (toNum), isPrime (ex [1,0] => "10" => 10 => 0)
          |+         #Sum the array to calculate number of truths (ex [0,0,0,1] => 1)

整洁，33字节

index({n:prime(n.n-1|int)}from N)

在线尝试！

说明

基本思想是创建一个有效数字序列，然后返回一个咖喱​​索引函数。

index({n:prime(n.n-1|int)}from N)
      {n:                }from       select all numbers `n` from...
                               N     the set of natural numbers, such that:
               n.n-1                     `n` concatenated with `n-1`
                    |int                 ...converted to an integer
         prime(         )                ...is prime
index(                          )    function that returns index of input in that sequence