挑战

给定一个输入整数n > 0，输出素数的数目（其他比n，如果n能够通过改变n的十进制扩展一个数字来制备本身是素数）（不改变的位数）。

例子

例如，n = 2。通过更改的十进制扩展一位2，我们可以得出三个附加的质数3, 5, 7，因此a(n) = 3。

再举一个例子n = 13。通过更改一位，您可以得到素数11, 17, 19, 23, 43, 53, 73, 83，因此a(13) = 8。

最后一个示例n = 20。通过更改一位，您可以得到素数23, 29，因此a(20) = 2。

序列

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

4, 3, 3, 4, 3, 4, 3, 4, 4, 4, 7, 4, 8, 4, 4, 4, 7, 4, 7, 2

规则

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

05AB1E，17 16 14 11字节

ā°`<Ÿʒ.L}pO

说明：

ā             Push inclusive range from 1 to the length of the input
 °            Raise 10 to the power of each element
  `           Push each element to the stack
   <          Decrement the topmost element
    Ÿ         Inclusive range
              For 13, this creates an array like [10 11 12 13 14 .. 98 99]
     ʒ.L}     Only keep elements with a levenshtein distance to the input of
              exactly one
         p    Check each element for primality
          O   Sum

在线尝试！或最多100个。

Python 2中，146个136 127 121 118字节

感谢@ Mr.Xcoder的建议

lambda I:sum(all(i%v for v in range(2,i))*sum(z!=x for z,x in zip(I,`i`))==1for i in range(1+10**~-len(I),10**len(I)))

说明：

生成长度等于输入长度的数字，首先跳过（1,10,100,1000，...）

for i in range(1+10**~-len(I),10**len(I))

检查生成的数字与输入的数字仅相差一位

sum(z!=x for z,x in zip(I,`i`))==1

检查素数

all(i%v for v in range(2,i))

计数

sum(...)    

在线尝试！

Javascript（ES6）148个字节

将输入作为字符串并作为数字返回

n=>(n.replace(/./g,"$`a$' ").split` `.map(s=>s&&[..."0123456789"].map(d=>r+=+(t=s.replace(/a/,d))[0]&&t^n&&(p=v=>t>1&(--v<2||t%v&&p(v)))(t)),r=0),r)

示例代码段：

f=
n=>(n.replace(/./g,"$`a$' ").split` `.map(s=>s&&[..."0123456789"].map(d=>r+=+(t=s.replace(/a/,d))[0]&&t^n&&(p=v=>t>1&(--v<2||t%v&&p(v)))(t)),r=0),r)

for(var k=1;k<=20;k++)
  o.innerText+=f(""+k)+" "

<pre id=o></pre>

果冻，21 18 15字节

3字节感谢丹尼斯。

æḟ⁵æR×⁵$DnDS€ċ1

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

Mathematica，105个字节

