Sfida

Dato un numero intero di input n > 0, genera il numero di numeri primi ( diverso da n, ifn stesso è primo) che può essere prodotto modificando una cifra nell'espansione decimale di n (senza cambiare il numero di cifre).

Esempi

Ad esempio n = 2,. Modificando una cifra nell'espansione decimale di 2, possiamo trovare tre numeri primi aggiuntivi 3, 5, 7, quindi a(n) = 3.

Per un altro esempio n = 13,. Modificando una cifra, puoi ottenere numeri primi 11, 17, 19, 23, 43, 53, 73, 83, quindi a(13) = 8.

Ad esempio finale, n = 20. Modificando una cifra, puoi ottenere numeri primi 23, 29, quindi a(20) = 2.

Sequenza

Ecco i primi 20 termini per iniziare. Questo è OEIS A048853 .

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

Regole

• Si presume che l'input e l'output si adattino al tipo intero nativo della tua lingua.
• L'input e l'output possono essere forniti in qualsiasi formato conveniente .
• Ignora gli zeri iniziali (ad esempio, 03non è un numero primo in questa formulazione).
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Scappatoie standardSono vietate le .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

05AB1E , 17 16 14 11 byte

ā°`<Ÿʒ.L}pO

Spiegazione:

ā             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

Provalo online! o fino a 100 .

Python 2 , 146 136 127 121 118 byte

Grazie a @ Mr.Xcoder per i suggerimenti

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

Spiegazione:

Genera numeri con lunghezza uguale alla lunghezza di input, saltando prima (1,10,100,1000, ...)

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

Verificare che il numero generato differisca dall'input di una sola cifra

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

Controlla il numero primo

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

Contare

sum(...)    

Provalo online!

Javascript (ES6) 148 byte

Prende l'input come stringa e restituisce come numero

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)

Esempio di frammento di codice:

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>

Gelatina , 21 anni 18 15 byte

3 byte grazie a Dennis.

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

Provalo online! oppure Verifica tutti i test .

Mathematica, 105 byte

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

Provalo online!

Functionche prevede un numero intero positivo #. Imposta fuguale alla funzione IntegerDigitsche restituisce l'elenco delle cifre del suo input. Prendiamo il Rangeda ga 10g(compreso), dove g=10^Length@f@#/10è la più grande potenza di 10minore o uguale all'ingresso #, allora Countil nmodo che PrimeQ@n&&MatchQ[f@n-f@#,{x=0...,_,x}]&&n!=#. PrimeQ@ncontrolla se nè primo, MatchQ[f@n-f@#,{x=0...,_,x}]controlla se la differenza tra l'elenco delle cifre di ne #è del modulo {0..., _, 0...}e n!=#assicura che ne lo #sono Unequal.

JavaScript (ES6), 153 142 139 byte

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)

Accetta input come stringa. Comportamento indefinito per input non valido, anche se dovrebbe terminare senza errori su qualsiasi stringa che mi viene in mente. Tuttavia, non necessariamente prima della morte per calore dell'universo, in particolare per le corde lunghe.

dimostrazione

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>

miglioramenti

Salvato 11 byte refactoring delle reduce()chiamate in map()chiamate e copiando implicitamente l'array anel parametro della funzione, anziché all'interno del contesto della splice()chiamata.

Parati 3 byte grazie @Neil suggerimento s' per convertire [...Array(10)]a [...''+1e9].

Codice non minificato

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
)

Spiegazione

La funzione utilizza un livello map()a due per sommare la quantità di permutazioni che superano il test di primalità, che è stato preso in prestito e modificato da questa risposta .

_{(Risposta originale)}

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

Ad esempio, per calcolare la somma di un array, si passa un initialValuedi 0e si restituisce un aggregateuguale a accumulator + currentValue. Modificando leggermente questo approccio, calcoliamo invece il numero di permutazioni che superano il test di primalità:

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

Questo è essenzialmente l'interno reduce(), che itera tutte le permutazioni digitArraycambiando ognuna decimalin una specifica permutatedDigit. Abbiamo quindi bisogno di un esterno reduce()per iterare tutte le possibili permutatedDigitcon cui sostituirle decimal, il che è giusto 0-9.

Anomalie nell'attuazione

[...''+1e9].map((u,j)=>...era la via più breve @Neil potrebbe pensare di iterare un argomento 0attraverso 9. Sarebbe preferibile farlo con u, ma unon è utile per ciascun elemento dell'array, in questo caso.

i+jnei controlli delle condizioni ternarie per assicurarsi che 0non sia possibile una permutazione della cifra iniziale, come da specifica della sfida. j!=cassicura che l'originale nnon sia un candidato per passare il test di primalità.

(a.splice(i,1,j),a.join``)è un po 'un casino. splice()sostituisce la cifra decimal == icon il permutatedDigit == j, ma da allorasplice() restituisce gli elementi rimossi (in questo caso, sarebbe uguale a [a[i]]) invece dell'array modificato, dobbiamo usare l'operatore virgola per passare l'array modificato aal test di primalità, ma non primajoin() inserirlo in una stringa numerica.

Infine, eval()è quello di salvare un byte poiché, rispetto all'approccio più canonico, è più breve:

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

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

Il riferimento al test principale pviene inizializzato in un argomento non utilizzato alla map()chiamata.

Python 2 , 134 byte

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

Provalo online!

Versione più elegante e più lunga:

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

L'input è preso come una stringa.

Spiegazione (versione precedente)

• lambda x,r=range,l=len:- Definisce un lambda con un parametro String xe due parametri costanti r=rangee l=len.

• sum(1...)- Ottieni la lunghezza, che consente di risparmiare 1 byte len([...]).

• for f in r(10**~-l(x),10**l(x))- Genera assolutamente tutti i numeri con lo stesso ordine di grandezza dell'input (aspettarsi 0). Ad esempio, un input di 3, comporterebbe [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 - Verifica se il numero corrente è esattamente a 1 cifra dall'ingresso e che è maggiore di 1.

• all(f%v for v in r(2,f)) - Verifica se il numero corrente è primo.

JavaScript (ES6), 137 byte

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)

Adatta la mia altra risposta a un invio a programma completo utilizzando i metodi dell'API Web prompt()e alert().

Fagiolo , 126 byte

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

Provalo online!

Un adattamento della mia presentazione JavaScript a programma completo .

JavaScript equivalente

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

Spiegazione

aè implicitamente inizializzato come prima riga di input come stringa e l'ultima istruzione sè implicitamente output, che contiene la somma delle permutazioni prime.

Buccia , 32 byte

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

Provalo online!

Ungolfed / Spiegazione

                              İ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 byte

-5 byte grazie a @ETHproductions.

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

Accetta una stringa come input.

Provalo online!

PHP , 151 147 141 140 136 134 129 128 byte

-6 byte grazie a @Einacio; -1 byte grazie a @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;

Provalo online!

Formattato, con commenti:

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

Per farla breve, ho:

• incarichi combinati $f = $t = 1;
• snook in un ++incremento come parte di un'altra espressione $f += $i % $t++ == 0(l'incremento viene eseguito dopo l'operazione del modulo e quindi non influisce sul suo risultato);
• e anziché utilizzare ifun'istruzione per un incremento condizionale hanno utilizzato il fatto che booleano true quando cast come numero intero diventa 1, usando $c += $f == 2;anziché if ($f == 2) $c++;.

Perl 6 , 83 byte

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

Provalo online!

PHP, 100 + 1 byte

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;

Esegui come pipe -nRo provalo online .

abbattersi

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 byte

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

Spiegazione:

Provalo qui.

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):"") comporterà questi numeri interi:

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

JavaScript (ES7), 118 byte

Accetta l'input come stringa.

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

Provalo online!

Commentate

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 with-rprime 101 byte

-rprimeimporta il modulo Prime in Ruby. Ottieni tutti i numeri primi$10^{floor(log_{10} n)+1}$ e conta quante hanno lo stesso numero di cifre da $n$ e sono anche 1 cifra fuori.

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

Provalo online!