Introducción

Su tarea es generar los primeros 1000 términos en la representación de fracción continua de la suma en dígitos de la raíz cuadrada de 2 y la raíz cuadrada de 3.

En otras palabras, produzca exactamente la siguiente lista (pero el formato de salida es flexible)

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

Desafío

La siguiente introducción general a la fracción continua se toma del desafío Simplificar una fracción continua .

Las fracciones continuas son expresiones que describen fracciones iterativamente. Se pueden representar gráficamente:

O pueden representarse como una lista de valores: [a0, a1, a2, a3, ... an]

Este desafío es encontrar la fracción continua de la suma de dígitos de sqrt(2)y sqrt(3), la suma de dígitos se define de la siguiente manera,

Tome los dígitos en la representación decimal de sqrt(2)y sqrt(3), y obtenga la suma 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 ...

Luego, solo guarde el último dígito de la suma y compílelos nuevamente con la representación decimal de un 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 ...

La suma en dígitos de sqrt(2)y sqrt(3)es 2.1462633698..., por lo tanto , y cuando se expresa con una fracción continua, los primeros 1000 valores (es decir, to ) obtenidos son los que figuran en la sección de introducción.a0a999

Especificaciones

• Puede escribir una función o un programa completo. Tampoco deben tomar entradas. En otras palabras, la función o el programa deberían funcionar correctamente sin entradas. No importa lo que haga la función o el programa si se proporciona una entrada no vacía.

• Debe enviar a STDOUT. Solo si su idioma no admite la salida a STDOUT, debe usar el equivalente más cercano en su idioma.

• No necesita mantener limpio STDERR, y se permite detener el programa por error siempre que la salida requerida se realice en STDOUT o sus equivalentes.

• Puede proporcionar resultados a través de cualquier formulario estándar .

• Este es el código de golf , gana el menor número de bytes.

• Como de costumbre, las lagunas predeterminadas se aplican aquí.

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

Un poco detallado, lamentablemente: /

Debe ejecutarse con JDK 9, como sqrtse agregó BigDecimalen esta versión. Curiosamente, no pude encontrar un sitio TIO con las características Kotlin 1.1 y JDK 9 (Ideone y repl.it ejecutan Kotlin 1.0, que no admitía la desestructuración en lambdas, y TIO se queja de que sqrtno existe).

Imprime cada elemento separado por una nueva línea.

Editar ( -11): se movió printlnal principio del cuerpo del bucle y agregó una iteración adicional para evitar repetir la llamada al método. Se realiza un cálculo adicional, pero no se utiliza 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)

Pruébalo en línea!

Calcular sqrt(2)y sqrt(3)con tanta precisión con un código corto es un trabajo difícil en Python y otros lenguajes.

Se necesitan 2000 dígitos para garantizar que la expansión sea correcta (1020 es suficiente, pero no voy a modificarla porque no hay mejora), y las líneas 4-6 son la raíz cuadrada entera.

193> 180: la suma de módulos en forma de dígitos ahora se realiza mediante un bucle en lugar de la manipulación de la matriz

180> 179: Reemplazó las 6 ocurrencias de 10uso dcon el costo de definir con 5 bytes, cortando 1 byte en total

179> 178: Acabo de darme cuenta de que a!=ise puede reemplazar pora-i

Jalea , 32 bytes

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

Pruébalo en línea!

Básicamente use aritmética de punto fijo. M puede funcionar mejor aquí, pero de alguna manera floor(HUGE_NUMBER × sqrt(2)no quiere evaluar demasiado HUGE_NUMBER. De todos modos, la división de punto fijo es definitivamente mejor.

Explicación:

-------
ȷ*`       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

No pude encontrar una manera fácil de calcular la fracción continua perezosamente, así que trabajé también con 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