Bir tamsayı verildiğinde, baş aşağı bir çadır çıkar.

Girdi, hem çadırın boyutunu (mutlak değer) hem de girişin sol tarafta mı (negatif sayılar) yoksa sağ tarafta mı (pozitif sayılar) olduğunu belirler.

If input = -1:
____
\/_/

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

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

If input = 1:
____
\_\/

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

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

et cetera

Çadırın tepesinin (yani son satırın) 2 * abs(input) - 1alt çizgi olduğunu unutmayın.

İlk satır doğrudan bir alt çizgi ile başlayacak şekilde hiçbir ön boşluk olamaz .

Girişin asla olmayacağını varsayalım 0.

Kodunuz mümkün olduğu kadar kısa olmalıdır.

Bu meydan okuma, Calvin Hobbies Public License koşulları altında gerçek meydan okumalarda kullanılmasına izin verilen Helka Homba'nın küçük bir sohbetine dayanıyor .

MATL , 55 53 52 51 bayt

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

Çevrimiçi deneyin!

açıklama

Let Ngirişi göstermektedirler. Kod üç adımda ilerler.

İlk olarak , 4*Nalt çizgi ilk satırı bir dize olarak oluşturulur ve görüntülenir (bu, yığından kaldırır).

İkincisi , çadırın “çerçevesi” iki eğik çizgi kullanılarak yapılır. Bunu yapmak için, iki eğik çizgi içeren 1ve 2bunlara karşılık gelen ve 0boşluk için sayısal bir 2D dizi oluşturulur .

Bu dört matrisi birleştirerek yapılır:

1. Boyutta bir kimlik matrisi abs (N);
2. 2Antidiagonalde içeren aynı büyüklükte bir matris ;
3. Aynı boyutta bir boş matris;
4. Matris 2'nin bir kopyası.

Bu dört matrisi dikey N=3olarak birleştirmek, örnek olarak aşağıdaki 4*N × Nmatrisi kullanarak:

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

(Bu, çevrilen çadır gibi görünmeye başlar).

Şimdi girdilerin işaretiyle ilgileniyoruz. Pozitifse, yukarıdaki matrisi ve indeksi dizgeye dönüştürelim '\/ '. İndeksleme 1 tabanlı ve modülerdir, yani 2D karakter dizisini üreten 1olur '\', 2olur '/'ve 0olur' '

\    /     /
 \  /     / 
  \/     /  

Öte yandan, eğer girdi negatifse, 4*N × Nmatrisi dikey olarak çevirir ve aritmetik olarak reddederiz.

-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

Dizin -1şimdi atıfta '/'ve -2için '\'. Yani, iki eğik çizgi gerektiği gibi birbiriyle değiştirildi. Yine ipin içine transpoze ve indeksleme, '\/ 'böylece ters çadırı verir:

\     \    /
 \     \  / 
  \     \/  

Üçüncü olarak , alt çizgiler, 2B karakter dizisinin son satırının bir bölümüne doldurulmalıdır. Bu çizginin yatay konumu, girişin işaretine bağlıdır ve uzunluğu abs(N).

Karşılık gelen boşluklar alt çizgi ile değiştirildikten sonra, sonuç ilk adımda zaten görüntülenen başlangıç ​​alt çizgi satırının altında dolaylı olarak görüntülenir.

Javascript (ES6), 139 bayt

Çadırı yinelemeli oluşturur:

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 ve yorum yaptı

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

Örnekler

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 bayt

