Iterações de Bailey – Borwein – Plouffe
Vimos alguns desafios de pi no PPCG, mas nenhum que dite especificamente o algoritmo que você deve usar. Gostaria de ver implementações do algoritmo Bailey-Borwein-Plouffe em qualquer idioma até a iteração n
. A fórmula é a seguinte:
Seu algoritmo deve gerar cada iteração até n, mostrando somas intermediárias e o resultado final para formar uma "piangle". Você também pode usar a forma polinomial reduzida do algoritmo mostrado na página da wikipedia. Um exemplo de execução n=50
é mostrado abaixo:
3
3.1
3.14
3.141
3.1415
3.14159
3.141592
3.1415926
3.14159265
3.141592653
3.1415926535
3.14159265358
3.141592653589
3.1415926535897
3.14159265358979
3.141592653589793
3.1415926535897932
3.14159265358979323
3.141592653589793238
3.1415926535897932384
3.14159265358979323846
3.141592653589793238462
3.1415926535897932384626
3.14159265358979323846264
3.141592653589793238462643
3.1415926535897932384626433
3.14159265358979323846264338
3.141592653589793238462643383
3.1415926535897932384626433832
3.14159265358979323846264338327
3.141592653589793238462643383279
3.1415926535897932384626433832795
3.14159265358979323846264338327950
3.141592653589793238462643383279502
3.1415926535897932384626433832795028
3.14159265358979323846264338327950288
3.141592653589793238462643383279502884
3.1415926535897932384626433832795028841
3.14159265358979323846264338327950288419
3.141592653589793238462643383279502884197
3.1415926535897932384626433832795028841971
3.14159265358979323846264338327950288419716
3.141592653589793238462643383279502884197169
3.1415926535897932384626433832795028841971693
3.14159265358979323846264338327950288419716939
3.141592653589793238462643383279502884197169399
3.1415926535897932384626433832795028841971693993
3.14159265358979323846264338327950288419716939937
3.141592653589793238462643383279502884197169399375
3.1415926535897932384626433832795028841971693993751
3.14159265358979323846264338327950288419716939937510
A precisão de cada iteração deve ser igual à n
que é passada para o algoritmo, ou seja, cada iteração deve calcular pi até a passada n
para todos k
.
Regras:
- Built-ins não são permitidos, nem é
pi
, você deve usar a fórmula. - Você deve suportar
n
até o máximo permitido pelo seu idioma em termos de cálculo de16^n
. Se a entrada estiver causando um estouro aritmético durante o cálculo após asx<n
execuções, porque seu idioma suporta apenas decimais até2^32-1
, tudo bem. Quaisquer outras suposiçõesn
não estão bem. - Você DEVE fornecer uma explicação de como obteve a saída, se não for óbvio. Por exemplo, se você estiver postando em um idioma de golfe, uma quebra é 100% necessária. Isso é para garantir que você esteja usando o algoritmo especificado.
- Os orifícios padrão não são permitidos.
- Isso é código-golfe, a menor contagem de bytes vence aqui.
Código de referência (código usado para gerar exemplo):
public static void main(String[] args) {
(0..50).each {
n->
def x=(0..n).collect {
j->
def k=new BigDecimal(j)
def s={it.setScale(n)}
def a=s(1.0g).divide(s(16.0g)**s(k))
def b=s(4.0g)/(s(8.0g)*s(k)+s(1.0g))
def c=s(2.0g)/(s(8.0g)*s(k)+s(4.0g))
def d=s(1.0g)/(s(8.0g)*s(k)+s(5.0g))
def e=s(1.0g)/(s(8.0g)*s(k)+s(6.0g))
def f=a*(b-c-d-e)
}.sum()
println(n + "\t" + x.setScale(n, BigDecimal.ROUND_DOWN))
}
}
Essa implementação é limitada em n=255
, você pode limitar em menos ou mais.
Esta implementação foi feita no Groovy.
Calculate foo via x method
desafios.Respostas:
05AB1E ,
635250 bytesFórmula de especialização
Experimente online!
Fórmula BBP
Experimente online!
fonte
Python 2,
109108 bytesTeste em Ideone .
fonte
Python 2, 174 bytes
Cara, é um momento em que eu gostaria que o Python tivesse uma maneira mais fácil de manter precisão infinita para decimais. Possivelmente, implementar seu próprio tipo de precisão infinita para esse desafio é mais curto, mas não consigo imaginar como. A fórmula está escrita literalmente.
Exemplo de saída para
n=100
(com alguns números de linha adicionados):Isso parece funcionar para números maiores,
n=1000
é executado em alguns segundos en=10000
parece que ainda não me deu nenhum erro!fonte
Haskell,
101100 bytesObrigado a @nimi por um byte.
Implementação direta. Calcula
n
até 15 dígitos (precisão dupla padrão).fonte
l<-[8*fromIntegral k]
em vez delet ...
salva um byte.J,
736462 bytesIsso gera cada aproximação para n dígitos como uma sequência formatada. Isso usa a simplificação polinomial da fórmula e obtém os primeiros n dígitos multiplicando a soma por uma potência de 10, pavimentando-a e dividindo pela mesma potência de 10.
A entrada é tomada como um número inteiro estendido, significando que os racionais são usados quando ocorre a divisão, o que mantém os resultados exatos.
Uso
Esta é a saída para n = 100, mostrando as somas cumulativas para k em [0, 100].
Explicação
Primeiro faça o intervalo [0, n ], mostrado para n = 5
Multiplique cada um por 8
Forme a tabela de adição entre
[1, 4, 5, 6]
e os produtos com 8Divida cada linha por
[4, 2, -1, 1]
Em seguida, reduza as colunas de baixo para cima usando subtração
Divida cada 16 k por k em [0, n ] por cada resultado
Encontre as somas cumulativas
Calcular 10 k para k em [0, n ] e multiplique-o cada
Em seguida, pavimente cada um dos produtos
Divida pelo mesmo poder de 10 para obter os resultados
fonte
PARI / GP, 86 bytes
Ou sem o ponto decimal em 69 bytes :
Em vez de dividir por 16 k cada iteração, o valor anterior de p é multiplicado por 16 . O piso de p 8 (8/5) k é então o valor de π truncado para o número correto de dígitos.
Uso da amostra
fonte
C GCC, 118 bytes
Golfe:
Ungolfed:
Para alterar n, basta alterar while (k <15) para while (k <n)
resultado:
precisão máxima é 15 casas decimais, eu poderia aumentar para qualquer valor com gmp, mas talvez no próximo dia pi: P
com impressão bonita, 143 bytes
Golfe:
Ungolfed:
resultado:
fonte
Fórmula IBM / Lotus Notes, 125 bytes
Fórmula em um campo computado com outro campo chamado "a" para entrada.
Basicamente, uma porta do algoritmo da resposta Python de @shebang. Calcula até 15 dígitos após os quais trunca devido a uma limitação do idioma (consulte a saída). Teve que desperdiçar 12 bytes com a instrução @If no final apenas para se livrar do. após os 3 no início: - /
Ungolfed
fonte
C #, 183 bytes
Golfe:
Ungolfed:
fonte
3.14159265358979
para qualquern >= 14
devido à precisão dupla?APL (NARS), 206 caracteres, 412 bytes
Isso encontra todas as aproximações em grande racional, do que usar uma função que converte grande racional em seqüência numérica ... test:
fonte