Les amorces sont partout ...

ils se cachent à l'intérieur de Pi

3,141592653 58979 3238 462643 3832 795028841 971693993751

Obtenons ces nombres premiers!

Le défi

Étant donné en entrée un entier n>0, découvrez combien de nombres premiers sont cachés à l'intérieur des premiers nchiffres dePi

Exemples

Car n=3nous devons rechercher des nombres premiers dans [3,1,4]. Il y a 2 Primes (3,31), donc votre code devrait sortir 2
Pour n=10, les 10 premiers chiffres sont [3,1,4,1,5,9,2,6,5,3]et votre code devrait sortir 12car [2, 3, 5, 31, 41, 53, 59, 653, 4159, 14159, 314159, 1592653]ont été cachés (et trouvés!)

Cas de test

entrée -> sortie

1->1  
3->2  
13->14  
22->28  
42->60  
50->93

150->197  
250->363  
500->895

Règles

Votre code doit être en mesure de trouver tous les nombres premiers au moins pourn=50
Oui, vous pouvez coder en dur les 50 premiers chiffres de Pisi vous aimez le
codage en dur les réponses sont invalides

C'est le code-golf . La réponse la plus courte en octets gagne!

05AB1E ,  10  8 octets

-2 octets grâce à Adnan ( pvectorise)

<žsþŒÙpO

Essayez-le en ligne! (fonctionnera jusqu'à n = 98413 mais sera très lent même pour n = 50 en raison de la nécessité de tester de si grands nombres pour la primalité - TIO expire à 60 secondes pour n = 50.)

Comment?

<žsþŒÙpO - implicitly push input, n
<        - decrement = n-1
 žs      - pi to that many decimal places (i.e. to n digits)
   þ     - only the digits (get rid of the decimal point)
    Π   - all sublists
     Ù   - unique values
      p  - is prime? (vectorises) 1 if so, 0 otherwise
       O - sum
         - implicitly print the top of the stack

Mathematica, 76 octets

Tr[1^Union@Select[FromDigits/@Subsequences@#&@@RealDigits[Pi,10,#],PrimeQ]]&

Mathematica, 104 97 90 octets

Length@DeleteDuplicates@Select[FromDigits/@Subsequences@First@RealDigits[Pi,10,#],PrimeQ]&

Hahahaha, j'ai réussi à faire ce travail. Je ne sais pas comment utiliser Mathematica. XD

Contribution:

[50]

Python 3 , 274 237 207 194 194 189 octets

-37 octets grâce à Wheat Wizard! -14 octets grâce à Mr.Xcoder.

Hardcode les 50 premiers chiffres de pi mais calcule manuellement tout le reste.

x=int(input());l="31415926535897932384626433832795028841971693993751"[:x]
print(sum(all(i%m for m in range(2,i))for i in{int(i)for w in range(x)for i in[l[j:j-~w]for j in range(x-w)]}-{1}))

Essayez-le en ligne!

R, 156 123 octets

cat(cumsum(c(1,1,0,1,1,4,1,0,0,3,0,0,2,7,3,1,0,3,0,0,0,0,0,0,4,1,0,6,0,3,2,0,0,0,0,0,0,4,3,3,6,0,4,8,2,5,3,6,0,5))[scan()])

Solution super intéressante. Travailler sur un bon.

Sauvegardé 33 octets grâce à @Giuseppe.

R (+ nombres et gmp), 198 octets

function(n,x=unique(gmp::as.bigz(unlist(sapply(1:n,function(x)substring(gsub("[.]","",numbers::dropletPi(50)),x,x:n))))))min(length(x),sum(sapply(sapply(x[x>0&!is.na(x)],gmp::factorize),length)==1))

Solution appropriée. Prend nen entrée.

Utilise numbers::dropletPi(50)pour générer les 50 premières décimales de pi. gsubsupprime le point décimal. substringprend toutes les sous-chaînes possibles (surprise surprise) de pi jusqu'à n.

La liste retournée est aplatie et converti en gmpde » bigzformat. Ce format est requis pour stocker des entiers de longueur 50. uniqueprend les valeurs uniques de ce vecteur. Ce résultat est stocké dans x.

Ensuite, nous vérifions la primauté. C'est délicat, car il y a un tas de cas de bord et de désagréments:

• Pour high n, il y a un 0in pi. Cela conduit à des sous-chaînes avec un zéro non significatif. as.bigzproduit NAs avec cela, qui doivent être supprimés.

• Sur une note similaire, la sous-chaîne "0"va planter gmp::factorize, elle doit donc également être supprimée.

• Pour n=1, x = 3. Ce qui en soi est correct, mais la bigzreprésentation de 3est itérable, donc sapplysera confus et rapportera 16 nombres premiers. À cette fin, nous prenons le minimum de la longueur du vecteur xet la quantité de nombres premiers en lui.

• gmp::isprimene semble pas pouvoir gérer de manière fiable les grands nombres de manière fiable. Donc, à la place, nous utilisons gmp::factorizeet vérifions que la longueur de la sortie est 1.

Donc, dans l'ensemble, nous supprimons 0et NAde x. Nous factorisons tout xet vérifions la longueur. Nous comptons le nombre d'occurrences de 1et retournons le min(occurences, length(x)).

Gelée , 59 32 octets

-27 octets grâce à Erik l'Outgolfer.

“!⁶⁷¬,6½ạEC.wʠ€Ẉ!+Ẉfṭ¡’Ṿḣ³ẆVQÆPS

Essayez-le en ligne!

Explication

“...’Ṿḣ³ẆVQÆPS

“...’           compressed string that evaluates to first 50 digits of pi (314159...)
     Ṿ          uneval; stringify
      ḣ³        first n characters of the string where n is the first command-line argument
        Ẇ       all sublists
         V      convert all elements to integers
          Q     deduplicate
           ÆP   convert all prime elements to 1 and others to 0
             S  sum