Generar MathJax para la fracción continua de Golden Ratio

17

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 :

eq0

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 comoComandos 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:

    eq1

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

    eq2

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

    eq3

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

    eq4

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.

Pasatiempos de Calvin
fuente
Solo una nota para aquellos que desean ejecutar el fragmento de pila: como muchos (¿la mayoría?) Fragmentos de pila, esto no funciona en Safari.
Alex A.
El fragmento de pila no funciona cuando Uncaught ReferenceError: textbox is not defined
escribes
@soktinpk Eso es extraño, estoy teniendo el mismo problema. Pero el fragmento de aquí funciona a pesar de que es exactamente el mismo ... Aquí hay un contador de bytes externo por si acaso.
Aficiones de Calvin
¡MathJax se ha vuelto a habilitar para PPCG!
wastl

Respuestas:

6

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í

Optimizador
fuente
1
Un pequeño barajado da 50:"$$\varphi=1+""\cfrac1{1+"ri:R*'\"ddots"R!>'}R*'$_
Sp3000
No miré tu respuesta en absoluto, solo una coincidencia. De cualquier manera, su solución Pyth 49 bytes es de 50 bytes en la realidad, ya que hay que escapar \va \\v.
orlp
@orlp y es por eso que retrocedí ya que no había ningún beneficio potencial en que esa solución estuviera presente aquí también.
Optimizador
10

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)
Sp3000
fuente
¡Me ganaste por 14 segundos! También 70 caracteres.
xnor
2
Creo que esto funciona sin usar un doble \ antes de cfrac.
xnor
@xnor Parece que sí, gracias! Y lo siento por tomar los campos de Python todo el tiempo ...
Sp3000
No, te he robado una buena cantidad de razas para publicar.
xnor
4

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

Sp3000
fuente
Dos pequeñas mejoras para 3 bytes (al final de la línea 1 y la línea 3): pastebin.com/wEbKhuUH
randomra
Ja, la primera y la última línea de espejos coinciden, no me di cuenta: P
Sp3000
4

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

Martin Ender
fuente
4

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!

Alex A.
fuente
"d"^(n>0)en lugar de (n>0?"d":"")lo haría más corto.
plannapus
@plannapus: ¡No entiendo lo que significa tu nombre pero eres un genio! Había olvidado que eso "string"^0era legítimo.
Alex A.
De nada. Mi seudónimo es el nombre de un género radiolariano, siendo yo mismo un paleontólogo radiolariano. Se traduce como "nabo aplanado", creo :)
plannapus
Estoy esperando una respuesta BF =)
flawr
@flawr: Espero que no me esperes eso ...
Alex A.
3

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 $$
PhiNotPi
fuente
+1 por usar Element! ¡Es hora de que Element se convierta en un nombre familiar!
Alex A.
3

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}}}}}$$
MickyT
fuente
3

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}}}$$
vvye
fuente
@ Sp3000 El primero no, ya que Ruby aparentemente no puede convertir los booleanos en enteros. Sin embargo, este último funcionó, ¡así que gracias por eso!
vvye
2

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í.

revs randomra
fuente
2

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}}}$$
MickyT
fuente
+1 pero en lugar de convertirlo en una función, si hace que el usuario ingrese ncomo stdin en su primera aparición, puede guardar algunos caracteres:cat("$$\\varphi=1+\\",rep("cfrac1{1+\\",n<-scan()),if(n)"d","dots",rep("}",n),"$$",sep="")
plannapus
2

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)+"$$";
   }

fuente
2
x = 'repetir' lo hace más largo, no más corto: use .repeat tal cual y guarde 3 caracteres
edc65
@ edc65 gracias !!
pastebin.com/uU7tgFm9 algunas mejoras más
edc65
Se puede convertir en 87 bytes de esta manera: pastebin.com/0Hkv9uft
George Reith
O 85 bytes pastebin.com/k90Fyr2m
George Reith
1

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
Maltysen
fuente
1

Pyth, 50 bytes

s["$$\\varphi=1+"*Q"\cfrac1{1+"\\<\dQ"dots"*Q\}"$$
orlp
fuente
1
Ver mi historial de edición :)
Optimizer
1

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}}}}$$
edc65
fuente
0

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}')
DenDenDo
fuente
Actualmente falta el n=0caso especial (puntos en lugar de puntos).
randomra
0

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!

Lynn
fuente