Les nombres pairs peuvent-ils devenir premiers?

24

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
code-golf  sequence  arithmetic  primes 
— AdmBorkBork
source
1
Pourquoi devez-vous le faire à l'envers? cQuents n'a pas ce mode :(
— Stephen
4
@StepHen Juste pour un changement de rythme; quelque chose de différent que d'habitude.
— AdmBorkBork
9
Je pense que ce serait beaucoup mieux comme problème de décision.
— Wheat Wizard
4
Non seulement 2 est le seul nombre premier divisible par 2, 3 est aussi le seul nombre premier divisible par 3, et 5 est le seul nombre premier divisible par 5. En général, un nombre premier nest toujours le seul nombre premier divisible par n. Ce n'est pas spécial - c'est comme ça que les nombres premiers fonctionnent.
— Esolanging Fruit

Réponses:

11

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
— Jonathan Allan
source
TIO n'est pas en panne pour moi, peut-être qu'il vient de se relever?
— Conor O'Brien
1
Corrigé il y a 2 minutes :)
— Jonathan Allan
Beau! Ce zip(head(), pop())truc est vraiment cool. :)
— DJMcMayhem
Dans quel encodage est-ce que 7 octets?
— kylefinn
1
@kylefinn Jelly a sa propre page de codes, cliquez sur le lien octets dans l'en-tête pour le voir.
— Jonathan Allan
8

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!

— Assistant de blé
source
1
Je pense que vous pouvez utiliser le test d'amorçage plus court p x=all((>0).mod x)[2..x-1]qui échoue pour 1, mais cela ne devrait pas avoir d'importance dans ce cas.
— Laikoni
1
show x++show(x-1)Peut également être raccourci show=<<[x,x-1].
— Laikoni
@Laikoni Merci pour les conseils! Je pensais que cela showpourrait être fait dans une méthode plus courte mais je n'ai pas pensé à une carte de concaturation pour une raison quelconque.
— Wheat Wizard
6

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
— DJMcMayhem
source
Pouvez-vous simplement supprimer le R et utiliser la plage implicite?
— nmjcman101
@ nmjcman101 Je ne savais absolument pas que c'était une chose. Merci!
— DJMcMayhem
5

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)
— Adnan
source
Bien sûr, cela profite du fait que 05AB1E ignore les erreurs ... car je ne pense pas que vous puissiez vérifier si '0-1'c'est premier.
— Erik the Outgolfer
5

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!

— ბიმო
source
1
£İpest équivalent à ṗ. Vous pouvez également enregistrer un octet avec #…ḣau lieu de £f…N.
— Zgarb
4

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.
— M. Xcoder
source
4

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
— Hirsute
source
1
— Oliver
Gah! Pourquoi ai-je un tel angle mort pour Æet Ç?! Merci, @Oliver; Je mettrai à jour quand je reviens à un ordinateur.
— Shaggy
2o+X(avec un espace de fin) fonctionnerait à la place de [XXÉ], bien que si je me tournais vers les []crochets d' équilibrage automatique, votre solution serait un octet plus courte. (En fait 2, puisque vous pourriez alors le faire õ_ZÉ]¬nÃèj)
— ETHproductions
@ETHproductions: Ces jours-ci, la première chose que je fais lorsque je travaille avec un tableau est de vérifier si l'équilibrage automatique a été ajouté pour []! : D
— Shaggy
Pour une raison quelconque, je pense que les points-virgules ont complètement cessé de fonctionner également, alors je vais essayer de résoudre ce problème. Ne pensez pas que j'aurai une chance jusqu'à demain après-midi.
— ETHproductions
3

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

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
— Jim
source
Vous m'avez battu de quelques secondes, je vous ai battu de quelques octets: P
— M. Xcoder
@ Mr.Xcoder Ma première version était lfTmP_s+`d`tdS, il est regrettable que je n'aie pas trouvé votre truc par moi-même à ce moment :)
— Jim
2

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 $_.

— Sean
source
— Jo King
2

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;
}
— algmyr
source
Selon votre compilateur, vous pourrez peut-être enregistrer quelques octets en utilisant à la n=c;place de 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
Je ne peux pas dire que je veux utiliser des choses qui semblent même varier avec les niveaux d'optimisation. En utilisant GCC, sans optimisation -O0, cela fonctionne, avec d'autres indicateurs d'optimisation, il ne fonctionne pas. Fait intéressant -O1 -O2 et -O3, il renvoie 0, avec -Os, il renvoie 1, avec -Og, il renvoie n-1.
— algmyr
Vous pouvez toujours spécifier dans votre réponse comment votre programme doit être compilé.
— Conor O'Brien
Je suppose que cela semble un peu bon marché. Mais je peux ajouter une alternative.
— algmyr
Je comprends, mais je ne me sentirais pas trop mal de le faire - c'est l'un des conseils pour jouer au golf en C
— Conor O'Brien
2

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!

— Arnauld
source
1

Mathematica, 77 octets

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

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
— steenbergh
source
0

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.

— Mic1780
source
0

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!

— Encre de valeur
source
0

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

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

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
— Conor O'Brien
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.