Sfondo:

Pi ( π) è un numero trascendentale e quindi ha una rappresentazione decimale non terminante. Simile, la rappresentazione non termina se scritta in qualsiasi altra base intera. E se lo scrivessimo in base π?

Le cifre in decimale rappresentano potenze di 10, quindi:

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

Quindi, in base π, le cifre rappresenterebbero i poteri di π:

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

In questa nuova base, gli interi ora hanno rappresentazioni non terminanti. Quindi 10 in decimale ora diventa il seguente:

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

Si noti che in base πle cifre utilizzate sono 0,1,2,3 perché queste sono le cifre inferiori a π.

Sfida:

Dato un numero intero non negativo x, sia:

1. Emette (senza arrestare) la sua rappresentazione in base π. Se il numero ha una rappresentazione finita (0, 1, 2, 3), il programma potrebbe arrestarsi invece di stampare zero infiniti.

2. Prendi un numero intero arbitrariamente grande ne genera le prime ncifre di xin base π.

Regole:

• Poiché un numero ha più possibili rappresentazioni, è necessario produrre quello che appare più grande (normalizzato). Proprio come 1.0 = 0.9999…in decimale, questo problema esiste anche in questa base. In base π, uno è ancora 1.0, ma potrebbe anche essere scritto come 0.3011…, per esempio. Allo stesso modo, dieci è 100.01022…, ma potrebbe anche essere scritto come 30.121…o 23.202….
• Questo è code-golf, quindi vince meno byte. Programma o funzione.
• Nessun built-in ( Sto guardando voi , Mathematica )

risultati:

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…

Prime 10.000 cifre di dieci in Pi base

Verifica:

È possibile verificare qualsiasi output desiderato utilizzando il codice Mathematica qui . Il primo parametro è x, il terzo è n. Se scade, scegli un piccolo ned eseguilo. Quindi fare clic su "Apri nel codice" per aprire un nuovo foglio di lavoro Mathematica con il programma. Non c'è limite di tempo lì.

Converti l'output risultante in un numero qui .

Relazionato:

• Wikipedia: rappresentazione non intera
• Quora: quanto fa 10 in base pi?
• Math.SE: Come sarebbe un sistema numerico π di base?
• Forum XKCD: conteggio in un sistema di numeri pi base?

Julia 0.6 , 81 byte

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

Stampa le cifre (e il. Che mi è costato 14 byte) fino a quando Stack non trabocca a circa 22k cifre su TIO. Se mi è permesso di passare l'input come BigFloatposso tagliare 5 byte. Utilizza la costante di precisione arbitraria incorporata π. Ma è un po 'più freddo di quello, in realtà è una costante di precisione adattiva, π*1.0è un numero in virgola mobile a 64 bit, π*big(1.0)(noto anche come moltiplicato per un numero di precisione più elevato) che dà πa qualunque sia la tua precisione.

Provalo online!

Python 3 , 471 317 310 byte

7 byte grazie al cahing coinheringaahing.

Sicuramente ci sono dei golf che mi sono perso. Sentiti libero di segnalarli nei commenti.

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

Provalo online!

Versione non golfata:

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

Provalo online!

Rubino -rbigdecimal/math , 111 103 97 byte

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

Provalo online!

Accetta il numero di input come xe la precisione desiderata come n. Stampa per stampa. Utilizza la libreria integrata BigDecimal per un valore PI arbitrario di pecision.

Python 3 + sympy, 144 byte

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

Provalo online!

Abbastanza lento, in realtà.