도전

입력 정수 주어 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

규칙

• 입력 및 출력은 언어의 기본 정수 유형에 맞는 것으로 가정 할 수 있습니다.
• 입력 및 출력은 편리한 형식으로 제공 될 수 있습니다 .
• 선행 0을 무시하십시오 (예 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 .

파이썬 2 , 146136127121118 바이트

제안에 대한 @ 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(...)    

온라인으로 사용해보십시오!

자바 스크립트 (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 바이트

Dennis 덕분에 3 바이트.

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

온라인으로 사용해보십시오! 또는 모든 테스트 케이스를 확인하십시오 .

수학, 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입력에 같거나보다 적은 #다음, 같은 그 . 있는지 검사 소수, 자릿수의리스트 간의 차이 여부를 확인 하고 형상이며 , 및 보장하지만 해당 하고 있다 .CountnPrimeQ@n&&MatchQ[f@n-f@#,{x=0...,_,x}]&&n!=#PrimeQ@nnMatchQ[f@n-f@#,{x=0...,_,x}]n#{0..., _, 0...}n!=#n#Unequal

자바 스크립트 (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()배열을 내재적으로 복사하여 11 바이트를 절약했습니다 .asplice()

@Neil 의 변환 제안 덕분에 3 바이트가 절약 [...Array(10)]되었습니다 [...''+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
)

설명

이 함수는 2 단계 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)=>...@Neil0 이를 통해 인수를 반복하는 것으로 생각할 수 있는 가장 짧은 방법이었습니다 9. 이 방법을 사용하는 것이 u좋지만 u이 경우 배열의 각 요소에는 유용하지 않습니다.

i+j삼항 조건 0에서 챌린지 사양에 따라 선행 숫자의 순열이 가능하지 않은지 확인합니다 . 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()호출에 사용되지 않은 인수로 초기화됩니다 .

파이썬 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:- 정의하는 문자열 매개 변수를 람다 x와 두 개의 상수 매개 변수 r=range와 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)) -현재 숫자가 소수인지 확인합니다.

자바 스크립트 (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)

적응 내 다른 대답 웹 API 방법을 사용하여 전체 프로그램의 제출로 prompt()와 alert().

빈 , 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 제출 의 적응 .

자바 스크립트

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

apt , 28 23 바이트

@ETHproductions 덕분에 -5 바이트

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

문자열을 입력으로 사용합니다.

온라인으로 사용해보십시오!

PHP , 151 147 141 140 136 134 129 128 바이트

@Einacio 덕분에 -6 바이트; @Titus 덕분에 -1 바이트

<?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;이 아닌 if ($f == 2) $c++;.

펄 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.
기타

자바 스크립트 (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

루비 와 -rprime101 바이트,

-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}}

온라인으로 사용해보십시오!