Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die als Eingabe eine natürliche Zahl ( n) zwischen 1 und 25 (einschließlich) verwendet und eine isometrische Darstellung einer Rutsche und einer Leiter mit der nAnzahl der Sprossen ausgibt.

Leiter- und Rutschenspezifikationen

Die Leiter ist immer links und die Rutsche rechts ausgerichtet. Wir betrachten es von der Leiterseite aus, sodass ein Teil der Folie in den oberen drei Ebenen verdeckt ist. Die Sprossen werden durch vier Striche ( ----) und die Seiten der Leiter dargestellt und gleiten durch Schrägstriche ( /und \). Das folgende Diagramm zeigt die Platzverhältnisse für einen Objektträger mit fünf Sprossen.

Slide              Blank space count
    /----/\        1234/----/\ 
   /----/  \       123/----/12\ 
  /----/    \      12/----/1234\ 
 /----/ \    \     1/----/1\1234\ 
/----/   \    \    /----/123\1234\

Beispiele

>>1
/----/\

>>3
  /----/\ 
 /----/  \ 
/----/    \ 

>>4
   /----/\ 
  /----/  \ 
 /----/    \ 
/----/ \    \ 

>>10
         /----/\ 
        /----/  \ 
       /----/    \ 
      /----/ \    \ 
     /----/   \    \ 
    /----/     \    \ 
   /----/       \    \ 
  /----/         \    \ 
 /----/           \    \ 
/----/             \    \ 

Dies ist Codegolf, daher gewinnt die Antwort mit der niedrigsten Bytezahl.

Hinweis: Der nachgestellte Leerraum ist in der Ausgabe zulässig, solange er die Zeilenlänge nicht überschreitet.

Retina , 81 72 52 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

.+
$* /\    \
^.

+` /(.+)$
$&¶$%`/  $1
/.{5}
/----/

Probieren Sie es online!

Erläuterung

Das Programm besteht aus vier Stufen, die alle aus Regex-Substitutionen bestehen (mit einigen Retina-spezifischen Merkmalen). Ich werde die Eingabe 5als Beispiel für die Erklärung verwenden.

Bühne 1

.+
$* /\    \

Dies wandelt die Eingabe nin nLeerzeichen um, gefolgt von /\ \der Spitze der Leiter / Folie:

     /\    \

Im Moment zeigen wir nur die Folie vollständig und stellen die Leiter nur mit der linken Hand dar /.

Stufe 2

^.

Leider sind nLeerzeichen eins mehr als wir brauchen, deshalb entfernen wir das erste Zeichen wieder. Wir haben jetzt:

    /\    \

Stufe 3

+` /(.+)$
$&¶$%`/  $1

Zeit, die gesamte Struktur zu erweitern. Zu wissen, wo sich das Dach befindet, reicht aus, um das Ganze zu bauen, denn wir können es einfach um jeweils eine Zeile verlängern und die Leiter und die Rutsche um zwei Felder auseinander bewegen.

Das +weist Retina an, diese Phase in einer Schleife zu wiederholen, bis sich die Ausgabe nicht mehr ändert (in diesem Fall, weil der reguläre Ausdruck nicht mehr übereinstimmt). Was den regulären Ausdruck selbst betrifft, stimmen wir einfach mit der /letzten Zeile und allem danach überein und stimmen auch mit einem Leerzeichen davor überein, was bedeutet, dass dies nicht mehr übereinstimmen kann, sobald /die erste Spalte erreicht ist.

Folgendes ersetzen wir durch:

 $&    The match itself. We don't want to remove the line we already have.
 ¶     A linefeed, because we want to append a new line.
 $%`   This is a very recent addition to Retina: it's like the normal $` but
      is bounded by linefeeds. That means this inserts everything in front
      of the match which is on the same line. In particular this one space
      less than the indentation of the matched line, hence we are shifting
      the / one column left.
 /     A literal /, representing the left edge of the ladder.
