Antecedentes:

Pi ( π) es un número trascendental y, por lo tanto, tiene una representación decimal sin terminación. Similar, la representación no termina si está escrita en cualquier otra base entera. Pero, ¿y si lo escribimos en la base π?

Los dígitos en decimal representan potencias de 10, entonces:

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

Entonces, en base π, los dígitos representarían poderes de π:

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

En esta nueva base, los enteros ahora tienen representaciones sin terminación. Entonces 10 en decimal ahora se convierte en lo siguiente:

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

Tenga en cuenta que en base πlos dígitos utilizados son 0,1,2,3 porque estos son los dígitos menores que π.

Desafío:

Dado un número entero no negativo x, ya sea:

1. Salida (sin detener) su representación en base π. Si el número tiene una representación finita (0, 1, 2, 3), entonces el programa puede detenerse en lugar de imprimir ceros infinitos.

2. Tome un entero arbitrariamente grande ny genere los primeros ndígitos de xin base π.

Reglas:

• Dado que un número tiene múltiples representaciones posibles, debe generar la que parece más grande (normalizada). Al igual que 1.0 = 0.9999…en decimal, este problema también existe en esta base. En la base π, uno está quieto 1.0, pero también podría escribirse como 0.3011…, por ejemplo. Del mismo modo, diez es 100.01022…, pero también podría escribirse como 30.121…o 23.202….
• Este es el código de golf, por lo que gana menos bytes. Programa o función.
• No hay muebles empotrados ( estoy mirando a usted , 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…

Primeros 10,000 dígitos de diez en la base Pi

Verificación:

Puede verificar cualquier salida que desee utilizando el código de Mathematica aquí . El primer parámetro es x, el tercero es n. Si se agota el tiempo de espera, elige uno pequeño ny ejecútalo. Luego haga clic en "Abrir en Código" para abrir una nueva hoja de trabajo de Mathematica con el programa. No hay límite de tiempo allí.

Convierta la salida resultante a un número aquí .

Relacionado:

• Wikipedia: representación no entera
• Quora: ¿Qué es 10 en base pi?
• Math.SE: ¿Cómo sería un sistema de números base π?
• Foro XKCD: ¿Contar en un sistema base de números pi?

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 (y el. Que me costó 14 bytes) hasta que la pila se desborda a unos 22k dígitos en TIO. Si se me permite pasar la entrada como un BigFloatpuedo cortar 5 bytes. Hace uso de la constante de precisión arbitraria incorporada π. Pero es un poco más genial que eso, en realidad es una constante de precisión adaptativa, π*1.0es un número de coma flotante de 64 bits, π*big(1.0)(también conocido como multiplicado por un número de precisión más alto) da πlo que sea que esté establecida su precisión.

Pruébalo en línea!

Python 3 , 471 317 310 bytes

7 bytes gracias a caird coinheringaahing.

Seguramente hay campos de golf que me perdí. Siéntase libre de señalarlos en los comentarios.

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

Pruébalo en línea!

Versión sin golf:

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

Pruébalo en línea!

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

Pruébalo en línea!

Toma el número de entrada como xy la precisión deseada como n. Salidas por impresión. Utiliza la biblioteca incorporada BigDecimal para el valor PI de precisión arbitraria.

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

Pruébalo en línea!

Muy lento, en realidad.