Dato un numero intero, genera una tenda rovesciata.

L'ingresso determina sia la dimensione della tenda (valore assoluto) sia se l'ingresso si trova sul lato sinistro (numeri negativi) o sul lato destro (numeri positivi).

If input = -1:
____
\/_/

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

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

If input = 1:
____
\_\/

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

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

et cetera

Si noti che la parte superiore della tenda (ovvero l'ultima riga) presenta caratteri di 2 * abs(input) - 1sottolineatura.

Ci possono essere presenti spazi iniziali, in modo tale che la prima linea inizia direttamente con una sottolineatura.

Supponiamo che l'input non sarà mai 0.

Il tuo codice dovrebbe essere il più breve possibile.

Questa sfida si basa su una mini sfida di chat di Helka Homba , che può essere utilizzata in sfide reali alle condizioni della Licenza pubblica Hobbies di Calvin .

MATL , 55 53 52 51 byte

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

Provalo online!

Spiegazione

Lasciate Ndenotare l'input. Il codice procede in tre passaggi.

Innanzitutto , la prima riga di caratteri di 4*Nsottolineatura è costruita come una stringa e viene visualizzata (che la rimuove dallo stack).

In secondo luogo , il "telaio" della tenda viene costruito utilizzando i due tipi di barre. Per fare ciò, viene creato un array 2D numerico che contiene 1e 2corrispondente ai due tipi di barre e 0per lo spazio.

Questo viene fatto concatenando quattro matrici:

1. Una matrice di identità di dimensioni abs (N);
2. Una matrice della stessa dimensione contenente 2nell'antidiagonale;
3. Una matrice nulla della stessa dimensione;
4. Una copia della matrice 2.

La concatenazione verticale di queste quattro matrici fornisce, usando N=3come esempio, la seguente 4*N × Nmatrice:

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

(che, trasposto, inizia ad assomigliare alla tenda).

Ora ci occupiamo del segno dell'input. Se è positivo, trasponiamo semplicemente la matrice e l'indice sopra nella stringa '\/ '. L'indicizzazione è basata su 1 e modulare, quindi 1diventa '\', 2diventa '/'e 0diventa ' ', producendo l'array di caratteri 2D

\    /     /
 \  /     / 
  \/     /  

D'altra parte, se l'input è negativo, capovolgiamo verticalmente e neghiamo aritmeticamente la 4*N × Nmatrice, producendo

-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

L'indice -1ora fa riferimento a '/'e -2a '\'. Cioè, i due tipi di barre sono stati scambiati, come richiesto. Anche in questo caso trasporre e indicizzare nella stringa '\/ 'dà quindi alla tenda invertita:

\     \    /
 \     \  / 
  \     \/  

In terzo luogo , i caratteri di sottolineatura devono essere riempiti in parte dell'ultima riga dell'array di caratteri 2D. La posizione orizzontale di questa linea dipende dal segno dell'input e la sua lunghezza è abs(N).

Una volta che gli spazi corrispondenti sono stati sostituiti da caratteri di sottolineatura, il risultato viene visualizzato implicitamente, sotto la linea iniziale di caratteri di sottolineatura che era già visualizzata nel primo passaggio.

Javascript (ES6), 139 byte

Costruisce la tenda in modo ricorsivo:

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)

Ungolf e commentato

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

