sfondo

La costante di Copeland-Erdős è la concatenazione di "0". con la base 10 rappresentazioni dei numeri primi in ordine. Il suo valore è

0.23571113171923293137414...

Vedi anche OEIS A033308 .

Copeland ed Erdős hanno dimostrato che questo è un numero normale . Ciò implica che ogni numero naturale può essere trovato ad un certo punto dell'espansione decimale della costante di Copeland-Erdős.

La sfida

Dato un numero intero positivo, esprimilo nella base 10 (senza zeri iniziali) e genera l'indice del suo primo aspetto all'interno della sequenza di cifre decimali della costante di Copeland-Erdős.

È consentito qualsiasi formato di input e output ragionevole, ma input e output devono essere nella base 10. In particolare, l'input può essere letto come una stringa; e in tal caso si può presumere che non contenga zeri iniziali.

L'output può essere basato su 0 o 1, a partire dal primo decimale della costante.

I risultati effettivi potrebbero essere limitati dal tipo di dati, dalla memoria o dalla potenza di calcolo, pertanto il programma potrebbe non riuscire per alcuni casi di test. Ma:

• Dovrebbe funzionare in teoria (cioè non tenere conto di tali limiti) per qualsiasi input.
• Dovrebbe funzionare in pratica per almeno i primi quattro casi e per ciascuno di essi il risultato dovrebbe essere prodotto in meno di un minuto.

Casi test

L'output è qui dato come 1 basato.

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 byte

Utilizza output indicizzato 0 . Le funzioni principali in osabie sono molto inefficienti. Codice:

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

Spiegazione:

[       ]        # 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

Utilizza la codifica CP-1252 . Provalo online! .

Python 2, 64 byte

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

Restituisce l'indice in base 1. Provalo su Ideone .

Gelatina , 17 byte

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

Restituisce l'indice in base 1. Provalo online! o verifica la maggior parte dei casi di test .

Ho verificato localmente l'ultimo caso di test; ci sono voluti 8 minuti e 48 secondi.

Come funziona

ç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).

Versione alternativa, 11 byte (non competitiva)

ÆRVw³
ḤÇßÇ?

L' watomo non esisteva quando questa sfida è stata pubblicata. Provalo online!

Come funziona

ḤÇßÇ?  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).

In realtà, 19 byte

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

Accetta una stringa come input e genera l'indice in base 1 della sottostringa

Provalo online!

Spiegazione:

╗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 byte

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

Restituisce l'indice in base 1. Completa tutti i casi di test in meno di un secondo. Provalo online!

Pyth, 17 byte

 fhJxs`MfP_YSTz2J

Lo spazio principale è importante.

Suite di test.

J , 37 byte

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

L'input è dato come un numero intero di base 10 e l'output utilizza l'indicizzazione in base zero.

uso

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

Spiegazione

Questa prima chiamata considera il verbo come una monade, tuttavia le chiamate successive che possono verificarsi lo ricorrono in modo ricorsivo come una diade.

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 byte

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

Combina la logica del mio Trova il numero nella risposta costante di Champernowne , insieme al metodo di generazione primaria del mio Stampa l'ennesimo numero primo che contiene n risposta, quindi sottrae 2per generare in modo appropriato l'indice (ovvero, non contando 0.il punto iniziale).

Accetta l'input come stringa. Trova 999quello in circa sette secondi sulla mia macchina, ma 33308quello in un po 'più a lungo ( modifica - ho rinunciato dopo 90 minuti ). Dovrebbe funzionare teoricamente per qualsiasi valore fino all'indice [Int32]::Maxvalueaka 2147483647, poiché è la lunghezza massima delle stringhe .NET. Probabilmente si imbatterà in problemi di memoria molto prima che ciò accada, tuttavia.