Wyzwanie

Biorąc pod uwagę liczbę całkowitą wejściową n > 0, wypisz liczbę liczb pierwszych ( innych niż n, jeśli nsama jest liczbą pierwszą), które można wytworzyć, zmieniając jedną cyfrę w rozwinięciu dziesiętnym n (bez zmiany liczby cyfr).

Przykłady

Na przykład n = 2. Zmieniając jedną cyfrę w rozwinięciu dziesiętnym 2, możemy uzyskać trzy dodatkowe liczby pierwsze 3, 5, 7, więc a(n) = 3.

Na innym przykładzie n = 13. Zmieniając jedną cyfrę, można uzyskać liczby pierwsze 11, 17, 19, 23, 43, 53, 73, 83, więc a(13) = 8.

Dla końcowego np n = 20. Zmieniając jedną cyfrę, można uzyskać liczby pierwsze 23, 29, więc a(20) = 2.

Sekwencja

Oto pierwsze 20 warunków na początek. To jest OEIS A048853 .

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

Zasady

• Można założyć, że dane wejściowe i wyjściowe pasują do natywnego typu liczb całkowitych twojego języka.
• Dane wejściowe i wyjściowe można podawać w dowolnym dogodnym formacie .
• Zignoruj ​​wiodące zera (na przykład 03nie jest liczbą pierwszą w tym sformułowaniu).
• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Jeśli to możliwe, dołącz link do internetowego środowiska testowego, aby inni mogli wypróbować Twój kod!
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

05AB1E , 17 16 14 11 bajtów

