Inteiros no Pi Base

11

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:

mbomb007
fonte
4
"No built-ins" inclui nenhum built-in para obter Pi?
Nit
3
@Nit Não, significa que nenhum componente interno conclui ou banaliza toda a tarefa. Ou se esse recurso interno existir (como o Mathematica que mostrei), inclua uma solução sem o interno que será usada para a pontuação real da resposta. Dessa forma, você ainda mostra às pessoas que o built-in existe.
mbomb007
Podemos usar um literal π de precisão limitada?
Erik the Outgolfer
@EriktheOutgolfer Não. Isso não será suficiente para chegar à saída correta. Embora eu não tenha certeza de quantos dígitos são necessários para uma entrada de n, acho que o Pi deve ter pelo menos ndígitos de precisão.
mbomb007
8
IMO: A proibição de incorporar conversões básicas apenas adiciona complexidade desnecessária. Se você sentir como ele trivializa o desafio, bem, talvez o desafio é apenas isso: trivial
Conor O'Brien

Respostas:

1

Julia 0.6 , 81 bytes

f(x,i=log(π,x1)=(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!

gggg
fonte
3

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!

Freira Furada
fonte
Você precisa de Python 3? Se 2 puder ser usado, você poderá usar espaços e guias mistos.
mbomb007
@ mbomb007 "golfs que eu perdi" não incluem a mudança para uma versão anterior apenas por uma questão de golfe: P
Leaky Nun
Então você também pode usar `i`.
mbomb007
3

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.

Kirill L.
fonte
construído em é expressamente proibido
Leaky Nun
1
Veja os comentários para a tarefa: "-" built-ins "não inclui os internos para obter Pi?" "- Não, isso significa que nenhum componente interno conclui ou banaliza a tarefa inteira."
Kirill L.
@LeakyNun Kirill está certo. Built-ins para Pi são permitidos desde que a resposta resultante esteja correta.
mbomb007
Você não precisa contar os bytes das opções da linha de comando? Não tenho certeza como isso funciona
mbomb007
Eu diria, não mais conforme esta meta . Algo nas linhas de "considera isso um tipo de linguagem diferente do comum Ruby".
Kirill L.
1

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.

Freira Furada
fonte