Pi est un nombre irrationnel , ce qui signifie que sa représentation décimale ne se termine ou ne se répète jamais.

Pi tronqué à 41 chiffres décimaux (40 places) est 3.1415926535897932384626433832795028841971.

Si nous ignorons le point décimal et listons les chiffres comme une séquence d'entiers positifs, en évitant les doublons , nous obtenons 3 1 4 15 9 2 6 5 35 8 97 93 23 84 62 64 33 83 27 950 28 841 971( OEIS A064809 ).
(Remarquez que cela 15apparaît dans la séquence plutôt que 1 5parce que cela 1s'est déjà produit.
Notez également que 0cela ne se produit pas car il n'est pas positif; 950contient le premier zéro.)

Pour construire le premier nombre de rotation, nous utilisons cette séquence pour indexer les chiffres de Pi (le premier chiffre étant 3, le second 1, etc.).

Ainsi, le premier chiffre du premier numéro de rotation est le 3e chiffre de Pi,
le deuxième chiffre est le 1er chiffre de Pi,
le troisième chiffre est le 4e chiffre de Pi,
le quatrième est le 15e chiffre de Pi,
et ainsi de suite.
Un point décimal est ajouté après le premier chiffre pour imiter Pi.

Ainsi, le premier numéro de pirration à 41 chiffres est 4.3195195867462520687356193644029372991880.
(Notez que pour le 30e chiffre, j'ai dû aller jusqu'au 974e chiffre de Pi.)

Pour construire le deuxième nombre de pirations, le processus est répété en utilisant le premier nombre de pirations au lieu de Pi. (Pi lui-même peut être appelé le nombre pirational zéro.) Ainsi, la nouvelle séquence est 4 3 1 9 5 19 58 ...et le premier nombre piirational est indexé pour produire la seconde, qui commence 9.14858....

D'autres nombres de pirration sont créés de la même manière, chacun étant généré à partir du précédent.

Défi

Votre tâche consiste à écrire le programme le plus court possible qui accepte deux nombres entiers, Net D, et Ngénère le numéro de génération tronqué en Dchiffres décimaux.

Dest toujours positif mais Nn'est pas négatif, et les Dchiffres de Pi doivent être sortis quand Nest 0.
Quand Dest 1, peu importe si le séparateur décimal est présent ou non.

L'entrée doit provenir de stdin ou de la ligne de commande et la sortie doit aller à stdout (ou aux alternatives les plus proches de votre langue).

Votre programme devrait fonctionner pour toutes les valeurs d'entrée inférieures Nou Dégales à 2 ¹⁶ , mais il ne doit pas être opportun ni efficace.

Le code le plus court en octets gagne.

(Notez que les nombres pirrationnels sortent dans d'autres bases mais tout dans ce défi se fait en base 10.)

Python 292 octets

Assez inefficace, je n'ai pu obtenir que quelques chiffres de N = 3 et aucun de N = 4.

import sympy
def P(N,D,s=''):
 if N<1:return'3'+`sympy.pi.evalf(D+9)`[2:-9]
 for i in range(D):
    h=[];l='';j=i;x=0
    while-~j:
     x+=1;d=P(N-1,x)[-1];l+=d
     while'1'>P(N-1,x+1)[-1]:x+=1;l+='0'
     if(l in h)<1:h+=[l];l='';j-=1
    s+=P(N-1,int(h[i]))[-1]
 return s
s=P(*input())
print s[0]+'.'+s[1:]

Exemple d'entrée:

0,20
3.1415926535897932384

1,20
4.3195195867462520687

2,10
9.148583196

3,5
9.9815

Haskell, 431 400 369

import Data.List
g(q,r,t,k,n,l)|4*q+r-t<n*t=n:g(q#0,(r-n*t)#0,t,k,div(r#(30*q))t-n#0,l)|1<2=g(q*k,(2*q+r)*l,t*l,k+1,div(q*(7*k+2)+r*l)(t*l),l+2)
u w@(x:y:xs)=x:v y xs 0 w
v a(r:s)n w|a`elem`take n(u w)||r==0=v(a#r)s n w|1<2=a:v r s(n+1)w
m p=map(genericIndex p.pred)$u p
a#b=a*10+b
(x:s)%n=show x++'.':show(foldl1(#)$n`take`s)
f n d=print$iterate m(g(1,0,1,1,3,3))!!n%d

Je dois aimer des listes infinies! Avec suffisamment de temps et de mémoire, ce programme finira par calculer la bonne réponse pour tout N et D (je suppose).

Je génère les chiffres de pi en gutilisant un algorithme de spigot (volé sans vergogne à un gars appelé Stanley Rabinowitz), en regroupant les chiffres / en créant la séquence en utilisant vet en générant un nombre de pirration à partir de ceux-ci en utilisant m.

Le voici en action:

λ> f 0 10
"3.1415926535"
λ> f 1 10
"4.3195195867"
λ> f 2 10
"9.Interrupted. --didn't have the time to wait for this to finish
λ> f 2 4
"9.1485"