Geben Sie bei einer Ganzzahl ein umgedrehtes Zelt aus.

Die Eingabe bestimmt sowohl die Größe des Zeltes (absoluter Wert) als auch, ob sich der Eingang auf der linken Seite (negative Zahlen) oder auf der rechten Seite (positive Zahlen) befindet.

If input = -1:
____
\/_/

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

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

If input = 1:
____
\_\/

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

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

et cetera

Beachten Sie, dass die Oberseite des Zeltes (dh die letzte Zeile) 2 * abs(input) - 1Unterstriche aufweist.

Es darf keine führenden Leerzeichen geben, sodass die erste Zeile direkt mit einem Unterstrich beginnt.

Angenommen, die Eingabe wird niemals sein 0.

Ihr Code sollte so kurz wie möglich sein.

Diese Herausforderung basiert auf einer Chat-Mini-Herausforderung von Helka Homba , die unter den Bedingungen der Calvin Hobbies Public License für echte Herausforderungen verwendet werden darf .

MATL , 55 53 52 51 Bytes

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

Probieren Sie es online!

Erläuterung

NBezeichnen wir die Eingabe. Der Code läuft in drei Schritten ab.

Zunächst wird die erste Zeile mit 4*NUnterstrichen als Zeichenfolge erstellt und angezeigt (wodurch sie aus dem Stapel entfernt wird).

Zweitens wird der "Rahmen" des Zeltes mit den beiden Arten von Schrägstrichen gebaut. Dazu wird ein numerisches 2D-Array erstellt, das die beiden Arten von Schrägstrichen und für den Raum enthält 1und diesen 2entspricht 0.

Dies geschieht durch Verketten von vier Matrizen:

1. Eine Identitätsmatrix der Größe abs (N);
2. Eine Matrix der gleichen Größe, die 2in der Antidiagonale enthält;
3. Eine Nullmatrix gleicher Größe;
4. Eine Kopie von Matrix 2.

Die vertikale Verkettung dieser vier Matrizen ergibt am N=3Beispiel der folgenden 4*N × NMatrix:

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

(der transponiert wie das Zelt aussieht).

Wir kümmern uns nun um das Vorzeichen der Eingabe. Wenn es positiv ist, transponieren wir einfach die obige Matrix und den Index in den String '\/ '. Die Indizierung basiert auf 1 und ist modular. Sie 1wird '\', 2wird '/'und 0wird zur ' 'Erzeugung des 2D-Zeichen-Arrays

\    /     /
 \  /     / 
  \/     /  

Wenn andererseits die Eingabe negativ ist, wird die 4*N × NMatrix vertikal umgedreht und arithmetisch negiert , wodurch erzeugt wird

-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

Index -1bezieht sich nun auf '/'und -2auf '\'. Das heißt, die beiden Arten von Schrägstrichen wurden nach Bedarf vertauscht. Durch erneutes Transponieren und Indizieren in den String '\/ 'erhält man also das umgekehrte Zelt:

\     \    /
 \     \  / 
  \     \/  

Drittens müssen Unterstriche in einen Teil der letzten Zeile des 2D-Zeichen-Arrays eingefügt werden. Die horizontale Position dieser Linie hängt vom Vorzeichen der Eingabe und ihrer Länge ab abs(N).

Sobald die entsprechenden Leerzeichen durch Unterstriche ersetzt wurden, wird das Ergebnis implizit unterhalb der ersten Zeile von Unterstrichen angezeigt, die bereits im ersten Schritt angezeigt wurde.

Javascript (ES6), 139 Byte

Baut das Zelt rekursiv auf:

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 und kommentiert

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

Beispiele

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 Bytes

-2 Byte dank @ Sp3000 (keine Notwendigkeit, exec in Python 2 in Klammern zu setzen)
-1 Byte dank @ Sp3000 (Verwendung 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

Teste es bei ideone

Zuerst sehen wir, ob nnegativ ist und machen, d +1ob es ist und -1wenn nicht.
Dann wählen wir die beiden Schrägstriche aus aund bverwenden sie dso, dass a='\', b='/'wann npositiv und a='/', b='\'wann nnegativ ist.
Als nächstes legen wir fest, s=abs(n)was durch erreicht werden kann s=n*d.
Dann berechnen wir die Anzahl von _oben (unten im Bild), die auch die Anzahl von an der Seite des Zeltes ist x=2*s-1.
Dann berechnen wir die Anzahl von _an der Basis des Zeltes (oben im Bild) und speichern sie so, wie y=4*ssie in der Schleife verwendet wird, um den Rest des Zeltes zu erstellen.
Nun drucken wir den Zeltboden mit print'_'*y.
Dann drucken wir den Rest des Zeltes aus, indem wir print- sAnweisungen mit einer Schleifenvariablen ausführen i, 0die initialisiert wird und 1für jede print-Anweisung um inkrementiert wird .
Der Rest des Zeltes hat dann y-3-x-i-iRäume in der Tür und xRäume in der Karosserie, bis die Oberseite erreicht ist, wenn s-i>1False ausgewertet wird und das _von auswählt '_ '.
Bei einem positiven Zelt mit linker Tür ist das gesamte Zelt, mit Ausnahme der führenden Felder, von hinten nach vorne, so dass es umgekehrt ist, während das positive Zelt mit „rechter Tür“ nicht vorhanden ist [::d].

Python 2, 121 Bytes

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

Nur eine Menge Zeichenfolgenformatierung.

C # 215 214 Bytes

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

Bei vorheriger Verwendung besteht die Möglichkeit, einige Bytes zu speichern 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;}

Das wären 15 (using) + 184 (method) = 199 Bytes.

TSQL, 195 Bytes

Golf gespielt:

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

Geige

