Biorąc pod uwagę liczbę całkowitą, wyślij namiot do góry nogami.

Dane wejściowe określają zarówno rozmiar namiotu (wartość bezwzględna), jak i to, czy wejście znajduje się po lewej stronie (liczby ujemne) czy po prawej stronie (liczby dodatnie).

If input = -1:
____
\/_/

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

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

If input = 1:
____
\_\/

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

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

et cetera

Pamiętaj, że góra namiotu (tj. Ostatnia linia) ma 2 * abs(input) - 1podkreślenia.

Nie może być żadnych spacje, tak, że pierwsza linia rozpoczyna się bezpośrednio z podkreślenia.

Załóż, że dane wejściowe nigdy nie będą 0.

Twój kod powinien być jak najkrótszy.

Wyzwanie to opiera się na mini-czacie Helki Homby na czacie , który może być używany w prawdziwych wyzwaniach zgodnie z warunkami licencji publicznej hobby Hobbina .

MATL , 55 53 52 51 bajtów

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

Wypróbuj online!

Wyjaśnienie

Niech Noznacza wejście. Kod przebiega w trzech krokach.

Po pierwsze , pierwsza linia 4*Nznaków podkreślenia jest budowana jako ciąg znaków i jest wyświetlana (co usuwa ją ze stosu).

Po drugie , „rama” namiotu jest zbudowana przy użyciu dwóch rodzajów cięć. Aby to zrobić, tworzona jest tablica numeryczna 2D, która zawiera 1i 2odpowiada dwóm typom ukośników oraz 0przestrzeni.

Odbywa się to poprzez połączenie czterech macierzy:

1. Matryca tożsamości wielkości abs (N);
2. Matryca tego samego rozmiaru zawierająca 2w antydiagonalnej;
3. Matryca zerowa o tym samym rozmiarze;
4. Kopia macierzy 2.

Łączenie tych czterech macierzy w pionie daje, N=3przykładowo, następującą 4*N × Nmacierz:

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

(który po transpozycji zaczyna wyglądać jak namiot).

Zajmujemy się teraz znakiem wejścia. Jeśli jest dodatni, po prostu transponujemy powyższą macierz i indeks do łańcucha '\/ '. Indeksowanie jest oparte na 1 i modułowe, więc 1staje się '\', 2staje się '/'i 0staje ' ', tworząc tablicę znaków 2D

\    /     /
 \  /     / 
  \/     /  

Z drugiej strony, jeśli dane wejściowe są ujemne, odwracamy pionowo i arytmetycznie negujemy 4*N × Nmatrycę, tworząc

-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

Wskaźnik -1odnosi się do '/'i -2do '\'. Oznacza to, że dwa typy ukośników zostały zamienione, zgodnie z wymaganiami. Ponowne transponowanie i indeksowanie do łańcucha '\/ 'daje w ten sposób odwrócony namiot:

\     \    /
 \     \  / 
  \     \/  

Po trzecie , podkreślenia należy wypełnić w części ostatniego wiersza tablicy znaków 2D. Pozioma pozycja tej linii zależy od znaku wejścia, a jej długość to abs(N).

Po zastąpieniu odpowiednich spacji znakami podkreślenia wynik jest domyślnie wyświetlany poniżej początkowej linii znaków podkreślenia, które były już wyświetlane w pierwszym kroku.

JavaScript (ES6), 139 bajtów

Namiot rekurencyjnie buduje:

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)

Nie golfił i skomentował

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

Przykłady

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 137 bajtów

-2 bajty dzięki @ Sp3000 (nie trzeba nawiasować exec w Pythonie 2)
-1 bajty dzięki @ Sp3000 (użyj 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

Przetestuj to w ideone

Najpierw sprawdzamy, czy njest negatywne, i robimy, jeśli d +1jest, a -1jeśli nie.
Następnie wybieramy dwa ukośniki ai bużywając dtakich, że a='\', b='/'kiedy njest dodatnia, a a='/', b='\'kiedy nujemna.
Następnie ustalamy, s=abs(n)co można osiągnąć s=n*d.
Następnie obliczamy liczbę _na górze (dół obrazu), która jest również liczbą z boku namiotu jako x=2*s-1.
Następnie obliczamy liczbę _u podstawy namiotu (u góry obrazu) i przechowujemy ją tak, y=4*sponieważ będzie używana w pętli do utworzenia pozostałej części namiotu.
Teraz drukujemy podstawę namiotu za pomocą print'_'*y.
Następnie drukujemy resztę namiotu, wykonując sinstrukcje print z izainicjalizowaną zmienną pętlową, do 0której zwiększa się 1dla każdej instrukcji print.
W pozostałej części namiotu znajdują się y-3-x-i-imiejsca w drzwiach i xmiejsca w ciele, aż do osiągnięcia szczytu, gdy s-i>1oceni na False, wybierając _z '_ '.
W przypadku pozytywnego namiotu z lewymi drzwiami cały namiot, z wyjątkiem wiodących miejsc, jest skierowany tyłem do przodu, więc jest odwrócony, podczas gdy namiot dodatni „z prawymi drzwiami” nie jest z nami [::d].

Python 2, 121 bajtów

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

Po prostu dużo formatowania napisów.

C #, 215 214 bajtów

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

Przed użyciem można zapisać kilka bajtów 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;}

