Pi tiene tu número


30

Desafío:

Se supone que Pi es infinito. Eso significa que cada número está contenido dentro de la parte decimal de pi. Su tarea será tomar un número entero positivo en la entrada y devolver la posición de este número en dígitos pi en la salida.

Por ejemplo, si la entrada es 59, volveremos4

He aquí por qué: buscaremos el número 59en los dígitos de pi

3.14159265...
     ^^

El valor comienza en el cuarto dígito, por lo que la salida será 4.

Algunos otros ejemplos:

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

Reglas :

  • No tiene que manejar dígitos que no existen dentro de los primeros 200 dígitos
  • Las lagunas estándar están, como siempre, prohibidas.
  • Esto es , por lo que gana menos bytes.

41
Los números con la propiedad que menciona se conocen como números normales . Una expansión decimal infinita, incluso si no es periódica, no implica normalidad. 0.101001000100001 ... es un contraejemplo.
Dennis

38
Y, absolutamente, no se supone que Pi sea ​​infinito. Es una representación decimal, sin embargo, tiene dígitos infinitos.
rafa11111

11
@Dennis Normal es una condición mucho más fuerte (todo uniforme vs todo lo existente)
user202729

66
¿Se nos permite generar el n'índice indexado 0 '? Entonces los casos de texto regresarían en 0, 6, 41, 8lugar de 1, 7, 42, 9.
Kevin Cruijssen

77
@ rafa11111 Estoy de acuerdo. Deberíamos abandonar los enteros y usar números en base-PI. Entonces los enteros tendrán dígitos infinitos, en su lugar.
mbomb007

Respuestas:


22

Python 2, 69 75 71 67 bytes

Guardado 4 bytes debido a caird coinheringaahing .

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

No encontrar 3en la posición cero cuesta 6 2 bytes. La entrada se da como una cadena.

Pruébalo en línea!


Versión sin límites

Python 2, 224 bytes

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

Usando una espita sin límites basada en la misma fórmula utilizada anteriormente.

Pruébalo en línea!


Versión más rápida

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

Una espita ilimitada mucho más rápida, basada en Ramanujan # 39 .

Pruébalo en línea!


Agradable, ni los
códigos rígidos


2
@Dennis 31 necesita coincidir en 137: /
primo

2
¿Qué algoritmo de aproximación es este? ¿Es uno que figura aquí? en.wikipedia.org/wiki/Approximations_of_%CF%80
Sphinxxx

44
@Sphinxxx es el resultado de aplicar la transformación de Euler a la serie Leibniz. He publicado una derivación en una publicación anterior .
primo

19

Casco , 5 bytes

€tİπd

Pruébalo en línea!

Explicación

€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

1
Ridículo, pero debo admitir que estoy impresionado.
Floris

66
Con los idiomas de golf, generalmente es una buena idea agregar una explicación, ya que alguien que no conoce el idioma no podrá leerlo. Si entiendo correctamente, es: tome el índice de ( ) con el primer elemento (los 3 primeros) eliminado ( t) de los dígitos de PI ( İπ), conviértalo a base-10 ( d) y envíe a STDOUT (implícitamente).
Kevin Cruijssen

De acuerdo, no tengo idea de lo que estoy viendo.
JA Terroba

1
@gggg parece que es un ejemplo de representación perezosa , verificación
solo ASCII el

1
@gggg İπes una lista infinita de dígitos, creada con una fuente de
H.PWiz

18

Excel, 212 bytes

=FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196")

Excel solo maneja 15 decimales, por lo que pi solo está codificado. Este debería ser un límite superior bastante débil para este desafío.


44
Lamento comentar sobre mi propia publicación, pero ¿algunos de los votantes pueden decirme por qué les gusta esta respuesta? Es tan golfístico como puede ser en una fórmula de Excel, pero es muy largo y nada inteligente.
Engineer Toast el

