Schreiben Sie ein Programm oder eine Funktion, die einen Gebirgszug zeichnet, bei dem jeder nachfolgende größere Berggipfel "hinter" dem vorderen liegt und abwechselnd die sichtbare Seite anzeigt.

Dies ist eine Bergkette von Größe 1

/\

Dies ist eine Bergkette von Größe 2

 /\
/\ \

Dies ist eine Bergkette von Größe 3

  /\
 / /\
/ /\ \

Dies ist eine Bergkette von Größe 4

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

Dies ist eine Bergkette von Größe 5

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

Und so weiter.

Eingang

Eine einzelne positive ganze Zahl in jedem geeigneten Format , n > 0.

Ausgabe

Eine ASCII-artige Darstellung des Gebirges nach den oben genannten Regeln. Führende / nachfolgende Zeilenumbrüche oder andere Leerzeichen sind optional, sofern die Spitzen richtig ausgerichtet sind.

Regeln

• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Kohle , 16 Bytes

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

Probieren Sie es online!

Wie?

Ｎλgibt die Größe des größten Berges ein λ. Ｆλ«Läuft eine Schleife über Werte von ιvon 0bis λ-1. (Der Abschluss »ist am Ende des Programms impliziert.)

Ｐ↘⁻λιBerechnet λ-ιund zeichnet innerhalb der Schleife eine Linie dieser Länge nach Südosten, ohne den Cursor danach zu bewegen. Diese Zeile besteht je nach Richtung aus \Zeichen. ←bewegt sich einen Schritt nach Westen und ↙¹zeichnet eine Linie der Länge 1 nach Südwesten (aus /). Schließlich ‖Ｔ→spiegelt sich horizontal um die Zeichnung, Zeichen gegebenenfalls Umwandlung: \wird /und /wird \.

Durch Hinzufügen der Dump-Anweisung Ｄam Anfang der Schleife ( probieren Sie es aus ) können wir den Fortschritt sehen:

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

JavaScript (ES6), 75 Byte

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

Das vollständige Programm ist derzeit etwas kürzer als die rekursive Funktion:

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]

Druckt zeilenweise und akkumuliert die Zeichenfolge, sindem abwechselnd ein Schrägstrich nach links oder rechts hinzugefügt wird, basierend auf der aktuellen Parität von n. Präfixe mit nLeerzeichen.

Eine alternative Möglichkeit zum Aktualisieren war die gleiche Länge:

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

Eine rekursive Methode war länger (70 Byte).

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)
(%"/\\")

Verwendung:

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

Druckt Zeile für Zeile, wobei die Zeichenfolge s durch abwechselndes Hinzufügen eines Schrägstrichs nach links oder rechts basierend auf der aktuellen Parität von n akkumuliert wird. Präfixe mit n-1 Leerzeichen.

Batch, 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%

Übernimmt die Eingabe als Befehlszeilenparameter. Fällt durch, um die letzte Schleife auszuführen.

Ruby, 61 Bytes

Eine ziemlich unkomplizierte Portierung der JavaScript-Antwort von ETHproductions .

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

Siehe es auf 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 Bytes

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

Probieren Sie es auf Ideone. Bearbeiten: 8 Bytes mit einer Idee von Neil gespeichert.

Ungolfed-Version:

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)

Rekursiver Ansatz. Die Form für nwird erzeugt, indem vor jeder Zeile der n-1Form ein Leerzeichen eingefügt und die letzte Zeile von n-1und addiert wird, "/ "bevor ob nungerade ist oder " \"nachdem ob gerade nist ... oder so alle rekursiven Schritte, wenn das Finale nungerade ist. Daher wird ein Flag bübergeben, das jeden rekursiven Aufruf abwechselt und bestimmt, ob der nächste Bergabschnitt links oder rechts hinzugefügt wird.

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

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 (Funktion)

Funktion: -

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

Volles Programm: -

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

HINWEIS: Die Funktion _getch()kann auf verschiedenen Compilern unterschiedliche Prototypnamen haben.