Herausforderung

Dies ist eine einfache Herausforderung. Bei zwei positiven ganzen Zahlen w und herstellen Sie einen ASCII-Zaun mit einer Breite wund einer Höhe von h. Der Zaun sollte nach folgenden Regeln gebaut werden:

• Der +Charakter wird einen Beitrag darstellen.
• Das -Zeichen wird verwendet, um die Breite des Zauns darzustellen.
• Das |wird verwendet, um die Höhe des Zauns darzustellen.
• Nachdem genau drei -Zeichen ausgegeben wurden, muss ein +Zeichen danach ausgegeben werden. Mit Ausnahme der vier Ecken ist jedes andere Mal, wenn Sie a ausgeben , ungültig. Sie können diese Regel entweder von links oder von rechts aus befolgen (siehe Beispiele), aber Sie müssen konsistent sein.+
• Nachdem genau zwei |Zeichen ausgegeben wurden, muss ein +Zeichen danach ausgegeben werden. Mit Ausnahme der vier Ecken ist jedes andere Mal, wenn Sie a ausgeben , ungültig. Sie können diese Regel entweder von oben oder von unten aus befolgen (siehe Beispiele), müssen jedoch konsistent sein.+
• Jeder Zaun hat genau vier Ecken und jede Ecke wird mit einem dargestellt +.

Mit anderen Worten: Bei jeweils drei -Zeichen müssen Sie a ausgeben +. Und bei jeweils zwei |Zeichen müssen Sie a ausgeben +.

Sie können davon ausgehen, dass der Zaun immer ein Rechteck sein wird und dass beide wund hniemals größer 100oder kleiner als sein werden 1. Leerzeichen dürfen nach- und / oder vorangestellt werden.

Beispiele / Testfälle

w = 1
h = 1

+-+ 
| |
+-+


w = 3
h = 2

+---+
|   |
|   |
+---+


w = 5
h = 7

+---+--+ or +--+---+
|      |    |      |
|      |    +      +
+      +    |      |
|      |    |      |
|      |    +      +
+      +    |      |
|      |    |      |
|      |    +      +
+      +    |      |
|      |    |      |
+---+--+    +--+---+

w = 10
h = 5

+---+---+---+-+  or +-+---+---+---+
|             |     |             |
|             |     +             +
+             +     |             |
|             |     |             |
|             |     +             +
+             +     |             |
|             |     |             |
+---+---+---+-+     +-+---+---+---+


w = 4
h = 4

+---+-+ or +-+---+
|     |    |     |
|     |    |     |
+     +    +     +
|     |    |     |
|     |    |     |
+---+-+    +-+---+

Regeln

• Es gelten Standardlücken .
• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

C 131 Bytes

#define L for(i=0,j=w;j;)putchar(i++%4?--j,45:43);puts("+")
f(w,h,i,j,c){L;for(j=1;h;printf("%c%*c\n",c,i,c))c=j++%3?--h,124:43;L;}

Probieren Sie es online!

Erläuterung:

// The first and the last line are always similar, so let's use a macro
// to avoid code duplication.
#define L

// Let's initialize 'i' and 'j'. 'i' will be used to keep track of which
// character ('+' or '-') we should print, whereas 'j' starts from the
// input width and the loop terminates when 'j' reaches zero.
for(i=0,j=w;j;)

// We post-increment 'i' and take a modulo 4 of its previous value.
// If i%4 == 0, we print '+' (ASCII 43), otherwise we decrement 'j'
// and print '-' (ASCII 45).
putchar(i++%4?--j,45:43);

// After the loop we print one more '+' and newline.
puts("+")

// The function declaration which takes the two input parameters, and
// also declares three integer variables. These three variables could
// also be declared as global variables with the same bytecount.
f(w,h,i,j,c)

// The start of the function body. We use the macro 'L' to print the 
// first line along with a newline.
{L;

// This loop prints all the lines between the first and the last. 'j'
// keeps track of when we should output a '+' instead of a '|'. 'h',
// which is the input parameter for height, serves as a terminator
// for the loop as it reaches zero.
for(j=1;h;<stuff missing from here>)

// We post-increment 'j' and check if its previous value is divisible
// by three, and if it isn't, we decrement 'h' and assign 124 (ASCII
// value for '|') to 'c'. Otherwise we assign '+' (ASCII 43) to 'c'.
c=j++%3?--h,124:43;

// The following is inside the 'increment' part of the 'for' loop.
// We print the character corresponding to the value of 'c', then
// the same character again, but padded with i-1  spaces before it 
// ('i' hasn't been touched since the first loop, so it still stores
// the length of the first line), then a newline.
printf("%c%*c\n",c,i,c)

// Lastly we print the first line again using the same macro 'L'.
L;}

Python 3 , 140 137 128 119 106 105 Bytes

def f(w,h):a=~-w//3-~w;b=("+---"*w)[:a]+'+';print(b,*[i+' '*~-a+i for i in"||+"*h][:h+~-h//2],b,sep='\n')

Probieren Sie es online!

Mathematica, 165 Bytes

