Écrivez un programme qui saisit les dimensions d'une peinture, la largeur du passe-partout et la largeur du cadre pour un portrait encadré. Le programme doit produire un diagramme utilisant le symbole Xde la peinture, +du tapis et #du cadrage. Les symboles doivent être séparés par des espaces. L'espace de fin est correct, tant que la sortie correspond visuellement aux critères. Les entrées peuvent être0 .

ENTRÉE: 3 2 1 2 (largeur, hauteur, largeur mate, largeur du cadre)

SORTIE:

Sous forme de texte:

# # # # # # # # #
# # # # # # # # #
# # + + + + + # #
# # + X X X + # #
# # + X X X + # #
# # + + + + + # #
# # # # # # # # #
# # # # # # # # #

Le code gagnant complète les conditions dans le moins d'octets possible.

Python 2 , 98 octets

w,h,a,b=input()
a*='+'
b*='#'
for c in b+a+h*'X'+a+b:print' '.join(min(c,d)for d in b+a+w*'X'+a+b)

Essayez-le en ligne!

Imprime une grille séparée par des espaces, en suivant strictement les spécifications. Je suis amusé qui *=est utilisé pour convertir aetb des nombres en chaînes.

Python 3 peut économiser quelques octets en évitant ' '.join, peut-être plus en utilisant des chaînes f et des expressions d'affectation. Merci à Jo King pour -2 octets.

Python 3 , 93 octets

def f(w,h,a,b):a*='+';b*='#';[print(*[min(c,d)for d in b+a+w*'X'+a+b])for c in b+a+h*'X'+a+b]

Essayez-le en ligne!

JavaScript (ES6),  118 113  107 octets

(w,h,M,F)=>(g=(c,n)=>'01210'.replace(/./g,i=>c(i).repeat([F,M,n][i])))(y=>g(x=>'#+X'[x<y?x:y]+' ',w)+`
`,h)

Essayez-le en ligne!

Commenté

(w, h, M, F) => (       // given the 4 input variables
  g = (                 // g = helper function taking:
    c,                  //   c = callback function returning a string to repeat
    n                   //   n = number of times the painting part must be repeated
  ) =>                  //
    '01210'             // string describing the picture structure, with:
    .replace(           //   0 = frame, 1 = matte, 2 = painting
      /./g,             // for each character in the above string:
      i =>              //   i = identifier of the current area
        c(i)            //   invoke the callback function
        .repeat         //   and repeat the result ...
        ([F, M, n][i])  //   ... either F, M or n times
    )                   // end of replace()
)(                      // outer call to g:
  y =>                  //   callback function taking y:
    g(                  //     inner call to g:
      x =>              //       callback function taking x:
        '#+X'           //         figure out which character to use
        [x < y ? x : y] //         according to the current position
        + ' ',          //         append a space
      w                 //       repeat the painting part w times
    )                   //     end of inner call
    + '\n',             //     append a line feed
  h                     //   repeat the painting part h times
)                       // end of outer call

MATL , 24 octets

&l,ithYaQ]'#+X'w)TFX*cYv

L'entrée est: Hauteur, Largeur, Largeur mate, Largeur du cadre.

Essayez-le en ligne!

Explication

&l      % Take height and width implicitly. Push matrix of that size with all
        % entries equal to 1
,       % Do twice
  i     %   Take input
  th    %   Duplicate, concatenate: gives a 1×2 vector with the number repeated
  Ya    %   Pad matrix with those many zeros vertically and horizontally
  Q     %   Add 1 to each entry 
]       % End
'#+X'   % Push this string
w)      % Index into the string with the padded matrix
TF      % Push row vector [1 0]
X*      % Kronecker product. This inserts columns of zeros
c       % Convert to char again. Char 0 is will be displayed as space
Yv      % Remove trailing spaces in each line. Implicitly display

Wolfram Language (Mathematica) , 142 octets

