La séquence

Tout le monde sait que le seul nombre premier pair est 2. Ho-hum. Mais, il existe certains nombres pairs noù, lorsqu'ils sont concaténés avec n-1, ils deviennent un nombre premier.

Pour commencer, 1n'est pas dans la liste, car 10n'est pas premier. De même avec 2( 21) et 3( 32). Cependant, 4fonctionne parce que 43est premier, c'est donc le premier nombre de la séquence a(1) = 4. Le nombre suivant qui fonctionne (ni 6( 65) ni 8( 87) ne fonctionne) est 10, car 109est premier, donc a(2) = 10. Ensuite, nous sautons un tas de plus jusqu'à ce que 22, parce que 2221c'est premier, donc a(3) = 22. Etc.

Évidemment, tous les termes de cette séquence sont pairs, car tout nombre impair nlorsqu'il est concaténé n-1devient pair (comme 3se transforme en 32), qui ne sera jamais premier.

Il s'agit de la séquence A054211 sur OEIS.

Le défi

Étant donné un nombre d'entrée nqui s'inscrit quelque part dans cette séquence (c'est-à-dire, nconcaténé avec n-1est premier), sortez sa position dans cette séquence. Vous pouvez choisir entre 0 ou 1, mais veuillez indiquer lequel dans votre soumission.

Règles

• L'entrée et la sortie peuvent être supposées correspondre au type d'entier natif de votre langue.
• L'entrée et la sortie peuvent être données dans n'importe quel format pratique .
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

Les exemples ci-dessous sont indexés 1.

n = 4
1

n = 100
11

n = 420
51

Gelée ,  8  7 octets

ḊżṖVÆPS

Un lien monadique prenant un membre de séquence et renvoyant son index dans la séquence.

Essayez-le en ligne!

Comment?

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

5 octets d'économie grâce à Laikoni

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

Essayez-le en ligne!

Gelée , 12, 10 , 8 octets

;’VÆPµ€S

Essayez-le en ligne!

1-2 octets enregistrés grâce à @ nmjmcman101, et 2 octets enregistrés grâce à @Dennis!

Explication:

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

Code

ƒNN<«pO

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication

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

Décortiquer , 13 11 10 octets

1- solution indexée:

#ȯṗdS¤+d←ḣ

Essayez-le en ligne!

Non golfé / Explication

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

Merci @Zgarb pour les -3octets!

Python 2 , 87 octets

-2 octets grâce à @officialaimm . 1 indexé.

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

Suite de tests.

Pyth , 12 octets

smP_s+`d`tdS

Essayez-le en ligne! ou Vérifiez tous les cas de test.

Comment?

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 octets

1 indexé.

ÇsiZÄÃèj

Essayez-le

Ç            :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 octets

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

Essayez-le en ligne!

1 indexé. Il utilise le flux pour faire des entrées et des sorties.

Explication:

{
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 octets

lfP_Tms+`d`tdS

Essayez-le en ligne!

Explication

              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 octets

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

Essayez-le en ligne!

Le grepproduit la séquence de nombres qualifiés, puis nous recherchons la clé ( :k) (c'est-à-dire, l'index) du firstnombre dans la liste qui est égal au paramètre d'entrée $_.

C, 99 94 octets

1 indexé. Cela me fait mal d'écrire des tests de primalité qui sont si inutiles en termes de calcul, mais les octets sont après tout des octets.

Si nous autorisons des choses vraiment fragiles, la compilation sur ma machine sans optimisation avec GCC 7.1.1 fonctionne sur les 94 octets suivants (merci @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;}

sinon ces 99 octets beaucoup plus robustes font le travail

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

Programme complet, un peu plus lisible:

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 octets

1 indexé. Limité par la taille de la pile d'appels de votre moteur.

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

Essayez-le en ligne!

Mathematica, 77 octets

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

QBIC , 25 octets

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

Explication

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

Cela utilise quelque chose de mathématique assez impliqué avec une conversion en chaîne giflée pour faire bonne mesure. Faire un chapeau de version ne fait que la concaténation basée sur des chaînes est un octet de plus:

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

PHP , 203 octets

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

Essayez-le en ligne!

Utilise un index basé sur 1 pour la sortie. Le lien TIO contient la version lisible du code.

Rubis , 42 + 9 = 51 octets

Utilise le -rprime -n drapeaux. 1 indexé.

Fonctionne en comptant tous les nombres égaux ou inférieurs à l'entrée qui remplissent la condition (ou plus techniquement, tous les nombres qui remplissent la n-1condition). Puisque l'entrée est garantie dans la séquence, il n'y a aucun risque d'erreur d'une entrée aléatoire comme 7celle-ci qui ne "devient pas principale".

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

Essayez-le en ligne!

Rubis , 62 octets

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

Essayez-le en ligne!

1 indexé

Python 2 , 85 octets

1 indexé

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

Tester

Amélioration de la réponse de M. Xcoder

Java 8, 108 octets

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 indexé

Explication:

Essayez-le en ligne.

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 octets

1- Indexé

Äm▬á┌╕|°φ♦

Exécuter et déboguer Explication

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)

Tidy , 33 octets

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

Essayez-le en ligne!

Explication

L'idée de base est de créer une séquence de nombres valides puis de renvoyer une fonction d'index au 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