I numeri pari possono diventare primi?

24

La sequenza

Tutti sanno che l'unico numero primo pari è 2. Ho-hum. Ma ci sono alcuni numeri pari in ncui, quando concatenati n-1, diventano un numero primo.

Per cominciare, 1non è nell'elenco, perché 10non è primo. Allo stesso modo con 2( 21) e 3( 32). Tuttavia, 4funziona perché 43è primo, quindi è il primo numero nella sequenza a(1) = 4. Il prossimo numero che funziona (né 6( 65) né 8( 87) funziona) è 10, perché 109è primo, quindi a(2) = 10. Quindi saltiamo un altro po 'fino a quando 22, perché 2221è primo, così a(3) = 22. E così via.

Ovviamente tutti i termini in questa sequenza sono pari, perché qualsiasi numero dispari nquando concatenato n-1diventa pari (come 3si trasforma in 32), che non sarà mai primo.

Questa è la sequenza A054211 su OEIS.

La sfida

Dato un numero di input nche si inserisce da qualche parte in questa sequenza (cioè, nconcatenato con n-1è primo), emette la sua posizione in questa sequenza. Puoi scegliere 0 o 1 indicizzato, ma per favore specifica quale nel tuo invio.

Regole

  • Si può presumere 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 .
  • È 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!
  • Sono vietate le scappatoie standard .
  • Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

Gli esempi seguenti sono 1 indicizzati.

n = 4
1

n = 100
11

n = 420
51
code-golf  sequence  arithmetic  primes 
— AdmBorkBork
fonte
1
Perché devi farlo al contrario? cQuents non ha questa modalità :(
— Stephen,
4
@StepHen Solo per un cambio di passo; qualcosa di diverso dal solito.
— AdmBorkBork,
9
Penso che questo sarebbe molto meglio come problema decisionale.
— Wheat Wizard
4
Non solo 2 è l'unico numero primo divisibile per 2, 3 è anche l'unico numero primo divisibile per 3 e 5 è l'unico numero primo divisibile per 5. In generale, un numero primo nè sempre l'unico numero primo divisibile per n. Non è speciale: è così che funzionano i numeri primi.
— Esolanging Fruit

Risposte:

11

Gelatina ,  8  7 byte

ḊżṖVÆPS

Un collegamento monadico che prende un membro della sequenza e restituisce il suo indice nella sequenza.

Provalo online!

Come?

ḊżṖ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
— Jonathan Allan
fonte
TIO non è giù per me, forse è appena tornato su?
— Conor O'Brien,
1
Risolto 2 minuti fa :)
— Jonathan Allan il
Bellissimo! Questo zip(head(), pop())trucco è davvero fantastico. :)
— DJMcMayhem
In quale codifica sono 7 byte?
— kylefinn,
1
@kylefinn Jelly ha una sua tabella codici, fai clic sul link byte nell'intestazione per vederlo.
— Jonathan Allan,
8

Haskell , 80 75 70 byte

5 byte risparmiati grazie a Laikoni

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

Provalo online!

— Mago del grano
fonte
1
Penso che tu possa usare il primo test più breve p x=all((>0).mod x)[2..x-1]che fallisce per 1, ma questo non dovrebbe importare in questo caso.
— Laikoni,
1
Inoltre show x++show(x-1)può essere abbreviato in show=<<[x,x-1].
— Laikoni,
@Laikoni Grazie per i suggerimenti! Ho pensato che showpotesse essere fatto con un metodo più breve, ma per qualche motivo non ho pensato a una mappa concat.
— Wheat Wizard
6

Gelatina , 12, 10 , 8 byte

;’VÆPµ€S

Provalo online!

1-2 byte salvati grazie a @nmjmcman101 e 2 byte salvati grazie a @Dennis!

Spiegazione:

     µ€   # 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
— DJMcMayhem
fonte
Puoi semplicemente rilasciare la R e usare l'intervallo implicito?
— nmjcman101,
@ nmjcman101 Non sapevo assolutamente che fosse una cosa. Grazie!
— DJMcMayhem
5

05AB1E , 9 8 7 byte

Codice

ƒNN<«pO

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione

ƒ          # 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)
— Adnan
fonte
Naturalmente questo sfrutta il fatto che 05AB1E ignora gli errori ... perché non penso che tu possa verificare se '0-1'è primo.
— Erik the Outgolfer,
5

Buccia , 13 11 10 byte

1soluzione indicizzata:

#ȯṗdS¤+d←ḣ

Provalo online!

Ungolfed / Spiegazione

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

Grazie @Zgarb per i -3byte!

— ბიმო
fonte
1
£İpè equivalente a ṗ. Inoltre, è possibile salvare un byte con #…ḣanziché £f…N.
— Zgarb,
4

Pyth , 12 byte

smP_s+`d`tdS

Provalo online! oppure Verifica tutti i casi di test.

Come?

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.
— Mr. Xcoder
fonte
4

Japt , 15 14 12 11 9 8 byte

1-indicizzati.

ÇsiZÄÃèj

Provalo