F=Count[Range[f=IntegerDigits;g=10^Length@f@#/10,10g],n_/;PrimeQ@n&&MatchQ[f@n-f@#,{x=0...,_,x}]&&n!=#]&;

在线尝试！

Function期望一个正整数#。设置f等于IntegerDigits返回其输入数字列表的函数。我们把Range从g到10g（含），其中g=10^Length@f@#/10是最大功率10小于或等于输入#，然后Count将n这样PrimeQ@n&&MatchQ[f@n-f@#,{x=0...,_,x}]&&n!=#。PrimeQ@n检查是否n为质数，MatchQ[f@n-f@#,{x=0...,_,x}]检查n和的数字列表之间的差异是否#为形式{0..., _, 0...}，并n!=#确保n和#为Unequal。

的JavaScript（ES6），153个 142 139字节

n=>([...n].map((c,i,[...a])=>[...''+1e9].map((u,j)=>s+=j+i&&j!=c?p((a.splice(i,1,j),a.join``)):0),s=0,p=q=>eval('for(k=q;q%--k;);k==1')),s)

接受输入为字符串。无效输入的不确定行为，尽管它应该在我能想到的任何字符串上终止而没有错误。虽然不一定在宇宙热死之前，特别是对于长弦。

演示版

f=
n=>([...n].map((c,i,[...a])=>[...''+1e9].map((u,j)=>s+=j+i&&j!=c?p((a.splice(i,1,j),a.join``)):0),s=0,p=q=>eval('for(k=q;q%--k;);k==1')),s)
console.log([...''+1e19].map((_,i)=>f(i+1+'')).join())
i.onchange=()=>console.log(f(i.value))

<input id=i>

改进措施

通过将reduce()调用重构为map()调用，并通过a在函数参数中而不是在splice()调用上下文中隐式复制数组，可以节省11个字节。

由于@Neil的建议将其转换[...Array(10)]为，因此节省了3个字节[...''+1e9]。

未缩小的代码

input => (
  [...input].map(
    (char, decimal, [...charArray]) =>
      [...'' + 1e9].map(
        (unused, digit) => sum +=
          digit + decimal && digit != char ?
            prime(
              (
                charArray.splice(decimal, 1, digit)
                , charArray.join``
              )
            ) :
            0
      )
    , sum = 0
    , prime = test => eval('for(factor = test; test % --factor;); factor == 1')
  )
  , sum
)

说明

该函数使用两级map()求和来对通过素数检验的排列数量求和，该数是从此答案中借用和修改的。

_{（原始答案）}

reduce((accumulator, currentValue, currentIndex, array) => aggregate, initialValue)

因此，例如，计算一个数组的总和，你会通过一个initialValue中0，并返回一个aggregate等于accumulator + currentValue。稍微修改此方法，我们改为计算通过素数测试的排列数：

reduce(
  (passedSoFar, currentDecimal, currentIndex, digitArray) =>
    isValidPermutation() ?
      passedSoFar + prime(getPermutation()) :
      passedSoFar
  , 0
)

那本质上是内部的reduce()，digitArray通过将每个改变decimal为一个具体的来迭代的所有排列permutatedDigit。然后，我们需要一个外部reduce()变量来迭代所有可能permutatedDigit的变量，以替换每个变量decimal，这就是0-9。

实施中的异常

[...''+1e9].map((u,j)=>...是最短的路@Neil可以争论想到的迭代0通过9。最好使用进行操作u，但u在这种情况下，对数组中的每个元素都没有用。

i+j0根据挑战说明，检查三元条件以确保不是前导数字的可能排列。j!=c确保原件n不是通过素数测试的候选人。

(a.splice(i,1,j),a.join``)有点混乱。splice()替换位在decimal == i与permutatedDigit == j，但因为splice()返回的移除的元件（在这种情况下，将等于[a[i]]），而不是修改后的数组，就必须使用逗号运算符通过修改后的数组a的素性测试，而不是之前join()荷兰国际集团它变成一个数字字符串。

最后，eval()就是要保存一个字节，因为与更规范的方法相比，它更短：

q=>eval('for(k=q;q%--k;);k==1')

q=>{for(k=q;q%--k;);return k==1}

初始测试的引用p在map()调用的未使用参数中初始化。

Python 2，134字节

lambda x,r=range,l=len:sum(~-f*(~-l(x)==sum(`f`[t]==x[t]for t in r(l(x))))and all(f%v for v in r(2,f))for f in r(10**~-l(x),10**l(x)))

在线尝试！

更优雅，更长的版本：

lambda x,r=range,l=len:l(filter(lambda f:(~-f*(~-l(x)==sum(`f`[t]==x[t]for t in r(l(x)))))*all(f%v for v in r(2,f)),r(10**~-l(x),10**l(x))))

输入被视为字符串。

说明（旧版本）

• lambda x,r=range,l=len:-用一个String参数x和两个常量参数r=range和定义一个lambda l=len。

• sum(1...)-获取长度，节省1个字节len([...])。

• for f in r(10**~-l(x),10**l(x))-绝对生成所有数量与输入相同数量级的数字（期望0）。例如，输入3会导致[1, 2, 3, 4, 5, 6, 7, 8, 9]。

• sum(1for t in r(l(x))if`f`[t]==x[t])==~-l(x)and f>1 -检查当前数字是否与输入数字正好相距1位数，并且大于1。

• all(f%v for v in r(2,f)) -检查当前数字是否为素数。

JavaScript（ES6），137个字节

i=(a=prompt()).length;s=0;while(i--)for(j=0;j<=9;j++){(b=[...a]).splice(i,1,j);k=b=b.join('');while(b%--k);s+=i+j&&a[i]!=j&&k==1}alert(s)

使用Web API方法和将我的其他答案调整为完整程序提交。prompt()alert()

Bean，126字节

00000000: a64d a065 8050 80a0 5d20 8001 a64d a06f  ¦M e.P. ] ..¦M o
00000010: 8025 39b5 cb81 2065 27a6 4da0 6680 2581  .%9µË. e'¦M f.%.
00000020: 0035 cb81 2066 27a6 53d0 80cd a05e 8043  .5Ë. f'¦SÐ.Í ^.C
00000030: cf20 5d00 2080 82a0 65a5 3a20 66a6 4da0  Ï ]. .. e¥: f¦M 
00000040: 6780 4da0 5e80 53d0 80a0 5e20 807b 2300  g.M ^.SÐ. ^ .{#.
00000050: b5cc a05e 8f4b c120 6728 264d a06f 814e  µÌ ^.KÁ g(&M o.N
00000060: cecc a065 8b20 6681 4cd0 84a0 5d20 6581  ÎÌ e. f.LÐ. ] e.
00000070: 2066 814c a067 8025 3a26 206f b130        f.L g.%:& o±0

在线尝试！

我的全程序JavaScript提交的改编版。

等效的JavaScript

i=a.length
s=0
while(i--){
  j=10
  while(j--){
    (b=[...a]).splice(i,1,j)
    k=b=b.join('')
    while(b%--k);
    s+=i+j&&a[i]!=j&&k==1
  }
}
s

说明

a被隐式初始化为输入的第一行（字符串），最后一条语句s被隐式输出，其中包含素数置换之和。

外壳，32字节

Lof§&ȯ=1Σzo±≠d⁰o=Ld⁰L↑o≤Ld⁰Lmdİp

在线尝试！

取消高尔夫/解释

                              İp  -- get all primes
                            md    -- and convert them to list of digits
                     ↑o≤   L      -- take as long as the lenghth of these digit lists are ≤ ..
                        Ld⁰       -- .. the number of digits of input 
 of                               -- from those primes filter:
               o=Ld⁰L             --   same number of digits as input
   §&                             --   and
        Σz                        --   the number of..
          o±≠d⁰                   --   .. digits that differ from input digits ..
     ȯ=1                          --   .. must be one
L                                 -- finally count them

Japt，28 23字节

-5个字节，感谢@ETHproductions。

¬x@AÇ|Y©+UhYZsÃâ kUn)èj

将字符串作为输入。

在线尝试！

PHP，151 147 141 140 136 134 129 128字节

-6个字节，感谢@Einacio; -1字节感谢@Titus

<?php for($i=$m=10**strlen($n=$argv[1]);$i-->$m/10;)if(levenshtein($n,$i)==$f=$t=1){while($t<$i)$f+=$i%$t++<1;$c+=$f==2;}echo$c;

在线尝试！

格式化，并带有注释：

<?php
// Work through each integer with the same number of digits as the input $argv[1].
for ($i = $m = 10 ** strlen($n = $argv[1]); $i-- > $m / 10;)
    // Is it exactly one digit different from the input?
    if (levenshtein($n, $i) == $f = $t = 1) {
        // Count its factors.
        while ($t < $i) $f += $i % $t++ < 1;
        // If there are exactly 2 factors then it's a prime, so increment the counter.
        $c += $f == 2;
    }
// Print the final count.
echo $c;

为了使它尽可能的短，我已经：

• 组合作业$f = $t = 1;
• 监听一个++增量作为另一个表达式的一部分$f += $i % $t++ == 0（该增量是在模运算之后执行的，因此不会影响其结果）；
• 而不是使用if条件增量语句，而是利用了一个事实，即使用$c += $f == 2;而不是将布尔值true转换为1时为true if ($f == 2) $c++;。

Perl 6、83个字节

{+grep &is-prime,m:ex/^(.*)(.)(.*)$/.map:{|map
.[0]~*~.[2],grep *-.[1],?.[0]..9}}

在线尝试！

PHP，100 + 1字节

for(;~($a=$argn)[$i];$i++)for($d=-!!$i;$d++<9;$c+=$k==1)for($a[$i]=$d,$k=$a;--$k&&$a%$k;);echo$c-$i;

与管道一起运行 -nR或在线尝试。

分解

for(;~($n=$argn)[$i];$i++)  # loop through argument digits, restore $n in every iteration
    for($d=-!!$i;               # loop $d from 0 (1 for first digit)
        $d++<9;                 # ... to 9
        $c+=$k==1                   # 3. if divisor is 1, increment counter
    )
        for($n[$i]=$d,              # 1. replace digit
            $k=$n;--$k&&$n%$k;      # 2. find largest divisor of $n smaller than $n
        );
echo$c-$i;                  # print counter - length

Java 8，201 194字节

n->{String s=n+"";int r=0,i=0,j,k,t,u,l=s.length();for(;i<l;i++)for(j=0;++j<10;r+=n==u|t<2?0:1)for(u=t=new Integer(s.substring(0,i)+j+(i<l?s.substring(i+1):"")),k=2;k<t;t=t%k++<1?0:t);return r;}

说明：

在这里尝试。

n->{                        // Method with integer as parameter and return-type
  String s=n+"";            //  String representation of the input-int
  int r=0,                  //  Result-integer
      i=0,j,k,              //  Index-integers
      t,u,                  //  Temp integers
      l=s.length();         //  Length of the String
  for(;i<l;i++)             //  Loop (1) from 0 to `l` (exclusive)
    for(j=0;++j<10;         //   Inner loop (2) from 1 to 10 (exclusive)
        r+=                 //     And after every iteration, raise the result by:
           n==u             //      If the current number equals the input
           |t<2?            //      or it is not a prime:
            0               //       Add nothing to the result-counter
           :                //      Else:
            1)              //       Raise the result-counter by one
      for(                  //    Inner loop (3)
          u=t=              //     First set both `u` and `t` to:
              new Integer(  //      Convert the following String to an integer: 
               s.substring(0,i)
                            //       Get the substring from 0 to `i` (exclusive)
               +j           //       + `j`
               +(i<l?       //       + If `i` is smaller than the String-length:
                  s.substring(i+1)
                            //          The substring from 0 to `i` (inclusive)
                 :          //         Else:
                  "")),     //          Nothing
          k=2;              //     And start `k` at 2
              k<t;          //     Continue looping as long as `k` is smaller than `t`
        t=t%k++<1?          //     If `t` is divisible by `k`:
           0                //      Change `t` to 0
          :                 //     Else:
           t                //      Leave `t` as is
      );                    //    End of inner loop (3)
                            //    (`t` remained the same after loop 3? -> It's a prime)
                            //   End of inner loop (2) (implicit / single-line body)
                            //  And of loop (1) (implicit / single-line body)
  return r;                 //  Return the result-counter
}                           // End of method

new Integer(s.substring(0,i)+j+(i<l?s.substring(i+1):"") 将导致这些整数：

为0-9：1, 2, 3, 4, 5, 6, 7, 8, 9。
为10：10, 20, 30, 40, 50, 60, 70, 80, 90, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19。
为11：11, 21, 31, 41, 51, 61, 71, 81, 91, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19。
等等

JavaScript（ES7），118个字节

将输入作为字符串。

n=>[...2**29+'4'].map(d=>n.replace(/./g,c=>s+=d+i>0&(P=k=>N%--k?P(k):N-n&&k==1)(N=p+d+n.slice(++i),p+=c),i=p=0),s=0)|s

在线尝试！

已评论

n =>                        // n = input number (as a string)
  [...2**29 + '4']          // generate "5368709124" (all decimal digits)
  .map(d =>                 // for each digit d in the above string:
    n.replace(/./g, c =>    //   for each digit c in n:
      s +=                  //     increment s if the following code yields 1:
        d + i > 0 & (       //       if this is not the first digit of n or d is not "0":
          P = k =>          //         P = recursive function taking k and using N:
            N % --k ?       //           decrement k; if k is not a divisor of N:
              P(k)          //             do recursive calls until it is
            :               //           else:
              N - n &&      //             return true if N is not equal to n
              k == 1        //             and k is equal to 1 (i.e. N is prime)
          )(                //         initial call to P ...
            N =             //           ... with N defined as:
              p +           //             the current prefix p
              d +           //             followed by d
              n.slice(++i), //             followed by the trailing digits
                            //             (and increment the pointer i)
            p += c          //           append c to p
          ),                //         end of initial call
          i = p = 0         //         start with i = p = 0
    ),                      //   end of replace()
    s = 0                   //   start with s = 0
  ) | s                     // end of map(); return s

红宝石用-rprime，101个字节

-rprime$10^{floor(log_{10} n)+1}$$n$

->n{d=n.digits;Prime.each(10**l=d.size).count{|x|d.zip(e=x.digits).count{|a,b|a==b}==l-1&&e.size==l}}

在线尝试！