Étant donné un entier, affichez une tente à l'envers.

L'entrée détermine à la fois la taille de la tente (valeur absolue) et si l'entrée est du côté gauche (nombres négatifs) ou du côté droit (nombres positifs).

If input = -1:
____
\/_/

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

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

If input = 1:
____
\_\/

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

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

et cetera

Notez que le haut de la tente (c'est-à-dire la dernière ligne) a des 2 * abs(input) - 1traits de soulignement.

Il ne peut pas y avoir d'espaces de début, de sorte que la première ligne commence directement par un trait de soulignement.

Supposons que l'entrée ne le sera jamais 0.

Votre code doit être aussi court que possible.

Ce défi est basé sur un mini défi de chat par Helka Homba , qui peut être utilisé dans de vrais défis dans les conditions de la licence publique Calvin's Hobbies .

MATL , 55 53 52 51 octets

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

Essayez-le en ligne!

Explication

Notons Nl'entrée. Le code se déroule en trois étapes.

Tout d'abord , la première ligne de 4*Nsoulignements est construite sous forme de chaîne et s'affiche (ce qui la supprime de la pile).

Deuxièmement , le «cadre» de la tente est construit à l'aide des deux types de barres obliques. Pour ce faire, un tableau numérique 2D est créé qui contient 1et 2correspondant aux deux types de barres obliques, et 0pour l'espace.

Cela se fait en concaténant quatre matrices:

1. Une matrice d'identité de taille abs (N);
2. Une matrice de même taille contenant 2dans l'antidiagonale;
3. Une matrice nulle de la même taille;
4. Une copie de la matrice 2.

La concaténation verticale de ces quatre matrices donne, à N=3titre d'exemple, la 4*N × Nmatrice suivante :

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

(qui, transposée, commence à ressembler à la tente).

Nous prenons maintenant soin du signe de l'entrée. S'il est positif, nous transposons simplement la matrice et l'index ci-dessus dans la chaîne '\/ '. L'indexation est basée sur 1 et modulaire, donc 1devient '\', 2devient '/'et 0devient ' ', produisant le tableau de caractères 2D

\    /     /
 \  /     / 
  \/     /  

D'un autre côté, si l'entrée est négative, nous inversons verticalement et nions arithmétiquement la 4*N × Nmatrice, produisant

-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'index -1fait maintenant référence à '/'et -2à '\'. Autrement dit, les deux types de barres obliques ont été échangés, comme requis. Transposer et indexer à nouveau dans la chaîne '\/ 'donne donc la tente inversée:

\     \    /
 \     \  / 
  \     \/  

Troisièmement , les traits de soulignement doivent être remplis dans une partie de la dernière ligne du tableau de caractères 2D. La position horizontale de cette ligne dépend du signe de l'entrée, et sa longueur est abs(N).

Une fois que les espaces correspondants ont été remplacés par des traits de soulignement, le résultat est affiché implicitement, sous la ligne initiale de traits de soulignement qui était déjà affichée à la première étape.

Javascript (ES6), 139 octets

Construit la tente récursivement:

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)

Non golfé et commenté

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

Exemples

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 139 138 137 octets

