정수가 주어지면 거꾸로 된 텐트를 출력하십시오.

입력은 텐트의 크기 (절대 값)와 입구가 왼쪽 (음수)인지 오른쪽 (양수)인지를 결정합니다.

If input = -1:
____
\/_/

If input = -2:
________
\  /   /
 \/___/

If input = -3:
____________
\    /     /
 \  /     /
  \/_____/

If input = 1:
____
\_\/

If input = 2:
________
\   \  /
 \___\/

If input = 3:
____________
\     \    /
 \     \  /
  \_____\/

et cetera

텐트 상단 (즉, 마지막 줄)에는 2 * abs(input) - 1밑줄이 있습니다.

첫 줄이 밑줄로 직접 시작되도록 선행 공백 은있을 수 없습니다 .

입력이 절대 없다고 가정합니다 0.

코드는 가능한 짧아야합니다.

이 도전은 Helka Homba 의 채팅 미니 도전을 기반으로하며 , Calvin 's Hobbies Public License 조건 하에서 실제 도전에 사용될 수 있습니다 .

MATL , 55 53 52 51 바이트

|95cy4*Y"DXytPEt0*yvG0>?P_]!'\/ 'w)95JG|G0<yEq:++&(

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

설명

하자 N입력을 나타낸다. 코드는 세 단계로 진행됩니다.

먼저4*N 밑줄 의 첫 번째 줄은 문자열로 만들어져 표시됩니다 (스택에서 제거).

둘째 , 텐트의 "프레임"은 두 가지 유형의 슬래시를 사용하여 만들어집니다. 이를 위해 두 가지 유형의 슬래시 를 포함 1하고 공간에 2해당 하는 숫자 2D 배열이 작성 0됩니다.

이것은 네 개의 행렬을 연결하여 수행됩니다.

1. 크기의 항등 행렬 abs (N);
2. 2반 대각선에 포함 된 동일한 크기의 행렬 ;
3. 같은 크기의 널 행렬.
4. 매트릭스 2의 사본.

이 네 가지 행렬을 세로로 연결 N=3하면 예를 들어 다음 4*N × N행렬 이 나타납니다 .

1 0 0
0 1 0
0 0 1
0 0 2
0 2 0
2 0 0
0 0 0
0 0 0
0 0 0
0 0 2
0 2 0
2 0 0

(임대 된 텐트처럼 보이기 시작합니다).

이제 입력의 부호를 처리합니다. 양수이면 위의 행렬과 색인을 문자열로 바꿉니다 '\/ '. 인덱싱 1 기반 모듈이 너무되어 1진다 '\', 2해진다 '/'및 0해진다 ' '차원 문자 배열을 제조

\    /     /
 \  /     / 
  \/     /  

반면에 입력이 음수이면 4*N × N행렬을 수직으로 뒤집고 산술적으로 부정하여

-2  0  0
 0 -2  0
 0  0 -2
 0  0  0
 0  0  0
 0  0  0
-2  0  0
 0 -2  0
 0  0 -2
 0  0 -1
 0 -1  0
-1  0  0

색인은 -1이제 '/'및 -2을 참조 합니다 '\'. 즉, 필요에 따라 두 가지 유형의 슬래시가 교환되었습니다. 다시 문자열로 조바꿈하고 색인을 생성 '\/ '하면 반전 된 텐트가 제공됩니다.

\     \    /
 \     \  / 
  \     \/  

셋째 , 밑줄은 2D 문자 배열의 마지막 행의 일부로 채워 져야합니다. 이 줄의 가로 위치는 입력 부호에 따라 다르며 길이는 abs(N)입니다.

해당 공백이 밑줄로 바뀌면 결과는 첫 번째 단계에서 이미 표시된 밑줄의 초기 줄 아래에 암시 적으로 표시됩니다.

자바 스크립트 (ES6), 139 바이트

재귀 적으로 텐트를 만듭니다.

f=(N,n=N>0?N:-N,i=0,r=(j,i)=>' _'[i||0].repeat(j),a=`\\${r(i)}/`,b=r(n*2+i-1,+!i))=>n--?f(N,n,i+2)+`
`+r(n)+(N<0?a+b+'/':'\\'+b+a):r(i*2,1)

언 골프 및 댓글

