La secuencia

Todos saben que el único número primo par es 2. Ho-hum Pero, hay ciertos números pares ndonde, cuando se concatenan n-1, se convierten en un número primo.

Para empezar, 1no está en la lista, porque 10no es primo. De manera similar con 2( 21) y 3( 32). Sin embargo, 4funciona porque 43es primo, por lo que es el primer número de la secuencia a(1) = 4. El siguiente número que funciona (ni 6( 65) ni 8( 87) funciona) es 10, porque 109es primo, entonces a(2) = 10. Luego nos saltamos un montón más hasta que 22, porque 2221es primo, entonces a(3) = 22. Y así.

Obviamente todos los términos en esta secuencia son pares, porque cualquier número impar ncuando se concatena con se n-1convierte en par (como se 3convierte en 32), lo que nunca será primo.

Esta es la secuencia A054211 en OEIS.

El reto

Dado un número de entrada nque encaja en algún lugar de esta secuencia (es decir, nconcatenado con n-1es primo), genera su posición en esta secuencia. Puede elegir entre 0 o 1 indexado, pero indique cuál en su envío.

Reglas

• Se puede suponer que la entrada y la salida encajan en el tipo entero nativo de su idioma.
• La entrada y la salida se pueden dar en cualquier formato conveniente .
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

Los siguientes ejemplos están indexados en 1.

n = 4
1

n = 100
11

n = 420
51

Jalea ,  8  7 bytes

ḊżṖVÆPS

Un enlace monádico que toma un miembro de secuencia y devuelve su índice en la secuencia.

Pruébalo en línea!

¿Cómo?

ḊżṖ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

Haskell , 80 75 70 bytes

5 bytes de ahorro gracias a Laikoni

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

Pruébalo en línea!

Gelatina , 12, 10 , 8 bytes

;’VÆPµ€S

Pruébalo en línea!

¡1-2 bytes guardados gracias a @ nmjmcman101, y 2 bytes guardados gracias a @Dennis!

Explicación:

     µ€   # 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 

05AB1E , 9 8 7 bytes

Código

ƒNN<«pO

Utiliza la codificación 05AB1E .Pruébalo en línea!

Explicación

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

Casco , 13 11 10 bytes

1solución indexada:

#ȯṗdS¤+d←ḣ

Pruébalo en línea!

Ungolfed / Explicación

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

Gracias @ Zgarb por -3bytes!

Python 2 , 87 bytes

-2 bytes gracias a @officialaimm . 1 indexado.

lambda n:sum(all(z%v for v in range(2,z))for i in range(4,n+1)for z in[int(`i`+`i-1`)])

Banco de pruebas.

Pyth , 12 bytes

smP_s+`d`tdS

Pruébalo en línea! o Verifique todos los casos de prueba.

¿Cómo?

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.

Japt , 15 14 12 11 9 8 bytes

1 indexado.

ÇsiZÄÃèj

Intentalo

Ç            :Map each Z in the range [0,input)
 s           :  Convert to string
  i          :    Prepend
   ZÄ        :    Z+1
     Ã       :End map
      è      :Count
       j     :  Primes

Röda , 73 bytes

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

Pruébalo en línea!

1 indexado. Utiliza la secuencia para hacer entrada y salida.

Explicación:

{
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 */
}

Pyth , 14 bytes

lfP_Tms+`d`tdS

Pruébalo en línea!

Explicación

              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

Perl 6 , 45 bytes

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

Pruébalo en línea!

El grepproduce la secuencia de números calificativos, luego buscamos la clave ( :k) (es decir, el índice) del firstnúmero en la lista que equivale al parámetro de entrada $_.

C, 99 94 bytes

1 indexado. Me duele escribir pruebas de primalidad que son tan inútiles desde el punto de vista computacional, pero los bytes son bytes después de todo.

Si permitimos algunas cosas realmente frágiles, compilar en mi máquina sin optimizaciones con GCC 7.1.1 los siguientes 94 bytes funcionan (gracias @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;}

de lo contrario, estos 99 bytes mucho más robustos hacen el trabajo

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

Programa completo, un poco más legible:

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

JavaScript (ES6),  49 48  47 bytes

1 indexado. Limitado por el tamaño de la pila de llamadas de su motor.

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

Pruébalo en línea!

Mathematica, 77 bytes

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

QBIC , 25 bytes

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

Explicación

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

Esto usa algo matemático bastante complicado con un molde de cuerda para una buena medida. Hacer una versión hat hace únicamente concatenación basada en cadenas es un byte más largo:

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

PHP , 203 bytes

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

Pruébalo en línea!

Utiliza un índice basado en 1 para la salida. El enlace TIO tiene la versión legible del código.

Ruby , 42 + 9 = 51 bytes

Utiliza las -rprime -nbanderas. 1 indexado.

Funciona contando todos los números iguales o inferiores a la entrada que cumple la condición (o más técnicamente, todos los números que cumplen la n-1condición). Dado que la entrada está garantizada para estar en la secuencia, no hay riesgo de error de una entrada aleatoria como 7esa que no "se convierte en primo".

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

Pruébalo en línea!

Ruby , 62 bytes

->g{(1..g).count{|r|(2...x=eval([r,r-1]*'')).none?{|w|x%w<1}}}

Pruébalo en línea!

1 indexado

Python 2 , 85 bytes

1 indexado

lambda n:sum(all(z%v for v in range(2,z))for i in range(3,n)for z in[int(`i+1`+`i`)])

Prueba

Mejora a la respuesta del Sr. Xcoder

Java 8, 108 bytes

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 indexado

Explicación:

Pruébalo en línea.

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

Stax , 10 bytes

1- indexado

Äm▬á┌╕|°φ♦

Ejecutar y depurarlo Explicación

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)

Ordenado , 33 bytes

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

Pruébalo en línea!

Explicación

La idea básica es crear una secuencia de los números válidos y luego devolver una función de índice curricular.

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