(t=(p=Table)["# ",2(c=#4+#3)+#2,2c+#];p[t[[i,j]]="+ ",{j,z=#4+1,c+#3+#},{i,z,c+#3+#2}];p[t[[i,j]]="X ",{j,#3+z,c+#},{i,#3+z,c+#2}];""<>#&/@t)&

Essayez-le en ligne!

Fusain , 48 47 44 octets

≔×ＮXθ≔×ＮXηＦＥ+#×Ｎι«≔⁺ι⁺θιθ≔⁺ι⁺ηιη»Ｅη⪫⭆θ⌊⟦ιλ⟧ 

Essayez-le en ligne! Le lien est vers la version détaillée du code. Remarque: Espace de fin. Edit: utilise maintenant l'algorithme @ xnor. Explication:

≔×ＮXθ≔×ＮXη

Saisissez la largeur et la hauteur et convertissez-les en chaînes de Xs.

ＦＥ+#×Ｎι

Faites une boucle sur les caractères +et #convertissez-les en chaînes de longueur données par les deux entrées restantes. Faites ensuite une boucle sur ces deux chaînes.

«≔⁺ι⁺θιθ≔⁺ι⁺ηιη»

Préfixez et suffixez le tableau avec les cordes pour le passe-partout et l'encadrement.

Ｅη⪫⭆θ⌊⟦ιλ⟧ 

Faites une boucle sur les chaînes, en prenant le minimum des caractères horizontaux et verticaux, puis en double-espaçant les lignes, imprimant implicitement chaque ligne sur sa propre ligne.

05AB1E (hérité) / 05AB1E --no-lazy , 32 31 octets

и'Xׄ+#vyI©×UεX.ø}®FDнgy×.ø]€S»

Prend l'entrée dans l'ordre height, width, matte, frame. Si l'ordre d'entrée spécifié dans le défi est strict (toujours en attente de vérification pour OP), uns (swap) peut être ajouté pour +1 octet.

Requis le --no-lazydrapeau du compilateur Elixir dans la nouvelle version de 05AB1E, car Elixir a un comportement étrange en raison de l'évaluation paresseuse des cartes / boucles imbriquées ( ici le résultat sans ce drapeau ).

Essayez-le en ligne dans la version héritée de 05AB1E.
Essayez-le en ligne dans la nouvelle version de 05AB1E avec --no-lazydrapeau ajouté .

Explication:

и              # Repeat the second (implicit) input the first (implicit) input amount of
               # times as list
 'X×          '# Repeat "X" that many times
„+#v           # Loop `y` over the characters ["+","#"]:
    y          #  Push character `y`
     I         #  Push the next input (matte in the first iteration; frame in the second)
      ©        #  And store it in the register (without popping)
       ×       #  Repeat character `y` that input amount of times
        U      #  Pop and store that string in variable `X`
    εX.ø}      #  Surround each string in the list with string `X`
    ®F         #  Inner loop the value from the register amount of times:
      Dнg      #   Get the new width by taking the length of the first string
         y×    #   Repeat character `y` that many times
           .ø  #   And surround the list with this leading and trailing string
   ]           # Close both the inner and outer loops
    €S         # Convert each inner string to a list of characters
      »        # Join every list of characters by spaces, and then every string by newlines
               # (and output the result implicitly)

Gelée , 17 octets

;ŒB“#+X+#”xʋⱮ«Ɱ/G

Essayez-le en ligne!

Argument 1: [Frame width, Matte width]
Argument 2:[Width, Height]

Canevas , 24 octets

Ｘ；«［ｌｘ＊ｅ⤢｝
X×＊+⁸#⁸ ＊Ｊ ×Ｏ

Essayez-le ici!

Doit être 5 octets plus court, mais ce n'est pas le cas car Canvas est bogué.

R , 119 octets

function(w,h,m,f)write(Reduce(function(x,y)rbind(y,cbind(y,x,y),y),rep(c("+","#"),c(m,f)),matrix("X",w,h)),1,w+2*f+2*m)

Essayez-le en ligne!

Python 3.8 (pré-version) , 116 115 113 octets

lambda a,b,c,d:"\n".join((g:=['#'*(a+2*c+2*d)]*d+[(h:='#'*d)+'+'*(a+c*2)+h]*c)+[h+'+'*c+'X'*a+'+'*c+h]*b+g[::-1])

Essayez-le en ligne!

La première tentative de golf sera bientôt améliorée. aest la largeur, la bhauteur, la clargeur mate etd largeur du cadre.

-1 octets utilisant l' :=opérateur pour définir hcommee * d

-2 octets grâce à Jo King me suggérant de supprimer les paramètres e et f

EXPLICATION:

lambda a,b,c,d:          Define a lambda which takes in arguments a, b, c, and d (The width of the painting, the height of the painting, the padding of the matte, and the padding of the frame width, respectively).
    "\n".join(                       Turn the list into a string, where each element is separated by newlines
        (g:=                         Define g as (while still evaling the lists)...
            ['#'*(a+2*c+2*d)]*d+       Form the top rows (the ones filled with hashtags)
            [(h:='#'*d)+'+'*(a+c*2)+h]*c Form the middle-top rows (uses := to golf this section)
        )+
        [h+'+'*c+'X'*a+'+'*c+h]*b+       Form the middle row
        g[::-1]                      Uses g to golf the code (forms the entire middle-bottom-to-bottom)
    )

Javascript, 158 octets

(w,h,m,f)=>(q="repeat",(z=("#"[q](w+2*(m+f)))+`
`)[q](f))+(x=((e="#"[q](f))+(r="+"[q](m))+(t="+"[q](w))+r+e+`
`)[q](m))+(e+r+"X"[q](w)+r+e+`
`)[q](h)+x+z)

