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#

피스, 56 54 바이트

온라인 통역사와 함께 전화로 Pyth를 골프화하고 있습니다. 정말 좋은 생각입니다.

2015-10-15 업데이트 : 나는 물건을 다시 작성하고 (아직 내 전화기에 lol) 2 바이트를 저장했는데 그 중 하나는 원본으로도 할 수있었습니다.

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

온라인으로 사용해보십시오.

Minkolang 0.8 , 100 바이트

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

스택을 쌓은 다음 한 번에 모두 인쇄합니다. 나는 이것이 골프를 칠 수 있다고 확신하지만 이미 이것에 많은 시간을 보냈습니다 ...

자바 스크립트 (ES6), 111 98 바이트

최적의 기술 발견! 템플릿 문자열에서 모든 보간기를 제거하면 많은 바이트가 절약 됩니다. 아마도 더 짧아 질 수도 있습니다. 어쨌든 ES6 템플릿 문자열 (및 화살표 기능)은 훌륭합니다. :)

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

파이썬 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

자바, 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명령문에 여러 개의 할당을 할 수 있으므로 일부 문자를 저장하는 데 도움이됩니다.

파이썬 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)
    );
}

파워 쉘 - 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)