Pi a ton numéro

30

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 , donc le moins d'octets gagne.
Le gars au hasard
la source
41
Les numéros avec la propriété que vous mentionnez sont appelés numéros normaux . Une expansion décimale infinie, même si elle n'est pas périodique, n'implique pas la normalité. 0.101001000100001 ... est un contre-exemple.
Dennis
38
Et, absolument, Pi n'est pas censé être infini. Sa représentation décimale, cependant, a des chiffres infinis.
rafa11111
11
@Dennis Normal est une condition beaucoup plus solide (tout uniforme vs tout existe)
user202729
6
Sommes-nous autorisés à sortir le n'e index indexé 0 ? Ainsi, les cas de texte reviendraient 0, 6, 41, 8au lieu de 1, 7, 42, 9.
Kevin Cruijssen
7
@ rafa11111 Je suis d'accord. Nous devons abandonner les entiers et utiliser des nombres dans la base-PI. Ensuite, les entiers auront à la place des chiffres infinis.
mbomb007

Réponses:

22

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!

primo
la source
Nice, ni hardcodes ni utilisation intégrée (parce que Python n'en a pas)
user202729
1
Réduction
triviale de
2
@Dennis 31 doit correspondre à 137: /
primo
2
De quel algorithme d'approximation s'agit-il? En est-il un répertorié ici? en.wikipedia.org/wiki/Approximations_of_%CF%80
Sphinxxx
4
@Sphinxxx, c'est le résultat d'appliquer la transformation d'Euler à la série Leibniz. J'ai publié une dérivation dans un précédent post .
primo
19

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
Fyr
la source
1
Ridicule - mais je dois admettre que je suis impressionné.
Floris
6
Avec les langues de golf, c'est généralement une bonne idée d'ajouter une explication, car quelqu'un qui ne connaît pas la langue ne pourra pas la lire. Si je comprends bien, c'est: Prenez l'index de ( ) avec le premier élément (le 3 en tête) supprimé ( t) des chiffres de PI ( İπ), convertissez-le en base 10 ( d) et sortez en STDOUT (implicitement).
Kevin Cruijssen
D'accord, je n'ai aucune idée de ce que je regarde.
JA Terroba
1
@gggg ressemble à un exemple de représentation paresseuse , vérification
ASCII uniquement
1
@gggg İπest une liste infinie de chiffres, créée avec une source de
H.PWiz
18

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.

Ingénieur Toast
la source
4
Je suis désolé de commenter mon propre post, mais certains des votants peuvent-ils me dire pourquoi ils aiment cette réponse? C'est aussi golfé que possible dans une formule Excel, mais c'est très long et pas du tout intelligent.
Ingénieur Toast
6
J'aime ça parce qu'il ne s'appuie pas sur les langages de golf qui ont intégré pour calculer pi à une décimale arbitraire. Ce n'est peut-être pas créatif, mais c'est pratique (pas que l'aspect pratique soit important ici).
Scott
Comme la question ne spécifie pas que l'entrée ou la réponse doit être en base 10, pourriez-vous jouer au golf en utilisant CONCATune formule BBP pour calculer les 200 premiers chiffres de π-base16 et rechercher à la place en hexadécimal? (Je n'ai pas 365, donc je ne peux pas tester)
Chronocidal
2
Office 365 uniquement: utilisation CONCAT, CODEet MIDj'ai réduit la chaîne PI de 202 caractères (guillemets CONCAT(CODE(MID(".ÜÁ£ÙÏ ¦®š«¦ Ï²œÔ“ÇŧÝËŠº”ᱬ»—‡ÑÀ†œ¾ˆãÖœƒ°™¢•‘†ÏÒŽÐÖ³ ÒžÂ¯‰¦¬¼ß²º–ŸÈµ»¨Ñœ°‹‘­‚ÔŠ›ÝÕ•Š·»À®–Þٶ݃Ñà",2*ROW(A1:A100)-1,2))-32)
compris
1
En testant avec Office365, il semble qu'il génère 14 indépendamment de l'entrée?
Matthew Schlachter
9

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.

