Ecrivez un programme ou une fonction qui dessine une chaîne de montagnes, où chaque plus grand sommet de montagne est "derrière" celui qui se trouve devant, et alterne le côté visible.

Ceci est une chaîne de montagnes de taille 1

/\

Ceci est une chaîne de montagnes de taille 2

 /\
/\ \

Ceci est une chaîne de montagnes de taille 3

  /\
 / /\
/ /\ \

Ceci est une chaîne de montagnes de taille 4

   /\
  /\ \
 / /\ \
/ /\ \ \

Ceci est une chaîne de montagnes de taille 5

    /\
   / /\
  / /\ \
 / / /\ \
/ / /\ \ \

Etc.

Contribution

Un entier positif unique dans un format pratique , n > 0.

Sortie

Une représentation ASCII-art de la chaîne de montagnes, en suivant les règles ci-dessus. Les nouvelles lignes et les autres espaces sont facultatifs, à condition que les pics s'alignent correctement.

Règles

• Un programme complet ou une fonction sont acceptables. Si une fonction est utilisée, vous pouvez renvoyer la sortie plutôt que de l’imprimer.
• Les échappatoires standard sont interdites.
• Il s’agit du code-golf, donc toutes les règles de golf habituelles s’appliquent et le code le plus court (en octets) gagne.

Charbon de bois , 16 octets

ＮλＦλ«Ｐ↘⁻λι←↙¹‖Ｔ→

Essayez-le en ligne!

Comment?

Ｎλentre la taille de la plus grande montagne dans λ. Ｆλ«exécute une boucle sur les valeurs ιfrom from 0through λ-1. (La clôture »est implicite à la fin du programme.)

À l'intérieur de la boucle, Ｐ↘⁻λιcalcule λ-ιet trace, sans déplacer le curseur par la suite, une ligne de cette longueur allant vers le sud-est. En fonction de sa direction, cette ligne sera composée de \caractères. ←se déplace d'un pas vers l'ouest et ↙¹trace une ligne de longueur 1 allant vers le sud-ouest (composée de /). Enfin, ‖Ｔ→reflète horizontalement le dessin en transformant les caractères selon les cas: \devient /et /devient \.

Ajouter l'instruction de dump Ｄau début de la boucle ( essayez-le ) nous permet de voir la progression:

    /\
   /  
  /   
 /    
/     
    /\    
   /\ \   
  /    \  
 /      \ 
/        \
    /\    
   / /\   
  / /\ \  
 / /    \ 
/ /      \
    /\    
   /\ \   
  / /\ \  
 / /\ \ \ 
/ /    \ \
    /\    
   / /\   
  / /\ \  
 / / /\ \ 
/ / /\ \ \

JavaScript (ES6), 75 octets

for(n=prompt(s="/\\");n--;s=n%2?s+' \\':'/ '+s)console.log(" ".repeat(n)+s)

Le programme complet est actuellement légèrement plus court que la fonction récursive:

f=n=>n?" ".repeat(--n)+`/\\
`+f(n).replace(/\S.+/g,x=>n%2?x+" \\":"/ "+x):""

Python 2, 67 octets

n=input()
s='/\\'
while n:n-=1;print' '*n+s;s=['/ '+s,s+' \\'][n%2]

Imprime ligne par ligne, en accumulant la chaîne sen ajoutant alternativement une barre oblique à gauche ou à droite en fonction de la parité actuelle de n. Préfixes avec des nespaces.

Une autre façon de mettre à jour était la même longueur:

s=n%2*'/ '+s+~n%2*' \\'
s=['/ '+s,s+' \\'][n%2]

Une méthode récursive était plus longue (70 octets).

f=lambda n,s='/\\':n*'_'and' '*~-n+s+'\n'+f(n-1,[s+' \\','/ '+s][n%2])

Haskell, 77 octets

0%_=""
n%s=(' '<$[2..n])++s++'\n':(n-1)%(cycle[s++" \\","/ "++s]!!n)
(%"/\\")

Usage:

putStrLn $ f 5
    /\
   / /\
  / /\ \
 / / /\ \
/ / /\ \ \

