Cho một số nguyên, xuất ra một cái lều lộn ngược.

Đầu vào xác định cả kích thước của lều (giá trị tuyệt đối) và lối vào nằm ở bên trái (số âm) hay bên phải (số dương).

If input = -1:
____
\/_/

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

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

If input = 1:
____
\_\/

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

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

et cetera

Lưu ý rằng phần trên cùng của lều (tức là dòng cuối cùng) có 2 * abs(input) - 1dấu gạch dưới.

Không thể có khoảng trắng hàng đầu, sao cho dòng đầu tiên trực tiếp bắt đầu bằng dấu gạch dưới.

Giả sử rằng đầu vào sẽ không bao giờ 0.

Mã của bạn nên càng ngắn càng tốt.

Thử thách này dựa trên thử thách trò chuyện nhỏ của Helka Homba , được phép sử dụng trong các thử thách thực tế trong các điều kiện của Giấy phép Sở thích Công cộng của Calvin .

MATL , 55 53 52 51 byte

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

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

Giải trình

Hãy Nbiểu thị đầu vào. Mã tiến hành theo ba bước.

Đầu tiên , dòng đầu tiên của 4*Ndấu gạch dưới được xây dựng dưới dạng một chuỗi và được hiển thị (loại bỏ nó khỏi ngăn xếp).

Thứ hai , "khung" của lều được xây dựng bằng hai loại dấu gạch chéo. Để làm điều này, một mảng 2D số được tạo ra có chứa 1và 2tương ứng với hai loại dấu gạch chéo và 0cho không gian.

Điều này được thực hiện nối bốn ma trận:

1. Một ma trận nhận dạng kích thước abs (N);
2. Một ma trận có cùng kích thước chứa 2trong antidia chéo;
3. Một ma trận null có cùng kích thước;
4. Một bản sao của ma trận 2.

Nối bốn ma trận này theo chiều dọc, sử dụng N=3làm ví dụ, 4*N × Nma trận sau :

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

(trong đó, chuyển đổi, bắt đầu trông giống như cái lều).

Bây giờ chúng tôi chăm sóc các dấu hiệu của đầu vào. Nếu nó dương, chúng ta chỉ cần hoán chuyển ma trận và chỉ mục trên thành chuỗi '\/ '. Indexing là 1-based và mô-đun, vì vậy 1trở thành '\', 2trở thành '/'và 0trở thành ' ', sản xuất các char mảng 2D

\    /     /
 \  /     / 
  \/     /  

Mặt khác, nếu đầu vào là âm, chúng ta sẽ lật theo chiều dọc và phủ định một cách hợp lý 4*N × Nma trận, tạo ra

-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

Index -1hiện nay đề cập đến '/'và -2đến '\'. Đó là, hai loại dấu gạch chéo đã được thay thế, theo yêu cầu. Một lần nữa hoán vị và lập chỉ mục vào chuỗi '\/ 'do đó cung cấp cho lều đảo ngược:

\     \    /
 \     \  / 
  \     \/  

Thứ ba , dấu gạch dưới cần được điền vào một phần của hàng cuối cùng của mảng char 2D. Vị trí nằm ngang của dòng này phụ thuộc vào dấu hiệu của đầu vào và chiều dài của nó là abs(N).

Khi các không gian tương ứng đã được thay thế bằng dấu gạch dưới, kết quả được hiển thị ngầm, bên dưới dòng dấu gạch dưới ban đầu đã được hiển thị trong bước đầu tiên.

Javascript (ES6), 139 byte

Xây dựng lều đệ quy:

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)

Ungolfed và bình luận

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

Ví dụ

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 byte

