Contexte:

Pi ( π) est un nombre transcendantal , et donc il a une représentation décimale sans terminaison. De même, la représentation ne se termine pas si elle est écrite dans une autre base entière. Et si on l'écrivait en base π?

Les chiffres en décimal représentent des puissances de 10, donc:

π = 3.14… = (3 * 10^0) + (1 * 10^-1) + (4 * 10^-2) + …

Donc en base π, les chiffres représenteraient des puissances de π:

π = 10 = (1 * π^1) + (0 * π^0)

Dans cette nouvelle base, les entiers ont désormais des représentations non terminales. Donc 10 en décimal devient maintenant le suivant:

10 => 100.01022… = (1 * π^2) + (0 * π^1) + (0 * π^0) + (0 * π^-1) + (1 * π^-2) + …

Notez qu'en base πles chiffres utilisés sont 0,1,2,3 car ce sont les chiffres inférieurs à π.

Défi:

Étant donné un entier non négatif x, soit:

1. Sortir (sans s'arrêter) sa représentation en base π. Si le nombre a une représentation finie (0, 1, 2, 3), le programme peut s'arrêter au lieu d'imprimer des zéros infinis.

2. Prenez un entier arbitrairement grand net sortez les premiers nchiffres de xen base π.

Règles:

• Puisqu'un nombre a plusieurs représentations possibles, vous devez sortir celle qui apparaît la plus grande (normalisée). Tout comme 1.0 = 0.9999…en décimal, ce problème existe également dans cette base. En base π, on est encore 1.0, mais pourrait aussi s'écrire 0.3011…par exemple. De même, dix est 100.01022…, mais pourrait également s'écrire 30.121…ou 23.202….
• Il s'agit de code-golf, donc le moins d'octets gagne. Programme ou fonction.
• Pas Encastrements ( je regarde vous , Mathematica )

Résultats:

0       = 0
1       = 1
2       = 2
3       = 3
4       = 10.220122021121110301000010110010010230011111021101…
5       = 11.220122021121110301000010110010010230011111021101…
6       = 12.220122021121110301000010110010010230011111021101…
7       = 20.202112002100000030020121222100030110023011000212…
8       = 21.202112002100000030020121222100030110023011000212…
9       = 22.202112002100000030020121222100030110023011000212…
10      = 100.01022122221121122001111210201201022120211001112…
42      = 1101.0102020121020101001210220211111200202102010100…
1337    = 1102021.0222210102022212121030030010230102200221212…
9999    = 100120030.02001010222211020202010210021200221221010…

10 000 premiers chiffres de dix en base Pi

Vérification:

Vous pouvez vérifier n'importe quelle sortie souhaitée à l'aide du code Mathematica ici . Le premier paramètre est x, le troisième est n. S'il expire, choisissez-en un petit net lancez-le. Cliquez ensuite sur "Ouvrir dans le code" pour ouvrir une nouvelle feuille de calcul Mathematica avec le programme. Il n'y a pas de limite de temps là-bas.

Convertissez la sortie résultante en nombre ici .

En relation:

• Wikipédia: représentation non entière
• Quora: Qu'est-ce que 10 en base pi?
• Math.SE: À quoi ressemblerait un système de nombres π de base?
• Forum XKCD: Compter dans un système de nombres pi de base?

Julia 0,6 , 81 octets

f(x,i=log(π,x)÷1)=(y=big(π)^i;d::Int=x÷y;print(i==0?"$d.":"$d");f(x-d*y,i-1))

Imprime des chiffres (et le. Qui m'a coûté 14 octets) jusqu'à ce que la pile déborde à environ 22k chiffres sur TIO. Si je suis autorisé à passer l'entrée en tant que BigFloatje peux couper 5 octets. Utilise la constante de précision arbitraire intégrée π. Mais c'est un peu plus cool que cela, c'est en fait une constante de précision adaptative, π*1.0c'est un nombre à virgule flottante de 64 bits, π*big(1.0)(alias multiplié par un nombre de précision plus élevé) donne πquel que soit votre précision.

Essayez-le en ligne!

Python 3 , 471 317 310 octets

7 octets grâce à caird coinheringaahing.

Il y a sûrement des golfs que j'ai ratés. N'hésitez pas à les signaler dans les commentaires.

def h(Q):
	a=0;C=b=4;c=d=s=1;P=o=3
	while P^C:
		a,b,c,d,s,o,P,A,B=b,s*a+o*b,d,s*c+o*d,s+o,o+2,C,0,1
		for I in Q:B*=c;A=A*a+I*B
		C=A>0
	return P
def f(n,p):
	Q=[-n];R=""
	while h([1]+Q)<1:Q=[0]+Q
	Q+=[0]*p
	for I in range(len(Q)):
		i=3;Q[I]+=3
		while h(Q):Q[I]-=1;i-=1
		R+=str(i)
	return R[:-p]+"."+R[-p:]

Essayez-le en ligne!

Version non golfée:

def poly_eval_pi_pos(poly,a=0,b=4,c=1,d=1,o=3,s=1,prev=9,curr=6):
	while prev != curr:
		a,b,c,d,s,o=b,s*a+o*b,d,s*c+o*d,s+o,o+2
		prev = curr
		res_n, res_d = 0,1
		for I in poly:
			res_d *= c
			res_n = res_n*a + I * res_d
		curr = res_n > 0
	return prev
def to_base_pi(n,precision):
	poly = [-n]
	res = ""
	while not poly_eval_pi_pos([1]+poly):
		poly = [0]+poly
	poly += [0]*precision
	for index in range(len(poly)):
		i = 3
		poly[index] += 3
		while poly_eval_pi_pos(poly):
			poly[index] -= 1
			i -= 1
		res += str(i)
	return res[:-precision]+"."+res[-precision:]

Essayez-le en ligne!

Ruby -rbigdecimal/math , 111 103 97 bytes

->x,n{q=BigMath::PI n;r=q**m=Math.log(x,q).to_i;n.times{$><<"#{?.if-2==m-=1}%i"%d=x/r;x%=r;r/=q}}

Essayez-le en ligne!

Prend le nombre d'entrée comme xet la précision souhaitée comme n. Sorties par impression. Utilise la bibliothèque BigDecimal intégrée pour une valeur PI de précision arbitraire.

Python 3 + sympy, 144 octets

from sympy import*
def f(n,p):
	R="";O=n and int(log(n,pi));r=pi**O
	for _ in range(O+p):R+=str(int(n/r));n%=r;r/=pi
	return R[:O+1]+"."+R[O+1:]

Essayez-le en ligne!

Assez lent, en fait.