Escriba un programa o función que tome un número entero mayor que 1 o menor que -1. Es decir, la entrada no será 0, 1 o -1.

Si la entrada es 2, la salida debería ser:

|\_/|
|___|

Si la entrada es 3, la salida debería ser:

|\_/\_/|
|______|

Si la entrada es 4, la salida debería ser:

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

El patrón continúa de la misma manera exacta para entradas más grandes. Por ejemplo, si la entrada es 10, la salida debería ser:

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

Si la entrada es -2, la salida debería ser:

 ____
|    |
|_/\_|

Si la entrada es -3, la salida debería ser:

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

Si la entrada es -4, la salida debería ser:

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

El patrón continúa de la misma manera exacta para entradas más pequeñas. Por ejemplo, si la entrada es -10, la salida debería ser:

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

El resultado se puede imprimir o devolver como una cadena con una nueva línea final opcional. La esquina superior derecha "vacía" de la salida para entradas negativas puede ser un espacio o puede permanecer vacía.

El código más corto en bytes gana.

Pyth, 45 bytes

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

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

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

Pruébelo en línea en intérprete de CJam.

Cómo funciona

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

Estoy jugando golf a Pyth por teléfono con el intérprete en línea. Esa es una idea totalmente genial.

Actualización 2015-10-15: Reescribí la cosa (todavía en mi teléfono, lol) y guardé 2 bytes, de los cuales uno podría haberse hecho con el original también.

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

Pruébalo en línea.

Minkolang 0.8 , 100 bytes

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

Simplemente acumula la pila y luego la imprime todo a la vez. Estoy seguro de que esto se puede jugar al golf, pero ya he pasado mucho tiempo en esto ...

JavaScript (ES6), 111 98 bytes

¡Técnica óptima descubierta! Resulta que eliminar todos esos interpoladores de las cadenas de plantillas ahorra muchos bytes. Tal vez aún podría hacerse más corto, tal vez no. En cualquier caso, las cadenas de plantilla ES6 (y las funciones de flecha) son increíbles. :)

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

Python 2.7, 144 bytes

Esto tomó más bytes de lo esperado. Aquí está el código.

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$es una IFdeclaración en línea , #13es una forma de incrustar nuevas líneas en una cadena (y no siempre necesita un "+" si está entre cadenas codificadas).

Desde hace unos pocos lanzamientos, SpecBAS le permite tener múltiples asignaciones a una LETdeclaración, lo que ayuda a guardar algunos caracteres.

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

¡Bajar de 120 a 118 fue divertido!

Ruby - 113 bytes

Parece demasiado largo Trataré de jugar golf un poco más.

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 # lucha con el golf repitiendo cuerdas.

Completamente golfizado:

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

Sangría y nuevas líneas agregadas para mayor claridad:

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

Golfed la ecuación (4 - (($ n-2) 3)) a (3 $ n-6) junto con algunos parens y puntos y comas extraños.

Encontramos que `n es el equivalente de [Environment]::NewLiney que $s -f [args]es el equivalente de [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)

La explicación conserva paréntesis aclaratorios:

$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)