Schreiben Sie ein Programm oder eine Funktion, die eine ganze Zahl größer als 1 oder kleiner als -1 akzeptiert. Das heißt, die Eingabe ist nicht 0, 1 oder -1.

Wenn die Eingabe ist 2, sollte die Ausgabe sein:

|\_/|
|___|

Wenn die Eingabe ist 3, sollte die Ausgabe sein:

|\_/\_/|
|______|

Wenn die Eingabe ist 4, sollte die Ausgabe sein:

|\_/\_/\_/|
|_________|

Das Muster wird für größere Eingaben genauso fortgesetzt. Wenn die Eingabe beispielsweise lautet 10, sollte die Ausgabe wie folgt lauten:

|\_/\_/\_/\_/\_/\_/\_/\_/\_/|
|___________________________|

Wenn die Eingabe ist -2, sollte die Ausgabe sein:

 ____
|    |
|_/\_|

Wenn die Eingabe ist -3, sollte die Ausgabe sein:

 _______
|       |
|_/\_/\_|

Wenn die Eingabe ist -4, sollte die Ausgabe sein:

 __________
|          |
|_/\_/\_/\_|

Das Muster wird für kleinere Eingaben genauso fortgesetzt. Wenn die Eingabe beispielsweise lautet -10, sollte die Ausgabe wie folgt lauten:

 ____________________________
|                            |
|_/\_/\_/\_/\_/\_/\_/\_/\_/\_|

Die Ausgabe kann gedruckt oder als Zeichenfolge mit optionalem Zeilenumbruch zurückgegeben werden. Die obere rechte "leere" Ecke der Ausgabe für negative Eingaben kann ein Leerzeichen sein oder leer bleiben.

Der kürzeste Code in Bytes gewinnt.

Pyth, 45 Bytes

