Напишите программу или функцию, которая принимает целое число больше 1 или меньше -1. То есть ввод не будет 0, 1 или -1.

Если на входе 2, выход должен быть:

|\_/|
|___|

Если на входе 3, выход должен быть:

|\_/\_/|
|______|

Если на входе 4, выход должен быть:

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

Шаблон продолжается точно таким же образом для больших входов. Например, если на входе 10, выход должен быть:

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

Если на входе -2, выход должен быть:

 ____
|    |
|_/\_|

Если на входе -3, выход должен быть:

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

Если на входе -4, выход должен быть:

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

Шаблон продолжается точно таким же образом для небольших входов. Например, если на входе -10, выход должен быть:

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

Вывод может быть напечатан или возвращен в виде строки с необязательным завершающим переводом строки. Верхний правый «пустой» угол вывода для отрицательных входов может быть пробелом или оставаться пустым.

Самый короткий код в байтах побеждает.

Pyth, 45 байт

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

Попробуйте онлайн: демонстрация или тестовый набор

Объяснение:

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 байтов

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

Попробуйте онлайн в интерпретаторе CJam.

Как это устроено

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 байта

Я играю в гольф Pyth по телефону с онлайн-переводчиком. Это совершенно отличная идея.

Обновление 2015-10-15: Я переписал эту вещь (все еще на моем телефоне, смеется) и сохранил 2 байта, из которых один мог бы быть сделан и с оригиналом.

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

Попробуйте онлайн.

Минколанг 0,8 , 100 байт

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

Просто создайте стек и затем распечатайте все сразу. Я уверен, что это может быть игра в гольф, но я уже потратил много времени на это ...

JavaScript (ES6), 111 98 байт

Оптимальная техника обнаружена! Оказывается, удаление всех этих интерполяторов из строк шаблона экономит много байтов. Возможно, это все еще можно сделать короче, а может и нет. В любом случае, строки шаблона ES6 (и функции со стрелками) потрясающие. :)

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

Python 2.7, 144 байта

Это заняло больше байтов, чем ожидалось. Вот код

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 байта

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 байт

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$является встроенным IFоператором, #13это способ встраивания новых строк в строку (и ему не всегда нужен знак «+», если он находится между жестко закодированными строками).

Начиная с нескольких выпусков назад, SpecBAS позволяет вам иметь несколько назначений для одного LETоператора, что помогает сохранять некоторые символы.

Python 2,7, 118 байт

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

Спуск со 120 до 118 был забавным!

Рубин - 113 байт

Кажется слишком долго Я попытаюсь сыграть в эту игру еще немного.

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 байт

C # борется с игрой в гольф повторяющимися струнами.

Полностью в гольф:

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

Отступы и новые строки добавлены для ясности:

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

Вычеркнули уравнение (4 - (($ n-2) 3)) - (3 $ n-6) вместе с некоторыми посторонними паренями и точками с запятой.

Найдено, что `n является эквивалентом [Environment]::NewLineи что $s -f [args]является эквивалентом [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)

Пояснение сохраняет уточняющие скобки:

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