66
Me gusta esto porque no se basa en idiomas de golf que tienen incorporados para calcular pi a un decimal decimal arbitrario. Puede que no sea creativo, pero es práctico (no es que la practicidad importe aquí).
Scott

Como la pregunta no especifica que la entrada o la respuesta tienen que ser base 10, ¿podría jugar golf usando CONCATuna fórmula BBP para calcular los primeros 200 dígitos de π-base16 y buscar en hexadecimal? (No tengo 365, así que no puedo probar)
Chronocidal

2
Solo Office 365: uso CONCAT, CODEy MIDreduje la cadena de PI de 202 caracteres (comillas inc) a 143:CONCAT(CODE(MID(".ÜÁ£ÙÏ ¦®š«¦ Ï²œÔ“ÇŧÝËŠº”ᱬ»—‡ÑÀ†œ¾ˆãÖœƒ°™¢•‘†ÏÒŽÐÖ³ ÒžÂ¯‰¦¬¼ß²º–ŸÈµ»¨Ñœ°‹‘­‚ÔŠ›ÝÕ•Š·»À®–Þٶ݃Ñà",2*ROW(A1:A100)-1,2))-32)
Chronocidal

1
Al probar con Office365, parece que genera 14 independientemente de la entrada.
Matthew Schlachter

9

Java 8, 615 217 202 184 182 166 165 bytes (calculado 999 200 dígitos)

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 indexado

Pruébalo en línea.

El código incorporado de Java Math.PItiene una precisión de 15 valores decimales, como muchos otros idiomas. Para tener más dígitos, deberá calcularlos usted mismo con BigIntegerso BigDecimals. Esto es una forma de hacerlo. Tal vez alguien pueda jugar golf por debajo de 211 bytes, jajaja.
EDITAR: creó un puerto de la respuesta de Python 2 de @primo ( ¡ asegúrate de votarlo !), Así que calcular ser más corto que difícil -coded ya no es tan descabellado. Solo 7 bytes más para jugar golf para que sea más corto.

-15 bytes gracias a @Neil , lo que lo hace más corto que la respuesta codificada a continuación.
-36 bytes gracias a @primo .
-1 byte cambiando java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;a var T=java.math.BigInteger.TEN.pow(200);var r=T;, porque vares 1 byte más corto que null(tengo que amar el nuevo Java 10).

Explicación:

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 bytes (200 dígitos codificados)

"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf

0 indexado

Pruébalo en línea.


1
!p.equals(t.ONE)¿quizás? Además, indexOf(n,1)-1creo que funciona. O guarde 2 bytes y hágalo 1 indexado.
Neil

No estoy seguro de cómo me perdí el primero, pero el segundo realmente necesito recordarlo. No sabía que había un indexOfmétodo que omite los primeros mcaracteres. TIL, gracias!
Kevin Cruijssen


1
También puede disminuir ppor uno cada vez ( for(int p=667;p-->1;)), y luego multiplicar por py dividir por p-~p.
primo

1
El valor inicial de rliteralmente puede ser cualquier cosa, aunque los valores extremos requerirán más iteraciones. La mejor semilla (menos iteraciones) es en realidad 4e200.
primo

6

05AB1E , 6 bytes

₁žs¦¹k

Pruébalo en línea!

¿Cómo?

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

Si obtengo una solución similar de 6 bytes en el mismo idioma, después de usted, ¿elimino mi respuesta?
nicael

@nicael generalmente no importa, pero su solución falla de 3todos modos
Uriel

Oh, de hecho, gracias
nicael

6

MATL , 16 15 bytes

YP8WY$4L)jXfX<q

Pruébalo en línea!

Explicación

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

Muy bonito y corto! ¿Puedes explicar cómo funciona?
El tipo al azar

@Therandomguy Claro, explicación agregada
Luis Mendo

4

Paquete de números R +, 52 bytes

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

Pruébalo en línea!

dropletPicalcula los primeros 200 dígitos decimales de pipero incluye un 3.al principio, por lo que eliminamos eso substringy luego lo combinamos regexec, lo que devuelve el índice de la coincidencia junto con algunos metadatos sobre la coincidencia.


