Vous êtes l'hôte des Jeux Olympiques et devez construire une piscine fantastique pour l'occasion, mais les superviseurs changent souvent d'avis concernant les dimensions et ont besoin d'un moyen rapide de le reconstruire avec la taille demandée!

Étant donné deux nombres entiers, Let xvotre tâche est de construire une piscine de longueur Letx voies.

Comment se construit une piscine?

• Il contient un carré intérieur, dont les parois horizontales sont constituées de Ltirets consécutifs ( -), et dont les parois verticales sont constituées de 3x - 1barres ( |). De plus, 4 +panneaux se trouvent dans chaque coin. Prenons un exemple (L = 10, x = 2 ):

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

• Chaque voie a une largeur de 2 unités verticales. Le carré intérieur est rempli de x-1séparateurs de voies, constitués de symboles Lconsécutifs horizontalement :. Après avoir mis les séparateurs de voies, notre piscine devrait ressembler à ceci:

  + ---------- +
  | |
  | |
  | :::::::::: | |
  | |
  | |
  + ---------- +
  

• Une piscine contient également un rembourrage (un carré extérieur), dont les parois horizontales sont (L + 4) -s et dont les parois verticales sont (3x + 1) |s, qui entoure le carré intérieur:

  + -------------- +
  | + ---------- + |
  | | | |
  | | | |
  | | :::::::::: | | |
  | | | |
  | | | |
  | + ---------- + |
  + -------------- +
  

Et c'est notre piscine de taille olympique **!

Spécifications:

• Pour des raisons de conception et de fonctionnalités, vous êtes assuré que 100 ≥ L ≥ 10et 15 ≥ x ≥ 2.

• La sortie doit être exactement comme indiqué. La sortie d'un pool "construit verticalement" * est interdite.

• Les espaces de fin et de début sont autorisés.

• Vous pouvez prendre des entrées et fournir des sorties par toute méthode standard .

• Les échappatoires par défaut s'appliquent.

Exemples / cas de test:

L = 20, x = 3

+ ------------------------ +
| + -------------------- + |
| | | |
| | | |
| | ::::::::::::::::::::: | |
| | | |
| | | |
| | ::::::::::::::::::::: | |
| | | |
| | | |
| + -------------------- + |
+ ------------------------ +



L = 50, x = 5:

+ ------------------------------------------------- ----- +
| + ------------------------------------------------- - + |
| | | |
| | | |
| | :::::::::::::::::::::::::::::::::::::::::::::::::: : | |
| | | |
| | | |
| | :::::::::::::::::::::::::::::::::::::::::::::::::: : | |
| | | |
| | | |
| | :::::::::::::::::::::::::::::::::::::::::::::::::: : | |
| | | |
| | | |
| | :::::::::::::::::::::::::::::::::::::::::::::::::: : | |
| | | |
| | | |
| + ------------------------------------------------- - + |
+ ------------------------------------------------- ----- +


L = 10, x = 15

+ -------------- +
| + ---------- + |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| | :::::::::: | | |
| | | |
| | | |
| + ---------- + |
+ -------------- +

C'est du code-golf , donc le code le plus court en octets gagne!

_{* L'eau pourrait s'écouler si elle est construite verticalement: P}

_{** Oui, je sais que plus les couloirs sont nombreux et plus la piscine est courte, moins le dessin ressemble à une piscine!}

Fusain , 32 octets

ＮθＮη↓Ｅθ×η:  Ｂ⁺θ²⁺׳η¹↖←Ｂ⁺θ⁶⁺׳η³

Essayez-le en ligne!

-4 merci à Neil .

AST:

Program
├Ｎ: Input Number
│└θ: Identifier θ
├Ｎ: Input Number
│└η: Identifier η
├Print
│├↓: Down
│└Ｅ: Map
│ ├θ: Identifier θ
│ └×: Product
│  ├η: Identifier η
│  └':  ': String ':  '
├Ｂ: Box
│├⁺: Sum
││├θ: Identifier θ
││└2: Number 2
│└⁺: Sum
│ ├×: Product
│ │├3: Number 3
│ │└η: Identifier η
│ └1: Number 1
├Move
│└↖: Up Left
├Move
│└←: Left
└Ｂ: Box
 ├⁺: Sum
 │├θ: Identifier θ
 │└6: Number 6
 └⁺: Sum
  ├×: Product
  │├3: Number 3
  │└η: Identifier η
  └3: Number 3

