En previsión de que MathJax se deshabilite temporalmente , el MathJax representado en esta pregunta ha sido reemplazado por imágenes. Aún puede publicar respuestas, pero tendrá que ver MathJax en otro sitio .

¡PPCG acaba de recibir MathJax ! Esto significa que ahora podemos incluir fácilmente fórmulas matemáticas bien formateadas en las publicaciones. ( Tutorial práctico de MathJax ) .

Por ejemplo, aquí está la proporción áurea expresada como una fracción continua infinita :

El código MathJax para esta ecuación es

$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$

^{Puede encontrar esto haciendo clic derecho en la fórmula y siguiendo Mostrar Matemáticas como → Comandos TeX .
Esto $$significa que se muestra solo en el centro de la página en lugar de en línea. Use un solo $para en línea.}

Desafío

Escriba un programa que tome un número entero no negativo, n, y genere el código MathJax para esa cantidad de "pasos" de la fracción continua para la proporción áurea.

Para mantener las cosas estándar en las respuestas, debe usar esta sintaxis exacta de MathJax:

• Para n = 0, la salida debe ser $$\varphi=1+\dots$$.
  Que se representa como:

  

• Para n = 1, la salida debe ser $$\varphi=1+\cfrac1{1+\ddots}$$.
  Que se representa como:

  

• Para n = 2, la salida debe ser $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  Que se representa como:

  

• Para n = 3, la salida debe ser $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  Que se representa como:

  

Este patrón continúa para n más grande. Se podría decir que n representa el número de líneas de división en la ecuación.

Notas

• \cfracse usa en lugar del más común \frac.
• \dotsse usa en lugar de \ddotspara n = 0.
• Tome la entrada de stdin o la línea de comando.
• Salida a stdout (con una nueva línea final opcional).
• Alternativamente, puede escribir una función que tome n como un entero y devuelva el código MathJax como una cadena (o aún lo imprima).

Puntuación

La presentación más pequeña en bytes gana. Tiebreaker va a la presentación anterior.

CJam, 51 50 bytes

$$\varphi=1+""\cfrac1{1+"ri:R*'\"ddots"R!>'}R*'$_

Explicación del código:

"$$\varphi=1+"             "This is a static string";
  "\cfrac1{1+"ri:R*'\      "Repeat this string input number times. Put a \ at the end";
    "ddots"R!>             "If input is 0, remove 1st characters, else not";
      '}R*                 "Put the closing bracket R times";
        '$_                "The final $$";

Pocos ejemplos:

N = 0

$$\varphi=1+\dots$$

N = 4

$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$

N = 15

$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}}}}}}}}}}}}$$

ACTUALIZACIÓN : ¡1 byte guardado gracias a Sp3000!

Pruébalo en línea aquí

Python, 70 68 67 bytes

lambda n:"$$\\varphi=1+\%sdots%s$$"%("cfrac1{1+\\"*n+"d"[:n],"}"*n)

Esto define una función anónima que solo usa la simple multiplicación de cadenas y el formato de cadenas.

(Gracias a @xnor por señalar que \\csolo se puede escribir como \c, ya cque no se puede escapar. Desafortunadamente, esto no es cierto \\v, ya que \ves ASCII 11.)

Intentos previos:

lambda n:"$$\\varphi="+"1+\\cfrac1{"*n+"1+\\"+"ddots"[n<1:]+"}"*n+"$$"
lambda n:r"$$\varphi=%s1+\%s$$"%("1+\cfrac1{"*n,"ddots"[n<1:]+"}"*n)

> <> , 89 86 + 3 = 89 bytes