Tal vez regexpr(scan(),numbers::dropletPi(200))-2?
djhurio

@djhurio que no funciona porque tenemos que hacer coincidir los dígitos después del punto decimal. Ese fue mi primer pensamiento también, pero ese caso lo arruina. Tal vez un "if"?
Giuseppe

No veo un problema aquí. Ninguna de las entradas contendrá 3.(supongo que tratamos con enteros, no reales en la entrada). Los ejemplos de prueba funcionan con esto.
djhurio

3
@djhurio está bien pero regexpr(3,numbers::dropletPi(200))-2regresa -1 cuando debería regresar 9, pruébalo
Giuseppe

3

Jalea , 23 bytes

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

Un enlace monádico que acepta una lista de caracteres (el entero para buscar) y devuelve el índice. Funciona para entradas contenidas dentro de los primeros 252 dígitos de la parte decimal de π.

Pruébalo en línea!

¿Cómo?

Utiliza la fórmula de Leibniz para π para calcular los primeros 253 dígitos, incluidos los primeros 3(más cuatro dígitos incorrectos finales). El líder 3se deja caer a continuación, y se encuentra el índice de la entrada:

⁵*⁹Ḥ;ȷḊ+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

Si prefiere una lista de dígitos como uso de entrada ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(también 23), mientras que si realmente desea darle un uso entero ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(para 24).


Te refieres a la transformación de Euler aplicada a la fórmula de Leibniz. Calcular 252 dígitos con la fórmula de Leibniz llevaría un poquito más de lo que la mayoría de la gente estaría dispuesta a esperar.
primo

Sí, tomaría mucho tiempo en forma cruda (todavía "usa la fórmula de Leibniz" ¡Creo!)
Jonathan Allan

3

BASH (GNU / Linux), 75 67 66 bytes

Guardado 1 byte gracias a Sophia Lechner, y 7 bytes gracias a Cows quack.

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

Este es un script de shell que toma un solo argumento, que es el número. Prueba con

$ bash <script-path> 59
4

Este script primero ejecuta una tubería de tres comandos:

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

El resultado de esta tubería se asigna a la variable de shell a, que luego se repite con cualquier cosa que no sea el primer número eliminado:

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

Desafortunadamente, bctiene la tendencia a romper las líneas de salida cuando se vuelven demasiado largas. Esto puede conducir a resultados incorrectos si el número que se encuentra no está en la primera línea. Puede evitar eso configurando la variable de entorno BC_LINE_LENGTH:

export BC_LINE_LENGTH=0

Esto desactiva la función de salto de línea por completo.


Obviamente, los dos últimos comandos pueden omitirse si se tolera otra salida.
Esto da un recuento de 48 bytes :

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

Con la salida resultante:

$ 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

¡Agradable! No necesita ese espacio entre -ly <<<sin embargo.
Sophia Lechner

Puede convertir a un programa y usar sed para guardar algunos bytes. ¡ Pruébelo en línea!
Kritixi Lithos

@Cowsquack ¿No necesitaría incluir una línea shebang en el conteo de bytes entonces?
cmaster

Las líneas @cmaster shebang no están incluidas en el recuento de bytes para ningún idioma
Kritixi Lithos

@Cowsquack Gracias por la sugerencia. Sin embargo, si permite una salida adicional, también podría sedomitirla (consulte la segunda parte de mi respuesta). Sin embargo, transformarme en un programa me dio 7 bytes, ¡así que gracias por eso! También he reemplazado el tr/ headcombo con magia variable de shell ahora para guardar otro byte.
cmaster

2

JavaScript, 197 187

-10: ¡Gracias Neil !

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

Toma una serie de enteros de base 36 de nueve dígitos, los convierte en base 10 y los concatena para crear los primeros 200 dígitos de pi.


Bien, sopló mis intentos de codificar los datos fuera del agua, su enfoque ahorra 38 bytes en los datos sin procesar.
Nit

