Враховуючи ціле число, виведіть намет вгору.

Вхід визначає як розмір намету (абсолютне значення), так і те, чи знаходиться вхід з лівого боку (від’ємні цифри) або правого боку (додатні цифри).

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.

Ваш код повинен бути якомога коротшим.

Цей виклик ґрунтується на чаті міні-виклику Хелки Хомби , яку дозволено використовувати в реальних викликах за умов публічної ліцензії Calvin's Hobbies .

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 масив знаків

\    /     /
 \  /     / 
  \/     /  

З іншого боку, якщо вхід негативний, ми вертикально перевертаємо і арифметично заперечуємо 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 байт

-2 байти завдяки @ Sp3000 (немає необхідності в скобках в Python 2)
-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

Перевірте це на 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 #, 215 214 байт

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обрана замість цього.

У будь-якому випадку трубопровід тепер містить масив рядків. Неявний вихід через Write-Outputвідбувається в процесі завершення програми, з новим рядком між елементами за замовчуванням.

Приклади

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 байт

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, тому будь-які ідеї для вдосконалення вітаються.

• 3 байти збережено завдяки @Myridium
• 1 байт збережено завдяки @nimi

Безумовно

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 (...) для використання синглу для циклу.

#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 # 241 231 байт

Збережено 10 байт завдяки @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;}

Стара версія:

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(...)як, 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"))}

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 байти

$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 байт

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

Спробуйте тут!