En prévision de la désactivation temporaire de MathJax , le MathJax rendu dans cette question a été remplacé par des images. Vous êtes toujours les bienvenus pour poster des réponses mais vous devrez voir le MathJax rendu sur un autre site .

PPCG vient d'obtenir MathJax ! Cela signifie que nous pouvons désormais facilement inclure des formules mathématiques bien formatées dans les publications. ( Tutoriel MathJax pratique. )

Par exemple, voici le nombre d' or exprimé en fraction continue infinie :

Le code MathJax pour cette équation est

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

^{Vous pouvez le trouver en cliquant avec le bouton droit sur la formule et en suivant Afficher les mathématiques sous → Commandes TeX .
Les $$moyens qu'il est affiché sur son propre dans le centre de la page au lieu de ligne. Utilisez un seul $pour inline.}

Défi

Écrivez un programme qui prend un entier non négatif, n, et génère le code MathJax pour autant de «pas» de la fraction continue pour le nombre d'or.

Pour garder les choses standard dans les réponses, vous devez utiliser cette syntaxe MathJax exacte :

• Pour n = 0, la sortie doit être $$\varphi=1+\dots$$.
  Qui est rendu comme:

  

• Pour n = 1, la sortie doit être $$\varphi=1+\cfrac1{1+\ddots}$$.
  Qui est rendu comme:

  

• Pour n = 2, la sortie doit être $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  Qui est rendu comme:

  

• Pour n = 3, la sortie doit être $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  Qui est rendu comme:

  

Ce modèle se poursuit pour un n plus grand. On pourrait dire que n représente le nombre de lignes de division dans l'équation.

Remarques

• \cfracest utilisé à la place du plus courant \frac.
• \dotsest utilisé au lieu de \ddotspour n = 0.
• Prenez l'entrée de stdin ou de la ligne de commande.
• Sortie vers stdout (avec une nouvelle ligne de fin facultative).
• Alternativement, vous pouvez écrire une fonction qui prend n comme un entier et renvoie le code MathJax sous forme de chaîne (ou l'imprime toujours).

Notation

La plus petite soumission en octets gagne. Tiebreaker revient à la communication précédente.

CJam, 51 50 octets

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

Explication du code:

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

Quelques exemples:

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

MISE À JOUR - 1 octet enregistré grâce au Sp3000!

Essayez-le en ligne ici

Python, 70 68 67 octets

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

Cela définit une fonction anonyme qui utilise simplement une multiplication de chaîne simple et un formatage de chaîne.

(Merci à @xnor d'avoir souligné que cela \\cpeut simplement être écrit comme \c, car cil ne peut pas être échappé. Malheureusement, cela ne vaut pas pour \\v, car \vc'est ASCII 11.)

Tentatives précédentes:

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 octets

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

Courez avec le -vdrapeau, par exemple

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

Étonnamment> <> ne fait pas trop mal ici, car nous pouvons imiter la multiplication des chaînes en ayant un compteur que nous décrémentons à chaque itération.

:&"$$"{\                     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 octets grâce à @randomra)

Rétine , 160 + 7 = 167 octets

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

Chaque ligne va dans un fichier source séparé, j'ai donc ajouté 1 octet pour chaque fichier après le premier . Cependant, pour plus de commodité, Retina prend désormais également en charge l' -sindicateur de ligne de commande, qui vous permet de mettre tout cela dans un seul fichier (auquel cas les retours à la ligne sont traités comme des séparateurs de fichiers).

La plus grande partie du code (98 octets) est utilisée pour convertir l'entrée décimale en unaire (fichiers 3 à 6). L'idée de base du code est d'entourer l'entrée $$\varphi=1+\dots...$$, puis de convertir l'entrée en unaire, puis d'étendre \dotsNou \ddotsNau niveau suivant de la fraction continue (tout en réduisant Nà N-1).

Julia, 76 73 octets

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

Cela crée une fonction lambda qui prend un seul entier en entrée et renvoie le MathJax sous forme de chaîne. Pour l'appeler, donnez-lui un nom, par exemple f=n->....

Malheureusement, les barres obliques inverses et les signes dollar doivent être échappés dans les chaînes Julia, car ils ont tous deux une signification particulière. La concaténation de chaînes est effectuée à l'aide de *et la répétition de chaînes avec ^.

Exemples:

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

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

Les suggestions sont les bienvenues comme toujours!

Edit: sauvé 3 octets grâce à plannapus!

Élément, 63 caractères

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

Il s'agit de la solution la plus simple. Malheureusement, la grande quantité de symboles dans la sortie entraîne une augmentation significative de la longueur du programme (placer les chaînes dans le programme entraîne directement les symboles pour effectuer des opérations). Je suis sûr qu'il y a de la place pour le golf, mais je n'ai pas plus de temps pour le moment.

Cette langue étant encore relativement inconnue, voici un lien vers l' interpréteur , écrit 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

Cela fait un moment que j'ai fait une réponse SQL et comme toujours c'est très verbeux. Éditer Bien sûr, j'ai trop compliqué les choses et je n'ai pas du tout eu besoin d'une requête récursive.

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

Cela crée une fonction de table en ligne qui utilise une requête récursive pour remplir les informations supplémentaires cfrac1{1+\par itération. Changer les points en points était coûteux, mais cela a permis à quelques personnes de se débarrasser du remplacement :). Le fait de devoir également transtyper la chaîne d'origine en 'VARCHAR (MAX)' coûte un peu.

Il est utilisé comme suit 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}}}}}$$

Rubis, 76 75 71 70 octets

Cela semble étrangement simple, alors faites-moi savoir si j'ai foiré quelque part.

Soit dit en passant, c'est la première chose que j'ai jamais écrite en Ruby - je cherchais un langage qui supportait la répétition de chaînes en se multipliant, et Ruby semblait faire l'affaire.

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

À appliquer ainsi:

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

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

J, 60 octets

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

Usage:

   ((<;._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éthode:

La chaîne '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'est coupée en espaces et les parties sont répétées plusieurs 1 n signum(n) 1 n 1fois, puis ces parties sont concaténées.

Essayez-le en ligne ici.

R, 93 90

À peu près la même chose que les autres réponses. Merci à @plannapus pour la pointe de numérisation.

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

catutilisé plutôt que coller0 car le résultat se retrouverait avec \\plutôt que\ .

Utilisé

> > 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 106 85 octets grâce à George Reith

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

Ceci est ma première entrée dans un concours de codegolf! Dites-moi comment vous améliorer.

Entrée précédente (106 octets):

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

Entrée précédente (109 octets):

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

Entrée précédente (114 octets):

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

Coller dans la console du navigateur et appeler comme f(n)oùn trouve le nombre d '«étapes».

Code simplifié :

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

Pyth - 52 octets

L'approche simple en Pyth, quasiment dérobée à la solution Python de @ Sp3000. Utilise l'opérateur de formatage de chaînes %.

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

Essayez-le en ligne ici .

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

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

JavaScript (ES6), 76 80

En partie récursif. Le simple / double d est la partie la plus ennuyeuse.

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

Tester dans la 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

comme la solution la plus efficace a déjà été publiée plusieurs fois, je préfère le remplacement de chaîne

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: putain, négligé le dotsau lieu de ddotspour n=0, maintenant la solution récursive avec une clause supplémentaire clouée est trop moche pour rivaliser.

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

Essentiellement la même approche que toutes les solutions ici. drop(0^n)"ddots"est mignon, cependant!