Escreva um programa ou função que receba um número inteiro maior que 1 ou menor que -1. Ou seja, a entrada não será 0, 1 ou -1.

Se a entrada for 2, a saída deve ser:

|\_/|
|___|

Se a entrada for 3, a saída deve ser:

|\_/\_/|
|______|

Se a entrada for 4, a saída deve ser:

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

O padrão continua da mesma maneira exata para entradas maiores. Por exemplo, se a entrada for 10, a saída deve ser:

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

Se a entrada for -2, a saída deve ser:

 ____
|    |
|_/\_|

Se a entrada for -3, a saída deve ser:

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

Se a entrada for -4, a saída deve ser:

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

O padrão continua da mesma maneira exata para entradas menores. Por exemplo, se a entrada for -10, a saída deve ser:

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

A saída pode ser impressa ou retornada como uma sequência com uma nova linha à direita opcional. O canto superior direito "vazio" da saída para entradas negativas pode ser um espaço ou pode permanecer vazio.

O código mais curto em bytes vence.

Pitão, 45 bytes

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

Experimente on-line: Demonstration or Test Suite

Explicação:

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

Experimente online no intérprete CJam.

Como 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#

Pitão, 56 54 bytes

Estou jogando Pyth no telefone com o intérprete on-line. Essa é uma ótima idéia.

Atualização 15/10/2015: Reescrevi a coisa (ainda no meu telefone, lol) e salvei 2 bytes, dos quais um poderia ter sido feito com o original também.

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

Experimente online.

Tamanho 0.8 , 100 bytes

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

Apenas cria a pilha e depois imprime tudo de uma vez. Tenho certeza de que isso pode ser praticado, mas já passei muito tempo nisso ...

JavaScript (ES6), 111 98 bytes

Técnica ótima descoberta! Acontece que remover todos esses interpoladores das seqüências de caracteres de modelo economiza muitos bytes. Talvez ainda pudesse ser reduzido, talvez não. Em qualquer caso, as seqüências de modelos do ES6 (e funções de seta) são impressionantes. :)

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

Python 2.7, 144 bytes

Isso levou mais bytes do que o esperado. Aqui está o 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$é uma IFinstrução embutida , #13é uma maneira de incorporar novas linhas em uma string (e nem sempre precisa de um "+" se estiver entre strings codificadas).

Desde alguns lançamentos atrás, o SpecBAS permite que você tenha várias atribuições para uma LETinstrução, o que ajuda a salvar alguns 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

Descer de 120 para 118 foi divertido!

Ruby - 113 bytes

Parece muito tempo. Vou tentar jogar isso um pouco mais.

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

O C # luta com as repetições de golfe.

Completamente jogado:

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

Recuo e novas linhas adicionadas para maior clareza:

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

Jogou fora a equação (4 - (($ n-2) 3)) a (3 $ n-6) junto com alguns parênteses e ponto e vírgula estranhos.

Constatou que `n é o equivalente a [Environment]::NewLinee que $s -f [args]é o equivalente a [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)

A explicação mantém parênteses claros:

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