Introdução

Sua tarefa é gerar os primeiros 1000 termos na representação de fração contínua da soma digitada da raiz quadrada de 2 e raiz quadrada de 3.

Em outras palavras, produza exatamente a seguinte lista (mas o formato de saída é flexível)

[2, 6, 1, 5, 7, 2, 4, 4, 1, 11, 68, 17, 1, 19, 5, 6, 1, 5, 3, 2, 1, 2, 3, 21, 1, 2, 1, 2, 2, 9, 8, 1, 1, 1, 1, 6, 2, 1, 4, 1, 1, 2, 3, 7, 1, 4, 1, 7, 1, 1, 4, 22, 1, 1, 3, 1, 2, 1, 1, 1, 7, 2, 7, 2, 1, 3, 14, 1, 4, 1, 1, 1, 15, 1, 91, 3, 1, 1, 1, 8, 6, 1, 1, 1, 1, 3, 1, 2, 58, 1, 8, 1, 5, 2, 5, 2, 1, 1, 7, 2, 3, 3, 22, 5, 3, 3, 1, 9, 1, 2, 2, 1, 7, 5, 2, 3, 10, 2, 3, 3, 4, 94, 211, 3, 2, 173, 2, 1, 2, 1, 14, 4, 1, 11, 6, 1, 4, 1, 1, 62330, 1, 17, 1, 5, 2, 5, 5, 1, 9, 3, 1, 2, 1, 5, 1, 1, 1, 11, 8, 5, 12, 3, 2, 1, 8, 6, 1, 3, 1, 3, 1, 2, 1, 78, 1, 3, 2, 442, 1, 7, 3, 1, 2, 3, 1, 3, 2, 9, 1, 6, 1, 2, 2, 2, 5, 2, 1, 1, 1, 6, 2, 3, 3, 2, 2, 5, 2, 2, 1, 2, 1, 1, 9, 4, 4, 1, 3, 1, 1, 1, 1, 5, 1, 1, 4, 12, 1, 1, 1, 4, 2, 15, 1, 2, 1, 3, 2, 2, 3, 2, 1, 1, 13, 11, 1, 23, 1, 1, 1, 13, 4, 1, 11, 1, 1, 2, 3, 14, 1, 774, 1, 3, 1, 1, 1, 1, 1, 2, 1, 3, 2, 1, 1, 1, 8, 1, 3, 10, 2, 7, 2, 2, 1, 1, 1, 2, 2, 1, 11, 1, 2, 5, 1, 4, 1, 4, 1, 16, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 8, 1, 2, 1, 1, 22, 3, 1, 8, 1, 1, 1, 1, 1, 9, 1, 1, 4, 1, 2, 1, 2, 3, 5, 1, 3, 1, 77, 1, 7, 1, 1, 1, 1, 2, 1, 1, 27, 16, 2, 1, 10, 1, 1, 5, 1, 6, 2, 1, 4, 14, 33, 1, 2, 1, 1, 1, 2, 1, 1, 1, 29, 2, 5, 3, 7, 1, 471, 1, 50, 5, 3, 1, 1, 3, 1, 3, 36, 15, 1, 29, 2, 1, 2, 9, 5, 1, 2, 1, 1, 1, 1, 2, 15, 1, 22, 1, 1, 2, 7, 1, 5, 9, 3, 1, 3, 2, 2, 1, 8, 3, 1, 2, 4, 1, 2, 6, 1, 6, 1, 1, 1, 1, 1, 5, 7, 64, 2, 1, 1, 1, 1, 120, 1, 4, 2, 7, 3, 5, 1, 1, 7, 1, 3, 2, 3, 13, 2, 2, 2, 1, 43, 2, 3, 3, 1, 2, 4, 14, 2, 2, 1, 22, 4, 2, 12, 1, 9, 2, 6, 10, 4, 9, 1, 2, 6, 1, 1, 1, 14, 1, 22, 1, 2, 1, 1, 1, 1, 118, 1, 16, 1, 1, 14, 2, 24, 1, 1, 2, 11, 1, 6, 2, 1, 2, 1, 1, 3, 6, 1, 2, 2, 7, 1, 12, 71, 3, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 1, 3, 5, 5, 1, 1, 1, 1, 4, 1, 1, 1, 3, 1, 4, 2, 19, 1, 16, 2, 15, 1, 1, 3, 2, 3, 2, 4, 1, 3, 1, 1, 7, 1, 2, 2, 117, 2, 2, 8, 2, 1, 5, 1, 3, 12, 1, 10, 1, 4, 1, 1, 2, 1, 5, 2, 33, 1, 1, 1, 1, 1, 18, 1, 1, 1, 4, 236, 1, 11, 4, 1, 1, 11, 13, 1, 1, 5, 1, 3, 2, 2, 3, 3, 7, 1, 2, 8, 5, 14, 1, 1, 2, 6, 7, 1, 1, 6, 14, 22, 8, 38, 4, 6, 1, 1, 1, 1, 7, 1, 1, 20, 2, 28, 4, 1, 1, 4, 2, 2, 1, 1, 2, 3, 1, 13, 1, 2, 5, 1, 4, 1, 3, 1, 1, 2, 408, 1, 29, 1, 6, 67, 1, 6, 251, 1, 2, 1, 1, 1, 8, 13, 1, 1, 1, 15, 1, 16, 23, 12, 1, 3, 5, 20, 16, 4, 2, 1, 8, 1, 2, 2, 6, 1, 2, 4, 1, 9, 1, 7, 1, 1, 1, 64, 10, 1, 1, 2, 1, 8, 2, 1, 5, 4, 2, 5, 6, 7, 1, 2, 1, 2, 2, 1, 4, 11, 1, 1, 4, 1, 714, 6, 3, 10, 2, 1, 6, 36, 1, 1, 1, 1, 10, 2, 1, 1, 1, 3, 2, 1, 6, 1, 8, 1, 1, 1, 1, 1, 1, 1, 2, 40, 1, 1, 1, 5, 1, 3, 24, 2, 1, 6, 2, 1, 1, 1, 7, 5, 2, 1, 2, 1, 6, 1, 1, 9, 1, 2, 7, 6, 2, 1, 1, 1, 2, 1, 12, 1, 20, 7, 3, 1, 10, 1, 8, 1, 3, 1, 1, 1, 1, 2, 1, 1, 6, 1, 2, 1, 5, 1, 1, 1, 5, 12, 1, 2, 1, 2, 1, 2, 1, 1, 3, 1, 1, 1, 8, 2, 4, 1, 3, 1, 1, 1, 2, 1, 11, 3, 2, 1, 7, 18, 1, 1, 17, 1, 1, 7, 4, 6, 2, 5, 6, 4, 4, 2, 1, 6, 20, 1, 45, 5, 6, 1, 1, 3, 2, 3, 3, 19, 1, 1, 1, 1, 1, 1, 34, 1, 1, 3, 2, 1, 1, 1, 1, 1, 4, 1, 2, 1, 312, 2, 1, 1, 1, 3, 6, 6, 1, 2, 25, 14, 281, 4, 1, 37, 582, 3, 20, 2, 1, 1, 1, 2, 1, 3, 7, 8, 4, 1, 11, 2, 3, 183, 2, 23, 8, 72, 2, 2, 3, 8, 7, 1, 4, 1, 4, 1, 2, 2, 1, 2, 1, 8, 2, 4, 1, 2, 1, 2, 1, 1, 2, 1, 1, 10, 2, 1, 1, 5, 2, 1, 1, 1, 2, 1, 1, 2, 1, 3, 2, 9]