jtW!J<Q0.b+.[YN+h*3t.aQJY.>[d.<"\_/"J\_)J" ||

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung:

jtW!J<Q0.b+.[YN+h*3t.aQJY.>[d.<"\_/"J\_)J" ||  implicit: Q = input number
    J<Q0                                       assign Q < 0 to J
                           [           )       create a list with
                            d                    * the string " "
                             .<"\_/"J            * the string "\_/" rotated to 
                                                   the left by J
                                     \_          * the string "_"
                         .>             J      rotate to the right by J
                                         " ||  the string " ||"
        .b                                     binary mapping, N iterates
                                               over list, Y over string:
           .[YN+h*3t.aQJ                         pad Y with N to reach a string
                                                 of length 3*(abs(Q)-1)+1-J
          +             Y                        and append Y
 tW!J                                           remove the first line if Q > 0
j                                               print each on separate line

CJam, 56 50 49 Bytes

ri_(z"\_/"*'_@0>{\4>W<_,@*SooNoS}|1$,*]${'|\'|N}/

Probieren Sie es online im CJam-Interpreter aus.

Wie es funktioniert

ri     e# Read an integer from STDIN and push it on the stack.
_(z    e# Push a copy, decrement it and apply absolute value.
       e# For positive n, (n -> n-1) and (-n -> n+1).
"\_/"* e# Repeat the string that many times.
'_     e# Push an underscore.
@0>    e# Check if the original integer is positive.
{      e# If it isn't:
  \    e#   Swap the generated string with the underscore.
  4>W< e#   Discard the string's first 4 and last character.
       e#   This makes the pattern of the bottom row start and end with an
       e#   underscore, truncating it to the correct length in the process.
  _,   e#   Push the length of a copy.
  @*   e#   Repeat the underscore that many times.
  So   e#   Print a space.
  oNo  e#   Print the underscores, then a linefeed.
  S    e#   Push a space.
}|     e#
1$,    e# Retrieve the strings length.
*      e# Repeat the underscore or space that many times.
]$     e# Wrap the two generated strings in an array and sort it.
{      e# For each string:
  '|\  e#   Push a vertical bar and swap the string on top of it.
  '|N  e#   Push a vertical bar and a linefeed.
}/     e#

Pyth, 56 54 Bytes

Ich spiele Pyth auf einem Telefon mit dem Online-Dolmetscher. Das ist eine großartige Idee.

Update 15.10.2015: Ich habe das Ding umgeschrieben (immer noch auf meinem Handy, lol) und 2 Bytes gespeichert, von denen man auch mit dem Original hätte fertig werden können.

J<Q0Ljb"||"jPW!J_WJ[y<>*K+J*3t.aQ"\_/"JKy*K?Jd\_+d*K\_

Probieren Sie es online aus.

Minkolang 0,8 , 100 Bytes

"|"nd0`u!vbd3*["_"]"|"25*"|"1g["\_/"]"|"(O).
"[d~g1"_"<.)O(" "D*3R~1"_"*52"|"D*3R1dg2"| "*52"|"]"\/_

Baut einfach den Stapel auf und druckt dann alles auf einmal aus. Ich bin mir sicher, dass das Golf spielen könnte, aber ich habe bereits viel Zeit damit verbracht ...

JavaScript (ES6), 111 98 Byte

Optimale Technik entdeckt! Wenn Sie alle diese Interpolatoren aus den Vorlagenzeichenfolgen entfernen, werden viele Bytes gespart . Vielleicht könnte es noch kürzer gemacht werden, vielleicht auch nicht. In jedem Fall sind ES6-Vorlagenzeichenfolgen (und Pfeilfunktionen) fantastisch. :)

x=>(x>0?`|\\_/A|
|___A|`:` ___A_
|   A |
|_/\\A_|`).replace(/(...)A/g,(_,y)=>y.repeat(x>0?x-1:~x))

Python 2.7, 144 Bytes

Das hat mehr Bytes gekostet als erwartet. Hier ist der Code.

c=int(input())
p,w,n,u=list('| \n_')
a=abs(c)-1
d=3*a
if c>0:
 s=p+"\\_/"*a+p+n+p+u*d+p
else:
 d=d+1
 s=w+u*d+n+p+w*d+p+n+p+"_/\\"*a+u+p
print s

Java, 272 Bytes

String f(int i) {
String p = i>0?"\\_/":"_/\\_",x = "|"+new String(new char[(i<0?-i:i)-1]).replace("\0",p)+"|",
l=new String(new char[x.length()-2]).replace("\0","_");
return i>0?x+"\n|"+l+"|":" "+l+" \n|"+new String(new char[x.length()-2]).replace("\0"," ")+"|\n"+x;
}

SpecBAS - 167 Bytes

1 INPUT n: DIM s$="\_/","_/\": LET t$=s$(2-(n>0))*(ABS n-1)+("_"*(n<0)),u$="_"*LEN t$
2 TEXT IIF$(n>0,"|"+t$+"|"#13"|"+u$+"|"," "+u$+#13"|"+" "*LEN t$+"|"#13"|"+t$+"|")

IIF$ist eine Inline- IFAnweisung, die das #13Einbetten von Zeilenumbrüchen in eine Zeichenfolge ermöglicht (und nicht immer ein "+" benötigt, wenn es sich um eine fest codierte Zeichenfolge handelt).

In SpecBAS können Sie einer LETAnweisung seit einigen Releases mehrere Zuweisungen zuweisen , wodurch einige Zeichen gespart werden können.

Python 2.7, 118 Bytes

n=input()*3-3
a=-n-6
s=' %s_\n| %s|\n|%s_|'%(a*'_',a*' ',a/3*'_/\\')
if n>0:s='|%s|\n|%s|'%(n/3*'\\_/',n*'_')
print s

Es hat Spaß gemacht, von 120 auf 118 herunter zu kommen!

Ruby - 113 Bytes

Scheint zu lang. Ich werde versuchen, dies ein bisschen mehr nach unten zu spielen.

n=gets.to_i;p,h=n.abs-1,?|;n>0 ? (puts h+'\\_/'*p+h,h+'___'*p+h):(k=p*3+1;puts' '+?_*k,h+' '*k+h,'|_'+'/\\_'*p+h)

C # 185 Bytes

C # kämpft mit sich wiederholenden Saiten.

Vollständig golfen:

string S(int n){int m=n>0?n:-n;return string.Format(n>0?"|{0}\n|{1}|":" {1}\n|{2}|\n|_{0}","|".PadLeft(m).Replace(" ",n>0?@"\_/":@"/\_"),"".PadLeft(m=m*3-(n>0?3:2),'_'),"".PadLeft(m));}

Einrückung und neue Zeilen zur Verdeutlichung hinzugefügt:

string S(int n){
    int m=n>0?n:-n;
    return string.Format(n>0?"|{0}\n|{1}|":" {1}\n|{2}|\n|_{0}",
        "|".PadLeft(m).Replace(" ",n>0?@"\_/":@"/\_"),
        "".PadLeft(m=m*3-(n>0?3:2),'_'),
        "".PadLeft(m)
    );
}

Powershell - 200 190 186 168 154

Erläuterte die Gleichung (4 - (($ n-2) 3)) bis (3 $ n-6) zusammen mit einigen überflüssigen Parens und Semikolons.

Gefunden, dass `n das Äquivalent von ist [Environment]::NewLineund dass $s -f [args]das Äquivalent von ist [String]::Format:

$n=$args;if($n-gt0){$s="|{1}|{0}|{2}|";$a=$n;$b=$n*3}else{$n*=-1;$s=" {2}{0}|{3}|{0}|_/{1}\_|";$a=$n-2;$b=$c=3*$n-2};$s-f"`n",("\_/"*$a),("_"*$b),(" "*$c)

In der Erläuterung bleiben klärende Klammern:

$n=$args;

// Basically a way of coming up with a string to format and the 
// necessary counts of repeated characters
if($n-gt0){
  // Placeholder format
  $s="|{1}|{0}|{2}|{3}";
  // Number of repeated "\_/" instances
  $a=$n;
  // Number of repeated "_" instances
  $b=$n*3
} else { 
  $n*=-1;
  $s=" {2}{0}|{3}|{0}|_/{1}\_|";
  $a=($n-2);
  $b=(4+(($n-2)*3));
  // Number of repeated " " instances .. not needed for "positive" saw
  $c=$b;
};
[String]::Format($s,[Environment]::NewLine,"\_/"*$a,"_"*$b," "*$c)