Imprime ligne par ligne, en accumulant la chaîne s en ajoutant alternativement une barre oblique à gauche ou à droite en fonction de la parité actuelle de n. Préfixes avec n-1 espaces.

Lot, 202 octets

@echo off
set/af=%1^&1
set m=/\
set s=
for /l %%i in (2,1,%1)do call set s= %%s%%
for /l %%i in (2,1,%1)do call:l
:l
echo %s%%m%
set s=%s:~1%
set/af^^=1
if %f%==1 (set m=%m% \)else set m=/ %m%

Prend l'entrée en tant que paramètre de ligne de commande. Chute pour exécuter la dernière boucle.

Ruby, 61 octets

Un port assez simple de la réponse JavaScript d' ETHproductions .

->n{s="/\\"
(puts" "*n+s
s=n%2>0?s+" \\":"/ "+s)until 0>n-=1}

Voir sur repl.it: https://repl.it/EPU5/1

Ungolfed

->n{
  s = "/\\"
  ( puts " "*n+s
    s = n%2 > 0 ? s+" \\" : "/ "+s
  ) until 0 > n -= 1
}

Haskell, 117 107 105 97 90 octets

b!1=["/\\"]
b!n|m<-(1-b)!(n-1)=map(' ':)m++[[("/ "++),(++" \\")]!!b$last m]
(unlines.(1!))

Essayez-le sur Ideone. Edit: 8 octets enregistrés avec une idée de Neil.

Version non-golfée:

p b 1 = ["/\\"]
p b n = let m = p (1-b) (n-1)
            k = last m
            r = map (' ':) m
        in if b == 1
           then r ++ [k ++ " \\"]
           else r ++ ["/ " ++ k]
f n = unlines(p 1 n)

Approche récursive. La forme de nest générée en ajoutant un espace devant chaque ligne de la n-1forme et en prenant la dernière ligne de n-1et ajouter "/ "avant si nest impair ou " \"après si nest pair ... ou alors j'ai pensé avant de remarquer que cette dernière étape est inversée pour toutes les étapes récursives lorsque la finale nest impaire. Par conséquent, un drapeau best passé qui alterne chaque appel récursif et détermine si la partie de montagne suivante est ajoutée à gauche ou à droite.

Java 7 130 octets

String f(int n,String s){String l="";for(int i=1;i++<n;l+=" ");return n>1?n%2<1?l+s+"\n"+f(--n,s+" \\"):l+s+"\n"+f(--n,"/ "+s):s;}

Ungolfed

class Mountain {
 public static void main(String[] args) {
    System.out.println(f( 5 , "/\\" ) );
  }
 static String f(int n,String s){
    String l = "";
    for (int i = 1; i++ < n; l += " ") ;
      return n > 1? n % 2 < 1?l + s + "\n" + f(--n , s + " \\")
                           :l + s + "\n" + f(--n , "/ " + s)
                            :s;
    }

}

C ++ 138 (fonction)

Une fonction :-

#define c(X) cout<<X;
#define L(X,Y) for(X=0;X<Y;X++)  

void M(int h){int l=1,r=1,j,H=h,i;L(i,h){for(j=H;j>0;j--)c(" ")L(j,l)c(" /")L(j, r)c("\\ ")c("\ n")(h%2)?(i%2)?r++:l++:(i%2)?l++:r++;H--;}  

Programme complet: -

#include<conio.h>
#include<iostream>

using namespace std;

#define c(X) cout<<X;
#define L(X,Y) for(X=0;X<Y;X++)

void M(int h)
{
    int l=1,r=1,j,H=h,i;

    L(i, h)
    {
        for (j = H;j > 0;j--)
            c(" ")
        L(j, l)
            c(" /")
        L(j, r)
            c("\\ ")
        c("\n")

        (h % 2) ? (i % 2) ? r++ : l++ :(i % 2) ? l++ : r++;
        H--;
    }
}

int main()
{
    int h;
    cin >> h;
    M(h);
    _getch();
    return 0;
}  

Remarque: la fonction _getch()peut avoir différents noms de prototype sur différents compilateurs.