Desafio

A seguinte introdução geral à fração continuada é retirada do desafio Simplificar uma fração continuada .

Frações continuadas são expressões que descrevem frações iterativamente. Eles podem ser representados graficamente:

Ou eles podem ser representados como uma lista de valores: [a0, a1, a2, a3, ... an]

Esse desafio é descobrir a fração contínua da soma digitada sqrt(2)e sqrt(3), a soma digitada é definida da seguinte maneira:

Pegue os dígitos na representação decimal de sqrt(2)e sqrt(3)e obtenha a soma dígito por dígito:

    1.  4  1  4  2  1  3  5  6  2  3 ...
+   1.  7  3  2  0  5  0  8  0  7  5 ...
=   2. 11  4  6  2  6  3 13  6  9  8 ...

Depois, mantenha apenas o último dígito da soma e compile-o de volta à representação decimal de um número real

    1.  4  1  4  2  1  3  5  6  2  3 ...
+   1.  7  3  2  0  5  0  8  0  7  5 ...
=   2. 11  4  6  2  6  3 13  6  9  8 ...
->  2.  1  4  6  2  6  3  3  6  9  8 ...

A soma dígitos-sábio de sqrt(2)e sqrt(3)é, portanto 2.1462633698..., e quando ele é expresso com fracção contínua, os primeiros valores de 1000 (ou seja, a ), obtida são os listados na secção de introdução.a0a999

Especificações

• Você pode escrever uma função ou um programa completo. Nem deve receber insumos. Em outras palavras, a função ou o programa deve funcionar corretamente, sem entradas. Não importa o que a função ou programa faz se for fornecida uma entrada não vazia.

• Você deve enviar para STDOUT. Somente se o seu idioma não suportar a saída para STDOUT você deve usar o equivalente mais próximo no seu idioma.

• Você não precisa manter o STDERR limpo e a interrupção do programa por erro é permitida, desde que a saída necessária seja feita no STDOUT ou em seus equivalentes.

• Você pode fornecer saída através de qualquer formulário padrão .

