Hintergrund:

Pi ( π) ist eine transzendentale Zahl und hat daher eine nicht terminierende Dezimaldarstellung. Ebenso wird die Darstellung nicht beendet, wenn sie in eine andere Ganzzahlbasis geschrieben wird. Aber was ist, wenn wir es in Base geschrieben haben π?

Dezimalstellen stehen für Potenzen von 10, also:

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

In der Basis πwürden die Ziffern also Potenzen darstellen von π:

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

In dieser neuen Basis haben Ganzzahlen jetzt nicht terminierende Darstellungen. Aus 10 Dezimalstellen wird nun Folgendes:

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

Beachten Sie, dass in der Basis πdie verwendeten Ziffern 0,1,2,3 sind, da dies die Ziffern sind, die kleiner als sind π.

Herausforderung:

Bei einer nicht negativen Ganzzahl xentweder:

1. Ausgabe (ohne anzuhalten) seiner Darstellung in der Basis π. Wenn die Zahl eine endliche Darstellung hat (0, 1, 2, 3), wird das Programm möglicherweise angehalten, anstatt unendliche Nullen zu drucken.

2. Nehmen Sie eine beliebig große Ganzzahl nund geben Sie die ersten nZiffern von xin base aus π.

Regeln:

• Da eine Zahl mehrere mögliche Darstellungen hat, müssen Sie diejenige ausgeben, die am größten erscheint (normalisiert). Genau wie 1.0 = 0.9999…bei Dezimalstellen besteht dieses Problem auch in dieser Basis. In der Basis πist man noch 1.0, könnte aber auch so geschrieben werden wie 0.3011…zum Beispiel. Ebenso ist zehn 100.01022…, könnte aber auch als 30.121…oder geschrieben werden 23.202….
• Dies ist Code-Golf, also gewinnen die wenigsten Bytes. Programm oder Funktion.
• Keine Einbauten ( ich sehe dich an , Mathematica )

Ergebnisse:

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…

Erste 10.000 Zehnerstellen in Basis Pi

Nachprüfung:

Sie können jede gewünschte Ausgabe mit dem Mathematica-Code hier überprüfen . Der erste Parameter ist x, der dritte ist n. Wenn die Zeit nabgelaufen ist , wählen Sie eine kleine aus und lassen Sie sie laufen. Klicken Sie dann auf "In Code öffnen", um ein neues Mathematica-Arbeitsblatt mit dem Programm zu öffnen. Dort gibt es keine zeitliche Begrenzung.

Konvertieren Sie die resultierende Ausgabe zu einer Reihe hier .

Verbunden:

• Wikipedia: Nicht ganzzahlige Darstellung
• Quora: Was ist 10 in Base Pi?
• Math.SE: Wie würde ein Basis-π-Zahlensystem aussehen?
• XKCD-Forum: Zählen in einem Basis-Pi-Nummernsystem?

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

Druckt Ziffern aus (und die., Die mich 14 Byte gekostet haben), bis der Stapel bei TIO mit etwa 22.000 Ziffern überläuft. Wenn ich die Eingabe als übergeben BigFloatdarf, kann ich 5 Bytes schneiden. Verwendet die eingebaute willkürliche Genauigkeit konstant π. Aber es ist ein bisschen cooler als das, es ist tatsächlich eine adaptive Präzisionskonstante, π*1.0eine 64-Bit-Gleitkommazahl π*big(1.0)(auch bekannt als multipliziert mit einer höheren Präzisionszahl), die πbei jeder eingestellten Genauigkeit angegeben wird.

Probieren Sie es online aus!

Python 3 , 471 317 310 Bytes

7 Bytes dank Caird Coinheringaahing.

Sicher gibt es Golf, die ich verpasst habe. Fühlen Sie sich frei, sie in den Kommentaren darauf hinzuweisen.

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

Probieren Sie es online aus!

Ungolfed Version:

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

Probieren Sie es online aus!

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

Probieren Sie es online aus!

Nimmt die Eingabenummer als xund die gewünschte Genauigkeit als n. Ausgaben durch Drucken. Verwendet die integrierte BigDecimal-Bibliothek für einen beliebigen PI-Wert.

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

Probieren Sie es online aus!

Eigentlich ziemlich langsam.