>  <   Two spaces, so that we can shift the slide one column right.
 $1    Capturing group 1 which contains the slide and its separation from
      the ladder.

Bei jeder Iteration wird die Zeichenfolge also um eine Zeile erweitert, bis Folgendes erreicht wird:

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

Stufe 4

/.{5}
/----/

Alles was übrig bleibt, ist die Leiter nach rechts zu bringen. Das ist ganz einfach: Wir passen nur die /und die nächsten 5 Zeichen an und fügen die richtige Leiterdarstellung ein, wodurch die Folie oder die bereits vorhandenen Leerzeichen überschrieben werden:

    /----/\
   /----/  \
  /----/    \
 /----/ \    \
/----/   \    \

V , 38, 37, 36, 34, 33, 32, 31, 30, 29 Bytes

Àé r\2é/4é-òhYpX$2P^ò3GEòjlr\

Probieren Sie es online!

Ich könnte Osabie einholen. Ein Byte kürzer als Osabie. \o/Gebunden mit 2sable! Ein Byte kürzer!

In anderen Nachrichten ist dies definitiv der längste durchgestrichene Header, den ich je gemacht habe.

Erläuterung:

Àé              "Insert 'arg1' spaces
   r\           "Turn the last one into a '\'
     2é/        "Insert 2 '/'
        4é-     "Insert 4 '-'

ò        ò      "Recursivly:
 h              "  Move one to the left
  Yp            "  Duplicate this line
    X           "  Delete one space from the left
     $2P        "  Paste two spaces at the end of this line
        ^       "  Move back to the beginning of this line.

Dies wird ausgeführt, bis ein Fehler auftritt, der dank des Befehls "Nach links bewegen" ("h") "arg1" -mal ist.

Jetzt müssen wir nur noch das innere Bein hinzufügen

3GE             "Move to the second slash of line 3
   ò    ò       "Recursively: (The second 'ò' is implicit)
    jl          "  Move down and to the right
      r\        "  And replace the character under the cursor with a '\'

Nicht konkurrierende Version (28 Bytes)

Pyth, 39 35 Bytes

VQ++*dt-QN"/----/">+*+ddN"\    \\"5

Erläuterung:

VQ                                  # Interate over 0 -> Q-1 (Q is the input)
  +                                 # Concatenate the 2 halfs of the slide
   +                                # Concatenate the whitespace block and the ladder
    *d                              # Multiply d (whitespace) by this number \/
      t-QN                          # Calculate the amount of spaces before : input - step of the iterarion -1
          "/----/"                  # Ladder
                  >               5 # Remove the first 5 chars  from the string generated in the following lines 
                   +                # Concatenate the whitespace block and the slide
                    *+ddN           # Multiply "+dd" (2 whitespace) by the step of the iterarion to generate the space between the ladder and the slide
                         "\    \\"  # Slide

Hier testen

2sable , 40 36 32 30 Bytes

Hmmm, V kommt furchtbar nahe ...

F¹N-<ð×…/--«ðð«N×…\  ««5F¦}¶

Verwendet die CP-1252- Codierung. Probieren Sie eine 05AB1E-kompatible Version aus! .

PowerShell v2 +, 99 90 82 Bytes

