Fundo:

Pi ( π) é um número transcendental e, portanto, possui uma representação decimal não-terminante. Similar, a representação não termina se escrita em qualquer outra base inteira. Mas e se nós o escrevemos na base π?

Dígitos em decimais representam potências de 10, portanto:

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

Portanto, na base π, os dígitos representariam potências de π:

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

Nesta nova base, os números inteiros agora têm representações sem terminação. Portanto, 10 em decimal agora se torna o seguinte:

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

Observe que, na base, πos dígitos usados ​​são 0,1,2,3, porque esses são dígitos menores que π.

Desafio:

Dado um número inteiro não negativo x, ou:

1. Saída (sem parar) sua representação na base π. Se o número tiver uma representação finita (0, 1, 2, 3), o programa poderá parar em vez de imprimir zeros infinitos.

2. Pegue um número inteiro arbitrariamente grande ne produza os primeiros ndígitos de xem base π.

Regras:

• Como um número tem várias representações possíveis, você deve exibir a que aparece a maior (normalizada). Assim como 1.0 = 0.9999…em decimal, esse problema também existe nesta base. Na base π, um ainda está 1.0, mas também pode ser escrito como 0.3011…, por exemplo. Da mesma forma, dez é 100.01022…, mas também pode ser escrito como 30.121…ou 23.202….
• Isso é código-golfe, e o menor número de bytes vence. Programa ou função.
• Sem built-ins ( estou olhando para você , Mathematica )

Resultados:

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…

Primeiros 10.000 dígitos de dez na base Pi

Verificação:

Você pode verificar qualquer saída que desejar usando o código do Mathematica aqui . O primeiro parâmetro é x, o terceiro é n. Se expirar, escolha um pequeno ne execute-o. Em seguida, clique em "Abrir no código" para abrir uma nova planilha do Mathematica com o programa. Não há limite de tempo lá.

Converta a saída resultante em um número aqui .

Palavras-chave:

• Wikipedia: Representação não inteira
• Quora: O que é 10 na base pi?
• Math.SE: Como seria um sistema de números π base?
• Fórum XKCD: contando em um sistema de números pi base?

Julia 0.6 , 81 bytes

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 dígitos (e o. Que me custou 14 bytes) até que a Pilha ultrapasse os 22k dígitos no TIO. Se eu tiver permissão para passar a entrada como um BigFloat, posso cortar 5 bytes. Faz uso constante da precisão arbitrária incorporada π. Mas é um pouco mais legal do que isso, na verdade é uma constante de precisão adaptativa, π*1.0é um número de ponto flutuante de 64 bits π*big(1.0)(também conhecido como multiplicado por um número de precisão mais alto) π.

Experimente online!

Python 3 , 471 317 310 bytes

7 bytes graças a caird coinheringaahing.

Certamente existem campos que eu perdi. Sinta-se livre para apontá-los nos comentários.

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

Experimente online!

Versão não destruída:

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

Experimente online!

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

Experimente online!

Toma o número de entrada como xe a precisão desejada como n. Saídas por impressão. Faz uso da biblioteca incorporada do BigDecimal para o valor de PI de pecisão arbitrária.

Python 3 + sympy, 144 bytes

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

Experimente online!

Muito lento, na verdade.