+1: estaba a punto de publicar exactamente el mismo enfoque.
darrylyeo

Use x=>'50...'.replace(/.{9}/g,a=>parseInt(a,36)).search(x)+1para guardar 10 bytes.
Neil

2

Primera vez haciendo código golf. Use delegados y expresiones lambda para reducir las llamadas a funciones. V2 acorta el nombre de la clase en un solo byte.

[C #], 361 355 bytes

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"));}}

Versión formateada:

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!

Nota: desconté la primera versión. Tenía 361 bytes, no 363 bytes.

[C #], tio versión 218 bytes

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

Pruébalo en línea!


No necesita incluir los casos de prueba en su código, y puede usar una función lambda (anónima) en lugar de un programa completo
Zac Faragher

Hyarus sugirió using System;f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;como una edición.
ovs

Soy nuevo aquí y pensé que debía incluir un programa completo que incluyera el caso de prueba. Parece que la gente está usando tio.run para la demostración en lugar de ideone. Veo que tio.run divide el código en partes.
Han

2

Haskell , 208 120 bytes

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

Pruébalo en línea!

¡Muchas gracias a Jonathan Allan por sus sugerencias!

Versión anterior (208 bytes)

(+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

En realidad no sé cómo funciona el código anterior; Lo tomé de este documento y todo lo que implementé fue la parte de búsqueda. g(1,0,1,1,3,3)devuelve los dígitos de pi y es sorprendentemente eficiente (calcula 10 000 dígitos en tio.run en menos de 4s).

La entrada es una lista que consta de los dígitos del número que se encuentra.

Pruébalo en línea!


Supongo que la fórmula de Leibniz será mucho más corta.
Jonathan Allan

@JonathanAllan ¡Gracias! Voy a darle una oportunidad. ¡Amo absolutamente este sitio! ¡He aprendido mucho de ustedes, muchachos! :)
Cristian Lupascu

@JonathanAllan Intenté aproximar el uso de pi l=4*sum[((-1)**x/(2*x+1))|x<-[0..1e6]], pero eso tarda 5 segundos en ejecutarse y el séptimo dígito ya está mal. Por lo tanto, podría no ser factible calcular 200 dígitos. Fue un ejercicio interesante de todos modos, ¡así que gracias!
Cristian Lupascu

1
Desea usar la transformación de Euler (vea mi respuesta de Jelly o la respuesta de Python de Primo)
Jonathan Allan

1
En referencia al documento que vinculó, es posible que le interese esta publicación , en la que vuelvo a implementar el código que se encuentra en este documento sin "ofuscación deliberada". También es bastante más simple (más corto) como resultado. Vea el método g1_refen la sección Generadores ilimitados más rápidos . El código es python.
primo

2

Haskell, 230 bytes

Usando la pereza para encontrar el número en cualquier parte de los dígitos infinitos de pi, no solo en los primeros 200 dígitos. Ah, sí, y te devuelve cada (¿infinidad de?) Instancia (s) del número, no solo la primera.

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]

Ejemplos del desafío

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

Créditos

'p' es la secuencia infinita de dígitos pi, tomada de 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]

Supongo que ya lo sabes, pero solo necesitas mostrar el primer número de tu secuencia ...
Timtech

Solo pensé en abrazar el infinito: D
tombop

2

SmileBASIC, 179 164 bytes

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

Los dígitos de pi están codificados y empaquetados en los valores ascii de los caracteres. 14 -> CHR$(14), 15 -> CHR$(15), 92 -> \, 65 -> A, 35 -> #.

La cadena contiene caracteres no imprimibles, así que aquí están los bytes escritos en hexadecimal: 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

En decimal, puedes ver los dígitos de 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


Si publica el código completo, sería más fácil verificar su respuesta.
primo

1
No puedo publicarlo porque hay caracteres no válidos que se eliminan / no se muestran. Aunque creo que puedo publicar los códigos ASCII.
12Me21

