Tło:

Pi ( π) jest liczbą transcendentalną , a zatem ma niekończącą się reprezentację dziesiętną. Podobnie reprezentacja nie kończy się, jeśli jest zapisana w jakiejkolwiek innej liczbie całkowitej. Ale co, jeśli napisalibyśmy to w bazie π?

Cyfry dziesiętne reprezentują potęgi 10, więc:

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

Zatem w bazie πcyfry reprezentowałyby moc π:

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

W tej nowej bazie liczby całkowite mają teraz reprezentacje nie kończące się. Zatem liczba dziesiętna staje się teraz następująca:

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

Zauważ, że w bazie πużyte cyfry to 0,1,2,3, ponieważ są to cyfry mniejsze niż π.

Wyzwanie:

Biorąc pod uwagę nieujemną liczbę całkowitą x:

1. Wyjście (bez zatrzymywania) jego reprezentacja w bazie π. Jeśli liczba ma skończoną reprezentację (0, 1, 2, 3), wówczas program może zatrzymać się zamiast drukować nieskończone zera.

2. Weź dowolną dużą liczbę całkowitą ni wypisz pierwsze ncyfry xw bazie π.

Zasady:

• Ponieważ liczba ma wiele możliwych reprezentacji, musisz wypisać tę, która wydaje się największa (znormalizowana). Podobnie jak 1.0 = 0.9999…w systemie dziesiętnym, ten problem istnieje również w tej bazie. W bazie πjeden jest nadal 1.0, ale można go również zapisać 0.3011…np. Jako . Podobnie dziesięć to 100.01022…, ale może być również zapisane jako 30.121…lub 23.202….
• To jest golf golfowy, więc wygrywa najmniej bajtów. Program lub funkcja.
• Brak wbudowanych elementów ( patrzę na ciebie , Mathematica )

Wyniki:

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…

Pierwsze 10 000 cyfr dziesięciu w bazie Pi

Weryfikacja:

Można sprawdzić każdą wyjściowego chcesz przy użyciu kodu Mathematica tutaj . Pierwszy parametr to xtrzeci n. Jeśli upłynie limit czasu, wybierz mały ni uruchom go. Następnie kliknij „Otwórz w kodzie”, aby otworzyć nowy arkusz Mathematica z programem. Nie ma tam limitu czasu.

Konwertuj wynikowy wynik na liczbę tutaj .

Związane z:

• Wikipedia: Reprezentacja niecałkowita
• Quora: Co to jest 10 w base pi?
• Math.SE: Jak wyglądałby podstawowy system liczb π?
• Forum XKCD: Liczenie w podstawowym systemie liczbowym?

Julia 0.6 , 81 bajtów

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

Drukuje cyfry (i., Które kosztują mnie 14 bajtów), aż stos się przepełni około 22k cyfr na TIO. Jeśli wolno mi przekazać dane wejściowe BigFloat, mogę wyciąć 5 bajtów. Wykorzystuje wbudowaną stałą dowolnej dokładności π. Ale jest nieco chłodniejszy, w rzeczywistości jest adaptacyjną stałą precyzji, π*1.0jest 64-bitową liczbą zmiennoprzecinkową π*big(1.0)(czyli pomnożoną przez liczbę o wyższej precyzji) daje πdowolną ustawioną precyzję.

Wypróbuj online!

Python 3 , 471 317 310 bajtów

7 bajtów dzięki Cairney Coheringaahing.

Na pewno są golfa, za którymi tęskniłem. Zachęcamy do wskazania ich w komentarzach.

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

Wypróbuj online!

Wersja bez golfa:

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

Wypróbuj online!

Rubin -rbigdecimal/math , 111 103 97 bajtów

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

Wypróbuj online!

Pobiera numer wejściowy jako xi pożądaną precyzję jako n. Wyjścia przez drukowanie. Wykorzystuje wbudowaną bibliotekę BigDecimal do dowolnej wartości PI dokładności.

Python 3 + sympy, 144 bajty

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

Wypróbuj online!

Właściwie dość wolno.