Défi

Ceci est un défi simple. Étant donné deux entiers positifs w et hcréer une clôture ASCII avec une largeur wet une hauteur de h. La clôture doit être construite selon les règles suivantes:

• Le +personnage représentera un message.
• Le -caractère sera utilisé pour représenter la largeur de la clôture.
• Le |sera utilisé pour représenter la hauteur de la clôture.
• Après que exactement trois -caractères ont été sortis, un +caractère doit être sorti par la suite. Excluant les quatre coins, toute autre fois que vous produisez un +serait invalide. Vous êtes autorisé à suivre cette règle en partant de la gauche ou de la droite (voir exemples), mais vous devez être cohérent.
• Après que exactement deux |caractères ont été sortis, un +caractère doit être sorti ensuite. Excluant les quatre coins, toute autre fois que vous produisez un +serait invalide. Vous êtes autorisé à suivre cette règle en partant du haut ou du bas (voir exemples), mais vous devez être cohérent.
• Chaque clôture aura exactement quatre coins et chaque coin sera représenté par un +.

En d'autres termes: tous les trois -caractères, vous devez afficher a +. Et à tous les deux |caractères, vous devez produire un +.

Vous pouvez supposer que la clôture sera toujours un rectangle et que les deux wet hne seront jamais supérieurs 100ou inférieurs à 1. Les espaces de fin et / ou de précédent sont autorisés.

Exemples / cas de test

w = 1
h = 1

+-+ 
| |
+-+


w = 3
h = 2

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


w = 5
h = 7

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

w = 10
h = 5

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


w = 4
h = 4

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

Règles

• Des échappatoires standard s'appliquent .
• C'est le code-golf , donc la réponse la plus courte en octets l'emporte!

C, 131 octets

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

Essayez-le en ligne!

Explication:

// 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 octets

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')

Essayez-le en ligne!

Mathematica, 165 octets

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 octets

37 octets de code, +1 pour l' -nindicateur.

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

Prend la largeur et la hauteur comme arguments de ligne de commande. Essayez-le en ligne!

Explication

                         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

Fusain, 47 45 40 octets

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

Explication: Fonctionne en dessinant les -s / |s de chaque côté à tour de rôle, en insérant des +s si nécessaire, puis en terminant par a +. Après avoir dessiné les côtés supérieur et droit, revient au début pour les dessiner dans l'ordre inverse, dessinant efficacement les côtés gauche et inférieur. Je ne sais pas si la symétrie de rotation est autorisée, mais si oui, alors pour 27 25 octets:

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

Prend l'idée ci-dessus à l'extrême en dessinant le côté supérieur, en tournant à gauche, en dessinant le côté droit, en tournant à nouveau, puis en répétant pour dessiner les côtés inférieur et gauche en sens inverse.

JavaScript (ES6), 133 132 octets

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

Prend entrée dans la syntaxe de curry: f(width)(height) .

Extrait de test

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 octets

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

Suite de tests .

Java (OpenJDK 8) , 178 177 octets

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

Essayez-le en ligne!

-1 octet grâce à @KevinCruijssen

Fusain , 47 45 37 octets

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

Essayez-le en ligne!

• 2 octets enregistrés après avoir joué avec les signes dans la création de la chaîne.
• 8 octets économisés grâce à Neil, qui a trouvé un moyen beaucoup plus simple de calculer les longueurs des clôtures.

Une approche différente de celle de @ Neil : d'abord je crée les chaînes αet βcontient les caractères dans les bordures horizontales et verticales, en utilisant l' Rangeopérateur qui crée une répétition d'une chaîne jusqu'à ce qu'une longueur donnée soit atteinte. Ensuite, je les imprime dans le bon ordre:

• Imprimez α sans déplacer le curseur.
• Imprimez β vers le bas.
• Imprimer α.
• Imprimez un "+".
• Déplacez le curseur vers le haut et vers la gauche.
• Impression β vers le haut, inversée.

Lien vers une version détaillée .

05AB1E , 58 octets

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

Essayez-le en ligne!

Plus dur dans 05AB1E que je ne le pensais.