Ç            :Map each Z in the range [0,input)
 s           :  Convert to string
  i          :    Prepend
   ZÄ        :    Z+1
     Ã       :End map
      è      :Count
       j     :  Primes
— ispido
fonte
1
— Oliver
Gah! Perché ho un tale punto cieco per Æe Ç?! Grazie, @Oliver; Aggiornerò quando torno a un computer.
— Shaggy
2o+X(con spazio finale) avrebbe funzionato al posto di [XXÉ], sebbene se dovessi mai aggirare le []parentesi di bilanciamento automatico la tua soluzione sarà un byte più breve. (In realtà 2, dato che allora potresti farlo õ_ZÉ]¬nÃèj)
— ETHproductions
@ETHproductions: al giorno d'oggi, la prima cosa che faccio quando lavoro con un array è verificare se è stato aggiunto il bilanciamento automatico []! : D
— Shaggy
Per qualche ragione penso che anche i punti e virgola abbiano smesso di funzionare, quindi proverò a risolverlo. Non pensare che avrò una possibilità fino a domani pomeriggio però.
— ETHproductions
3

Röda , 73 byte

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

Provalo online!

1-indicizzati. Utilizza lo stream per eseguire input e output.

Spiegazione:

{
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 */
}
— fergusq
fonte
2

Pyth , 14 byte

lfP_Tms+`d`tdS

Provalo online!

Spiegazione

              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
— Jim
fonte
Mi hai battuto di qualche secondo, ti ho battuto di pochi byte: P
— Mr. Xcoder
@ Mr.Xcoder La mia prima versione è stata lfTmP_s+`d`tdS, è un peccato che non abbia trovato il tuo trucco da solo in quel momento :)
— Jim
2

Perl 6 , 45 byte

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

Provalo online!

Il grepproduce la sequenza di numeri qualificanti, quindi cerchiamo la chiave ( :k) (cioè l'indice) del firstnumero nell'elenco che equivale al parametro di input $_.

— Sean
fonte
— Jo King
2

C, 99 94 byte

1 indicizzato. Mi fa male scrivere test di primalità che sono così dispendiosi dal punto di vista computazionale, ma dopo tutto i byte sono byte.

Se permettiamo alcune cose veramente fragili, compilando sulla mia macchina senza ottimizzazioni con GCC 7.1.1 funzionano i seguenti 94 byte (grazie @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;}

altrimenti questi 99 byte molto più robusti fanno il lavoro

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

Programma completo, un po 'più leggibile:

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;
}
— algmyr
fonte
A seconda del compilatore, potresti essere in grado di salvare alcuni byte utilizzando n=c;invece di 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;);}n=c;}
— Conor O'Brien
Non posso dire di voler usare cose che sembrano anche variare con i livelli di ottimizzazione. Utilizzando GCC, senza ottimizzazione -O0 funziona, con altri flag di ottimizzazione non funziona. È interessante notare che -O1 -O2 e -O3 restituiscono 0, con -Os restituisce 1, con -Og restituisce n-1.
— algmyr,
È sempre possibile specificare nella risposta come compilare il programma.
— Conor O'Brien,
Immagino sia un po 'economico. Ma posso aggiungere un'alternativa.
— algmyr,
Capisco, ma non mi dispiacerebbe farlo - è uno dei consigli per giocare a golf in C
— Conor O'Brien,
2

JavaScript (ES6),  49 48  47 byte

1-indicizzati. Limitato dalle dimensioni dello stack di chiamate del tuo motore.

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

Provalo online!

— Arnauld
fonte
1

Mathematica, 77 byte

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

QBIC , 25 byte

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

Spiegazione

[:|     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.

Questo utilizza alcune cose matematiche piuttosto coinvolte con un cast-to-string schiaffeggiato per una buona misura. Creare un cappello versione esegue solo la concatenazione basata su stringhe è più lunga di un byte:

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

PHP , 203 byte

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

Provalo online!

Utilizza un indice basato su 1 per l'output. Il collegamento TIO ha la versione leggibile del codice.

— Mic1780
fonte
0

Rubino , 42 + 9 = 51 byte

Usa il -rprime -n bandiere. 1-indicizzati.

Funziona contando tutti i numeri uguali o inferiori all'input che soddisfa la condizione (o più tecnicamente, tutti i numeri che soddisfano la n-1condizione). Dal momento che l'ingresso è garantito per essere nella sequenza, non c'è rischio di errore da un input casuale come 7quello che non "diventa primo".

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

Provalo online!

— Value Ink
fonte
0

Java 8, 108 byte

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

Spiegazione:

Provalo online.

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
— Kevin Cruijssen
fonte
0

Stax , 10 byte

1- indicizzato

Äm▬á┌╕|°φ♦

Eseguire ed eseguire il debug Spiegazione

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)
— Multi
fonte
0

Ordinato , 33 byte

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

Provalo online!

Spiegazione

L'idea di base è creare una sequenza di numeri validi, quindi restituire una funzione di indice al curry.

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
— Conor O'Brien
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.