Fusain , 40 39 37 octets

ＮθＮηＢ⁺θ⁶⁺׳η³↘→Ｂ⁺θ²⁺׳η¹→Ｆ⁻η¹«Ｍ³↓Ｐ×:θ

Essayez-le en ligne!

je sais Neil a déjà une réponse au charbon de bois de la même longueur, mais j'ai adopté une approche légèrement différente, alors j'ai pensé que je pourrais aussi poster la mienne.

Explication

ＮθＮηＢ⁺θ⁶⁺׳η³↘→Ｂ⁺θ²⁺׳η¹→Ｆ⁻η¹«Ｍ³↓Ｐ×:θ
ＮθＮη                                         take the two inputs as numbers in θ and η
      Ｂ⁺θ⁶⁺×³η³                               draw a rectangle θ + 6 by 3η + 3
                                               (characters default to |, - and +)
                ↘→                             move the cursor down one and right two
                   Ｂ⁺θ²⁺×³η¹                  draw a rectangle θ + 2 by 3η + 1
                             Ｆ⁻η¹«            for ι (unused) from 0 up until η - 1:
                                   Ｍ³↓            move the cursor down by 3
                                       Ｐ×:θ       print θ :s without moving the cursor
                                               [implicit end of for]

Fusain, 40 38 36 31 octets

Ａ⁺²ＮθＡ⁺¹×³ＮηＵＯθη:¶¶Ｂθη↖←Ｂ⁺⁴θ⁺²η

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ａ⁺²Ｎθ       Assign(Plus(2, InputNumber()), q);

Les primitives de dessin de Charcoal utilisent le nombre total de caractères, y compris +s, mais l'entrée n'est que le nombre de -s, nous devons donc ajouter 2 pour obtenir la largeur de la paroi intérieure.

Ａ⁺¹×³Ｎη     Assign(Plus(1, Times(3, InputNumber())), h);

Calculez la hauteur de la paroi intérieure, encore une fois, y compris la rangée du bas, donc trois par voie plus une.

ＵＯθη:¶¶     Oblong(q, h, ":\n\n");

Dessinez les voies. Il s'agit simplement d'un rectangle rempli de :s séparés verticalement par deux lignes vides (les pilcrows représentent des caractères de nouvelle ligne).

Ｂθη         Box(q, h);

La Rectanglecommande est exactement ce dont nous avons besoin pour dessiner la paroi intérieure. Edit: Boxpermet d'omettre son troisième paramètre, me faisant économiser 2 octets.

↖           Move(:UpLeft);
←           Move(:Left);
Ｂ⁺⁴θ⁺²η     Box(Plus(4, q), Plus(2, h));

Et encore pour dessiner le mur extérieur, sauf légèrement plus large et plus haut, et centré sur le mur intérieur.

T-SQL, 284 281 octets

DECLARE @ INT,@x INT,@S VARCHAR(MAX)='+--d--+b| +d+ |b'SELECT @=L,@x=x FROM t
P:SET @S+='| |s| |b| |s| |b| |c| |b'SET @x-=1IF @x>0GOTO P
PRINT REPLACE(REPLACE(REPLACE(REPLACE(LEFT(@S,LEN(@S)-6)+'+d+ |b+--d--+','d',REPLICATE('-',@)),'b',CHAR(13)),'s',SPACE(@)),'c',REPLICATE(':',@))

L'entrée est tirée des colonnes INT L et x dans le tableau préexistant t , selon nos méthodes d'entrée autorisées .

Fondamentalement, je crée une longue chaîne avec des lettres représentant les caractères répétés (d = tirets, s = espaces, c = deux-points, b = saut de ligne), puis REMPLACEZ-les tous à la fin avec les remplisseurs appropriés.

Formaté:

DECLARE @ INT,@x INT,@S VARCHAR(MAX)='+--d--+b| +d+ |b'
SELECT @=L,@x=x FROM t
P:
    SET @S+='| |s| |b| |s| |b| |c| |b'
    SET @x-=1
IF @x>0 GOTO P
PRINT REPLACE(REPLACE(REPLACE(REPLACE( LEFT(@S,LEN(@S)-6)+'+d+ |b+--d--+'
     ,'d',REPLICATE('-',@))
     ,'b',CHAR(13))
     ,'s',SPACE(@))
     ,'c',REPLICATE(':',@))

À l'intérieur de la boucle, j'ajoute 2 rangées de blancs et 1 rangée de deux-points, puis à la fin, je coupe cette ligne de séparation et j'ajoute la bordure du pool avant d'effectuer les remplacements.

EDIT : sauvegarde de 3 octets en passant @à la variable la plus utilisée et en inversant l'ordre d'initialisation.

JavaScript (ES6), 137 124 octets

Je l'ai joué un peu sur mon téléphone, plus à suivre.

x=>y=>`+--0--+
| +0+ |
${((a=`| |1| |
`)+a+`| |2| |
`).repeat(y-1)+a+a}| +0+ |
+--0--+`.replace(/\d/g,n=>"- :"[n].repeat(x))

Essayez-le

f=
x=>y=>`+--0--+
| +0+ |
${((a=`| |1| |
`)+a+`| |2| |
`).repeat(y-1)+a+a}| +0+ |
+--0--+`.replace(/\d/g,n=>"- :"[n].repeat(x))
oninput=_=>o.innerText=f(+i.value)(+j.value);o.innerText=f(i.value=50)(j.value=5)

input{font-family:sans-serif;margin:0 5px 0 0;width:50px;}

<label for=i>L: </label><input id=i type=number><label for=j>x: </label><input id=j type=number><pre id=o>

Python 2 , 124 120 117 octets

^{-2 octets grâce à Hyper Neutrino}

l,x=input()
o='+--%s--+\n| +%s+ |\n'%(('-'*l,)*2)
print o+'| |%s| |\n'*(x*3-1)%((' '*l,' '*l,':'*l)*x)[:-1]+o[-2::-1]

Essayez-le en ligne!

SOGL V0.12 , 52 51 octets

:┌* +1Ο;@*┐1ΟG∙⁴++⁰
b3*Ie4+⁰b3*He⁰32žbH∫3*2+4;e :*ž

Essayez-le ici!
Pas mal étant donné que 20 octets sont une fonction rectangulaire, pour laquelle le charbon de bois a une fonction intégrée.

Explication:

Rectangle function: (example: on stack 4, 2)
:                   duplicate the top of stack (X pos)      [4, 2, 2]
 ┌*                 get that many "-"es                     [4, 2, "--"]
    +               push "+"                                [4, 2, "--", "+"]
     1Ο             wrap the dashes in pluses               [4, 2, "+--+"]
       ;            get the duplicated X position           [4, "+--+", 2]
        @*          get that many spaces                    [4, "+--+", "  "]
          ┐         push "|"                                [4, "+--+", "  ", "|"]
           1Ο       wrap the spaces with "|"                [4, "+--+", "|  |"]
             G      get the Y value ontop                   ["+--+", "|  |", 4]
              ∙     get an array with that many strings     ["+--+", ["|  |", "|  |", "|  |", "|  |"]]
               ⁴    duplicate the dashes wrapped in pluses  ["+--+", ["|  |", "|  |", "|  |", "|  |"], "+--+"]
                ++  add everything to one array             [["+--+", "|  |", "|  |", "|  |", "|  |", "+--+"]]