@ Sp3000 sayesinde -2 bayt (Python 2'de parantez uygulamasına gerek yoktur)
@ Sp3000 sayesinde -1 bayt (kullanım 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

İdeone'da test et

Öncelikle nnegatif olup olmadığına bakarız ve d +1eğer yaparsanız yaparız -1.
Sonra iki eğik çizgi seçin ave bkullanma, döyle a='\', b='/'zaman npozitiftir ve a='/', b='\'zaman nnegatiftir.
Daha s=abs(n)sonra ulaşılabilecek olanı belirledik s=n*d.
Daha sonra , çadırın yan tarafındaki _sayı olarak da üstteki (resmin altındaki) sayısını hesaplıyoruz . Sonra çadırın tabanındaki (resmin üstündeki) sayısını hesaplıyoruz ve çadırın geri kalanını oluşturmak için döngüde kullanılacak gibi saklıyoruz. Şimdi çadırın tabanını kullanarak yazdırıyoruz .x=2*s-1
_y=4*s
print'_'*y
Sonra yürüterek çadırın kalanını yazdırmak sbir döngü değişkeni ile baskı ifadeleri ibaşlatıldığı için 0tarafından hangi artışlarla 1her baskı ifadesi için.
Çadırın kalanı daha sonra sahip y-3-x-i-ikapı boşlukları ve xzaman üst, ulaşılıncaya kadar vücutta boşluk s-i>1değerlendirir False olarak, toplama _gelen '_ '.
Olumlu, soldan bir kapı için, öndeki boşluklar hariç, çadırın tamamı öne doğru uzanır, bu nedenle pozitif, 'sağ kapı' çadırı yokken ters çevrilir [::d].

Python 2,121 bayt

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

Sadece bir sürü dize formatı.

C #, 215 214 bayt

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;Önceden kullanırken birkaç byte tasarruf imkanı vardır .

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 (kullanma) + 184 (yöntem) = 199 bayt olacaktır.

TSQL, 195 bayt

golfed:

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

Ungolfed:

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

Keman

V , 66 bayt

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

Çevrimiçi deneyin!

Bu oldukça naif bir yaklaşım, bu yüzden bugün daha sonra golf oynamaya çalışacağım. Bu çözüm yazdırılamayan karakterler içeriyor, bu yüzden burada bir 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 bayt

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

açıklama

                                                     # 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

Çevrimiçi deneyin!

PowerShell v2 +, 217 205 190 187 184 bayt

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]

Giriş alır $bBir tamsayı olarak . $bNegatif ise , uygun şekilde yayınlamak için parens ile açıkça çevrelemeniz gerektiğini unutmayın (örneklere bakın), aksi takdirde PowerShell bunun bir dize olduğunu düşünecektir.

Çadırın hangi yöne baktığından bağımsız olarak, ilk satır aynıdır, birkaç alt çizgi; 4*abs(input)Aslında tam olarak çoğu. Bu numara $adaha sonra kullanılmak üzere saklanır . Ek olarak, artık $bdepolanan mutlak değere sahip $aolduğumuza göre,$b için, işareti için bir Boole'ye dönüşüyoruz $yve ve içine yerleştirilmiş eğik çizgimizi seçiyoruz $z.

Bir sonraki satır, çıktının oluşturulması ve formüle edilmesidir ve bir sersemlemektir, o yüzden hadi parçalayalım.

Biz aslında iki elemanlarının bir diziye indeksleme, konum (big long calculations saved into $x)ya $xdayanan,$b .

Hesaplamalar, çadır gövdesinin yapıldığı yerdir. Biz döngü 1..$a|%{...}. Her yineleme çadır gövdesinin bir çizgisini inşa ediyoruz. Doğru olan -1sola hizalı olacak şekilde, üzerinde bulunduğumuz çizgiye eşit sayıda boşlukla başlıyoruz . Bu $w, daha sonra depolanır ve uygun eğik çizgiyle ($ z, temel alınarak $b), sonra da ana kare sayısı, sonra diğer eğik çizgiyle birleştirilir $y, sonra alt satırda olup olmamıza bağlı olarak alt çizgi veya boşluk, daha sonra başka bir eğik çizgi $yve son olarak $wdikdörtgen bir dize oluşturmak için uygun sayıda boşluk ( ). Elde edilen dizge dizisi içine kaydedilir $x.

Dizinin sol yarısı seçildiyse (yani, giriş pozitif $bolduğundan Falseberi), $xher satır öğesini döndürüp tersine çevirmemiz gerekir - bu, takip eden boşlukların devreye girdiği yerdir; mesafeleri yeniden hesaplamak yerine çizgileri basitçe tersine çevirmemizi sağlar.

Eğer $bbir True, daha sonra dizinin sağ yarısı $xyerine seçilir.

Her iki durumda da, boru hattı şimdi bir dizi dizi içerir. Örtülü çıktılar Write-Output, program bitiminde, elemanlar arasında varsayılan yeni satır ile olur.

Örnekler

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 bayt

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]

Bunun Haskell için harika bir puan olmadığını hissediyorum, bu yüzden herhangi bir iyileştirme fikri memnuniyetle karşılanıyor.

• @Myridium sayesinde 3 bayt kurtarıldı
• @Nimi sayesinde 1 bayt kurtarıldı

Ungolfed

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 Bayt

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

Bu kez g (...) fonksiyonunu bir döngü forması kullanmak için optimize ettim.

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

Bu kez makro X, g (...) işlevi olarak daha iyidir ve y ve z, yeni bir kapsamdaki parametreler olduğu için, onları sadece g kapsamında azaltabilirim.

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

Bu ana işlevle test edin; Bu çok daha küçük golf gerekir.

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

C # 241 231 Bayt

@Kevin Cruijssen sayesinde 10 bayt kaydedildi

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

Eski versiyon:

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

Başlangıçta new string(...)birFunc<char,int,string> yapıcı ama kurucu kullanarak bir bayt kurtardı. Keşke int-> chargizliyse

Tabii ki matematiğim de düzeltilebilir ama göremiyorum

Swift 2,2 421 bayt

Şey ... Bu bir deneme oldu.

golfed:

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 bayt

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

koşmak php -r '<code>' <parameter>

Yıkmak

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

Toplu iş, 289 bayt

@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'de girişi ele alır. Bir 2*(abs(n)-1)alt çizgi dizisi oluşturarak başlar . Bu daha sonra tekrarlanır, ayrıca çadırın tabanı için ek 4 alt çizgi bulunur. Çadırın geri kalanı daha sonra bir girintiden (her satırda 1 artar), a \, çadırın ortasından ve a /. Çadırın ortası 2*(abs(n)-1)boşluklar, artı ya \da /artı bir boşluk (Markdown'da temsil edemediğim) artı bir 2*(abs(n)-1)boşluk olarak başlar. Alt çizgi dizisini yeniden kullanıyorum ve bunları kolaylık olması için boşluklarla değiştiriyorum, ancak boşlukları son satır için alt çizgi olarak değiştiriyorum. Her satır, çadırın ortasının bir tarafından iki alanı kaldırır, ancak gerekirse iki alanı da dizenin başlangıcına taşımak biraz daha golfcüdür.

Tuval , 25 bayt

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

Burada dene!