Contexte

La constante de Copeland – Erdős est la concaténation de "0". avec la base 10 représentations des nombres premiers dans l'ordre. Sa valeur est

0.23571113171923293137414...

Voir aussi OEIS A033308 .

Copeland et Erdős ont prouvé qu'il s'agit d'un nombre normal . Cela implique que chaque nombre naturel peut être trouvé à un certain point dans l'expansion décimale de la constante de Copeland-Erdős.

Le défi

Étant donné un entier positif, exprimez-le en base 10 (sans zéros non significatifs) et sortez l'indice de sa première apparition dans la séquence de chiffres décimaux de la constante de Copeland – Erdős.

Tout format d'entrée et de sortie raisonnable est autorisé, mais l'entrée et la sortie doivent être en base 10. En particulier, l'entrée peut être lue comme une chaîne; et dans ce cas, on peut supposer qu'il ne contient pas de zéros non significatifs.

La sortie peut être basée sur 0 ou 1, en commençant par la première décimale de la constante.

Les résultats réels peuvent être limités par le type de données, la mémoire ou la puissance de calcul, et donc le programme peut échouer pour certains cas de test. Mais:

• Cela devrait fonctionner en théorie (c'est-à-dire sans tenir compte de ces limitations) pour toute entrée.
• Cela devrait fonctionner dans la pratique pour au moins les quatre premiers cas, et pour chacun d'eux, le résultat devrait être produit en moins d'une minute.

Cas de test

La sortie est ici donnée en 1.

13       -->         7   # Any prime is of course easy to find
997      -->        44   # ... and seems to always appear at a position less than itself
999      -->      1013   # Of course some numbers do appear later than themselves
314      -->       219   # Approximations to pi are also present
31416    -->     67858   # ... although one may have to go deep to find them
33308    -->     16304   # Number of the referred OEIS sequence: check
36398    -->     39386   # My PPCG ID. Hey, the result is a permutation of the input!
1234567  -->  11047265   # This one may take a while to find

05AB1E , 14 octets

Utilise une sortie indexée 0 . Les fonctions principales d'osabie sont très inefficaces. Code:

[NØJD¹å#]¹.Oð¢

Explication:

[       ]        # Infinite loop...
 N               # Get the iteration value
  Ø              # Get the nth prime
   J             # Join the stack
    D            # Duplicate this value
     ¹å#         # If the input is in this string, break out of the loop
         ¹.O     # Overlap function (due to a bug, I couldn't use the index command)
            ð¢   # Count spaces and implicitly print

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Python 2, 64 octets

f=lambda n,k=2,m=1,s='':-~s.find(`n`)or f(n,k+1,m*k*k,s+m%k*`k`)

Renvoie l'index basé sur 1. Testez-le sur Ideone .

Gelée , 17 octets

ÆRDFṡL}i
Ḥçßç?
çD

Renvoie l'index basé sur 1. Essayez-le en ligne! ou vérifiez la plupart des cas de test .

J'ai vérifié le dernier cas de test localement; cela a pris 8 minutes et 48 secondes.

Comment ça fonctionne

çD        Main link. Argument: n (integer)

 D        Decimal; yield A, the array of base 10 digits of n.
ç         Call the second helper link with arguments n and A.


Ḥçßç?     Second helper link. Left argument: n. Right argument: A.

Ḥ         Unhalve; yield 2n.
    ?     If...
   ç        the first helper link called with 2n and A returns a non-zero integer:
 ç            Return that integer.
          Else:
  ß           Recursively call the second helper link with arguments 2n and A.


ÆRDFṡL}i  First helper link. Left argument: k. Right argument: A.

ÆR        Prime range; yield the array of all primes up to k.
  DF      Convert each prime to base 10 and flatten the resulting nested array.
     L}   Yield l, the length of A.
    ṡ     Split the flattened array into overlapping slices of length l.
       i  Find the 1-based index of A in the result (0 if not found).

Version alternative, 11 octets (non concurrente)

ÆRVw³
ḤÇßÇ?

