Escriba un programa o función que dibuje una cadena montañosa, donde cada pico de montaña más grande posterior esté "detrás" de los que están al frente, y alterna qué lado es visible.

Esta es una cordillera de tamaño 1

/\

Esta es una cordillera de tamaño 2

 /\
/\ \

Esta es una cordillera de tamaño 3

  /\
 / /\
/ /\ \

Esta es una cordillera de tamaño 4

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

Esta es una cordillera de tamaño 5

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

Y así.

Entrada

Un número entero positivo solo en cualquier formato conveniente , n > 0.

Salida

Una representación ASCII-art de la cordillera, siguiendo las reglas anteriores. Las nuevas líneas iniciales / finales u otros espacios en blanco son opcionales, siempre que los picos se alineen adecuadamente.

Reglas

• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Carbón , 16 bytes

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

Pruébalo en línea!

¿Cómo?

Ｎλintroduce el tamaño de la montaña más grande en λ. Ｆλ«ejecuta un bucle sobre valores de ιa 0través λ-1. (El cierre» está implícito al final del programa).

Dentro del bucle, Ｐ↘⁻λιcalcula λ-ιy dibuja, sin mover el cursor después, una línea de esa longitud que va hacia el sureste. Según su dirección, esta línea constará de \caracteres. ←se mueve un paso hacia el oeste y ↙¹dibuja una línea de longitud 1 que va hacia el suroeste (hecha de /). Finalmente, ‖Ｔ→refleja horizontalmente el dibujo, transformando los personajes según corresponda: se \convierte /y se /convierte en\ .

Agregar la instrucción de volcado Ｄal comienzo del ciclo ( pruébelo ) nos permite ver la progresión:

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

JavaScript (ES6), 75 bytes

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

El programa completo es actualmente un poco más corto que la función recursiva:

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

Python 2, 67 bytes

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

Imprime línea por línea, acumulando la cadena sagregando alternativamente una barra diagonal a la izquierda o derecha según la paridad actual de n. Prefijos conn espacios.

Una forma alternativa de actualizar era la misma longitud:

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

Un método recursivo fue más largo (70 bytes).

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

Haskell, 77 bytes

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

Uso:

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

Imprime línea por línea, acumulando la cadena s agregando alternativamente una barra inclinada a la izquierda o derecha según la paridad actual de n. Prefijos con n-1 espacios.

Lote, 202 bytes

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

Toma la entrada como un parámetro de línea de comando. Se cae para ejecutar el último bucle.

Ruby, 61 bytes

Un puerto bastante sencillo de la respuesta JavaScript ETHproductions .

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

Véalo en repl.it: https://repl.it/EPU5/1

Sin golf

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

Haskell, 117107105 97 90 bytes

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

Pruébalo en Ideone. Editar: guardado 8 bytes con una idea de Neil.

Versión sin golf:

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)

Enfoque recursivo. La forma para nse genera al agregar un espacio en frente de cada línea de la n-1forma y tomar la última línea de n-1y agregar "/ "antes si nes impar o " \"después si nes par ... o eso pensé antes de notar que este último paso se invierte todos los pasos recursivos cuando el final nes impar. Por lo tanto, bse pasa una bandera que alterna cada llamada recursiva y determina si la siguiente parte de la montaña se agrega a la izquierda o la derecha.

Java 7.130 bytes

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

Sin golf

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 (función)

Función: -

#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--;}  

Programa completo: -

#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;
}  

NOTA: la función _getch()puede tener diferentes nombres de prototipo en diferentes compiladores.