Sfida:

Pi dovrebbe essere infinito. Ciò significa che ogni numero è contenuto nella parte decimale di pi. Il tuo compito sarà prendere un numero intero positivo sull'input e restituire la posizione di questo numero in cifre pi sull'output.

Ad esempio, se l'input è 59, torneremo4

Ecco perché: cercheremo il numero 59tra le cifre di pi

3.14159265...
     ^^

Il valore inizia dalla quarta cifra, quindi l'uscita sarà 4.

Alcuni altri esempi:

input : 1      output : 1
input : 65     output : 7
input : 93993  output : 42
input : 3      output : 9

Regole :

• Non è necessario gestire cifre che non esistono entro le prime 200 cifre
• Le scappatoie standard sono, come sempre, vietate.
• Questo è codegolf , quindi vince meno byte.

Python 2, 69 75 71 67 byte

Salvato 4 byte a causa del cahing coinheringaahing .

x=p=1333
while~-p:x=p/2*x/p+2*10**200;p-=2
print`x`.find(input(),1)

Il mancato reperimento 3in posizione zero costa 6 2 byte. L'input è dato come una stringa.

Provalo online!

Versione illimitata

Python 2, 224 byte

def g():
 q,r,t,i,j=1,0,1,0,1
 while True:
  i+=1;j+=2;q,r,t=q*i,(2*q+r)*j,t*j;n=(q+r)/t
  if n*t>4*q+r-t:yield n;q,r=10*q,10*(r-n*t)
a=input()
l=len(`a`)
s=z=10**l;i=1-l
p=g().next;p()
while s!=a:s=(s*10+p())%z;i+=1
print i

Utilizzo di uno spigot illimitato basato sulla stessa formula utilizzata in precedenza.

Provalo online!

Versione più veloce

from gmpy2 import mpz
def g():
  # Ramanujan 39, multi-digit
  q, r, s ,t = mpz(0), mpz(3528), mpz(1), mpz(0)
  i = 1
  z = mpz(10)**3511
  while True:
    n = (q+r)/(s+t)
    if n == (22583*i*q+r)/(22583*i*s+t):
      for d in digits(n, i>597 and 3511 or 1): yield d
      q, r = z*(q-n*s), z*(r-n*t)
    u, v, x = mpz(1), mpz(0), mpz(1)
    for k in range(596):
      c, d, f = i*(i*(i*32-48)+22)-3, 21460*i-20337, -i*i*i*24893568
      u, v, x = u*c, (u*d+v)*f, x*f
      i += 1
    q, r, s, t = q*u, q*v+r*x, s*u, s*v+t*x

def digits(x, n):
  o = []
  for k in range(n):
    x, r = divmod(x, 10)
    o.append(r)
  return reversed(o)

a=input()
l=len(`a`)
s=z=10**l;i=1-l
p=g().next;p()
while s!=a:s=(s*10+p())%z;i+=1
print i

Uno spigot illimitato molto più veloce, basato su Ramanujan # 39 .

Provalo online!

Buccia , 5 byte

€tİπd

Provalo online!

Spiegazione

€tİπd                              59
    d  Convert to base-10 digits   [5,9]
  İπ     The digits of pi          [3,1,4,1,5,9..]
 t       Remove the first element  [1,4,1,5,9,2..]
€      Index of the sublist        4

Excel, 212 byte

=FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196")

Excel gestisce solo 15 cifre decimali, quindi pi è appena codificato. Questo dovrebbe essere un limite superiore piuttosto debole per questa sfida.

Java 8, 615 217 202 184 182 166 165 byte (calcolati 999 200 cifre)

n->{var t=java.math.BigInteger.TEN.pow(200);var r=t;for(int p=667;p-->1;)r=t.valueOf(p).multiply(r).divide(t.valueOf(p-~p)).add(t).add(t);return(r+"").indexOf(n,1);}

1-indicizzato

Provalo online.

Il builtin di Java Math.PIha una precisione di 15 valori decimali, come molte altre lingue. Per avere più cifre, dovrai calcolarle tu stesso con BigIntegerso BigDecimals. Questo sopra è un modo per farlo .. Forse qualcuno può giocare a golf al di sotto di 211 byte, lol ..
EDIT: Creato un port della risposta Python 2 di @primo (assicurati di votarlo!), Quindi calcolando di essere più breve che difficile -coded non è più così inverosimile. Solo 7 byte in più per giocare a golf perché sia ​​più breve.