Kevin Cruijssen
la source
1
!p.equals(t.ONE)peut-être? Aussi, indexOf(n,1)-1je pense que ça marche. Ou enregistrez 2 octets et rendez-le indexé 1.
Neil
Je ne sais pas comment j'ai raté le premier, mais le second dont je dois vraiment me souvenir. Je ne savais pas qu'il existait une indexOfméthode qui saute les premiers mcaractères. TIL, merci!
Kevin Cruijssen
1
Que diriez-vous de garder p un entier ?
primo
1
Vous pouvez également décrémenter pde un à chaque fois ( for(int p=667;p-->1;)), puis multiplier pet diviser par p-~p.
primo
1
La valeur initiale de rpeut littéralement être n'importe quoi, bien que les valeurs extrêmes nécessitent plus d'itérations. La meilleure graine (le moins d'itérations) est en fait 4e200.
primo
6

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
Uriel
la source
Si j'obtiens la solution similaire à 6 octets dans la même langue, après vous, est-ce que je supprime ma réponse?
nicael le
@nicael cela n'a généralement pas d'importance, mais votre solution échoue 3quand même
Uriel
Oh, en effet, merci
nicael
6

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
Luis Mendo
la source
Très joli et court! Pouvez-vous expliquer comment cela fonctionne?
Le gars au hasard
@Therandomguy Bien sûr, explication ajoutée
Luis Mendo
4

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.

Giuseppe
la source
Peut regexpr(scan(),numbers::dropletPi(200))-2- être ?
djhurio
@djhurio qui ne fonctionne pas car nous devons faire correspondre les chiffres après le point décimal. C'était aussi ma première pensée mais cette affaire la ruine. Peut-être un "if"?
Giuseppe
Je ne vois pas de problème ici. Aucune entrée ne contiendra 3.(je suppose que nous traitons avec des entiers non réels en entrée). Les exemples de test fonctionnent avec cela.
djhurio
3
@djhurio à droite mais regexpr(3,numbers::dropletPi(200))-2revient -1 quand il devrait revenir 9, essayez-le
Giuseppe
3

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

Jonathan Allan
la source
Vous voulez dire la transformation d'Euler appliquée à la formule de Leibniz. Calculer 252 chiffres avec la formule de Leibniz prendrait un peu plus longtemps que la plupart des gens seraient prêts à attendre.
primo
Oui, cela prendrait beaucoup de temps sous forme brute (c'est toujours "en utilisant la formule de Leibniz" je crois!)
Jonathan Allan
3

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
cmaster
la source
Agréable! Vous n'avez pas besoin de cet espace entre -let <<<bien.
Sophia Lechner
Vous pouvez convertir en programme et utiliser sed pour économiser quelques octets, essayez-le en ligne!
Kritixi Lithos
@Cowsquack Ne devrais-je pas alors avoir besoin d'inclure une ligne de shebang dans le nombre d'octets?
cmaster
Les lignes @cmaster shebang ne sont pas incluses dans le nombre d'octets pour toutes les langues
Kritixi Lithos
@Cowsquack Merci pour la suggestion. Cependant, si vous autorisez une sortie supplémentaire, vous pourriez aussi bien laisser de côté le sed(voir la deuxième partie de ma réponse). Néanmoins, la transformation en programme m'a donné 7 octets, alors merci! J'ai également remplacé le tr/ headcombo par la magie variable du shell maintenant pour enregistrer un autre octet.
cmaster
2

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.

absides
la source
Sympa, vous soufflez mes tentatives d'encodage des données hors de l'eau, votre approche économise 38 octets sur les données brutes.
Nit
+1 - J'étais sur le point de publier exactement la même approche.
darrylyeo
Utilisez x=>'50...'.replace(/.{9}/g,a=>parseInt(a,36)).search(x)+1pour économiser 10 octets.
Neil
2

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!

Han
la source
Vous n'avez pas besoin d'inclure les cas de test dans votre code, et vous pouvez simplement utiliser une fonction lambda (anonyme) au lieu d'un programme complet
Zac Faragher
Hyarus a suggéré using System;f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;une modification.
2018
Je suis nouveau ici et je pensais que je devais inclure un programme complet comprenant le cas de test. Il semble que les gens utilisent tio.run pour la démonstration au lieu de l'idéone. Je vois que tio.run divise le code en parties.
Han
2

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!

Cristian Lupascu
la source
Je suppose que la formule de Leibniz sera beaucoup plus courte.
Jonathan Allan
@JonathanAllan Merci! Je vais essayer. J'adore ce site! J'ai tellement appris de vous, les gars! :)
Cristian Lupascu
@JonathanAllan J'ai essayé d'approximer pi en utilisant l=4*sum[((-1)**x/(2*x+1))|x<-[0..1e6]], mais cela prend 5 secondes pour fonctionner et le 7ème chiffre est déjà faux. Il pourrait donc ne pas être possible de calculer 200 chiffres. C'était un exercice intéressant de toute façon, alors merci!
Cristian Lupascu
1
Vous voudriez utiliser la transformation d'Euler (voir ma réponse Jelly ou la réponse Python de Primo)
Jonathan Allan
1
En référence à l'article que vous avez lié, vous pourriez être intéressé par cet article , dans lequel je réimplémente le code trouvé dans cet article sans "obfuscation délibérée". C'est aussi un peu plus simple (plus court) en conséquence. Voir la méthode g1_refdans la section Générateurs plus rapides et sans limites . Le code est en python.
primo
2

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]
tombop
la source
Je suppose que vous le savez déjà, mais il vous suffit de sortir le premier numéro de votre séquence ...
Timtech
Je pensais juste embrasser l'infini: D
tombop
2

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

