Antecipando que o MathJax seja temporariamente desativado , o MathJax renderizado nesta pergunta foi substituído por imagens. Você ainda pode postar respostas, mas precisará visualizar o MathJax renderizado em outro site .

O PPCG acabou de receber o MathJax ! Isso significa que agora podemos incluir facilmente postagens em fórmulas matemáticas bem formatadas. ( Tutorial prático do MathJax. )

Por exemplo, aqui está a proporção áurea expressa como uma fração contínua infinita :

O código MathJax para esta equação é

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

^{Você pode encontrar isso clicando com o botão direito do mouse na fórmula e seguindo Show Math As → Comandos TeX .
O $$meio que é exibido por si só no centro da página, em vez de embutido. Use um único $para inline.}

Desafio

Escreva um programa que receba um número inteiro não negativo, n, e emita o código MathJax para as muitas "etapas" da fração continuada da proporção áurea.

Para manter as coisas padrão nas respostas, você deve usar esta sintaxe exata do MathJax:

• Para n = 0, a saída deve ser $$\varphi=1+\dots$$.
  O qual é renderizado como:

  

• Para n = 1, a saída deve ser $$\varphi=1+\cfrac1{1+\ddots}$$.
  O qual é renderizado como:

  

• Para n = 2, a saída deve ser $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  O qual é renderizado como:

  

• Para n = 3, a saída deve ser $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  O qual é renderizado como:

  

Esse padrão continua para n maior. Você poderia dizer que n representa o número de linhas de divisão na equação.

Notas

• \cfrac é usado em vez dos mais comuns \frac .
• \dots é usado em vez de \ddots para n = 0.
• Pegue a entrada do stdin ou da linha de comando.
• Saída para stdout (com uma nova linha à direita opcional).
• Como alternativa, você pode escrever uma função que receba n como um número inteiro e retorne o código MathJax como uma string (ou ainda o imprima).

Pontuação

O menor envio em bytes vence. O desempatador vai para a finalização anterior.

CJam, 51 50 bytes

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

Explicação do 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 $$";

Poucos exemplos:

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

ATUALIZAÇÃO - 1 byte economizado graças ao Sp3000!

Experimente online aqui

Python, 70 68 67 bytes

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

Isso define uma função anônima que apenas usa multiplicação e formatação simples de cadeias.

(Obrigado a @xnor por apontar que \\cpode ser escrito apenas como \c, uma vez cque não pode ser escapado. Infelizmente isso não se aplica \\v, pois \vé o ASCII 11.)

Tentativas anteriores:

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

Corra com a -vbandeira, por exemplo

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

Surpreendentemente> <> não se sai muito mal aqui, pois podemos imitar a multiplicação de cadeias por ter um contador que diminui cada iteração.

:&"$$"{\                     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 graças 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 linha entra em um arquivo de origem separado, então adicionei 1 byte para cada arquivo após o primeiro . No entanto, por conveniência, o Retina agora também suporta o-s sinalizador da linha de comando, que permite colocar tudo isso em um único arquivo (nesse caso, as novas linhas são tratadas como separadores de arquivos).

A maior parte do código (98 bytes) é usada para converter a entrada de decimal em unária (arquivos 3 a 6). A idéia básica do código é envolver a entrada $$\varphi=1+\dots...$$, converter a entrada em unário e expandir \dotsNou \ddotsNavançar para o próximo nível da fração continuada (enquanto reduz Npara N-1).

Julia, 76 73 bytes

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

Isso cria uma função lambda que recebe um único número inteiro como entrada e retorna o MathJax como uma sequência. Para chamá-lo, dê um nome, por exemplof=n->... .

Infelizmente, as barras invertidas e os cifrões precisam ser escapados nas strings de Julia, porque ambos têm um significado especial. A concatenação de strings é realizada usando *e repetição de strings com^ .

Exemplos:

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

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

Sugestões são bem-vindas como sempre!

Edit: Salvo 3 bytes graças ao plannapus!

Elemento, 63 caracteres

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

Esta é a solução mais direta. Infelizmente, a grande quantidade de símbolos na saída causa um aumento significativo no comprimento do programa (colocar as strings no programa faz com que os símbolos executem operações diretamente). Tenho certeza de que há espaço para jogar golfe, mas não tenho mais tempo no momento.

Como esse idioma ainda é relativamente desconhecido, aqui está um link para o intérprete , escrito em 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

Já faz um tempo desde que eu fiz uma resposta SQL e, como sempre, é muito detalhada. Editar É claro que eu o complicava demais e não precisava de uma consulta recursiva.

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=@

Isso cria uma função de tabela embutida que usa uma consulta recursiva para inserir itens adicionais cfrac1{1+\por iteração. Mudar os pontos para ddots era caro, mas salvou alguns se livrando da substituição :). Também ter que converter a string original como 'VARCHAR (MAX)' custa um pouco.

É usado da seguinte maneira 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

Isso parece suspeito, então, por favor, deixe-me saber se eu errei em algum lugar.

Aliás, esta é a primeira coisa que eu já escrevi em Ruby - eu estava procurando uma linguagem que suportava a repetição de strings multiplicando, e Ruby parecia fazer o truque.

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

Para ser aplicado assim:

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:

A corda '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'é cortada em espaços e as partes são repetidas 1 n signum(n) 1 n 1vezes e, em seguida, essas partes são concatenadas.

Experimente online aqui.

R, 93 90

Muito parecido com as outras respostas. Obrigado a @plannapus pela dica de digitalização.

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

cat usado em vez de colar0, pois o resultado acabaria com \\ vez de \.

Em 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 graças a George Reith

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

Esta é a minha primeira participação em um concurso de codegolf! Por favor me diga como melhorar.

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

Cole no console do navegador e chame como f(n)onde nestá o número de 'etapas'.

Código simplificado :

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

Pitão - 52 bytes

A abordagem simples no Pyth, praticamente roubada da solução Python do @ Sp3000. Usa o operador de formatação de string %.

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

Experimente online aqui .

%                  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

Pitão, 50 bytes

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

JavaScript (ES6), 76 80

Parcialmente recursivo. O single / double d é a parte mais irritante.

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

Teste no console 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 a solução mais eficiente já foi lançada várias vezes, eu substituo a string

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

Edit: caramba, esquecido o em dotsvez de ddotspara n=0, agora a solução recursiva com uma cláusula extra é muito feia 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%"}"++"$$"

Essencialmente, a mesma abordagem de todas as soluções aqui. drop(0^n)"ddots"é fofo!