-15 byte grazie a @Neil , rendendolo più breve della risposta codificata di seguito!
-36 byte grazie a @primo .
-1 byte cambia java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;in var T=java.math.BigInteger.TEN.pow(200);var r=T;, perché varè 1 byte più corto di null(devo amare il nuovo Java 10).

Spiegazione:

n->{                            // Method with String parameter and integer return-type
  var t=java.math.BigInteger.TEN.pow(200);
                                //  Temp BigInteger with value 10^200
  var r=t;                      //  Result BigInteger, also starting at 10^200
  for(int p=667;                //  Index-integer, starting at 667
      p-->1;)                   //  Loop as long as this integer is still larger than 1
                                //  (decreasing `p` by 1 before every iteration with `p--`)
    r=                          //   Replace the Result BigInteger with:
      t.valueOf(p)              //    `p`
       .multiply(r)             //    multiplied by `r`,
       .divide(t.valueOf(p-~p)) //    divided by `2*p+1`
       .add(t).add(t);          //    And add 2*10^200
  return(r+"")                  //  Convert the BigInteger to a String
    .indexOf(n,                 //  And return the index of the input,
               1);}             //  skipping the 3 before the comma

Java 8, 211 byte (200 cifre hardcoded)

"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf

0-indicizzato

Provalo online.

05AB1E , 6 byte

₁žs¦¹k

Provalo online!

Come?

₁        push 256
 žs      push pi to 256 places
   ¦     remove the leading 3
    ¹    push the input
     k   index inside that string

MATL , 16 15 byte

YP8WY$4L)jXfX<q

Provalo online!

Spiegazione

YP     % Push pi as a double
8W     % Push 2^8, that is, 256
Y$     % Compute pi with 256 significant digits using variable-precision arithmetic
       % The result as a string
4L)    % Remove first character. This is to avoid finding '3' in the integer part
       % of pi
j      % Push input as a string
Xf     % Strfind: gives array of indices of occurrences of the input string in the
       % pi string
X<     % Mimimum
q      % Subtract 1. Implicitly display

Pacchetto numeri R +, 52 byte

regexec(scan(),substring(numbers::dropletPi(200),3))

Provalo online!

dropletPicalcola le prime 200 cifre decimali di pima include 3.a all'inizio, quindi lo eliminiamo con substringe quindi abbiniamo con regexec, che restituisce l'indice della partita insieme ad alcuni metadati sulla partita.

Gelatina , 23 byte

⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SṾḊw