le w atome n'existait pas lorsque ce défi a été publié. Essayez-le en ligne!

Comment ça fonctionne

ḤÇßÇ?  Main link. Argument: n (integer)

Ḥ      Unhalve; yield 2n.
    ?  If...
   Ç     the helper link called with argument 2n returns a non-zero integer:
 Ç         Return that integer.
       Else:
  ß      Recursively call the main link with argument 2n.


ÆRVw³  Helper link. Argument: k (integer)

ÆR     Prime range; yield the array of all primes up to k.
  V    Eval; concatenate all primes, forming a single integer.
    ³  Yield the first command-line argument (original value of n).
   w   Windowed index of; find the 1-based index of the digits of the result to
       the right in the digits of the result to the left (0 if not found).

En fait, 19 octets

╗1`r♂Pεj╜@íu`;)╓i@ƒ

Prend une chaîne en entrée et sort l'index basé sur 1 de la sous-chaîne

Essayez-le en ligne!

Explication:

╗1`r♂Pεj╜@íu`;)╓i@ƒ
╗                    push input to register 0
  `r♂Pεj╜@íu`;)      push this function twice, moving one copy to the bottom of the stack:
   r♂Pεj               concatenate primes from 0 to n-1 (inclusive)
        ╜@íu           1-based index of input, 0 if not found
1              ╓     find first value of n (starting from n = 0) where the function returns a truthy value
                i@   flatten the list and move the other copy of the function on top
                  ƒ  call the function again to get the 1-based index

Julia, 55 octets

\(n,s="$n",r=searchindex(n|>primes|>join,s))=r>0?r:3n\s

Renvoie l'index basé sur 1. Termine tous les cas de test en moins d'une seconde. Essayez-le en ligne!

Pyth, 17 octets

 fhJxs`MfP_YSTz2J

L'espace de tête est important.

Suite de tests.

J , 37 octets

(0{":@[I.@E.[:;<@":@p:@i.@]) ::($:+:)

L'entrée est donnée sous la forme d'un entier de base 10 et la sortie utilise une indexation de base zéro.

Usage

   f =: (0{":@[I.@E.[:;<@":@p:@i.@]) ::($:+:)
   f 1
4
   f 13
6
   f 31416
67857

Explication

Ce premier appel traite le verbe comme une monade, mais les appels ultérieurs qui peuvent survenir le traitent récursivement comme une dyade.

0{":@[I.@E.[:;<@":@p:@i.@]  Input: n on LHS, k on RHS
                         ]  Get k
                      i.@   Get the range [0, 1, ..., k-1]
                   p:@      Get the kth prime of each
                ":@         Convert each to a string
              <@            Box each string
           [:;              Unbox each and concatenate to get a string of primes
     [                      Get n
  ":@                       Convert n to a string
      I.@E.                 Find the indices where the string n appears in
                            the string of primes
0{                          Take the first result and return it - This will cause an error
                            if there are no matches

(...) ::($:+:)  Input: n on RHS, k on LHS
(...)           Execute the above on n and k
      ::(    )  If there is an error, execute this instead
           +:   Double k
         $:     Call recursively on n and 2k

PowerShell v2 +, 90 octets

for($a="0.";!($b=$a.IndexOf($args)+1)){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$a+=$i}}$b-2

Combine la logique de ma recherche du nombre dans la réponse constante de Champernowne , couplée à la méthode de génération de nombres premiers de mon impression du nième nombre premier qui contient n réponse, puis soustrait 2pour produire l'index de manière appropriée (c'est-à-dire sans compter le0. le début).

Prend l'entrée sous forme de chaîne. Trouve 999celui en environ sept secondes sur ma machine, mais 33308celui en un peu plus longtemps ( modifier - j'ai abandonné après 90 minutes ). Devrait théoriquement fonctionner pour n'importe quelle valeur jusqu'à l'index [Int32]::Maxvalueaka 2147483647, car c'est la longueur maximale des chaînes .NET. Sera probablement confronté à des problèmes de mémoire bien avant que cela ne se produise, cependant.