Puede publicar un hexdump, usando xxd por ejemplo.
Nathaniel

2

Ruby , 37 35 bytes

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

Pruébalo en línea!

Nada especial, solo muestra la biblioteca incorporada. La salida está indexada en 0. La cadena Pi está formateada como 0.31415...e1, por lo que necesitamos quitar los primeros 3 caracteres. La e1parte al final realmente no hace ningún daño, pero también se elimina, ya que de todos modos debemos proporcionar un valor de final de rango (o longitud de corte).


corto y legible!
pjs

2

Carbón , 27 15 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Funciona hasta casi 1000 dígitos. Explicación:

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

fijo, 13 bytes . nota al margen: esto se siente realmente engañoso: P
Solo ASCII

En realidad fijo, 13 bytes . usa entrada implícita. (comportamiento no intencionado pero parece más útil que cualquier otra forma). ¿también podría vincular a un ejemplo del error de relleno?
Solo ASCII

@ Rareza de relleno solo ASCII : ¿por qué el cursor termina allí?
Neil

: | oh, no tengo idea de que debería arreglar eso lo antes posible
solo ASCII el

nvm soy un idiota , una solución comprometida.
Solo ASCII

2

Japt , 186 177 bytes

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

Dado que Japt comparte la restricción Pi de 15 dígitos de JavaScript y shoco , la codificación utilizada por Japt no codifica números, se requieren algunas travesuras para la compresión.

Brevemente explicado, el comienzo es la siguiente cadena en forma codificada:

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

Que es una cadena donde cada letra es 'm' + corresponding digit of pi . Probé todo el alfabeto y esa letra da la mejor compresión en unos pocos bytes.

Los backticks le dicen a Japt que decodifique la cadena. El resto es bastante sencillo:

®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.

Emite un índice basado en 0 del fragmento coincidente.
Afeitó otros dos bytes gracias a Oliver .

Pruébalo en línea!


1
¡Idea inteligente! Puede reemplazar £Xcon ®y } conÃ
Oliver

@ Oliver Muchas gracias por eso, todavía estoy aprendiendo Japt, así que toda la ayuda es muy apreciada.
Nit

1
¡Lo has estado haciendo muy bien hasta ahora! Tenía curiosidad por ver si había un mejor desplazamiento que 109. Hice un bruteforcer , y resulta que 109 es óptimo. Bien hecho :)
Oliver

@Oliver Gracias por eso, simplemente probé todo el rango az manualmente ya que no era demasiado trabajo. : P
Nit

1

AWK -M, 131 119 117 bytes

Utiliza la -Mbandera para cálculos de precisión arbitrarios. Agregado p=k=0(5 bytes) al enlace TIO para permitir la entrada multilínea

{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

Pruébalo en línea!

Explicación:

{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

Mi primer intento solía sprintfobtener los decimales. Usar CONVFMTes definitivamente más limpio.
Robert Benson el

2
No es necesario usar la bandera: el meta consenso es considerar esto como un lenguaje distinto de AWK , "AWK con -Mbandera"
Giuseppe

Bueno saber. Supongo que debería pasar más tiempo en meta ... con mis montones de tiempo libre. :)
Robert Benson el

1

Jalea , 24 bytes

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

Pruébalo en línea!

Use una fórmula similar a Machin , específicamente 1/4 pi == tan -1 (1/2) + tan -1 (1/3).

Use la fórmula pi / 2 == 1 + 1/3 × (1 + 2/5 × (1 + 3/7 × (1 + 4/9 × (...))))


¿Hay alguna forma de obtener dígitos ØPen M?
dylnan

@dylnan Algo , pero M no es Jelly.
user202729

Sé que son diferentes. No puedo creer que no haya pensado floor. ¿Te importa si uso eso para publicar como respuesta en M?
dylnan


1

Python 2 239 238 229 214 bytes

-9 bytes debido 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

Utiliza el algoritmo Chudnovsky-Ramanujan para encontrar los primeros 1 millón de dígitos 50000 dígitos de π (cambiar 10**10**5a 10**10**6más, pero lleva años ejecutarlos) y luego busca la cadena deseada.


Traté de confirmar el resultado, pero parece que no termina ( n=10**10**5tarda unos 10 segundos).
primo

@primo ¡Nunca dije que fuera rápido! 10**10**6toma alrededor de 7 minutos en mi máquina ... Para ser justos, 10**10**5da los primeros 50000 dígitos, así que supongo que tampoco es tan malo :)
DividedByZero 05 de