Un collegamento monadico che accetta un elenco di caratteri (l'intero da trovare) e restituisce l'indice. Funziona con input contenuti entro le prime 252 cifre della parte decimale di π.

Provalo online!

Come?

Questo utilizza la formula di Leibniz per π per calcolare le prime 253 cifre incluso il primo 3(più quattro cifre finali errate). Il lead 3viene quindi eliminato e viene trovato l'indice dell'input:

⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SṾḊw - Link: list of characters
⁵                       - literal ten
  ⁹                     - literal 256
 *                      - exponentiate = 10000...0 (256 zeros)
   Ḥ                    - double       = 20000...0
          ¤             - nilad followed by links as a nilad:
     ȷ                  -   literal 1000
      Ḋ                 -   dequeue -> [2,3,4,5,...,1000]
         $              -   last two links as a monad:
        J               -     range of length -> [1,2,3,4,...,999]
       +                -     addition (vectorises) -> [3,5,7,9,...,1999]
    ;                   -   concatenate -> [20000...0,3,5,7,9,...,1999]
                  \     - cumulative reduce with:
                 ɗ      -   last three links as a dyad:
               ¤        -     nilad followed by link(s) as a nilad:
            ⁹           -       chain's right argument (the right of the pair as we traverse the pairs in the list -- 3, 5, 7, 9, ...)
              2         -       literal two
             :          -       integer division (i.e. 1, 2, 3, ...)
           ×            -     multiply (the left of the pair, the "current value", by that)
                :       -   integer divide by the right argument (i.e. 3, 5, 7, 9, ...)
                   S    - sum up the values (i.e. 20000...0 + 66666...6 + 26666...6 + 11428...2 + ... + 0)
                    Ṿ   - un-evaluate (makes the integer become a list of characters)
                     Ḋ  - dequeue (drop the '3')
                      w - first (1-based) index of sublist matching the input

Se preferisci un elenco di cifre come input usa ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(anche 23), mentre se vuoi davvero dargli un numero intero usa ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(per 24).

BASH (GNU / Linux), 75 67 66 byte

Salvato 1 byte grazie a Sophia Lechner e 7 byte grazie al ciarlatano Cows.

a=`bc -l<<<"scale=999;4*a(1)"|tail -c+2|grep -ob $1`;echo ${a%%:*}

Questo è uno script di shell che accetta un singolo argomento, che è il numero. Prova con

$ bash <script-path> 59
4

Questo script esegue innanzitutto una pipeline di tre comandi:

bc -l<<<"scale=999;4*a(1)"|    #produce pi with its first 999 fractional digits
tail -c+2|                     #cut off the "3."
grep -ob $1                    #compute the byte offsets of our argument in the string

Il risultato di questa pipeline viene assegnato alla variabile shell a, che viene quindi echo rimossa con qualsiasi cosa tranne il primo numero rimosso:

a=`...`;         #assign the result of the pipeline to a variable
echo ${a%%:*}    #cleave off the first : character and anything following it

Sfortunatamente, bcha la tendenza a interrompere le linee di output quando diventano troppo lunghe. Ciò può portare a risultati errati se il numero da trovare non si trova sulla prima riga. Puoi evitarlo impostando la variabile di ambiente BC_LINE_LENGTH:

export BC_LINE_LENGTH=0

Ciò disattiva completamente la funzione di interruzione di linea.

Ovviamente, gli ultimi due comandi possono essere omessi se è tollerato un altro output.
Questo dà un conteggio di 48 byte :

bc -l<<<"scale=999;4*a(1)"|tail -c+2|grep -ob $1

Con l'output risultante:

$ bash <script-path> 59
4:59
61:59
143:59
179:59
213:59
355:59
413:59
415:59
731:59
782:59
799:59
806:59
901:59
923:59
940:59
987:59

JavaScript, 197 187

^{-10: Grazie, Neil !}

x=>"50ood0hab15bq91k1j9wo6o2iro3by0h94bg3geu0dnnq5tcxz7lk62855h72el61sx7vzsm1thzibtd23br5tr3xu7wsekkpup10cek737o1gcr6t00p3qpccozbq0bfdtfmgk".replace(/.{9}/g,a=>parseInt(a,36)).search(x)+1

Prende una serie di numeri interi base-36 a nove cifre, li converte in base 10 e li concatena per creare le prime 200 cifre di pi.

Prima volta facendo il golf del codice. Utilizzare i delegati e le espressioni lambda per ridurre le chiamate di funzione. V2 abbrevia il nome della classe in un singolo byte.

[C #], 361 355 byte

using System;class P{static void Main(){Func<string,int>F=f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;Action<int>w=Console.WriteLine;w(F("1"));w(F("65"));w(F("93993"));w(F("3"));}}

Versione formattata:

using System;

class P
{
    static void Main()
    {
        Func<string,int>F=f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;
        Action<int>w=Console.WriteLine;
        w(F("1"));
        w(F("65"));
        w(F("93993"));
        w(F("3"));
    }
}

Ideone!

NB: ho contato male la prima versione. Era 361 byte, non 363 byte.

[C #], tio versione 218 byte

f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1

Provalo online!

Haskell , 208 120 byte

a=1333
x=tail$show$foldr(\p x->p`div`2*x`div`p+2*10^200)a[3,5..a]
x!n|take(length n)x==n=0|1<2=1+tail x!n
f n=1+x!show n

Provalo online!

^{Mille grazie a Jonathan Allan per i suoi suggerimenti!}

Vecchia versione (208 byte)

(+1).((tail$g(1,0,1,1,3,3))!)
g(q,r,t,k,n,l)=([n:g(10*q,10*(r-n*t),t,k,div(10*(3*q+r))t-10*n,l)|4*q+r-t<n*t]++[g(q*k,(2*q+r)*l,t*l,k+1,div(q*(7*k+2)+r*l)(t*l),l+2)])!!0
x!n|take(length n)x==n=0|1<2=1+tail x!n

In realtà non so come funziona il codice sopra; L'ho preso da questo documento e tutto quello che ho implementato era la parte di ricerca. g(1,0,1,1,3,3)restituisce le cifre di pi ed è sorprendentemente efficiente (calcola 10 000 cifre su tio.run in meno di 4 secondi).

L'input è un elenco costituito dalle cifre del numero da trovare.

Provalo online!

Haskell, 230 byte

Usando la pigrizia per trovare il numero ovunque nelle cifre infinite di pi, non solo nelle prime 200 cifre. Oh sì, e ti restituisce ogni (infinitamente?) Istanza (e) del numero, non solo la prima.

p=g(1,0,1,1,3,3)where g(q,r,t,k,n,l)=if 4*q+r-t<n*t then n:g(10*q,10*(r-n*t),t,k,div(10*(3*q+r))t-10*n,l) else g(q*k,(2*q+r)*l,t*l,k+1,div(q*(7*k+2)+r*l)(t*l),l+2)
z n=[(i,take n$drop i p)|i<-[1..]]
f l=[n|(n,m)<-z$length l,m==l]

Esempi dalla sfida

>  take 10 $ f [1]
[1,3,37,40,49,68,94,95,103,110]
>  take 10 $ f [6,5]
[7,108,212,239,378,410,514,672,870,1013]
>  take 1 $ f [9,3,9,9,3]
[42]
>  take 10 $ f [3]
[9,15,17,24,25,27,43,46,64,86]

Crediti

'p' è il flusso infinito di cifre pi, tratto da https://rosettacode.org/wiki/Pi#Haskell

> take 20 p
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4]

SmileBASIC, 179 164 byte

INPUT I$FOR I=0TO 103Q$=Q$+STR$(ASC("\A#YO &.+& O2TGE']KiRa1,;N(>VYb>P0*uCb0V3 RB/]T._2:H5;(Q0oJ2)&4n7;@.^Y6]&"[I]))NEXT?INSTR(Q$,I$)+1

Le cifre di pi sono codificate e raggruppate nei valori ascii dei personaggi. 14 -> CHR$(14), 15 -> CHR$(15), 92 -> \, 65 -> A, 35 -> #.

La stringa contiene caratteri non stampabili, quindi ecco i byte scritti in esadecimale: 0E 0F 5C 41 23 59 4F 20 26 2E 1A 2B 26 20 4F 32 1C 54 13 47 45 27 5D 4B 69 52 00 61 31 2C 3B 17 00 4E 10 28 3E 56 14 59 62 3E 50 03 30 19 03 2A 75 00 43 62 15 30 00 56 33 20 52 1E 42 2F 00 5D 54 2E 00 5F 32 3A 16 1F 48 35 3B 28 51 1C 30 6F 4A 32 1C 29 00 1B 00 13 26 34 6E 37 3B 40 2E 16 5E 59 36 5D 00 26 13 06

In decimale, puoi vedere le cifre di pi: 14 15 92 65 35 89 79 32 38 46 26 43 38 32 79 50 28 84 19 71 69 39 93 75 105 82 0 97 49 44 59 23 0 78 16 40 62 86 20 89 98 62 80 3 48 25 3 42 117 0 67 98 21 48 0 86 51 32 82 30 66 47 0 93 84 46 0 95 50 58 22 31 72 53 59 40 81 28 48 111 74 50 28 41 0 27 0 19 38 52 110 55 59 64 46 22 94 89 54 93 0 38 19 6

Rubino , 37 35 byte

p"#{BigMath::PI 200}"[3..-3]=~/#$_/

Provalo online!

Niente di speciale, solo in mostra la libreria integrata. L'output è indicizzato 0. La stringa Pi è formattata come 0.31415...e1, quindi dobbiamo eliminare i primi 3 caratteri. La e1parte alla fine non fa davvero alcun danno, ma è anche spogliata, dato che dobbiamo comunque fornire un valore di fine intervallo (o lunghezza della sezione).

Carbone , 27 15 byte

Ｉ⊖∨⌕Ｉ▷N⟦≕Piφ⟧θχ

Provalo online! Il collegamento è alla versione dettagliata del codice. Funziona fino a quasi 1000 cifre. Spiegazione:

        ≕Pi     Get variable `Pi`
           φ    Predefined variable 1000
     ▷N⟦    ⟧   Evaluate variable to specified precision
    Ｉ           Cast to string
             θ  First input
   ⌕            Find
              χ Predefined variable 10
   ∨             Logical OR
  ⊖              Decrement
 Ｉ               Cast to string
                 Implicitly print

Japt , 186 177 byte

`nqnrvosrpruvtvpopuqsosqppÕÝvr¶uuqnvtnsvpvvptrnmruomvtqvqqrvopmÉæqÛàÑ$vvÔàmpqupqm¡vuqum«rnpopmssqtmvpuqqsmvrrmruoopÌÊprvqÛ$uqunnqr¶uqn¶tmnvpÔnmrrrvsqqsoovquvrqvpmpunvs`®c -#mÃbU

Poiché Japt condivide il vincolo Pi di 15 cifre di Javascript e shoco , la codifica utilizzata da Japt, non codifica i numeri, alcuni shenanigans sono richiesti per la compressione.

Brevemente spiegato, l'inizio è la stringa sotto in forma codificata:

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

Che è una stringa in cui si trova ogni lettera 'm' + corresponding digit of pi. Ho testato l'intero alfabeto e quella lettera offre la migliore compressione di pochi byte.

I backtick dicono a Japt di decodificare la stringa. Il resto è piuttosto semplice:

®c -#mÃbU
®          // Given the above string, map each letter
 c         // and return its charcode
   -#m     // minus the charcode of 'm', 109.
      Ã    // When that's done,
        bU // find the index of the implicit input U.

Emette un indice basato su 0 del frammento corrispondente.
Rasato altri due byte grazie a Oliver .

Provalo online!

AWK -M, 131 119 117 byte

Utilizza -Mflag per calcoli di precisione arbitrari. Aggiunto p=k=0(5 byte) al collegamento TIO per consentire l'immissione su più righe

{CONVFMT="%.999f";PREC=1e3;for(p=k=0;k<1e3;)p+=(4/(8*k+1)-2/(8*k+4)-1/(8*k+5)-1/(8*k+6))/16^k++;$0=$1==3?9:index(p,$1)-2}1

Provalo online!

Spiegazione:

{CONVFMT="%.999f";  # Allows 999 decimal digits to be used when numbers are convert to strings
PREC=1e3;           # Digits of precision to use for calculations
for(;k<1e3;)p+=(4/(8*k+1)-2/(8*k+4)-1/(8*k+5)-1/(8*k+6))/16^k++; # The most concise numerical calculation I could find. It doesn't converge  extremely rapidly, but it seems to work OK
$0=$1==3?9:index(p,$1)-2}  # Replace input line with either 9 or index-2
                           # since indices will either be 1 (meaning 3 was input) or >= 3
1                   # Print the "new" input line

Gelatina , 24 byte

ȷ*
ȷR×¢:Ḥ‘$ƲU×:¢+¢ʋ/ḤṾḊw

Provalo online!

Usa una formula simile a quella di Machin , in particolare 1/4 pi == tan ^-1 (1/2) + tan ^-1 (1/3).

Usa la formula pi / 2 == 1 + 1/3 × (1 + 2/5 × (1 + 3/7 × (1 + 4/9 × (...))))

Python 2 239 238 229 214 byte

-9 byte grazie a @primo

from bigfloat import*;a=s=n=10**10**5;b=k=0
while a:k+=1;a*=k*(k*(108-72*k)-46)+5;a/=k**3*(640320**3/24);s+=a;b+=k*a
with precision(10**7):print`(426880*sqrt(10005*n)*n)/(13591409*s+545140134*b)`.find(input())-16

Utilizza l'algoritmo Chudnovsky-Ramanujan per trovare i primi 1 milione di cifre 50000 cifre di π (cambia 10**10**5in 10**10**6per altro, ma ci vogliono anni per l'esecuzione) e quindi cerca la stringa desiderata.

Visual Basic - 114 byte

Ok, prima presentazione. Vacci piano con me!

    Dim s,p As String
    s=Console.Readline()
    p=Math.PI
    Console.Write((p.IndexOf(s,2)-1))

Feedback di benvenuto!

Non mi sono limitato alle prime 256 parti di PI poiché la domanda dice "Non devi", non "Non dovresti" Spero che lo stia facendo bene :)