v=Column;d[w_,y_,m_,n_]:=Table[If[Mod[i,y]==0&&i!=w,m,n],{i,w}];(a="+"<>d[#,3,"-+","-"]<>"+";b=v@d[#2,2,"|\n+","|"];v[{a,Row[{b,""<>Table[" ",#+Floor[#/3]],b}],a}])&

Pip , 38 Bytes

37 Byte Code, +1 für -nFlag.

Ph:'-Xa<>3JW'+PsX#h-2WR:'|Xb<>2J'+^xh

Übernimmt width und height als Befehlszeilenargumente. Probieren Sie es online!

Erläuterung

                         a,b are cmdline args; s is space; x is empty string (implicit)
Ph:'-Xa<>3JW'+
   '-Xa                  String of hyphens of length a
       <>3               grouped into substrings of (maximum) length 3
          JW'+           Join on +, also wrapping the result in +
 h:                      Assign that string to h (mnemonic: "header")
P                        and print it (with newline)

PsX#h-2WR:'|Xb<>2J'+^xh
          '|Xb           String of pipes of length b
              <>2        grouped into substrings of (maximum) length 2
                 J'+     joined on +
                    ^x   and split on empty string (i.e. converted to list of chars)
 sX#h-2                  String of len(h)-2 spaces
       WR:               Wrap the spaces with the list of chars
                         Note 1: WR operates itemwise on lists, so the result is a list,
                          each item of which consists of the spaces wrapped in an item
                          from the list of chars
                         Note 2: the : compute-and-assign meta-operator is here abused
                          to give WR: lower precedence than J and ^ and avoid parentheses
P                        Print that list, newline-separated (-n flag)
                      h  Autoprint the header a second time as the footer

Holzkohle, 47 45 40 Bytes

Ｆ⁴«¿﹪ι³ＦＩη↓⁺×+¬﹪κ²|ＦＩθ⁺×+¬﹪κ³-Ｐ+¿⁼ι¹Ｊ⁰¦⁰

Erläuterung: Werke von jeder Seite Zeichnung -s / |s wiederum Einsetzen +s bei Bedarf dann mit einem Finishing +. Nachdem Sie die obere und die rechte Seite gezeichnet haben, springen Sie zum Anfang zurück, um sie in umgekehrter Reihenfolge zu zeichnen. Dabei werden die linke und die untere Seite effektiv gezeichnet. Ich weiß nicht, ob Rotationssymmetrie zulässig ist, aber wenn ja, dann für 27 25 Bytes:

Ｆ⁴«ＦＩ⎇﹪ι²ηθ⁺×+¬﹪κ⁻³﹪ι²-⟲Ｔ

Bringt die obige Idee auf das Äußerste, indem Sie die Oberseite zeichnen, nach links drehen, die rechte Seite zeichnen, erneut drehen und dann wiederholen, um die untere und die linke Seite in umgekehrter Reihenfolge zu zeichnen.

JavaScript (ES6), 133 132 Bytes

w=>h=>(a="-".repeat(w).replace(/--?-?/g,"+$&")+`+`)+(`
|`.padEnd(a.length)+`|`).repeat(h).replace(/(\|( +)\|\n)\1/g,`$&+$2+
`)+`
`+a

Nimmt die Eingabe in currying Syntax: f(width)(height).

Testschnipsel

f=
w=>h=>(a="-".repeat(w).replace(/--?-?/g,"+$&")+`+`)+(`
|`.padEnd(a.length)+`|`).repeat(h).replace(/(\|( +)\|\n)\1/g,`$&+$2+
`)+`
`+a
O.innerHTML=f(W.value=5)(H.value=10)

<div oninput="O.innerHTML=f(+W.value)(+H.value)">
W <input id=W type=number min=1> H <input id=H type=number min=1>
</div>
<pre id=O>

Pyth , 40 Bytes

AQj++KjJj\+c*\-G3"++"m++d*lJ;dj\+c*\|H2K

Testsuite .

Java (OpenJDK 8) , 178 177 Bytes

w->h->{int i=0;String t="",m,r;for(;i<w;)t+=i++%3<1?"+-":"-";r=t+="+\n";m=t.format("|%"+(t.length()-3)+"s|\n","");for(i=0;i<h;)r+=i++%2<1&i>1?m.replace("|","+")+m:m;return r+t;}

Probieren Sie es online!

-1 Byte dank @KevinCruijssen

Charcoal , 47 45 37 Bytes

Ａ…+---÷⁺²×⁴Ｎ³αＡ…+||÷⁺¹×³Ｎ²βＰα↓βα+↖↑⮌β

Probieren Sie es online!

• 2 Bytes, die nach dem Spielen mit den Zeichen in der Zeichenfolgenerstellung gespeichert wurden.
• 8 Bytes gespart dank Neil, der eine viel einfachere Möglichkeit gefunden hat, die Länge der Zäune zu berechnen.

Ein anderer Ansatz als bei @ Neil : Zuerst erstelle ich die Zeichenfolgen αund βfüge die Zeichen in die horizontalen und vertikalen Ränder ein. Dabei verwende ich den RangeOperator, der eine Wiederholung der Zeichenfolge erstellt, bis eine bestimmte Länge erreicht ist. Dann drucke ich sie in der richtigen Reihenfolge aus:

• Drucken Sie α, ohne den Cursor zu bewegen.
• Drucke β nach unten.
• Drucke α.
• Drucken Sie ein "+".
• Bewegen Sie den Cursor nach oben und links.
• Drucken Sie β umgekehrt nach oben.

Link zu einer ausführlichen Version .

05AB1E , 58 Bytes

D3/ó+DU'-×'+.ø©'|DXú«²D2/ó+.D®»'-4×D'+3ǝ.:¶¡ø'|3×D'+2ǝ.:ø»

Probieren Sie es online!

Härter in 05AB1E als ich dachte.