-2 byte nhờ @ Sp3000 (không cần ngoặc đơn thực thi trong Python 2)
-1 byte nhờ @ Sp3000 (sử dụng 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

Kiểm tra nó tại ideone

Đầu tiên chúng ta thấy nếu nlà tiêu cực và thực hiện d +1nếu nó là và -1nếu không.
Sau đó, chúng tôi chọn hai dấu gạch chéo, avà b, sử dụng dsao cho a='\', b='/'khi nào nlà dương và a='/', b='\'khi nào nlà âm.
Tiếp theo chúng tôi thiết lập s=abs(n)có thể đạt được bởi s=n*d.
Sau đó, chúng tôi tính số lượng _ở trên cùng (dưới cùng của hình ảnh), cũng là số lượng ở bên cạnh của lều như x=2*s-1.
Sau đó, chúng tôi tính toán số lượng _ở chân lều (trên cùng của hình ảnh) và lưu trữ y=4*svì nó sẽ được sử dụng trong vòng lặp để tạo ra phần còn lại của lều.
Bây giờ chúng tôi in cơ sở của lều bằng cách sử dụng print'_'*y.
Sau đó, chúng tôi in phần còn lại của lều bằng cách thực hiện các scâu lệnh in với một biến lặp được ikhởi tạo để 0tăng theo 1từng câu lệnh in.
Phần còn lại của lều sau đó có y-3-x-i-ikhoảng trống ở cửa và xkhoảng trống trong thân cho đến khi đạt đến đỉnh, khi s-i>1đánh giá thành Sai, chọn _từ '_ '.
Đối với một cửa tích cực, bên trái, lều toàn bộ lều, không bao gồm các không gian hàng đầu là mặt trước, vì vậy nó bị đảo ngược trong khi tích cực, 'cửa bên phải', lều không có [::d].

Python 2, 121 byte

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

Chỉ là rất nhiều định dạng chuỗi.

C #, 215 214 byte

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

Có khả năng lưu một vài byte khi sử dụng using s=string;trước.

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

đó sẽ là 15 (sử dụng) + 184 (phương thức) = 199 byte.

TSQL, 195 byte

Chơi gôn

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

Ung dung:

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ĩ cầm

V , 66 byte

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

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

Đây là một cách tiếp cận khá ngây thơ, vì vậy tôi sẽ cố gắng đánh gôn nó sâu hơn vào ngày hôm nay. Giải pháp này chứa các ký tự không thể in được, vì vậy đây là một hexdump:

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 byte

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

Giải trình

                                                     # 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

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

PowerShell v2 +, 217 205 190 187 184 byte

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]

Lấy đầu vào $blà một số nguyên. Lưu ý rằng nếu $blà âm, bạn cần bao quanh nó một cách rõ ràng bằng các phép liệt kê để sử dụng nó một cách thích hợp (xem ví dụ), nếu không PowerShell sẽ nghĩ đó là một chuỗi.

Bất kể hướng nào mà lều phải đối mặt, dòng đầu tiên là như nhau, một loạt các dấu gạch dưới; chính xác 4*abs(input)nhiều người trong số họ, thực sự. Số đó cũng được lưu trữ $ađể sử dụng sau. Ngoài ra, bây giờ chúng ta có giá trị tuyệt đối $bđược lưu trữ $a, chúng ta biến $bthành Boolean cho dấu hiệu của nó và chọn dấu gạch chéo được lưu trữ vào $yvà $z.

Dòng tiếp theo đang xây dựng và hình thành đầu ra, và nó thật khó hiểu, vì vậy hãy phá vỡ nó.

Về cơ bản, chúng tôi đang lập chỉ mục thành một mảng gồm hai yếu tố, (big long calculations saved into $x)hoặc $x, dựa trên $b.