ā°`<Ÿʒ.L}pO

Wyjaśnienie:

ā             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

Wypróbuj online! lub do 100 .

Python 2 , 146 136 127 121 118 bajtów

Dzięki @ Mr.Xcoder za sugestie

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

Wyjaśnienie:

Generuj liczby o długości równej długości wejściowej, najpierw pomijając (1,10,100,1000, ...)

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

Sprawdź, czy wygenerowana liczba różni się od danych wejściowych tylko jedną cyfrą

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

Sprawdź liczbę pierwszą

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

Liczyć

sum(...)    

Wypróbuj online!

JavaScript (ES6) 148 bajtów

Pobiera dane wejściowe jako ciąg znaków i zwraca jako liczbę

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)

Przykładowy fragment kodu:

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>

Galaretka , 21 18 15 bajtów

3 bajty dzięki Dennisowi.

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

Wypróbuj online! lub Zweryfikuj wszystkie przypadki testowe .

Mathematica, 105 bajtów

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

Wypróbuj online!

Functionktóra oczekuje dodatniej liczby całkowitej #. Ustawia wartość frówną funkcji, IntegerDigitsktóra zwraca listę cyfr jej wejścia. Bierzemy Rangeod gdo 10g(włącznie), gdzie g=10^Length@f@#/10jest największa moc 10mniejsza lub równa do wejścia #, a następnie takie, że . sprawdza, czy jest liczbą pierwszą, sprawdza, czy różnica między listą cyfr i ma postać , oraz zapewnia, że i są .CountnPrimeQ@n&&MatchQ[f@n-f@#,{x=0...,_,x}]&&n!=#PrimeQ@nnMatchQ[f@n-f@#,{x=0...,_,x}]n#{0..., _, 0...}n!=#n#Unequal

JavaScript (ES6), 153 142 139 bajtów

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)

Akceptuje dane wejściowe jako ciąg. Niezdefiniowane zachowanie dla niepoprawnych danych wejściowych, chociaż powinno zakończyć się bezbłędnie na dowolnym łańcuchu, jaki mogę wymyślić. Jednak niekoniecznie przed śmiercią we wszechświecie, szczególnie w przypadku długich łańcuchów.

Próbny

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>

Ulepszenia

Zaoszczędzono 11 bajtów, refaktoryzując reduce()wywołania na map()wywołania i niejawnie kopiując tablicę aw parametrze funkcji, zamiast w kontekście splice()wywołania.

Zapisany 3 bajty dzięki @Neil sugestia „s przekonwertować [...Array(10)]do [...''+1e9].

Kod nieuprawniony

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
)

Wyjaśnienie

Funkcja używa dwupoziomowego map()do zsumowania liczby permutacji, które przejdą test pierwotności, który został pożyczony i zmodyfikowany na podstawie tej odpowiedzi .

_{(Oryginalna odpowiedź)}

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

Tak na przykład, aby obliczyć sumę tablicy, należy zdać initialValuez 0, i zwróci aggregaterówna accumulator + currentValue. Nieznacznie modyfikując to podejście, zamiast tego obliczamy liczbę permutacji, które przejdą test pierwotności:

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

Jest to zasadniczo wewnętrzna reduce(), która iteruje wszystkie permutacje digitArray, zmieniając każdą decimalz nich na określoną permutatedDigit. Następnie potrzebujemy zewnętrznego, reduce()aby iterować wszystkie możliwe elementy permutatedDigit, które można zastąpić decimal, co jest słuszne 0-9.

Nieprawidłowości we wdrażaniu

[...''+1e9].map((u,j)=>...była najkrótsza droga @Neil mógł wymyślić iteracyjne argument 0za 9. Byłoby to wskazane u, ale uw tym przypadku nie jest przydatne dla każdego elementu w tablicy.

i+jw warunkach trójskładnikowych sprawdza, 0czy nie jest możliwa permutacja cyfry wiodącej, zgodnie ze specyfikacją wyzwania. j!=czapewnia, że ​​oryginał nnie jest kandydatem do przejścia testu pierwotności.

(a.splice(i,1,j),a.join``)jest trochę bałaganu. splice()zamienia cyfrę at decimal == ina permutatedDigit == j, ale ponieważ splice()zwraca usunięte elementy (w tym przypadku byłyby równe [a[i]]) zamiast zmodyfikowanej tablicy, musimy użyć operatora przecinka, aby przekazać zmodyfikowaną tablicę ado testu pierwotności, ale nie przed join()jej wprowadzeniem na ciąg liczbowy.

Na koniec eval()należy zapisać bajt, ponieważ w porównaniu z podejściem bardziej kanonicznym jest krótszy:

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

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

Odwołanie do testu podstawowego pjest inicjowane nieużywanym argumentem map()wywołania.

Python 2 , 134 bajty

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

Wypróbuj online!

Bardziej elegancka, dłuższa wersja:

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

Dane wejściowe są traktowane jako ciąg.

Objaśnienie (starsza wersja)

• lambda x,r=range,l=len:- Definiuje lambda z parametrem String xi dwoma stałymi parametrami r=rangeoraz l=len.

• sum(1...)- Uzyskaj długość, która pozwala zaoszczędzić 1 bajt len([...]).

• for f in r(10**~-l(x),10**l(x))- Generuje absolutnie wszystkie liczby o tym samym rzędzie wielkości co dane wejściowe (oczekiwane dla 0). Na przykład wpisanie 3spowoduje, że [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 - Sprawdza, czy bieżąca liczba jest dokładnie o 1 cyfrę od wejścia i czy jest większa niż 1.

• all(f%v for v in r(2,f)) - Sprawdza, czy bieżąca liczba jest liczbą pierwszą.

JavaScript (ES6), 137 bajtów

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)

Dostosowuje moją drugą odpowiedź do przesłania pełnego programu przy użyciu metod interfejsu API sieci Web prompt()i alert().

Fasola , 126 bajtów

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

Wypróbuj online!

Dostosowanie mojego pełnego kodu JavaScript .

Odpowiednik 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

Wyjaśnienie

ajest domyślnie inicjowany jako pierwszy wiersz danych wejściowych jako ciąg, a ostatnia instrukcja sjest niejawnie wyprowadzana, która zawiera sumę pierwszych permutacji.

Łuska , 32 bajty

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

Wypróbuj online!

Niegolfowane / Wyjaśnienie

                              İ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 bajtów

-5 bajtów dzięki @ETHproductions.

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

Pobiera ciąg jako dane wejściowe.

Wypróbuj online!

PHP , 151 147 141 140 136 134 129 128 bajtów

-6 bajtów dzięki @Einacio; -1 bajt dzięki @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;

Wypróbuj online!

Sformatowane, z komentarzami:

<?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;

Aby było tak krótkie, jak tylko mogłem,:

• połączone zadania $f = $t = 1;
• snook ++inkrement jako część innego wyrażenia $f += $i % $t++ == 0(przyrost jest wykonywany po operacji modułu, a więc nie wpływa na jego wynik);
• i zamiast używać ifinstrukcji dla przyrostu warunkowego, wykorzystano fakt, że wartość logiczna true, gdy rzutuje się na liczbę całkowitą, staje się 1, używając $c += $f == 2;raczej niż if ($f == 2) $c++;.

Perl 6 , 83 bajtów

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

Wypróbuj online!

PHP, 100 + 1 bajtów

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;

Uruchom jako potok z -nRlub spróbuj online .

awaria

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 bajtów

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

Wyjaśnienie:

Wypróbuj tutaj.

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):"") spowoduje, że te liczby całkowite:

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

JavaScript (ES7), 118 bajtów

Pobiera dane wejściowe jako ciąg.

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

Wypróbuj online!

Skomentował

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

Ruby z-rprime , 101 bajtów

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

Wypróbuj online!