Main function: (example input: 2, 5)
b3*                              push variable B (input 1, Y length) multiplied by 3                     [6]
   I                             increase it                                                             [7]
    e4+                          push variable E (input 2, X length) + 4                                 [7, 9]
       ⁰                         execute the rectangle function [in X: E+4, Y: b*3+1]                    [["+---------+","|         |","|         |","|         |","|         |","|         |","|         |","|         |","+---------+"]]
        b3*                      push variable B * 3                                                     [["+---------+",..,"+---------+"], 6]
           H                     decrease it                                                             [["+---------+",..,"+---------+"], 5]
            e                    push variable E                                                         [["+---------+",..,"+---------+"], 5, 5]
             ⁰                   execute the rectangle function [on X: E, Y: B*3-1]                      [["+---------+",..,"+---------+"], ["+-----+","|     |","|     |","|     |","|     |","|     |","+-----+"]]
              32ž                at coordinates [3;2] (1-indexed) in the first rectangle put in the 2nd  [["+---------+",
                                                                                                           "| +-----+ |",
                                                                                                           "| |     | |",
                                                                                                           "| |     | |",
                                                                                                           "| |     | |",
                                                                                                           "| |     | |",
                                                                                                           "| |     | |",
                                                                                                           "| +-----+ |",
                                                                                                           "+---------+"]
                 bH∫             iterate over the numbers from 1 to B-1:                                 [[...], 1]
                    3*2+           push pop()*3+2                                                        [[...], 5]
                        4;         push 4 one below the stack                                            [[...], 4, 5]
                          e        push the variable E (X length)                                        [[...], 4, 5, 5]
                            :*     get that many colons                                                  [[...], 4, 5, ":::::"]
                              ž    insert [at coordinates [4; cIter*3+2] the colons]                     

C # (.NET Core) , 202 octets

(L,x)=>{char p='+',n='\n',e=' ';string v="|",r="",s=p+new string('-',L+4)+p+n,q=v+e+p+new string('-',L)+p+e+v+n;r+=s+q;for(int i=0;i<3*x-1;)r+=v+e+v+new string(i++%3<2?e:':',L)+v+e+v+n;r+=q+s;return r;}

Essayez-le en ligne!

Python 2 , 128 126 octets

L,x=input()
k='+'+'-'*(L+4)+'+\n| +'+'-'*L+'+ |\n'
f=lambda k:'| |'+k*L+'| |\n'
print k+f(':').join([f(' ')*2]*x)[:-1]+k[::-1]

Essayez-le en ligne!

-2 octets grâce à @ Mr.Xcoder

PHP , 153 octets

for(;$i-2<$z=3*$argv[2]+1;$i++)echo str_pad(strrev($r=["--+","+ |","| |"][!($b=$i>1&$i<$z)?$i&&$i<$z+1?1:0:2]),$argv[1]+3,"- :"[$b?$i%3!=1?1:2:0])."$r
";

Essayez-le en ligne!

Python 2 , 97 octets

L,x=input()
for i in'01'+'223'*~-x+'2210':r=('+|||-   -+||'+L*'-- :')[int(i)::4];print r+r[2::-1]

Essayez-le en ligne!

Python 2 , 98 octets

L,x=input()
s='+---| +-%s+-+---'%'|:'.join(['| '*5]*x)
while s:print s[:3]+s[3]*L+s[2::-1];s=s[4:]

Essayez-le en ligne!

Fusain , 36 octets

ＮθＮηＦη«Ｍ³↑Ｐ×θ:»←Ｂ⁺θ²⁺׳η¹↖←Ｂ⁺θ⁶⁺׳η³

Essayez-le en ligne!

Ceci est un algorithme plus Charcoal-y que mon autre réponse.

C (gcc) , 195 octets

#define P printf
y;f(L,l){char s[L+1],t[L+1];memset(s,45,L);memset(t,58,L);t[L]=s[L]=0;P("+-%s-+\n|+%s+|\n",s,s);for(y=3*l;y-->1;y%3?P("||%*c||\n",L,32):P("||%s||\n",t));P("|+%s+|\n+-%s-+",s,s);}

Essayez-le en ligne!

Perl 5 , 124 + 1 (-a) = 125 octets

say$o='+'.'-'x($l=pop@F),$t="----+
",$i="| $o+ |
",$e=($d="| |").$"x$l.$d,$/,$e;say$d.':'x$l."$d
$e
$e"for 2..$_;say$i,$o,$t

Essayez-le en ligne!