czyli 15 (przy użyciu) + 184 (metoda) = 199 bajtów.

TSQL, 195 bajtów

Gra w golfa:

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

Nie golfowany:

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

Skrzypce

V , 66 bajtów

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

Wypróbuj online!

Jest to dość naiwne podejście, więc postaram się dzisiaj zagrać w golfa. To rozwiązanie zawiera znaki niedrukowalne, więc oto zrzut heksowy:

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 bajty

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

Wyjaśnienie

                                                     # 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

Wypróbuj online!

PowerShell v2 +, 217 205 190 187 184 bajtów

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]

Pobiera dane wejściowe $bjako liczbę całkowitą. Zauważ, że jeśli $bjest ujemne, musisz jawnie otoczyć go parens, aby odpowiednio rzucić (patrz przykłady), w przeciwnym razie PowerShell będzie myślał, że to ciąg.

Niezależnie od tego, w którą stronę skierowany jest namiot, pierwsza linia jest taka sama, kilka podkreślników; właściwie 4*abs(input)wielu z nich. Numer ten jest również zapisywany w $acelu późniejszego wykorzystania. Dodatkowo, teraz, gdy mamy wartość bezwzględną $bprzechowywaną w $a, zmieniamy $bsię w logiczną wartość jego znaku i wybieramy nasze ukośniki przechowywane w $yi $z.

Następnym wierszem jest konstruowanie i formułowanie danych wyjściowych, i to jest doozy, więc podzielmy to.

Zasadniczo indeksujemy do tablicy dwóch elementów (big long calculations saved into $x)lub $xna podstawie $b.

Obliczenia dotyczą budowy namiotu. Od pętli 1..$a|%{...}. W każdej iteracji budujemy linię ciała namiotu. Zaczynamy od liczby spacji równych linii #, w której się znajdujemy -1, dzięki czemu jest odpowiednio wyrównana do lewej. Jest to przechowywane na $wpóźniej i połączone z odpowiednim ukośnikiem ($ z, na podstawie $b), następnie liczba spacji w ramce drzwi, następnie drugi ukośnik $y, a następnie podkreślenia lub spacje, w zależności od tego, czy znajdujemy się w dolnej linii, czy nie, następnie kolejny ukośnik $yi wreszcie odpowiednia liczba końcowych spacji ( $w) do skonstruowania prostokątnego ciągu. Ta wynikowa tablica ciągów jest przechowywana w $x.

Jeśli wybrana jest lewa połowa tablicy (czyli $bjest Falseod wejścia była pozytywna), a następnie musimy pętli $xi odwrócić każdy element liniowy - to jest, gdy w grę wchodzą te spacje; pozwala nam po prostu odwrócić linie, a nie ponownie obliczyć odległości.

Jeśli $btak True, to $xzamiast tego wybrana jest prawa połowa tablicy .

W obu przypadkach potok zawiera teraz tablicę ciągów. Wyjście niejawne przez Write-Outputnastępuje po zakończeniu programu, z domyślną nową linią między elementami.

Przykłady

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 bajtów

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]

Wydaje mi się, że nie jest to świetny wynik dla Haskell, więc wszelkie pomysły na ulepszenia są mile widziane.

• 3 bajty zapisane dzięki @Myridium
• 1 bajt zapisany dzięki @nimi

Nie golfił

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 bajtów

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

Tym razem zoptymalizowałem funkcję g (...) do użycia pojedynczej pętli 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("/");}}

Tym razem makro X lepiej działa jako funkcja g (...), a ponieważ y i z są parametrami w nowym zakresie, mogę je po prostu zmniejszyć w zakresie 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("/");}}

Przetestuj za pomocą tej głównej funkcji; To powinno znacznie zmniejszyć golf.

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

C # 241 231 bajtów

Zaoszczędź 10 bajtów dzięki @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;}

Stara wersja:

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

Pierwotnie miał new string(...)jako, Func<char,int,string>ale zapisany jeden bajt za pomocą konstruktora. Chciałbym int-> charbyło niejawne

Jestem pewien, że moją matematykę też można jakoś naprawić, ale nie widzę jej

Swift 2,2 421 bajtów

Cóż ... To była próba.

Gra w golfa:

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

UnGolfed:

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 bajty

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

Biegnij z php -r '<code>' <parameter>

awaria

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

Partia, 289 bajtów

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

Pobiera dane wejściowe na STDIN. Zaczyna się od utworzenia ciągu znaków 2*(abs(n)-1)podkreślenia. Następnie powtarza się to plus 4 dodatkowe podkreślenia podstawy namiotu. Reszta namiotu składa się z wcięcia (które zwiększa się o 1 w każdej linii), a \, środka namiotu i a /. Środek namiotu zaczyna się jako 2*(abs(n)-1)spacje plus plus \lub /plus spacja (której nie mogę reprezentować w Markdown) plus inne 2*(abs(n)-1)spacje. Używam ponownie łańcucha podkreślenia i dla wygody zmieniam je na spacje, ale potem z powrotem zmieniam spacje na podkreślenia dla ostatniego wiersza. Każda linia usuwa dwa spacje z jednej strony środka namiotu, chociaż przesunięcie dwóch spacji na początek sznurka jest nieco bardziej golfowe, jeśli to konieczne.

Płótno , 25 bajtów

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

Wypróbuj tutaj!