param($n)1..$n|%{" "*($n-$_)+"/----/"+-join(" "*($_+$i++)+"\    \")[6..(6+$_+$i)]}

Übernimmt die Eingabe $n, startet eine Schleife von 1bis $nmit |%{...}. Bei jeder Iteration konstruieren wir einen String. Wir beginnen mit der entsprechenden Anzahl von Plätzen " "*($n-$_)und der Leiter "/----/".

Dazu fügen wir eine weitere Zeichenfolge hinzu, die geschnitten [...]und -joinwieder zusammengefügt wurde. Die zweite Zeichenfolge ist die Folie, und wir gehen davon aus, dass die gesamte Folie immer sichtbar ist. Dies ist die Anzahl der Leerzeichen, bevor die Folie gestartet wird " "*($_+$i++), gefolgt von der Folie selbst "\ \". Dies wird durch einen Bereich aufgeschnitten, der als Teil der "Felder plus Folie" berechnet wird, der teilweise von der Leiter verdeckt wird.

Beispiele

PS C:\Tools\Scripts\golfing> .\draw-a-ladder-and-slide.ps1 7
      /----/\
     /----/  \
    /----/    \
   /----/ \    \
  /----/   \    \
 /----/     \    \
/----/       \    \

PS C:\Tools\Scripts\golfing> .\draw-a-ladder-and-slide.ps1 15
              /----/\
             /----/  \
            /----/    \
           /----/ \    \
          /----/   \    \
         /----/     \    \
        /----/       \    \
       /----/         \    \
      /----/           \    \
     /----/             \    \
    /----/               \    \
   /----/                 \    \
  /----/                   \    \
 /----/                     \    \
/----/                       \    \

Python 2 - 79 76 75 Bytes

x=input()
for i in range(x):print(x-i)*' '+'/----/'+(i*'  '+'\\    \\')[5:]

Vielen Dank an Hubert Grzeskowiak, der mich "disqualifiziert" hat, da mein Programmdruck tatsächlich 3 Bytes eingespart hat! Danke auch an Eʀɪᴋ ʀɪᴋ Gᴏʟғᴇʀ für das Speichern von 1 weiteren Byte!

Vim, 71 Tastenanschläge

Das ist so dumm, aber es macht ein bisschen Spaß. Die Eingabe erfolgt als Textdatei mit einer einzelnen Zeile, die eine Ganzzahl enthält. Dies ist wahrscheinlich ziemlich golferisch, aber es wird fürs Erste reichen ( Bearbeiten: Umgeschalteter Stil von Steuerzeichen auf Anfrage ):

A@qyyPgg<c-v><c-v>GkI <c-v><esc>G$i  <c-v><esc><esc>
Tq"qDI/----/\^[lD@"ddh<c-v>god:%s/     \\/\\    \\<cr>

<c-v>, <esc>Und <cr>sind alle einzelnen Tastenanschläge; Strg + v, Escape und Wagenrücklauf (Eingabe). Für eine einfache Version mit den richtigen Literale zu verdauen, hier ist die Datei ladder.keyslaufen zwar xxd:

00000000: 4140 7179 7950 6767 1616 476b 4920 161b  A@qyyPgg..GkI ..
00000010: 4724 6920 2016 1b1b 5471 2271 4449 2f2d  G$i  ...Tq"qDI/-
00000020: 2d2d 2d2f 5c1b 6c44 4022 6464 6816 676f  ---/\.lD@"ddh.go
00000030: 643a 2573 2f20 2020 2020 5c5c 2f5c 5c20  d:%s/     \\/\\
00000040: 2020 205c 5c0d 0d0a                         \\...

Um es auszuprobieren (nix mit den entsprechenden Tools vorausgesetzt), führen Sie es aus xxd -rund fügen Sie es in die Datei ein ladder.keys. Erstellen Sie eine Dateiladder.txt mit einer Ganzzahl. Dann mach:

vim -s ladder.keys -u NONE ladder.txt

Bash, 61

for((;i<$1;)){ printf "%$[$1+i]s\    \^M%$[$1-++i]s/----/\n";}

Wo ^Mist ein wörtlicher Wagenrücklauf

$ ./ladder 1
/----/\
$ ./ladder 4
   /----/\
  /----/  \
 /----/    \
/----/ \    \
$ ./ladder 10
         /----/\
        /----/  \
       /----/    \
      /----/ \    \
     /----/   \    \
    /----/     \    \
   /----/       \    \
  /----/         \    \
 /----/           \    \
/----/             \    \

JavaScript (ES6), 79 Byte

f=
n=>" ".repeat(n).replace(/./g,"$'/$`$`\\    \\\n").replace(/\/...../g,"/----/")
;

<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

Arbeiten Sie, indem Sie eine Reihe von nLeerzeichen verwenden, dann eine exotische Substitution durchführen, um die Folie mit einer Stütze zu versehen, und dann die Stütze durch eine Leiter ersetzen.

Ruby, 61 Bytes

->n{n.times{|i|puts"%*s\\    \\\r%*s----/"% [n+i,"",n-i,?/]}}

Ungolfed

->(num_rows) {
  num_rows.times {|row_idx|
    puts "%*s\\    \\\r%*s----/" % [ num_rows + row_idx, "", num_rows - row_idx, "/" ]
  }
}

Ich könnte zwei Bytes einsparen, indem ich für die Formatzeichenfolge '%*s\ \^M%*s----/'(wo ^Mist ein wörtlicher Wagenrücklauf) verwende, aber dann gibt Ruby die Warnung aus "warning: encountered \r in middle of line, treated as a mere space " aus. ¯ \ _ (ツ) _ / ¯

Vorherige Lösung (64 Bytes)

->n{n.times{|i|puts" "*(n+i)+"\\    \\\r"+" "*(n-i-1)+"/----/"}}

Batch, 194 Bytes

@echo off
for /l %%i in (1,1,%1)do call:l %1 %%i
exit/b
:l
set s=\    \
for /l %%j in (1,1,%2)do call set s=  %%s%%
set s=/----/%s:~7%
for /l %%j in (%2,1,%1)do call set s= %%s%%
echo%s%

Es hat sich als recht einfach herausgestellt: Folie einrücken, die ersten 7 Zeichen entfernen, Leiter einrücken, das führende Leerzeichen entfernen. Dieses letzte Stück ist allerdings ein wenig trickreich!

Java, 116 Bytes

c->{for(int i=0;i<c;i++)System.out.format("%"+(5+c-i)+"s%"+(i<3?i*2+1:2*(i-2))+"s%5s\n","/----/","\\",i<3?"":"\\");};

Leider können Sie Strings in Java nicht [leicht] duplizieren, sodass ich am Ende die Formatierungsfunktion missbrauche.

Scala, 95 Bytes

def l(n:Int)=for(i<- 0 to n-1){println(" "*(n-i-1)+"/----/"+("  "*i+"\\    \\").substring(5))}

Haskell, 81 Bytes

a n=[1..n]>>" "
f n=[1..n]>>=(\i->a(n-i)++"/----/"++drop 7(a(2*i)++"\\    \\\n"))

eacal , nicht konkurrierend , 386 Bytes

init .
define @ curry push .
define ~ curry exec .--func
alias $ strap
alias ' string
set n set m cast number arg number 0
set s empty string
label l
@ get n
set n ~ dec
@ space
@ get n
$ ~ repeat
$ ' /----/
@ space
@ get m
@ get n
@ ~ sub
@ ~ dec
@ number 2
@ ~ mul
$ ~ repeat
$ ' \
$ newline
@ get n
@ number 0
if ~ more
goto l
@ $
@ regex gm '   ( {4})(?=.$)
@ '  \$1
print ~ replace

Ich habe offiziell die ausführlichste Sprache möglich gemacht.Ich machte den Kommentar im Scherz und im Sarkasmus. Bitte beruhigen. Anweisungen zum Ausführen des im Header verlinkten Github-Repos.

Ungolfed

init .
set n set m cast number arg number 0
set s empty string
label loop
    push . get n
    set n exec .--func dec
    push . space
    push . get n
    strap exec .--func repeat
    strap string /----/
    push . space
    push . get m
    push . get n
    push . exec .--func sub
    push . exec .--func dec
    push . number 2
    push . exec .--func mul
    strap exec .--func repeat
    strap string \
    strap newline
    push . get n
    push . number 0
    if exec .--func more
        goto loop

push . strap
push . regex gm string   ( {4})(?=.$)
push . string  \$1
print exec .--func replace