给定一个整数，输出一个颠倒的帐篷。

输入确定帐篷的大小（绝对值）以及入口是在左侧（负数）还是在右侧（正数）。

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的聊天迷你挑战，该挑战可在加尔文的“业余爱好公共许可证”的条件下用于实际挑战。

MATL，55 53 52 51字节

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

在线尝试！

说明

让N表示输入。代码分三步进行。

首先，4*N下划线的第一行 构建为字符串并显示（将其从堆栈中删除）。

其次，使用两种类型的斜线构建帐篷的“框架”。为此，创建一个数字2D数组，该数组包含1并2对应于两种类型的斜线，并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成为' '，产生2D char数组

\    /     /
 \  /     / 
  \/     /  

另一方面，如果输入为负，则我们将垂直翻转并在算术上取反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 char数组的最后一行的部分中添加下划线。这条线的水平位置取决于输入的符号，其长度为abs(N)。

一旦相应的空格已被下划线替换，结果将隐式显示在第一步已显示的下划线的初始行下方。

Javascript（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));

Python 2中，143个141 139 138 137字节

@ Sp3000 -2个字节（在Python 2中不需要用括号括起来）
@ Sp3000 -1个字节（使用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

在ideone上测试

首先，我们查看是否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评估为False时，_从中选择）'_ '。
对于正面的左门帐篷，整个帐篷（不包括前导空间）都是从前向后的，因此，当正面的“右门”帐篷不与一起时，则将其反转[::d]。

Python 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Íܨ[ _]*©Ü¨ *©/ܲ¯±

在线尝试！

这是一种非常幼稚的方法，所以今天晚些时候我将尝试进一步研究。该解决方案包含不可打印的字符，因此这是一个十六进制转储：

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|%{...}。每次迭代，我们都会构建一条帐篷主体线。我们以等于我们在＃号行上的空格开头-1，以便将其适当地左对齐。将其存储到$w后面，并与适当的斜杠（$ z，基于$b），门框的空格数，另一个斜杠$y，下划线或空格（取决于我们是否位于底行）相连接，然后是另一个斜杠$y，最后是适当数量的尾随空格（$w），以构造一个矩形字符串。产生的字符串数组存储在中$x。

如果选择了阵列的左半部分（即，$b是False由于输入是正），那么我们通过需要循环$x和反向每个订单项-这是在尾部空格开始发挥作用; 它使我们可以简单地反转线，而不必重新计算距离。

如果$b为True，则$x选择数组的右半部分。

无论哪种情况，管道现在都包含一个字符串数组。隐式输出via 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("/");}}

这次我优化了函数g（...）以使用单个for循环。

#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范围内将它们减1。

#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>但是使用构造函数保存了一个字节。我希望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），一个a \，帐篷的中间部分和一个a组成/。帐篷的中间开始是2*(abs(n)-1)空格，再加上一个\或/多个空格（我不能在Markdown中表示），再加上另一个2*(abs(n)-1)空格。为了方便起见，我重新使用了下划线字符串并将其更改为空格，但最后一行将空格更改回下划线。每行从帐篷中间的一侧删除两个空格，不过如果需要的话，将两个空格先移到字符串的开头稍微有点高尔夫球手。

画布，25 个字节

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

在这里尝试！