Peut probablement être réduit un peu

f=

(w,h,m,f)=>(q="repeat",(z=("# "[q](w+2*(m+f))+`
`)[q](f))+(x=((e="# "[q](f))+(r="+ "[q](m))+(t="+ "[q](w))+r+e+`
`)[q](m))+(e+r+"X "[q](w)+r+e+`
`)[q](h)+x+z)

console.log(f(3,2,1,2))

Perl 6 , 98 octets

{map(&min,[X] map (($_='#'x$^d~'+'x$^c)~'X'x*~.flip).comb,$^a,$^b).rotor($b+2*($c+$d)).join("\n")}

Essayez-le en ligne!

Il s'agit d'un portage de la réponse Python de xnor .

Perl 6 , 115 octets

->\a,\b,\c,\d{$_=['#'xx$!*2+a]xx($!=c+d)*2+b;.[d..^*-d;d..^a+$!+c]='+'xx*;.[$!..^*-$!;$!..^a+$!]='X'xx*;.join("
")}

Essayez-le en ligne!

Un bloc de code anonyme approximativement utilisé en utilisant l'affectation de liste multidimensionnelle de Perl 6. Par exemple, @a[1;2] = 'X';affectera 'X'à l'élément avec l'index 2 de la liste avec l'index 1, et @a[1,2,3;3,4,5]='X'xx 9;remplacera tous les éléments avec les index 3,4,5des listes avec les index1,2,3 avec'X' .

Explication:

Tout d' abord, nous avons la liste initialisez comme a+2*(c+d)par b+2*(c+d)rectangle de #s.

$_=['#'xx$!*2+a]xx($!=c+d)*2+a;
State:
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #

Ensuite, nous attribuons le rectangle intérieur de +s

.[d..^*-d;d..^a+$!+c]='+'xx*;
State:
# # # # # # # # #
# # # # # # # # #
# # + + + + + # #
# # + + + + + # #
# # + + + + + # #
# # + + + + + # #
# # # # # # # # #
# # # # # # # # #

Enfin, le rectangle le plus à l'intérieur de l' Xart.

.[$!..^*-$!;$!..^a+$!]='X'xx*;
# # # # # # # # #
# # # # # # # # #
# # + + + + + # #
# # + X X X + # #
# # + X X X + # #
# # + + + + + # #
# # # # # # # # #
# # # # # # # # #

Gelée , 35 31 28 24 octets

Dịx@“#+X+#”
⁽-Fç«þ⁽-ȥç$G

Essayez-le en ligne!

Prend l'entrée dans le cadre de commande, mat, largeur, hauteur; séparées par des virgules. Sort l'image ASCII-art avec cadre et mat. Si l'ordre d'entrée est strict, j'aurais besoin d'ajouter plus d'octets (selon mon message d'origine).

Quelques golfs basés sur la réponse de @ EriktheOutgolfer; J'avais réalisé que les personnages étaient en ordre ASCII, mais je n'avais pas pensé comment tirer le meilleur parti de cela, et j'avais oublié G. C'est quand même une meilleure réponse!

Perl 5, 115 octets

$_=(X x$F[0].$/)x$F[1];sub F{s,^|\z,/.*/;$_[0]x"@+".$/,ge,s/^|(?=
)/$_[0]/gm while$_[1]--}F('+',$F[2]);F('#',$F[3])

TIO

PowerShell , 132 octets

param($w,$h,$m,$f)filter l{"$(,'#'*$f+,$_[0]*$m+,$_[1]*$w+,$_[0]*$m+,'#'*$f)"}($a=@('##'|l)*$f)
($b=@('++'|l)*$m)
@('+X'|l)*$h
$b
$a

Essayez-le en ligne!