Ospiti i Giochi olimpici e devi creare un fantastico pool per il bene dell'occasione, ma i supervisori cambiano spesso idea delle dimensioni e hanno bisogno di un modo rapido per ricostruirlo con le dimensioni richieste!

Dati due numeri interi Le x, il tuo compito è quello di costruire una piscina di lunghezza Le xcorsie.

Come viene costruita una piscina?

• Contiene un quadrato interno, le cui pareti orizzontali sono costituite da Ltrattini consecutivi ( -) e le cui pareti verticali sono costituite da 3x - 1barre ( |). Inoltre, 4 +segni si trovano in ogni angolo. Facciamo un esempio ( L = 10, x = 2):

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

• Ogni corsia ha una larghezza di 2 unità verticali. Il quadrato interno è pieno di x-1separatori di corsia, costituiti da simboli Lorizzontalmente consecutivi :. Dopo aver inserito i separatori di corsia, il nostro pool dovrebbe apparire così:

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

• Una piscina contiene anche un'imbottitura (un quadrato esterno), le cui pareti orizzontali sono (L + 4) se le -cui pareti verticali sono (3x + 1) |, che circonda il quadrato interno:

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

E questa è la nostra piscina ** di dimensioni olimpiche!

Specifiche:

• Ai fini di progettazione e funzionalità, è garantito che 100 ≥ L ≥ 10e 15 ≥ x ≥ 2.

• L'output deve essere esattamente come mostrato. L'output di un pool "costruito verticalmente" * non è consentito.

• Sono consentiti spazi secondari e iniziali.

• È possibile accettare input e fornire output tramite qualsiasi metodo standard .

• Si applicano scappatoie predefinite .

Esempi / casi di test:

L = 20, x = 3

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



L = 50, x = 5:

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


L = 10, x = 15

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

Questo è code-golf , quindi vince il codice più corto in byte !

_{* L'acqua potrebbe fuoriuscire se costruita in verticale: P}

_{** Sì, sono consapevole che più sono le corsie e più corta è la piscina, meno il disegno sembra una piscina!}

Carbone , 32 byte

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

Provalo online!

-4 grazie a 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

Carbone di legna , 40 39 37 byte

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

Provalo online!

So che Neil ha già una risposta al carbone di circa la stessa lunghezza, ma ho adottato un approccio un po 'diverso, quindi ho pensato di poter pubblicare anche la mia.

Spiegazione

ＮθＮηＢ⁺θ⁶⁺׳η³↘→Ｂ⁺θ²⁺׳η¹→Ｆ⁻η¹«Ｍ³↓Ｐ×:θ
ＮθＮη                                         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]

Carbone di legna, 40 38 36 31 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Le primitive di disegno di Charcoal usano il conteggio complessivo dei caratteri inclusi +s, tuttavia l'input è solo il numero di -s, quindi dobbiamo aggiungere 2 per ottenere la larghezza della parete interna.

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

Calcola di nuovo l'altezza della parete interna, compresa la riga inferiore, quindi tre per corsia più una.

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

Disegna le corsie. Questo è semplicemente un rettangolo riempito con :s separati verticalmente da due linee vuote (i caratteri a tratteggio rappresentano i caratteri di nuova riga).

Ｂθη         Box(q, h);

Il Rectanglecomando è esattamente ciò di cui abbiamo bisogno per disegnare la parete interna. Modifica: Boxconsente di omettere il suo terzo parametro, salvandomi 2 byte.

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

E ancora per disegnare il muro esterno, tranne leggermente più largo e più alto, e centrato sul muro interno.

T-SQL, 284 281 byte

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'input è preso dalle colonne INT L e x nella tabella preesistente t , secondo i nostri metodi di input consentiti .

Fondamentalmente sto creando una lunga stringa con lettere che rappresentano i caratteri ripetuti (d = trattini, s = spazi, c = due punti, b = interruzione di riga), quindi SOSTITUALI tutti alla fine con i riempitori appropriati.

formattato:

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(':',@))

All'interno del ciclo aggiungo 2 file di spazi vuoti e 1 riga di due punti, quindi alla fine taglio la riga del divisore e aggiungo il bordo della piscina prima di eseguire i rimpiazzi.

EDIT : salvato 3 byte passando @alla variabile più utilizzata e scambiando l'ordine di inizializzazione.

JavaScript (ES6), 137 124 byte

Scivolando un po 'sul mio telefono, ne seguiranno altri.

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

Provalo

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 byte

^{-2 byte grazie a 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]

Provalo online!

SOGL V0.12 , 52 51 byte

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

Provalo qui!
Non male considerando che 20 byte di questo è una funzione rettangolare, per cui il carbone ha un built-in.

Spiegazione:

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 byte

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

Provalo online!

Python 2 , 128 126 byte

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]

Provalo online!

-2 byte grazie a @ Mr.Xcoder

PHP , 153 byte

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

Provalo online!

Python 2 , 97 byte

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

Provalo online!

Python 2 , 98 byte

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

Provalo online!

Carbone , 36 byte

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

Provalo online!

Questo è un algoritmo più carbone-y rispetto alla mia altra risposta.

C (gcc) , 195 byte

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

Provalo online!

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

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

Provalo online!