Défi :

Pi est censé être infini. Cela signifie que chaque nombre est contenu dans la partie décimale de pi. Votre tâche sera de prendre un entier positif en entrée et de retourner la position de ce nombre en chiffres pi en sortie.

Par exemple, si l'entrée est 59, nous retournerons4

Voici pourquoi: nous allons chercher le nombre 59dans les chiffres de pi

3.14159265...
     ^^

La valeur commence au 4ème chiffre, donc la sortie sera 4.

Quelques autres exemples:

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

Règles :

• Vous n'avez pas à gérer les chiffres qui n'existent pas dans les 200 premiers chiffres
• Les failles standard sont, comme toujours, interdites.
• Il s'agit de codegolf , donc le moins d'octets gagne.

Python 2, 69 75 71 67 octets

Enregistré 4 octets en raison de coinheringaahing caird .

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

Ne pas trouver 3à la position zéro coût 6 2 octets. L'entrée est donnée sous forme de chaîne.

Essayez-le en ligne!

Version illimitée

Python 2, 224 octets

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

Utilisation d'un bout uni sans limite basé sur la même formule que celle utilisée ci-dessus.

Essayez-le en ligne!

Version plus rapide

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

Un robinet sans limite beaucoup plus rapide, basé sur Ramanujan # 39 .

Essayez-le en ligne!

Husk , 5 octets

€tİπd

Essayez-le en ligne!

Explication

€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 octets

=FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196")

Excel ne gère que 15 décimales, donc pi est simplement codé en dur. Cela devrait être une limite supérieure assez faible pour ce défi.

Java 8, 615 217 202 184 182 166 165 165 octets (calculé 999 200 chiffres)

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 indexé

Essayez-le en ligne.

La fonction intégrée de Java Math.PIa une précision de 15 valeurs décimales, comme beaucoup d'autres langages. Pour avoir plus de chiffres, vous devrez les calculer vous-même avec BigIntegersou BigDecimals. Ce qui précède est une façon de le faire .. Peut - être que quelqu'un peut le golf ce ci - dessous 211 octets, lol ..
EDIT: Création d' un port de @primo « s réponse Python 2 (assurez - vous de le upvote!), Si le calcul étant plus courte que dure -coded n'est plus si farfelu. Juste 7 octets de plus pour jouer au golf pour qu'il soit plus court.

-15 octets grâce à @Neil , ce qui le rend plus court que la réponse codée en dur ci-dessous!
-36 octets grâce à @primo .
-1 octet change java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;à var T=java.math.BigInteger.TEN.pow(200);var r=T;, car varest 1 octet plus courte que null(dois - amour le nouveau Java 10).

Explication:

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 octets (200 chiffres codés en dur)

"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf

0 indexé

Essayez-le en ligne.

05AB1E , 6 octets

₁žs¦¹k

Essayez-le en ligne!

Comment?

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

MATL , 16 15 octets

YP8WY$4L)jXfX<q

Essayez-le en ligne!

Explication

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

RPaquet de numéros +, 52 octets

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

Essayez-le en ligne!

dropletPicalcule les 200 premiers chiffres décimaux de pimais inclut un 3.au début, donc nous supprimons cela avec substringpuis nous faisons correspondre avec regexec, qui retourne l'index de la correspondance avec quelques métadonnées sur la correspondance.

Gelée , 23 octets

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

Un lien monadique acceptant une liste de caractères (l'entier à trouver) et renvoyant l'index. Fonctionne pour les entrées contenues dans les 252 premiers chiffres de la partie décimale de π.

Essayez-le en ligne!

Comment?

Cela utilise la formule de Leibniz pour π pour calculer les 253 premiers chiffres, y compris le premier 3(plus quatre derniers chiffres incorrects). Le début 3est ensuite supprimé et l'index de l'entrée est trouvé:

⁵*⁹Ḥ;ȷḊ+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 vous préférez une liste de chiffres comme entrée, utilisez ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(également 23), tandis que si vous voulez vraiment lui donner une utilisation entière ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(pour 24).

BASH (GNU / Linux), 75 67 66 octets

1 octet enregistré grâce à Sophia Lechner et 7 octets grâce au charlatan des vaches.

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

Il s'agit d'un script shell qui prend un seul argument, qui est le nombre. Testez avec

$ bash <script-path> 59
4

Ce script exécute d'abord un pipeline de trois commandes:

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

Le résultat de ce pipeline est affecté à la variable shell a, qui est ensuite renvoyée avec tout sauf le premier nombre supprimé:

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

Malheureusement, bca tendance à casser les lignes de sortie quand elles deviennent trop longues. Cela peut conduire à des résultats erronés si le numéro à trouver n'est pas sur la première ligne. Vous pouvez éviter cela en définissant la variable d'environnement BC_LINE_LENGTH:

export BC_LINE_LENGTH=0

Cela désactive complètement la fonction de saut de ligne.

Évidemment, les deux dernières commandes peuvent être omises si une autre sortie est tolérée.
Cela donne un nombre de 48 octets :

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

Avec la sortie résultante:

$ 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: Merci, Neil !}

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