Esempi

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 grazie a @ Sp3000 (non è necessario parentizzare exec in Python 2)
-1 byte grazie a @ Sp3000 (uso 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

Provalo su ideone

Per prima cosa vediamo se nè negativo e facciamo d +1se lo è e -1se no.
Quindi selezioniamo le due barre ae b, usando dtale che a='\', b='/'quando nè positivo e a='/', b='\'quando nè negativo.
Successivamente stabiliamo s=abs(n)quale può essere raggiunto da s=n*d.
Quindi calcoliamo il numero di _in alto (in basso nell'immagine), che è anche il numero di nel lato della tenda come x=2*s-1.
Quindi calcoliamo il numero di _alla base della tenda (parte superiore dell'immagine) e lo memorizziamo come y=4*sda quando verrà utilizzato nel ciclo per creare il resto della tenda.
Ora stampiamo la base della tenda usando print'_'*y.
Quindi stampiamo il resto della tenda eseguendo sle istruzioni di stampa con una variabile di loop iinizializzata su 0cui si incrementa 1per ciascuna istruzione di stampa.
Il resto della tenda ha quindi y-3-x-i-ispazi nella porta e xspazi nel corpo fino a quando non viene raggiunta la cima, quando si s-i>1valuta Falso, selezionando _da '_ '.
Per una tenda positiva, con porta a sinistra, l'intera tenda, esclusi gli spazi di testa, è dalla parte anteriore a quella posteriore, quindi è invertita mentre la tenda positiva, "a destra", non è con [::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

Solo molta formattazione delle stringhe.

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'è la possibilità di salvare alcuni byte quando si utilizza in using s=string;anticipo.

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

che sarebbe 15 (usando) + 184 (metodo) = 199 byte.

TSQL, 195 byte

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

Violino

V , 66 byte

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

Provalo online!

Questo è un approccio piuttosto ingenuo, quindi cercherò di approfondire più tardi oggi. Questa soluzione contiene caratteri non stampabili, quindi ecco un 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,

Spiegazione

                                                     # 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

Provalo online!

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]

Accetta l'input $bcome numero intero. Nota che se $bè negativo, devi circondarlo esplicitamente di parentesi per lanciarlo in modo appropriato (vedi esempi), altrimenti PowerShell penserà che sia una stringa.

Indipendentemente dalla direzione verso cui è rivolta la tenda, la prima linea è la stessa, un gruppo di caratteri di sottolineatura; esattamente 4*abs(input)molti di loro, in realtà. Quel numero è anche memorizzato $aper l'uso in un secondo momento. Inoltre, ora che abbiamo il valore assoluto di $barchiviato $a, ci trasformiamo $bin un booleano per il suo segno e scegliamo le nostre barre in $ye $z.

La riga successiva sta costruendo e formulando l'output, ed è un doozy, quindi analizziamolo.

Stiamo essenzialmente indicizzando in una matrice di due elementi (big long calculations saved into $x)o $x, in base a $b.

I calcoli sono dove viene costruito il corpo della tenda. Andiamo da 1..$a|%{...}. Ogni iterazione stiamo costruendo una linea del corpo della tenda. Iniziamo con un numero di spazi pari alla linea # in cui ci troviamo -1, in modo che sia opportunamente allineato a sinistra. Viene archiviato $wper dopo e concatenato con la barra appropriata ($ z, in base a $b), quindi il numero di spazi dello stipite della porta, quindi l'altra barra $y, quindi sottolineatura o spazi a seconda che siamo sulla riga inferiore o meno, poi un'altra barra $ye infine il numero appropriato di spazi finali ( $w) per costruire una stringa rettangolare. Quell'array risultante di stringhe è archiviato in $x.

Se si seleziona la metà sinistra della matrice (cioè, $bè Falsequanto l'ingresso era positivo), allora dobbiamo scorrere $xe invertire ogni elemento - questo è dove gli spazi finali entrano in gioco; ci consente semplicemente di invertire le linee anziché ricalcolare le distanze.

Se $bè True, allora la metà destra della matrice $xviene invece selezionato.

In entrambi i casi, la pipeline ora contiene una matrice di stringhe. L'output implicito Write-Outputavviene al completamento del programma, con la nuova riga predefinita tra gli elementi.

Esempi

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]

Penso che questo non sia un ottimo punteggio per Haskell, quindi qualsiasi idea di miglioramento è benvenuta.

• 3 byte salvati grazie a @Myridium
• 1 byte salvato grazie a @nimi

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

Questa volta ho ottimizzato la funzione g (...) per utilizzare un singolo ciclo.

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

Questa volta la macro X è migliore come funzione g (...) e poiché yey sono parametri in un nuovo ambito, posso semplicemente diminuirli nell'ambito di 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("/");}}

Prova con questa funzione principale; Questo dovrebbe essere molto più piccolo.

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

C # 241 231 byte

Salvato 10 byte grazie a @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;}

Vecchia versione:

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

Inizialmente aveva new string(...)come un Func<char,int,string>ma salvato un byte usando il costruttore. Vorrei int-> charera implicito

Abbastanza sicuro che anche la mia matematica possa essere risolta in qualche modo, ma non riesco a vederlo

Swift 2.2 421 byte

Bene ... Questo è stato un tentativo.

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

Corri con php -r '<code>' <parameter>

abbattersi

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

Lotto, 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%

Accetta input su STDIN. Inizia creando una stringa di caratteri di 2*(abs(n)-1)sottolineatura. Questo viene quindi ripetuto più altri 4 caratteri di sottolineatura per la base della tenda. Il resto della tenda consiste quindi di un rientro (che aumenta di 1 su ogni riga), a \, il centro della tenda e a /. Il centro della tenda inizia come 2*(abs(n)-1)spazi, più uno \o /più uno spazio (che non posso rappresentare in Markdown), più altri 2*(abs(n)-1)spazi. Riutilizzo la stringa di sottolineatura e li cambio in spazi per comodità, ma poi cambio gli spazi in caratteri di sottolineatura per l'ultima riga. Ogni linea rimuove due spazi da un lato del centro della tenda, anche se è leggermente più golfoso spostare i due spazi all'inizio della stringa, se necessario.

Tela , 25 byte

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

Provalo qui!