:&"$$"{\l?!;o70.
}-1v!?:<{"}"
&:&\~"stod"&:&?:
{1->:?!v}"\+1{1carfc"
rav\$$"\~"\+1=ihp

Corre con la -vbandera, por ej.

py -3 fish.py program.fish -v 3

Sorprendentemente> <> no hace demasiado mal aquí, ya que podemos imitar la multiplicación de cadenas al tener un contador que disminuimos cada iteración.

:&"$$"{\                     Put n into the register and push "$$"
}-1v!?:<{"}"                 Push n "}"s
&:&\~"stod"&:&?:             Push "stod", and copy the final "d" if n != 0
{1->:?!v}"\+1{1carfc"        Push n "\+1{1carfc"s
rav\$$"\~"\+1=ihp            Push "\+1=ihprav\$$"
       \l?!;o70.             Keep printing chars until the stack is empty

(-3 bytes gracias a @randomra)

Retina , 160 + 7 = 167 bytes

;`.+
$$$$\varphi=1+\dots#$0$$$$

; + (\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0) $1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10# ;#

;+`\\d?dots\d(\d*)
\cfrac1{1+\ddots$1}

Cada línea entra en un archivo fuente separado, por lo que agregué 1 byte para cada archivo después del primero . Sin embargo, por conveniencia, Retina ahora también admite el -sindicador de línea de comandos, que le permite poner todo esto en un solo archivo (en cuyo caso las nuevas líneas se tratan como separadores de archivos).

La mayor parte del código (98 bytes) se utiliza para convertir la entrada de decimal a unario (archivos 3 a 6). La idea básica del código es rodear la entrada $$\varphi=1+\dots...$$, luego convertir la entrada en unaria y luego expandir \dotsNo \ddotsNal siguiente nivel de la fracción continua (mientras se reduce Na N-1).

Julia, 76 73 bytes

n->("\$\$\\varphi=1+"*"\\cfrac1{1+"^n*"\\"*"d"^(n>0)*"dots"*"}"^n*"\$\$")

Esto crea una función lambda que toma un entero entero como entrada y devuelve MathJax como una cadena. Para llamarlo, dale un nombre, por ejemplo f=n->....

Desafortunadamente, tanto las barras invertidas como los signos de dólar deben escaparse en las cadenas de Julia porque ambos tienen un significado especial. La concatenación de cadenas se realiza utilizando *y la repetición de cadenas con ^.

Ejemplos:

julia> f(0)
"$$\varphi=1+\dots$$"

julia> f(4)
"$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$"

¡Las sugerencias son bienvenidas como siempre!

Editar: ¡ Guardado 3 bytes gracias a plannapus!

Elemento, 63 caracteres

_+2:'\$\$\\varphi\=1\+`[\\cfrac1\{1\+`]?\\[d.]`"dots`[\}`]\$\$`

Esta es la solución más directa. Desafortunadamente, la gran cantidad de símbolos en la salida causa un aumento significativo en la longitud del programa (poner las cadenas en el programa directamente hace que los símbolos realicen operaciones). Estoy seguro de que hay espacio para jugar al golf, pero no tengo más tiempo en este momento.

Dado que este lenguaje aún es relativamente desconocido, aquí hay un enlace al intérprete , escrito en Perl.

_+2:                     take input, add 0 to it to make it a number, and duplicate
'                        put one copy onto the control stack
\$\$\\varphi\=1\+        a "bare" string
`                        output the string
[                        start a for loop, based on the input from earlier
    \\cfrac1\{1\+        a bare string
    `                    output it
]                        end the for loop
?                        test the second copy of the input for non-zero-ness
\\                       a bare \
[d.]                     a "for" loop used as an if block, appends a "d"
`                        output it
dots`                    output dots
"                        get rid of the if condition result so the old result is on top
[                        another for loop, still using the input from earlier
    \}`                  output a }
]                        end for loop
\$\$`                    output $$

T-SQL, 229 227 138

Ha pasado un tiempo desde que hice una respuesta SQL y, como siempre, es muy detallado. Editar Por supuesto, lo compliqué demasiado y no necesité una consulta recursiva en absoluto.

CREATE FUNCTION A(@ INT)RETURNS TABLE RETURN SELECT'$$\varphi=1+\'+REPLICATE('cfrac1{1+\',@)+IIF(@>0,'d','')+'dots'+REPLICATE('}',@)+'$$'S

Original

CREATE FUNCTION A(@ INT)RETURNS TABLE RETURN WITH R AS(SELECT CAST('$$\varphi=1+\dots'AS VARCHAR(MAX))S,0N UNION ALL SELECT REPLACE(STUFF(S,14,0,'cfrac1{1+\'),'\do','\ddo')+'}',N+1FROM R WHERE N<=@)SELECT S+'$$'S FROM R WHERE N=@

Esto crea una función de tabla en línea que utiliza una consulta recursiva para completar la cfrac1{1+\iteración adicional . Cambiar los puntos a ddots fue costoso, pero salvó a un par de deshacerse del reemplazo :). También tener que emitir la cadena original como 'VARCHAR (MAX)' cuesta un poco.

Se utiliza de la siguiente manera SQLFiddle :

SELECT * 
FROM (SELECT N FROM(VALUES(0),(1),(2),(3),(4),(5))A(N)) N
    CROSS APPLY A(N.N)
N   S
--- ---------------------------------------------------------------------------
0   $$\varphi=1+\dots$$
1   $$\varphi=1+\cfrac1{1+\ddots}$$
2   $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$
3   $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$
4   $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$
5   $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}}$$

Ruby, 76 75 71 70 bytes

Esto se siente sospechosamente sencillo, así que avíseme si me equivoqué en alguna parte.

Por cierto, esto es lo primero que he escrito en Ruby: estaba buscando un lenguaje que admitiera la repetición de cuerdas al multiplicar, y Ruby parecía hacer el truco.

f=proc{|n|'$$\varphi=1+'+'\cfrac1{1+'*n+'\dd'[0,n+2]+'ots'+'}'*n+'$$'}

Para ser aplicado así:

f.call(0)
$$\varphi=1+\dots$$

f.call(3)
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$

J, 60 bytes

(<;._2'$$\varphi=1+\ cfrac1{1+\ d dots } $$ ');@#~1,~5$1,],*

Uso:

   ((<;._2'$$\varphi=1+\ cfrac1{1+\ d dots } $$ ');@#~1,~5$1,],*) 0
$$\varphi=1+\dots$$

   ((<;._2'$$\varphi=1+\ cfrac1{1+\ d dots } $$ ');@#~1,~5$1,],*) 3
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$

Método:

La cadena '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'se corta en espacios y las partes se repiten 1 n signum(n) 1 n 1veces y luego estas partes se concatenan.

Pruébelo en línea aquí.

R, 93 90

Al igual que las otras respuestas. Gracias a @plannapus por la sugerencia de escaneo.

cat('$$\\varphi=1+\\',rep('cfrac1{1+\\',n<-scan()),if(n)'d','dots',rep('}',n),'$$',sep='')

catutilizado en lugar de paste0 como el resultado terminaría en \\lugar de \.

En uso

> > cat('$$\\varphi=1+\\',rep('cfrac1{1+\\',n<-scan()),if(n)'d','dots',rep('}',n),'$$',sep='')
1: 3
2: 
Read 1 item
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$

JavaScript, 114 109 106 85 bytes gracias a George Reith

f=n=>'$$\\varphi=1+\\'+((x='cfrac1{1+\\'.repeat(n))&&x+'d')+'dots'+'}'.repeat(n)+'$$'

¡Esta es mi primera entrada en un concurso de codegolf! Por favor dime como mejorar.

Entrada anterior (106 bytes):

w="$$\\varphi=";y=n=>{return a=!n?w+"1+\\dots$$":w+"1+\\cfrac1{".repeat(n)+"1+\\ddots"+"}".repeat(n)+"$$"}

Entrada anterior (109 bytes):

x="repeat",w="$$\\varphi=";y=n=>{return a=!n?w+"1+\\dots$$":w+"1+\\cfrac1{"[x](n)+"1+\\ddots"+"}"[x](n)+"$$"}

Entrada anterior (114 bytes):

x="repeat";y=n=>{return a=!n?"$$\\varphi=1+\\dots$$":"$$\\varphi="+"1+\\cfrac1{"[x](n)+"1+\\ddots"+"}"[x](n)+"$$"}

Pegue en la consola del navegador y llame como f(n)donde nestá el número de 'pasos'.

Código simplificado :

function y(n) {
   if(n === 0) {
      return "$$\\varphi=1+\\dots$$";
   } else {
      return "$$\\varphi=" + "1+\\cfrac1{".repeat(n) + "1+\\ddots"+"}".repeat(n)+"$$";
   }

Pyth - 52 bytes

El enfoque simple en Pyth, prácticamente robado de la solución Python de @ Sp3000. Utiliza el operador de formato de cadena %.

%"$$\\varphi=1+\%sdots%s$$"(+*"cfrac1{1+\\"Q<\dQ*\}Q

Pruébelo en línea aquí .

%                  String formatting
 "$$ . . . $$"     String to be formatted
 (                 Tuple (no need to close it)
  +                String concatenation
   *"..."Q         String repetition input times
   <\dQ            If Q>0 then d
  *                String repetition
   \}              The character "}"
   Q               Q times

Pyth, 50 bytes

s["$$\\varphi=1+"*Q"\cfrac1{1+"\\<\dQ"dots"*Q\}"$$

JavaScript (ES6), 76 80

Parcialmente recursivo. El simple / doble d es la parte más molesta.

F=n=>"$$\\varphi=1+\\"+(R=d=>n--?"cfrac1{1+\\"+R("d")+"}":d+"dots")("")+"$$"

Prueba en la consola Firefox / FireBug

> for(i=0;i<5;i++)console.log(F(i))

$$\varphi=1+\dots$$
$$\varphi=1+\cfrac1{1+\ddots}$$
$$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$

Python, 90 116

Como la solución más eficiente ya se ha publicado varias veces, en su lugar, uso el reemplazo de cadena

f=lambda n:'$$\\varphi=1+\ddots$$'if n==0 else f(n-1).replace('\ddots','\cfrac{1+\ddots}')
# or, with exactly the same length
x='\ddots';f=lambda n:'$$\\varphi=1+'x+'$$'if n==0 else f(n-1).replace(x,'\cfrac{1+'x+'}')

Editar: maldición, pasado por alto en dotslugar de ddotspor n=0, ahora la solución recursiva con una cláusula adicional añadida es demasiado fea para competir.

x='$$\\varphi=1+\d%sots$$';f=lambda n:x%''if n==0 else x%'d'if n==1 else f(n-1).replace('\ddots','\cfrac{1+\ddots}')

Haskell, 86

n%x=[1..n]>>x
f n="$$\\varphi=1+"++n%"\\cfrac1{1+"++'\\':drop(0^n)"ddots"++n%"}"++"$$"

Esencialmente, el mismo enfoque que todas las soluciones aquí. drop(0^n)"ddots"es lindo, sin embargo!