f = (
  N,                                  // N is the original parameter (remains unchanged)
  n = N > 0 ? N : -N,                 // n is initialized to abs(N)
  i = 0,                              // i is the row counter (*2)
  r = (j, i) => ' _'[i||0].repeat(j), // helper function to repeat ' ' or '_' j times
  a = `\\${r(i)}/`,                   // a = '\ /' pattern
  b = r(n*2+i-1, +!i)                 // b = padding pattern filled with ' ' or '_'
) =>
  n-- ?                               // if we haven't made it yet to the top row:
    f(N, n, i+2) + `\n` +             //   - compute next row(s) / append line break
    r(n) +                            //   - append leading spaces
    (N < 0 ? a+b+'/' : '\\'+b+a)      //   - append a/b patterns according to N sign
  :                                   // else:
    r(i*2, 1)                         //   - return top row, made of '_' characters

예

var f=(N,n=N>0?N:-N,i=0,r=(j,i)=>' _'[i||0].repeat(j),a=`\\${r(i)}/`,b=r(n*2+i-1,+!i))=>n--?f(N,n,i+2)+`
`+r(n)+(N<0?a+b+'/':'\\'+b+a):r(i*2,1)

console.log(f(3));
console.log(f(-4));

파이썬 2 143 141 139 138 137 바이트

-2 (파이썬 2 parenthesise 간부 필요) SP3000 @ 덕분에 바이트
-1 바이트 감사 SP3000 @ (사용하는 cmp)

def f(n):d=cmp(n,0);a,b='\/'[::-d];s=n*d;x=2*s-1;y=4*s;print'_'*y;i=0;exec"print' '*i+(b+' '*(y-3-x-i-i)+a+'_ '[s-i>1]*x+a)[::d];i+=1;"*s

이데온 에서 테스트

먼저 n부정적 d +1인지 확인 하고 -1그렇지 않은지 확인합니다.
그런 다음 우리는 두 개의 슬래시를 선택 a하고 b사용하여, d그러한 a='\', b='/'경우 n긍정적이고 a='/', b='\'경우에 n부정적이다.
다음으로에 s=abs(n)의해 달성 될 수있는 것을 설정 합니다 s=n*d.
그런 다음 _상단의 수 (그림의 하단)를 계산합니다 . 텐트 측면의 수이기도합니다 x=2*s-1.
그런 다음 _텐트 바닥 (그림 상단)의 수를 계산하여 y=4*s나머지 텐트를 만들기 위해 루프에서 사용되는 것처럼 저장합니다 .
이제를 사용하여 텐트 바닥을 인쇄합니다 print'_'*y.
그럼 우리가 실행하여 텐트의 나머지 부분을 인쇄 s루핑 변수로 인쇄 문 i에 초기화 0에 의해하는 단위 1각 인쇄 문.
텐트의 나머지 부분은 y-3-x-i-i문에 x공간이 있고 상단에 도달 할 때까지 몸에 공간 s-i>1이 _있습니다 '_ '.
긍정적 인 왼쪽 문 텐트의 경우, 앞 공간을 제외한 텐트 전체가 앞뒤로 오게되므로 긍정적 인 '오른쪽 문'텐트가없는 동안 반전됩니다 [::d].

파이썬 2, 121 바이트

def f(n):i=k=abs(n);print'_'*k*4;exec"print' '*(k-i)+r'\\\%%s%\*%c%%*sc/'[n<0::2]%(' _'[i<2]*(2*k-1))%(2*i-1,47);i-=1;"*k

많은 문자열 형식.

C #, 215214 바이트

string t(int N){var n=N<0;N=n?-N:N;var t=new string('_',4*N);for(int i=0;i<N;){string f=new string(i<N-1?' ':'_',2*N-1),p=new string(' ',2*N-2*i-2);t+='\n'+new string(' ',i++)+'\\'+(n?p+'/'+f:f+'\\'+p)+'/';}return t;}

using s=string;미리 사용할 때 몇 바이트를 절약 할 수 있습니다.

s t(int N){var n=N<0;N=n?-N:N;var t=new s('_',4*N);for(int i=0;i<N;){s f=new s(i<N-1?' ':'_',2*N-1),p=new s(' ',2*N-2*i-2);t+='\n'+new s(' ',i++)+'\\'+(n?p+'/'+f:f+'\\'+p)+'/';}return t;}

이는 15 (사용) + 184 (방법) = 199 바이트입니다.

TSQL, 195 바이트

골프 :

DECLARE @ INT=-2
DECLARE @b INT=ABS(@),@i INT=0PRINT REPLICATE('_',4*@b)z:SET @i+=1PRINT SPACE(@i-1)+'\'+STUFF(REPLICATE(IIF(@i<@b,' ','_'),4*@b-2*@i),@b*2-IIF(@<0,@i*2-1,0),1,IIF(@<0,'/','\'))+'/'IF @i<@b GOTO z