-2 octets grâce à @ Sp3000 (pas besoin de parenthèse exec en Python 2)
-1 octet grâce à @ Sp3000 (utilisation 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

Testez-le chez ideone

D'abord, nous voyons si nest négatif et faisons d +1si c'est le -1cas et sinon.
Ensuite, nous sélectionnons les deux barres obliques, aet b, en utilisant de dtelle sorte que a='\', b='/'quand nest positif et a='/', b='\'quand nest négatif.
Ensuite, nous définissons s=abs(n)ce qui peut être atteint par s=n*d.
Ensuite, nous calculons le nombre de _en haut (bas de l'image), qui est également le nombre de sur le côté de la tente comme x=2*s-1.
Ensuite, nous calculons le nombre de _à la base de la tente (haut de l'image), et le stockons comme y=4*scar il sera utilisé dans la boucle pour créer le reste de la tente.
Maintenant, nous imprimons la base de la tente en utilisant print'_'*y.
Ensuite, nous imprimons le reste de la tente en exécutant sdes instructions d'impression avec une variable en boucle iinitialisée à 0laquelle s'incrémente par 1pour chaque instruction d'impression.
Le reste de la tente a alors des y-3-x-i-iespaces dans la porte et des xespaces dans le corps jusqu'à ce que le sommet est atteint, quand s-i>1evalue sur False, la cueillette _de '_ '.
Pour une tente positive à gauche, la totalité de la tente, à l'exclusion des espaces de tête, est de l'arrière vers l'avant, donc elle est inversée tandis que la tente positive, à droite, n'est pas avec [::d].

Python 2, 121 octets

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

Juste beaucoup de formatage de chaînes.

C #, 215 214 octets

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

Il est possible d'enregistrer quelques octets lors de l'utilisation using s=string;préalable.

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

ce qui serait 15 (en utilisant) + 184 (méthode) = 199 octets.

TSQL, 195 octets

Golfé:

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

Non golfé:

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

Violon

V , 66 octets

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

Essayez-le en ligne!

C'est une approche assez naïve, donc j'essaierai de l'explorer plus tard dans la journée. Cette solution contient des caractères non imprimables, voici donc 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 octets

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

Explication

                                                     # 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

Essayez-le en ligne!

PowerShell v2 +, 217 205 190 187 187 184 octets

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]

Prend entrée $b comme un entier. Notez que si $best négatif, vous devez l'entourer explicitement de parens pour le caser correctement (voir les exemples), sinon PowerShell pensera que c'est une chaîne.

Quelle que soit la direction dans laquelle la tente fait face, la première ligne est la même, un tas de soulignements; exactement 4*abs(input)beaucoup d'entre eux, en fait. Ce numéro est également stocké dans $apour une utilisation ultérieure. De plus, maintenant que nous avons la valeur absolue de $bstocké dans $a, nous nous transformons $ben booléen pour son signe, et choisissons nos barres obliques stockées dans$y et $z.

La ligne suivante construit et formule la sortie, et c'est un doozy, alors décomposons-le.

Nous indexons essentiellement dans un tableau de deux éléments, (big long calculations saved into $x)ou $x, en fonction de$b .

Les calculs sont l'endroit où le corps de la tente est construit. Nous bouclons 1..$a|%{...}. À chaque itération, nous construisons une ligne du corps de la tente. Nous commençons avec un nombre d'espaces égal à la ligne # sur laquelle nous sommes -1, afin qu'il soit correctement aligné à gauche. C'est stocké dans $wpour plus tard, et concaténé avec la barre oblique appropriée ($ z, basée sur $b), puis le nombre d'espaces d'encadrement de porte, puis l'autre barre oblique $y, puis soit des traits de soulignement soit des espaces selon que nous sommes sur la ligne du bas ou non, puis une autre barre oblique $y, et enfin le nombre approprié d'espaces de fin ( $w) pour construire une chaîne rectangulaire. Ce tableau de chaînes résultant est stocké dans $x.

Si la moitié gauche du tableau est sélectionnée (c'est-à- $bdire Falseque l'entrée est positive), alors nous devons parcourir$x et inverser chaque élément de ligne - c'est là que les espaces de fin entrent en jeu; cela nous permet simplement d'inverser les lignes plutôt que de recalculer les distances.

Si $bc'est le cas True, alors la moitié droite du tableau$x est sélectionnée à la place.

Dans les deux cas, le pipeline contient désormais un tableau de chaînes. Sortie implicite viaWrite-Output se produit à la fin du programme, avec une nouvelle ligne par défaut entre les éléments.

Exemples

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 octets

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]

Je pense que ce n'est pas un bon score pour Haskell, donc toutes les idées d'amélioration sont les bienvenues.

• 3 octets économisés grâce à @Myridium
• 1 octet enregistré grâce à @nimi

Non golfé

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 octets

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

Cette fois, j'ai optimisé la fonction g (...) pour utiliser une boucle simple.

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

Cette fois, la macro X est mieux gérée en tant que fonction g (...) et comme y et z sont des paramètres dans une nouvelle portée, je peux simplement les décrémenter dans la portée de 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("/");}}

Testez avec cette fonction principale; Cela devrait jouer au golf beaucoup plus petit.

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

C # 241231 octets

10 octets enregistrés grâce à @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;}

Ancienne version:

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

A l' origine avait l' new string(...)une , Func<char,int,string>mais sauvé un octet en utilisant le constructeur. Je souhaite int-> charétait implicite

Je suis sûr que mes calculs peuvent être corrigés d'une manière ou d'une autre, mais je ne le vois pas

Swift 2.2 421 octets

Eh bien ... C'était une tentative.

Golfé:

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

Non golfé:

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 octets

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

courir avec php -r '<code>' <parameter>

panne

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

Lot, 289 octets

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

Prend entrée sur STDIN. Commence par créer une chaîne de 2*(abs(n)-1)traits de soulignement. Ceci est ensuite répété plus 4 soulignements supplémentaires pour la base de la tente. Le reste de la tente se compose alors d'un tiret (qui augmente de 1 sur chaque ligne), a \, le milieu de la tente et a /. Le milieu de la tente commence comme des 2*(abs(n)-1)espaces, plus soit \ou /plus un espace (que je ne peux pas représenter dans Markdown), plus d'autres 2*(abs(n)-1)espaces. Je réutilise la chaîne de soulignement et les change en espaces pour plus de commodité, mais je change ensuite les espaces en soulignements pour la dernière ligne. Chaque ligne supprime deux espaces d'un côté du milieu de la tente, bien qu'il soit légèrement plus golfeur de déplacer les deux espaces au début de la chaîne en premier si nécessaire.

Toile , 25 octets

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

Essayez-le ici!