• Isso é código-golfe , o menor número de bytes vence.

• Como sempre, as brechas padrão se aplicam aqui.

Script Kotlin 1.1 , 304 293 bytes

import java.math.BigDecimal as b
import java.math.*
val m=MathContext(1022)
var B=b(2)
var A=b((""+B.sqrt(m)).zip(""+b(3).sqrt(m)).joinToString(""){(a,b)->if(a=='.')".";else ""+(a-'0'+(b-'0'))%10})
val g=b(1).setScale(1022)
repeat(1000){println(B);A=g/(A-B);B=A.setScale(0,RoundingMode.FLOOR)}

Um pouco detalhado, infelizmente: /

Deve ser executado com o JDK 9, como sqrtfoi incluído BigDecimalneste release. Curiosamente, eu não consegui encontrar um site TIO com os recursos Kotlin 1.1 e JDK 9 (tanto o Ideone quanto o repl.it executam o Kotlin 1.0, que não suportava a desestruturação em lambdas, e o TIO reclama que sqrtnão existe).

Imprime cada elemento separado por uma nova linha.

Edit ( -11): movido printlnpara o início do corpo do loop e adicionado uma iteração adicional para evitar repetir a chamada do método. Um cálculo extra é feito, mas não é usado para nada.

Python 2 , 193 ... 179 178 bytes

d=10
u=d**2000
v=u*u
def s(n,a=d,i=9):
 while a-i:i,a=a,(a+n/a)/2
 return a
p,q,r,t=s(2*v),s(3*v),1,0
while p:t+=(p+q)%d*r;p/=d;q/=d;r*=d
for i in range(1000):print t/u;t=v/(t%u)

Experimente online!

Calcular sqrt(2)e sqrt(3)com tal precisão com um código curto é uma tarefa difícil no Python e em outras linguagens.

São necessários 2000 dígitos para garantir que a expansão esteja correta (1020 é suficiente, mas não vou modificá-la porque não há melhorias) e as linhas 4-6 são a raiz quadrada inteira.

193> 180: A soma do módulo digitado agora é carregada por um loop em vez de manipulação de array

180> 179: substituídas as 6 ocorrências de 10uso dpelo custo de definição com 5 bytes, cortando 1 byte no total

179> 178: Acabei de perceber que a!=ipode ser substituído pora-i

Geléia , 32 bytes

ȷ*`
%¢¢²¤:
2,3×Ñ×ÑƽDS%⁵ḌÇȷСṖ:Ñ

Experimente online!

Use basicamente aritmética de ponto fixo. M pode funcionar melhor aqui, mas de alguma forma floor(HUGE_NUMBER × sqrt(2)não deseja avaliar por muito grande HUGE_NUMBER. De qualquer forma, a divisão de ponto fixo é definitivamente melhor.

Explicação:

-------
ȷ*`       Calculate the base for fixed-point arithmetic.
ȷ         Number 1000.
 *        Raise to the power of...
  `       self. (so we have 1000 ** 1000 == 1e3000) Let B=1e3000.

-------
%¢¢²¤:    Given f × B, return a number approximately (1/frac(f)) × B.
          Current value: f × B.
%¢        Modulo by B. Current value: frac(f) × B.
  ¢²¤     B² (that is, 1e6000)
     :    integer-divide by. So we get B²/(frac(f)×B) ≃ 1/frac(f) × B.

-------
2,3×Ñ×ÑƽDS%⁵ḌÇȷСṖ:Ñ  Main link.
2,3                    The list [2,3].

    Ñ                  This refers to the next link as a monad, which is the
                       first link (as Jelly links wraparound)
   ×                   Multiply by. So we get [2,3]×1e3000 = [2e3000,3e3000]
     ×Ñ                Again. Current value = [2e6000,3e6000] = [2B²,3B²]

       ƽ              Integer square root.
                       Current value ≃ [sqrt(2B²),sqrt(3B²)]
                                     = [B sqrt(2),B sqrt(3)]

         DS            Decimal digits, and sum together.
           %⁵          Modulo 10.
             Ḍ         Convert back from decimal digits to integer.

                С     Repeatedly apply...
              Ç          the last link...
               ȷ         for 1000 times, collecting the intermediate results.
                  Ṗ    Pop, discard the last result.
                   :Ñ  Integer divide everything by B.

Haskell 207 bytes

Não consegui encontrar uma maneira fácil de calcular a fração continuada preguiçosamente, então trabalhei também com 2000 dígitos.

import Data.Ratio
r#y|x<-[x|x<-[9,8..],r>(y+x)*x]!!0=x:(100*(r-(y+x)*x))#(10*y+20*x)
c r|z<-floor r=z:c(1/(r-z%1))
main=print.take 1000.c$foldl1((+).(10*))(take 2000$(`mod`10)<$>zipWith(+)(3#0)(2#0))%10^1999