Javascript 217 byte (200 hardcoded)

a=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".search(a)+1

PHP, 27 byte

^{Non è una risposta molto serie, richiede una modifica delle impostazioni di php.ini poiché pi () viene impostato automaticamente su 14 cifre, non su 200, ma per una volta la soluzione PHP è abbastanza elegante:}

<?=strpos(pi(),$_GET[n])-1;

Julia 0.6 , 53 byte

setprecision(9^6)
x->searchindex("$(big(π))","$x",3)

Imposta la precisione per BigFloats abbastanza in alto, quindi converti piin una stringa e cerca. Precisione delle 9^6impugnature 159980 cifre.

Provalo online!

J, 25 byte

{.I.(}.":<.@o.10x^999)E.~

Provalo online!

0-indicizzato

Accetta l'input come stringa, +2 byte ( ":) se ciò non è consentito.

Spiegazione alla fine.

Perl 5 con -MMath::BigFloat+bpie -n, 20 byte

bpi($>)=~/.$_/;say@-

Provalo online!

Non sono sicuro di dove l'uso di $>stand, dal momento che è il EFFECTIVE_USER_IDche non è portatile, ma su TIO questo è il 1000 e soddisfa la nostra esigenza, per -1 di byte vs. 200.

Buccia , 5 byte

€tİπd

Provalo online!

€        The 1-based index as a substring of
    d    the decimal digits of
         the input
  İπ     in the infinite list of digits of pi
 t       after the radix point.