@primo He cambiado la biblioteca de precisión arbitraria a bigfloat, ahora funciona mucho más rápido.
DividedByZero

Es mucho más rápido ahora, iba a sugerir cambiar a gmpy2, pero bigfloatahorra una docena de bytes. La asignación de kse puede combinar k=b=0si se mueve k+=1al inicio de la iteración. -(6*k-5)*(2*k-1)*(6*k-1)se puede escribir de manera más sucinta como k*(k*(108-72*k)-46)+5. Si declara Python 2, las //divisiones de enteros se pueden reemplazar por /, y tampoco se necesitan paréntesis print. El espacio también se puede eliminar en import*. Solo valida a 50000 dígitos, por cierto.
primo

El nen sqrt(10005*n)parece ser el problema; mueve el punto decimal al lugar 50000. En caso de que esté interesado, aquí está mi propia implementación de Chudnovsky: ¡ Pruébelo en línea!
primo

1

Visual Basic - 114 bytes

Bien, primera presentación. ¡Se paciente conmigo!

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

Comentarios bienvenidos!

No me he limitado a las primeras 256 partes de PI ya que la pregunta dice "No tienes que hacerlo", no "No deberías" Espero que esté haciendo esto correctamente :)


No sé mucho sobre virtual básico, pero supongo que puede guardar algunos bytes eliminando todos los espacios. También debería poder almacenar su código en una función y devolver el valor en lugar de "console.log" (supongo que obtendría algunos bytes como ese). Ah, y tienes que ingresar el valor y no codificarlo.
El tipo al azar

Gracias. Se eliminaron espacios y se eliminó el valor codificado a favor de la entrada. Aumenta el recuento a 114! ¿La función para devolver el valor no se incluiría en el recuento de bytes? Me imagino que sería más largo si es así
user9338709

Bienvenido al sitio! Parece que funciona (¡ pruébelo en línea! ), Pero parece ser un fragmento y las presentaciones deben ser un programa completo o una función.
Dom Hastings

Algo como esto podría funcionar, ¡pero probablemente hay mejores maneras de hacer las cosas! ¡Mira el menú de enlaces en la parte superior de esa página para ver la plantilla que utilizan muchas presentaciones!
Dom Hastings

En realidad, parece que la constante no tiene 200 dígitos :( ¡ Pruébelo en línea! - Esto debería devolver 197.
Dom Hastings

0

Javascript 217 bytes (200 codificados)

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

0

PHP, 27 bytes

No es una respuesta muy seria, requiere un cambio en la configuración de php.ini ya que pi () está predeterminado a 14 dígitos, no a 200, pero por una vez la solución PHP es bastante elegante:

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

No creo que esto realmente funcione. la precisionetiqueta en php.ini solo altera la precisión de visualización, y en realidad no aumenta la precisión de las constantes definidas. testigo
primo

0

Julia 0.6 , 53 bytes

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

Establezca la precisión para BigFloats lo suficientemente alta, luego conviértala pien una cadena y busque. Precisión de 9^6asas 159980 dígitos.

Pruébalo en línea!



0

Perl 5 con -MMath::BigFloat+bpiy -n, 20 bytes

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

Pruébalo en línea!

No estoy seguro de donde el uso de $>soportes, ya que es la EFFECTIVE_USER_IDque no es portátil, pero en esta TIO es de 1000 y satisface nuestras necesidades, por -1 bytes vs 200.


Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.