Các tính toán là nơi xây dựng cơ thể lều. Chúng tôi lặp từ 1..$a|%{...}. Mỗi lần lặp chúng ta sẽ xây dựng một đường của thân lều. Chúng tôi bắt đầu với một số khoảng trắng bằng với dòng # chúng tôi đang bật -1, sao cho nó được căn trái một cách thích hợp. Nó được lưu trữ $wđể sử dụng sau này và được ghép với dấu gạch chéo thích hợp ($ z, dựa trên $b), sau đó là số khung không gian, sau đó là dấu gạch chéo khác $y, sau đó gạch dưới hoặc dấu cách tùy thuộc vào việc chúng ta có ở dòng dưới hay không, sau đó là một dấu gạch chéo khác $yvà cuối cùng là số dấu cách ( $w) thích hợp để tạo chuỗi hình chữ nhật. Mảng kết quả của chuỗi được lưu trữ vào $x.

Nếu nửa bên trái của mảng được chọn (nghĩa $blà Falsedo đầu vào là dương), thì chúng ta cần lặp $xlại và đảo ngược từng mục hàng - đây là nơi các khoảng trắng theo sau phát huy tác dụng; nó cho phép chúng ta đơn giản đảo ngược các dòng hơn là tính lại khoảng cách.

Nếu $blà True, thì một nửa bên phải của mảng $xđược chọn thay thế.

Trong cả hai trường hợp, đường ống hiện chứa một chuỗi các chuỗi. Đầu ra tiềm ẩn thông qua Write-Outputxảy ra khi hoàn thành chương trình, với dòng mới mặc định giữa các yếu tố.

Ví dụ

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

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

Haskell, 187 184 183 byte

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]

Tôi cảm thấy như đây không phải là một điểm số tuyệt vời cho Haskell, vì vậy mọi ý tưởng để cải thiện đều được hoan nghênh.

• 3 byte được lưu nhờ @Myridium
• Lưu 1 byte nhờ @nimi

Bị đánh cắp

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 byte

#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("/");}}

Lần này tôi đã tối ưu hóa hàm g (...) để sử dụng một vòng lặp 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("/");}}

Lần này macro X tốt hơn là một hàm g (...) và vì y và z là các tham số trong một phạm vi mới, tôi chỉ có thể giảm chúng trong phạm vi của 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("/");}}

Kiểm tra với chức năng chính này; Điều này nên golf xuống nhỏ hơn nhiều.

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

C # 241 231 byte

Đã lưu 10 byte nhờ @Kevin Cruijssen

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

Phiên bản cũ:

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

Ban đầu có new string(...)một Func<char,int,string>nhưng được lưu một byte bằng cách sử dụng hàm tạo. Tôi ước int-> charlà ngầm

Khá chắc chắn rằng toán học của tôi có thể được sửa chữa bằng cách nào đó, nhưng tôi không thể nhìn thấy nó

Swift 2.2 421 byte

Chà ... Đây là một nỗ lực.

Chơi gô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"))}

Vô song:

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 byte

$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/";}

chạy với php -r '<code>' <parameter>

phá vỡ

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

Hàng loạt, 289 byte

@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%

Đưa đầu vào vào STDIN. Bắt đầu bằng cách tạo ra một chuỗi các 2*(abs(n)-1)dấu gạch dưới. Điều này sau đó được lặp lại cộng với 4 dấu gạch dưới cho đế lều. Phần còn lại của lều sau đó bao gồm một vết lõm (tăng 1 trên mỗi dòng), a \, giữa lều và a /. Giữa lều bắt đầu là 2*(abs(n)-1)không gian, cộng với \hoặc /cộng với một khoảng trắng (mà tôi không thể đại diện trong Markdown), cộng với các 2*(abs(n)-1)không gian khác . Tôi sử dụng lại chuỗi gạch dưới và thay đổi chúng thành khoảng trắng để thuận tiện, nhưng sau đó thay đổi khoảng trắng trở lại dấu gạch dưới cho dòng cuối cùng. Mỗi dòng sẽ loại bỏ hai khoảng trống từ một bên của giữa lều, mặc dù nó hơi golf hơn để di chuyển hai khoảng trống đến đầu chuỗi nếu cần thiết.

Canvas , 25 byte

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

Hãy thử nó ở đây!