언 골프 드 :

DECLARE @ INT=-2

DECLARE @b INT=ABS(@),@i INT=0

PRINT REPLICATE('_',4*@b)
z:
  SET @i+=1
  PRINT 
    SPACE(@i-1)+'\'
    +STUFF(REPLICATE(IIF(@i<@b,' ','_'),
      4*@b-2*@i),@b*2-IIF(@<0,@i*2-1,0),1,IIF(@<0,'/','\'))
    +'/'
IF @i<@b GOTO z

깡깡이

V , 66 바이트

é /ä
"aDoÀñá_>ñ^hr\A\/ò^hÄX$2é_Ó_/ òÄÒ_ñ/-
ddÍܨ[ _]*©Ü¨ *©/ܲ¯±

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

이것은 매우 순진한 접근 방식이므로 오늘 나중에 더 골프화하려고합니다. 이 솔루션에는 인쇄 할 수없는 문자가 포함되어 있으므로 다음은 16 진 덤프입니다.

0000000: e920 2fe4 0a22 6144 6f1b c0f1 e15f 3ef1  . /.."aDo...._>.
0000010: 5e68 725c 415c 2f1b f25e 68c4 5824 32e9  ^hr\A\/..^h.X$2.
0000020: 5fd3 5f2f 20f2 c4d2 5ff1 2f2d 0a64 64cd  _._/ ..._./-.dd.
0000030: dca8 5b20 5f5d 2aa9 dca8 202a a92f dcb2  ..[ _]*... *./..
0000040: afb1                                     ..

05AB1E , 52 바이트

Ä©'_4®*×,FNð×'\®·<N>®Qi'_ëð}×®N>-·ð×®¹Qi'\ës'/}s'/J,

설명

                                                     # implicit input, call this A
Ä©                                                   # store abs(A) in register for later use
  '_4®*×,                                            # print 4*A underscores (tent floor)
         F                                           # for each non-floor section in range(N)
          Nð×'\                                      # push N spaces at the beginning of the 
                                                     # row followed by a backslash
                  N>®Qi'_ëð}                         # if we're on the last row push an
                                                     # underscore, else a space
               ®·<          ×                        # repeat that char abs(A)*2-1 times
                             ®N>-·ð×                 # push 2*(abs(A)-(N+1)) spaces
                                    ®¹Qi'\ës'/}      # if input is positive push backslash
                                                     # else push a slash
                                               s'/   # move that char between the 2 sections
                                                     # of spaces
                                                  J, # join the row and print

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

PowerShell을 V2 +, 217 205 190 187 184 바이트

param($b)"_"*(($a=[math]::Abs($b))*4);$z,$y='/\'[($b=$b-lt0),!$b]
((($x=1..$a|%{($w=" "*($_-1))+$z+" "*(2*($a-$_))+$y+(' ','_')[$_-eq$a]*($a*2-1)+$y+$w})|%{-join$_[($a*4)..0]}),$x)[$b]

입력 $b을 정수로 취합니다 . 경우주의 $b부정적이다, 당신이 필요로하는 명시 적으로 다른 PowerShell을이 캐릭터라고 생각합니다 (예 참조) 적절하게 캐스팅 괄호로 둘러싸입니다.

텐트가 향하는 방향에 관계없이 첫 줄은 동일합니다. 정확히 4*abs(input)그들 중 많은 사실. 이 번호는 $a나중에 사용하기 위해 저장됩니다 . 또한, 지금 우리의 절대 값이 있는지 $b에 저장을 $a, 우리는 설정 $b의 기호에 대한 부울로, 우리의 슬래시에 저장을 선택 $y하고 $z.

다음 줄은 출력을 구성하고 공식화하는 것입니다.

우리는 기본적으로 두 가지 요소의 배열로 인덱싱하고 (big long calculations saved into $x)나 $x에 기반 $b.

계산은 텐트 본체가 구성되는 위치입니다. 에서 반복 1..$a|%{...}합니다. 반복 할 때마다 텐트 바디의 라인을 구성합니다. 우리는 on # 행과 동일한 수의 공백으로 시작하여 -1적절하게 왼쪽 정렬됩니다. 그것은 $w나중에 저장되어 적절한 슬래시 ($ z,에 따라 $b), 문틀 수, 다른 슬래시 $y, 밑줄 또는 공백에 연결됩니다. 그런 다음 다른 슬래시 $y와 마지막으로 적절한 수의 후행 공백 ( $w)을 사용하여 직사각형 문자열을 구성하십시오. 결과 문자열 배열이에 저장됩니다 $x.

어레이의 좌측 절반이 선택된 경우 (즉, $b인 False, 우리는 전체 순환에 필요한 입력이 포지티브 이후) $x과 각 광고 항목 리버스 - 트레일 링 스페이스가 활동하기 시작하는 곳이고; 거리를 다시 계산하지 않고 단순히 선을 뒤집을 수 있습니다.

경우 $b이고 True, 그 배열의 오른쪽 절반이 $x대신 선택된다.

두 경우 모두 파이프 라인에 문자열 배열이 포함됩니다. 를 통한 암시 적 출력 Write-Output은 프로그램 완료시 발생하며 요소 사이에 기본 줄 바꿈이 있습니다.

예

PS C:\Tools\Scripts\golfing> .\print-upside-down-tent.ps1 (-5)
____________________
\        /         /
 \      /         / 
  \    /         /  
   \  /         /   
    \/_________/    

PS C:\Tools\Scripts\golfing> .\print-upside-down-tent.ps1 (4)
________________
\       \      /
 \       \    / 
  \       \  /  
   \_______\/   

하스켈 187 184 183 바이트

f x=unlines$[(n*4)%'_']++((' '#)<$>[0..n-2])++['_'#(n-1)]where m#i=i%' '++'\\':m!i++"/";m!i|x>0=(2*n-1)%m++'\\':(2*(n-i-1))%' '|q<-2*(n-i-1)=q%' '++'/':(2*n-1)%m;n=abs x;m%c=c<$[1..m]

나는 이것이 Haskell에게 큰 점수가 아니라고 생각하므로 개선을위한 아이디어를 환영합니다.

• @Myridium 덕분에 3 바이트 절약
• @nimi 덕분에 1 바이트 절약

언 골프

tent :: Int -> String
tent x = unlines $ [replicate (n*4) '_'] ++ (row ' '<$>[0..n-2]) ++ [row '_' (n-1)]
    where row m i = replicate i ' ' ++ "\\" ++ dir m i ++ "/"
          -- direction selector
          dir m i | x > 0 = side m ++ "\\" ++ entrance i ' '
                  | 1 > 0 = entrance i ' ' ++ "/" ++ side m
          side = replicate (2*n-1)
          entrance i = replicate (2*(n-i-1))
          n = abs x

C, 240 (207) 193 바이트

#define P putchar
a,j,l,m;g(x,y,z){for(m=y+z+1;m--;P(m^z?l?32:95:x));}f(n){g(32,(a=abs(n))*4,0);for(P(10),j=2*(l=a)-1;l--;){for(m=a;--m>l;P(32));P(92);m=n>0?g(92,j,l*2):g(47,l*2,j);puts("/");}}

이번에는 단일 for 루프를 사용하도록 g (...) 함수를 최적화했습니다.

#define P putchar
a,j,l,m;g(x,y,z){for(;y--;P(l?32:95));for(P(x);z--;P(l?32:95));}f(n){g(32,(a=abs(n))*4,0);l=a;j=2*a-1;P(10);for(;l--;){for(m=a;--m>l;P(32));P(92);m=n>0?g(92,j,l*2):g(47,l*2,j);puts("/");}}

이번에는 매크로 X가 함수 g (...)로 더 좋으며 y와 z는 새로운 범위의 매개 변수이므로 g의 범위에서 매개 변수를 줄일 수 있습니다.

#define P putchar
#define X(x,y,z){for(k=0;k++<y;P(l?32:95));P(x);for(k=0;k++<z;P(l?32:95));}
a,i,j,k,l,m;f(n){for(l=a=abs(n);i++<a*4;P(95));j=2*a-1;P(10);while(l--){for(m=a;--m>l;P(32));P(92);if(n>0)X(92,j,l*2)else X(47,l*2,j)puts("/");}}

이 주요 기능으로 테스트하십시오. 이것은 훨씬 작아 질 것입니다.

main(c,v)char**v;
{
    f(atoi(v[1]));
}

C # 241231 바이트

@Kevin Cruijssen 덕분에 10 바이트 절약

using s=System.String;s f(int N){var f=N<0;N=N>0?N:-N;var o=new s('_',N*4);for(int j=0,z;j<N;){z=-2*j+2*N-2;var O=j>N-2?'_':' ';o+='\n'+new s(' ',j)+'\\'+new s(' ',z)+(f?'/':O)+new s(O,j++*2)+(f?O:'\\')+new s(' ',z)+'/';}return o;}

구 버전:

string f(int N){var f=N<0;N=N>0?N:-N;var o=new string('_',N*4);for(int j=0;j<N;){int z=-2*j+2*N-2;var O=j>N-2?'_':' ';o+='\n'+new string(' ',j)+'\\'+new string(' ',z)+(f?'/':O)+new string(O,j++*2)+(f?O:'\\')+new string(' ',z)+'/';}return o;}

원래는 생성자를 사용하여 new string(...)as Func<char,int,string>이지만 1 바이트를 저장했습니다. 나는 암시 적이었다 int->char

내 수학도 어떻게 든 고칠 수는 있지만 볼 수는 없습니다.

스위프트 2.2 421 바이트

글쎄 ... 이것은 시도였다.

골프 :

let t={(s:String,n:Int)->String in return String(count:n,repeatedValue:Character(s))};let e={(n:Int)in var w=[String]();w.append(t("_",abs(n)*4));let c = abs(n);let d = n>0 ? "/": "\\";let f = n>0 ? "\\": "/";for var i in 0...abs(n)-1 {w.append(t(" ",i)+d+t(" ",c*2-2-(2*i))+f+(i<c-1 ?t(" ",2*c-1)+f:t("_",2*c-1)+f)+(n>0 ?t(" ",i):""));};w=n<0 ?w:w.map(){String($0.characters.reverse())};print(w.joinWithSeparator("\n"))}

언 골프 드 :

let t={(s:String,n:Int) -> String in
    return String(count:n,repeatedValue:Character(s))
};
let e={(n:Int) in
    var w=[String]();
    w.append(t("_",abs(n)*4));
    let c = abs(n);
    let d = n>0 ? "/": "\\";
    let f = n>0 ? "\\": "/";
    for var i in 0...abs(n)-1 {
        w.append(t(" ",i)+d+t(" ",c*2-2-(2*i))+f+(i<c-1 ?t(" ",2*c-1)+f:t("_",2*c-1)+f)+(n>0 ?t(" ",i):""));
    };
    w=n<0 ?w:w.map(){String($0.characters.reverse())};
    print(w.joinWithSeparator("\n"))
}

PHP, 143 바이트

$t=str_repeat;echo$t(_,4*$s=$k=abs($n=$argv[1]));for(;$k--;$p.=" "){$f=$t("  ",$k);$r=$t($k?" ":_,2*$s-1);echo"
$p\\",$n<0?"$f/$r/":"$r\\$f/";}

와 실행 php -r '<code>' <parameter>

고장

$t=str_repeat;  // function name to variable saves 10-1 bytes
echo$t(_,4*$s=$k=abs($n=$argv[1])); // print bottom
for(
    ;
    $k--;   // $k from abs($n-1) to 0
    $p.=" "                 // create padding
)
{
    $f=$t("  ",$k);         // create front
    $r=$t($k?" ":_,2*$s-1); // create side/roof
    echo"\n$p\\",$n<0
        ?"$f/$r/"   // print, entrance left
        :"$r\\$f/"  // print, entrance right
    ;
}

배치, 289 바이트

@echo off
set/pn=
set u=
for /l %%i in (2,1,%n:-=%)do call set u=_%%u%%_
echo _%u%__%u%_
set l=
set m=%u%/_%u%
if %n% gtr 0 set m=%u%_\%u%
set m=%m:_= %
for /l %%i in (2,1,%n:-=%)do call:l
set m=%m: =_%
:l
echo %l%\%m%/
set l= %l%
if %n% gtr 0 set m=  %m:~0,-2%
set m=%m:~2%

STDIN에서 입력을받습니다. 2*(abs(n)-1)밑줄 문자열을 만들어 시작합니다 . 그런 다음 텐트 바닥에 4 개의 밑줄을 더한 다음 반복합니다. 텐트의 나머지 부분은 들여 쓰기 (각 줄마다 1 씩 증가), \텐트 중간, 및로 구성 /됩니다. 텐트의 중간은 2*(abs(n)-1)공백과 함께 플러스 \또는 /공백 (Markdown에서 표시 할 수없는 2*(abs(n)-1)공백 )과 다른 공백으로 시작합니다. 밑줄 문자열을 재사용하고 편의를 위해 공백으로 변경 한 다음 마지막 줄의 공백을 다시 밑줄로 변경합니다. 각 줄은 텐트 중앙의 한쪽에서 2 개의 공간을 제거하지만, 필요한 경우 두 공간을 먼저 끈의 시작 부분으로 이동시키는 것이 약간 골퍼입니다.

캔버스 , 25 바이트

⤢＼║ｌ╵：╷：«_×╋ｌ／＋Ｌ_×；∔⁸０＞？↔

여기 사용해보십시오!