Viết chương trình hoặc hàm lấy số nguyên lớn hơn 1 hoặc nhỏ hơn -1. Đó là, đầu vào sẽ không là 0, 1 hoặc -1.

Nếu đầu vào là 2, đầu ra phải là:

|\_/|
|___|

Nếu đầu vào là 3, đầu ra phải là:

|\_/\_/|
|______|

Nếu đầu vào là 4, đầu ra phải là:

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

Các mô hình tiếp tục theo cách chính xác tương tự cho đầu vào lớn hơn. Ví dụ: nếu đầu vào là 10, đầu ra phải là:

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

Nếu đầu vào là -2, đầu ra phải là:

 ____
|    |
|_/\_|

Nếu đầu vào là -3, đầu ra phải là:

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

Nếu đầu vào là -4, đầu ra phải là:

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

Mẫu tiếp tục theo cách chính xác tương tự cho các đầu vào nhỏ hơn. Ví dụ: nếu đầu vào là -10, đầu ra phải là:

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

Đầu ra có thể được in hoặc trả lại dưới dạng một chuỗi với một dòng mới tùy chọn. Góc "trống" trên cùng bên phải của đầu ra cho đầu vào âm có thể là khoảng trắng hoặc có thể vẫn trống.

Mã ngắn nhất tính bằng byte thắng.

Bình thường, 45 byte

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

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình:

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 byte

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

Dùng thử trực tuyến trong thông dịch CJam.

Làm thế nào nó hoạt động

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 byte

Tôi đang chơi Pyth trên điện thoại với thông dịch viên trực tuyến. Đó là một ý tưởng hoàn toàn tuyệt vời.

Cập nhật 2015-10-15: Tôi viết lại thứ đó (vẫn trên điện thoại của tôi, lol) và lưu 2 byte, trong đó một cái cũng có thể được thực hiện với bản gốc.

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

Hãy thử trực tuyến.

Chồn 0,8 , 100 byte

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

Chỉ cần xây dựng ngăn xếp và sau đó in tất cả ra cùng một lúc. Tôi chắc chắn rằng điều này có thể được chơi golf nhưng tôi đã dành rất nhiều thời gian cho việc này ...

JavaScript (ES6), 111 98 byte

Kỹ thuật tối ưu được phát hiện! Hóa ra việc loại bỏ tất cả các bộ nội suy khỏi chuỗi mẫu sẽ tiết kiệm rất nhiều byte. Có lẽ nó vẫn có thể được làm ngắn hơn, có lẽ không. Trong mọi trường hợp, chuỗi mẫu ES6 (và các hàm mũi tên) là tuyệt vời. :)

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

Python 2.7, 144 byte

Điều này mất nhiều byte hơn dự kiến. Đây là mã.

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 byte

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 byte

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$là một IFtuyên bố nội tuyến ,#13 là một cách để nhúng các dòng mới vào một chuỗi (và không phải lúc nào cũng cần một dấu "+" nếu nó nằm giữa các chuỗi được mã hóa cứng).

Vì một vài bản phát hành trước đây, SpecBAS cho phép bạn có nhiều bài tập cho một LETcâu lệnh, giúp lưu một số ký tự.

Python 2.7, 118 byte

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

Xuống từ 120 đến 118 thật thú vị!

Ruby - 113 byte

Có vẻ quá dài. Tôi sẽ cố gắng đánh golf này xuống một chút nữa.

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 byte

C # đấu tranh với các chuỗi lặp lại golf.

Chơi golf hoàn toàn:

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

Sự thụt dòng và dòng mới được thêm vào cho rõ ràng:

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

Quyền hạn - 200 190 186 168 154

Chơi theo phương trình (4 - (($ n-2) 3)) thành (3 $ n-6) cùng với một số dấu chấm phẩy và dấu chấm phẩy ngoại lai.

Tìm thấy rằng `n là tương đương [Environment]::NewLinevà $s -f [args]tương đương với [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)

Giải thích giữ lại làm rõ dấu ngoặc đơn:

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