V , 66 Bytes

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

Probieren Sie es online!

Dies ist eine ziemlich naive Herangehensweise, daher werde ich versuchen, sie später noch weiter zu vertiefen. Diese Lösung enthält nicht druckbare Zeichen. Hier ist ein 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 Bytes

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

Erläuterung

                                                     # 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

Probieren Sie es online!

PowerShell v2 +, 217 205 190 187 184 Bytes

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]

Übernimmt die Eingabe $bals Ganzzahl. Wenn dies $bnegativ ist, müssen Sie es explizit mit Parens umgeben, um es entsprechend umzuwandeln (siehe Beispiele). Andernfalls wird PowerShell es für einen String halten.

Unabhängig davon, in welche Richtung das Zelt zeigt, ist die erste Zeile dieselbe, eine Reihe von Unterstrichen. eigentlich genau 4*abs(input)viele von ihnen. Diese Nummer wird auch $azur späteren Verwendung gespeichert . Zusätzlich wenden wir uns, nachdem wir den absoluten Wert von $bgespeichert haben $a, zu$b zu einem Booleschen für sein Vorzeichen und wählen unsere in $yund gespeicherten Schrägstriche aus $z.

In der nächsten Zeile wird die Ausgabe erstellt und formuliert, und sie ist doozy. Lassen Sie uns sie also aufschlüsseln.

Wir indizieren im Wesentlichen in ein Array aus zwei Elementen (big long calculations saved into $x)oder $xbasierend auf$b .

Die Berechnungen beziehen sich auf den Aufbau des Zeltkörpers. Wir fahren ab 1..$a|%{...}. Bei jeder Iteration konstruieren wir eine Linie des Zeltkörpers. Wir beginnen mit einer Anzahl von Leerzeichen, die der Zeile # entsprechen, in der wir uns befinden -1, damit sie linksbündig ausgerichtet ist. Das wird $wfür später gespeichert und mit dem entsprechenden Schrägstrich ($ z, basierend auf $b), dann der Türrahmen-Anzahl von Leerzeichen, dann dem anderen Schrägstrich $y, dann entweder Unterstrichen oder Leerzeichen, je nachdem, ob wir uns in der unteren Zeile befinden oder nicht, verknüpft. dann ein weiterer Schrägstrich $yund schließlich die entsprechende Anzahl von nachgestellten Leerzeichen ( $w), um eine rechteckige Zeichenfolge zu erstellen. Das resultierende Array von Zeichenfolgen wird in gespeichert$x .

Wenn die linke Hälfte des Feldes ausgewählt wird (dh, $bist , Falseda der Eingang positiv war), dann müssen wir eine Schleife durch$x und jede Position rückwärts - dies ist , wo die hinteren Plätze ins Spiel kommen; Dies ermöglicht es uns, die Linien einfach umzukehren, anstatt Entfernungen neu zu berechnen.

Wenn $bja True, dann die rechte Hälfte des Arrays$x wird stattdessen ausgewählt.

In beiden Fällen enthält die Pipeline jetzt ein Array von Zeichenfolgen. Implizite Ausgabe überWrite-Output erfolgt bei Programmabschluss mit Standard-Zeilenumbruch zwischen Elementen.

Beispiele

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 Bytes

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]

Ich bin der Meinung, dass dies kein großartiges Ergebnis für Haskell ist, daher sind Verbesserungsvorschläge willkommen.

• 3 Bytes gespart dank @Myridium
• 1 Byte gespeichert dank @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 Bytes

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

Dieses Mal habe ich die Funktion g (...) optimiert, um eine einzelne for-Schleife zu verwenden.

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

Dieses Mal ist Makro X als Funktion g (...) besser dran, und da y und z Parameter in einem neuen Bereich sind, kann ich sie im Bereich von g einfach dekrementieren.

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

Testen Sie mit dieser Hauptfunktion; Dies sollte deutlich kleiner ausfallen.

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

C # 241 231 Bytes

Dank @Kevin Cruijssen 10 Bytes gespart

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

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

Ursprünglich hatte das new string(...)als Func<char,int,string>aber ein Byte mit dem Konstruktor gespeichert. Ich wünschte int-> charwar implizit

Ich bin mir ziemlich sicher, dass meine Mathematik auch irgendwie repariert werden kann, aber ich kann es nicht sehen

Swift 2.2 421 Bytes

Nun ... Dies war ein Versuch.

Golf gespielt:

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 Bytes

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

renn mit php -r '<code>' <parameter>

Nervenzusammenbruch

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

Batch, 289 Bytes

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

Übernimmt die Eingabe für STDIN. Beginnt mit der Erstellung einer Folge von 2*(abs(n)-1)Unterstrichen. Dies wird dann mit weiteren 4 Unterstrichen für den Zeltboden wiederholt. Der Rest des Zeltes besteht dann aus einem Einzug (der in jeder Zeile um 1 erhöht wird), a \, der Mitte des Zeltes und a /. Die Mitte des Zeltes beginnt als 2*(abs(n)-1)Leerzeichen plus eines \oder /plus eines Leerzeichens (das ich in Markdown nicht darstellen kann) plus eines weiteren 2*(abs(n)-1)Leerzeichens. Ich verwende die Unterstreichungszeichenfolge erneut und ändere sie der Einfachheit halber in Leerzeichen, ändere die Leerzeichen dann jedoch wieder in Unterstriche für die letzte Zeile. Jede Zeile entfernt zwei Leerzeichen von einer Seite der Mitte des Zeltes, obwohl es etwas golfer ist, die beiden Leerzeichen zuerst an den Anfang der Zeichenfolge zu verschieben, falls erforderlich.

Canvas , 25 Bytes

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

Probieren Sie es hier aus!