12Me21
la source
Si vous postez le code complet, il serait plus facile de vérifier votre réponse.
primo
1
Je ne peux pas le poster car il y a des caractères invalides qui sont supprimés / non affichés. Je suppose que je peux poster les codes ascii cependant.
12Me21
Vous pouvez publier un hexdump, en utilisant xxd par exemple.
Nathaniel
2

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

Kirill L.
la source
court ET lisible!
pjs
2

Fusain , 27 15 octets

I⊖∨⌕I▷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
    I           Cast to string
             θ  First input
   ⌕            Find
              χ Predefined variable 10
   ∨             Logical OR
  ⊖              Decrement
 I               Cast to string
                 Implicitly print
Neil
la source
fixe, 13 octets . note latérale: cela semble vraiment tricheur: P
ASCII uniquement
en fait fixe, 13 octets . utilise une entrée implicite. (comportement non prévu mais il semble plus utile que toute autre manière). pourriez-vous également créer un lien vers un exemple de bogue de remplissage?
ASCII uniquement
@ ASCII uniquement Remplissage bizarre - pourquoi le curseur se retrouve-t-il là?
Neil
: | oh je n'ai aucune idée que je devrais résoudre ce problème dès que possible
ASCII uniquement
nvm je suis un idiot , un correctif engagé.
ASCII uniquement à
2

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!

Lente
la source
1
Idée brillante! Vous pouvez remplacer £Xpar ®et } avecÃ
Oliver
@Oliver Merci beaucoup pour ceux-ci, j'apprends toujours Japt donc toute aide est très appréciée.
Nit
1
Vous vous en sortez bien jusqu'à présent! J'étais curieux de voir s'il y avait un meilleur décalage que 109. J'ai fait un bruteforcer , et il s'avère que 109 est optimal. Bien joué :)
Oliver
@Oliver Merci pour cela, j'ai simplement essayé toute la gamme az manuellement car ce n'était pas trop de travail. : P
Nit
1

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
Robert Benson
la source
Ma première tentative sert sprintfà obtenir les décimales. L'utilisation CONVFMTest définitivement plus propre.
Robert Benson
2
Pas besoin d'utiliser le drapeau: le méta-consensus est de considérer cela comme un langage distinct d'AWK , "AWK avec -Mdrapeau"
Giuseppe
Bon à savoir. Je suppose que je devrais passer plus de temps sur la méta ... avec mes charges de temps libre. :)
Robert Benson
1

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 × ( ... ))))

user202729
la source
Is there a way to get digits from ØP in M?
dylnan
@dylnan Somewhat, but M is not Jelly.
user202729
I know they're different. Can't believe I didn't think of floor. Mind if I use that to post as answer in M?
dylnan
Nevermind. Doesn't work above 104 digits...
dylnan
1

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.

DividedByZero
la source
I tried to confirm the result but it doesn't seem to terminate (n=10**10**5 takes about 10s).
primo
@primo I never said it was fast! 10**10**6 takes about 7 minutes on my machine.. To be fair, 10**10**5 gives the first 50000 digits, so I guess it's not that bad either :)
DividedByZero
@primo I've changed the arbitrary precision library to bigfloat, it runs much quicker now.
DividedByZero
It's much faster now, I was going to suggest switching to gmpy2, but bigfloat saves a dozen or so bytes. The assignment of k can be merged with k=b=0 if you move k+=1 to the start of the iteration. -(6*k-5)*(2*k-1)*(6*k-1) can be written more succinctly as k*(k*(108-72*k)-46)+5. If you declare Python 2, the // integer divisions can be replaced by /, and also parentheses aren't necessary for print. Space can also be removed in import*. Only validates to 50000 digits, btw.
primo
The n in sqrt(10005*n) seems to be the problem; it's moving the decimal point to 50000th place. In case you're interested, here's my own Chudnovsky implementation: Try it online!
primo
1

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 :)

user9338709
la source
I don't know much about virtual basic, but i guess you can save some bytes by removing all the spaces. You also should be able to store your code into a function and return the value instead of "console.log" it (i guess you would gain some bytes like that). Oh, and you have to input the value and not hardcode it.
The random guy
Thanks. Removed spaces and removed the hardcoded value in favour of input. Increases the count to 114! Would the function for returning the value not be included in the byte count? I imagine it would make it longer if so.
user9338709
Welcome to the site! This looks like it works (try it online!), but it appears to be a snippet and submissions need to be either a full program, or a function.
Dom Hastings
Something like this might work, but there are probably better ways to do the things! Check out the link menu at the top of that page for the template a lot of submissions use!
Dom Hastings
Actually, it looks like the constant doesn't have 200 digits :( Try it online! - this should return 197.
Dom Hastings
0

Javascript 217 bytes (200 hardcoded)

a=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".search(a)+1
Luis felipe De jesus Munoz
la source
0

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;
Martijn
la source
I don't think this will actually work. the precision tag in php.ini only alters the display precision, and doesn't actually increase the precision of defined constants. witness
primo
0

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!

gggg
la source
0

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.

Dom Hastings
la source
0

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.
Unrelated String
la source