In previsione della disattivazione temporanea di MathJax , il MathJax renderizzato in questa domanda è stato sostituito con immagini. Puoi comunque inviare le risposte ma dovrai visualizzare MathJax su un altro sito .

PPCG ha appena ottenuto MathJax ! Ciò significa che ora possiamo facilmente includere nei post formule matematiche ben formattate. ( Esercitazione pratica di MathJax. )

Ad esempio, ecco il rapporto aureo espresso come una frazione continua infinita :

Il codice MathJax per questa equazione è

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

^{Puoi trovarlo facendo clic con il tasto destro del mouse sulla formula e seguendo Mostra Matematica come → Comandi TeX .
I $$mezzi che viene visualizzato sul proprio nel centro della pagina, invece di linea. Usa un singolo $per in linea.}

Sfida

Scrivi un programma che accetta un numero intero non negativo, n, e genera il codice MathJax per i numerosi "passaggi" della frazione continua per il rapporto aureo.

Per mantenere le cose standard tra le risposte, è necessario utilizzare questa sintassi MathJax esatta :

• Per n = 0, l'output deve essere $$\varphi=1+\dots$$.
  Che è reso come:

  

• Per n = 1, l'uscita deve essere $$\varphi=1+\cfrac1{1+\ddots}$$.
  Che è reso come:

  

• Per n = 2, l'uscita deve essere $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  Che è reso come:

  

• Per n = 3, l'uscita deve essere $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  Che è reso come:

  

Questo modello continua per n più grande. Si potrebbe dire che n rappresenta il numero di linee di divisione nell'equazione.

Appunti

• \cfracviene utilizzato al posto del più comune \frac.
• \dotsviene utilizzato anziché \ddotsper n = 0.
• Prendi input da stdin o dalla riga di comando.
• Uscita su stdout (con una nuova riga finale opzionale).
• In alternativa, è possibile scrivere una funzione che accetta n come numero intero e restituisce il codice MathJax come stringa (o lo stampa ancora).

punteggio

Vince il più piccolo invio in byte. Tiebreaker va alla presentazione precedente.

CJam, 51 50 byte

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

Spiegazione del codice:

"$$\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 $$";

Alcuni esempi:

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

AGGIORNAMENTO - 1 byte salvato grazie a Sp3000!

Provalo online qui

Python, 70 68 67 byte

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

Questo definisce una funzione anonima che utilizza semplicemente la moltiplicazione e la formattazione delle stringhe.

(Grazie a @xnor per aver sottolineato che \\cpuò essere semplicemente scritto come \c, poiché cnon può essere evitato. Sfortunatamente questo non vale per \\v, poiché \vè ASCII 11.)

Tentativi precedenti:

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 byte

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

Corri con la -vbandiera, ad es

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

Sorprendentemente> <> non fa troppo male qui, dal momento che possiamo imitare la moltiplicazione delle stringhe avendo un contatore che diminuiamo ogni iterazione.

:&"$$"{\                     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 byte grazie a @randomra)

Retina , 160 + 7 = 167 byte

;`.+
$$$$\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}

Ogni riga va in un file sorgente separato, quindi ho aggiunto 1 byte per ogni file dopo il primo . Tuttavia, per comodità, Retina ora supporta anche il -sflag della riga di comando, che consente di inserire tutto questo in un singolo file (nel qual caso le newline vengono trattate come separatori di file).

La maggior parte del codice (98 byte) viene utilizzata per convertire l'input da decimale a unario (file da 3 a 6). L'idea di base del codice è di circondare l'ingresso $$\varphi=1+\dots...$$, quindi convertire l'ingresso in unario, quindi espandere \dotsNo \ddotsNal livello successivo della frazione continua (riducendo Na N-1).

Julia, 76 73 byte

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

Questo crea una funzione lambda che accetta un singolo intero come input e restituisce MathJax come stringa. Per chiamarlo, dagli un nome, ad es f=n->....

Sfortunatamente sia le barre rovesciate che i segni del dollaro devono essere sfuggiti nelle stringhe di Julia perché entrambi hanno un significato speciale. La concatenazione di stringhe viene eseguita utilizzando *e ripetizione di stringa con ^.

Esempi:

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

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

I suggerimenti sono i benvenuti come sempre!

Modifica: salvato 3 byte grazie a plannapus!

Elemento, 63 caratteri

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

Questa è la soluzione più diretta. Sfortunatamente, la grande quantità di simboli nell'output provoca un aumento significativo della lunghezza del programma (inserendo direttamente le stringhe nel programma, i simboli eseguono le operazioni). Sono sicuro che ci sia spazio per giocare a golf, ma non ho più tempo in questo momento.

Poiché questa lingua è ancora relativamente sconosciuta, ecco un link all'interprete , scritto in 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

È passato un po 'di tempo da quando ho fatto una risposta SQL e come sempre è molto dettagliata. Modifica Naturalmente l'ho complicato troppo e non ho avuto bisogno di una query ricorsiva.

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

Originale

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

Ciò crea una funzione di tabella incorporata che utilizza una query ricorsiva per aggiungere elementi cfrac1{1+\nell'iterazione aggiuntiva . Cambiare i punti in punti era costoso, ma è stato risparmiato un paio per sbarazzarsi del rimpiazzo :). Anche dover lanciare la stringa originale come 'VARCHAR (MAX)' costa un po '.

Viene utilizzato come segue 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}}}}}$$

Rubino, 76 75 71 70 byte

Questo sembra sospettosamente semplice, quindi per favore fatemi sapere se ho fatto un casino da qualche parte.

Per inciso, questa è la prima cosa che io abbia mai scritto in Ruby: stavo cercando un linguaggio che supportasse la ripetizione delle corde moltiplicandosi, e Ruby sembrava fare il trucco.

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

Da applicare in questo modo:

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

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

J, 60 byte

(<;._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}}}$$

Metodo:

La stringa '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'viene tagliata negli spazi e le parti vengono ripetute 1 n signum(n) 1 n 1volte e quindi queste parti vengono concatenate.

Provalo online qui.

R, 93 90

Più o meno le stesse risposte. Grazie a @plannapus per il suggerimento di scansione.

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

catusato anziché paste0 poiché il risultato sarebbe \\invece di \.

In 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 byte grazie a George Reith

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

Questa è la mia prima partecipazione a un concorso codegolf! Per favore, dimmi come migliorare.

Voce precedente (106 byte):

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

Voce precedente (109 byte):

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

Voce precedente (114 byte):

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

Incollare nella console browser e chiamata come f(n)dove nè il numero di 'passi'.

Codice semplificato :

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

Pyth - 52 byte

Il semplice approccio in Pyth, praticamente rubato dalla soluzione Python di @ Sp3000. Utilizza l'operatore di formattazione delle stringhe %.

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

Provalo online qui .

%                  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 byte

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

JavaScript (ES6), 76 80

Parzialmente ricorsivo La singola / doppia d è la parte più fastidiosa.

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

Test nella console di 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

poiché la soluzione più efficiente è già stata pubblicata più volte, vado invece con la sostituzione delle stringhe

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

Modifica: dannazione, trascurato dotsinvece che ddotsper n=0, ora la soluzione ricorsiva con una clausola aggiuntiva applicata è troppo brutta per competere.

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

Essenzialmente lo stesso approccio di tutte le soluzioni qui. drop(0^n)"ddots"è carino, però!