Prend une série d'entiers de base 36 à neuf chiffres, les convertit en base 10 et les concatène pour créer les 200 premiers chiffres de pi.

Première fois faire du golf à code. Utilisez des délégués et des expressions lambda pour réduire les appels de fonction. V2 raccourcit le nom de la classe en un seul octet.

[C #], 361 355 octets

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

Version formatée:

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: j'ai mal compté la première version. C'était 361 octets, pas 363 octets.

[C #], tio version 218 octets

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

Essayez-le en ligne!

Haskell , 208 120 octets

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

Essayez-le en ligne!

^{Un grand merci à Jonathan Allan pour ses suggestions!}

Ancienne version (208 octets)

(+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 fait, je ne sais pas comment fonctionne le code ci-dessus; Je l'ai repris de ce document et tout ce que j'ai implémenté était la partie recherche. g(1,0,1,1,3,3)renvoie les chiffres de pi et est étonnamment efficace (il calcule 10 000 chiffres sur tio.run en moins de 4s).

L'entrée est une liste composée des chiffres du numéro à rechercher.

Essayez-le en ligne!

Haskell, 230 octets

Utiliser la paresse pour trouver le nombre n'importe où dans les chiffres infinis de pi, pas seulement dans les 200 premiers chiffres. Oh oui, et cela vous renvoie toutes les (infiniment nombreuses?) Instances du nombre, pas seulement la première.

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]

Exemples du défi

>  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édits

'p' est le flux infini de chiffres pi, extrait 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]

SmileBASIC, 179 164 octets

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

Les chiffres de pi sont codés en dur et regroupés dans les valeurs ascii des caractères. 14 -> CHR$(14), 15 -> CHR$(15), 92 -> \, 65 -> A, 35 -> #.

La chaîne contient des caractères non imprimables, voici donc les octets écrits en hexadécimal: 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 décimal, vous pouvez voir les chiffres 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

Rubis , 37 35 octets

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

Essayez-le en ligne!

Rien de spécial, juste pour présenter la bibliothèque intégrée. La sortie est indexée 0. La chaîne Pi est formatée en tant que 0.31415...e1, nous devons donc supprimer les 3 premiers caractères. lee1 partie à la fin ne fait pas vraiment de mal, mais elle est également supprimée, car nous devons de toute façon fournir une valeur de fin de plage (ou de longueur de tranche).

Fusain , 27 15 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Fonctionne jusqu'à près de 1000 chiffres. Explication:

        ≕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 octets

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

Puisque Japt partage la contrainte Pi à 15 chiffres et le shoco de Javascript , l'encodage utilisé par Japt ne code pas les nombres, certains manigances sont nécessaires pour la compression.

En bref, le début est la chaîne ci-dessous sous forme codée:

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

C'est une chaîne où se trouve chaque lettre 'm' + corresponding digit of pi. J'ai testé l'alphabet entier et cette lettre donne la meilleure compression de quelques octets.

Les backticks indiquent à Japt de décoder la chaîne. Le reste est assez simple:

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

Génère un index basé sur 0 du fragment correspondant.
Rasé encore deux octets grâce à Oliver .

Essayez-le en ligne!

AWK -M, 131 119 117 117 octets

Utilise l' -Mindicateur pour les calculs de précision arbitraires. Ajouté p=k=0(5 octets) au lien TIO pour permettre l'entrée multi-ligne

{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

Essayez-le en ligne!

Explication:

{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

Gelée , 24 octets

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

Essayez-le en ligne!

Utilisez une formule semblable à Machin , spécifiquement 1/4 pi == tan ^-1 (1/2) + tan ^-1 (1/3).

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

Python 2 239 238 229 214 bytes

-9 bytes due to @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

Uses the Chudnovsky-Ramanujan algorithm to find the first 1 million digits 50000 digits of π (change 10**10**5 to 10**10**6 for more, but it takes ages to run) and then searches them for the desired string.

Visual Basic - 114 Bytes

Okay, first submission. Go easy on me!

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

Feedback welcome!

I haven't restricted to the first 256 parts of PI as the question says "You don't have to", not "You shouldn't" Hope I'm doing this right :)

Javascript 217 bytes (200 hardcoded)

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

PHP, 27 bytes

^{Not a very serieus answer, it requires a change in the php.ini settings as pi() defaults to 14 digits, not 200, but for once the PHP solution is fairly elegant:}

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

Julia 0.6, 53 bytes

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

Set the precision for BigFloats high enough, then convert pi to a string and search. Precision of 9^6 handles 159980 digits.

Try it online!

J, 25 Bytes

{.I.(}.":<[email protected]^999)E.~

Try it online!

0-Indexed

Takes input as a string, +2 Bytes (":) if that's not allowed.

Explanation eventually.

Perl 5 with -MMath::BigFloat+bpi and -n, 20 bytes

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

Try it online!

I'm not sure where usage of $> stands, since it's the EFFECTIVE_USER_ID which is not portable, but on TIO this is 1000 and satisfies our requirement, for -1 byte vs. 200.

Husk, 5 bytes

€tİπd

Try it 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.