Escriba un programa que ingrese las dimensiones de una pintura, el ancho de estera y el ancho del marco para un retrato enmarcado. El programa debe generar un diagrama utilizando el símbolo Xde la pintura, +el tapete y #el marco. Los símbolos deben estar separados por espacios. El espacio en blanco final está bien, siempre que la salida coincida visualmente con los criterios. Las entradas pueden ser 0.

ENTRADA: 3 2 1 2 (Ancho, Altura, Ancho mate, Ancho del marco)

SALIDA:

En forma de texto:

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

El código ganador completa las condiciones en el menor número de bytes posible.

Python 2 , 98 bytes

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)

Pruébalo en línea!

Imprime una cuadrícula separada por espacios, siguiendo estrictamente la especificación. Me divierte que *=se use para convertir ayb de números a cadenas.

Python 3 puede guardar algunos bytes evitando ' '.join, quizás más, usando cadenas f y expresiones de asignación. Gracias a Jo King por -2 bytes.

Python 3 , 93 bytes

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]

Pruébalo en línea!

JavaScript (ES6),  118 113  107 bytes

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

Pruébalo en línea!

Comentado

(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 bytes

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

La entrada es: Altura, Ancho, Ancho mate, Ancho del marco.

Pruébalo en línea!

Explicación

&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 bytes

(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)&

Pruébalo en línea!

Carbón , 48 47 44 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Nota: espacio final. Editar: ahora usa el algoritmo de @ xnor. Explicación:

≔×ＮXθ≔×ＮXη

Ingrese el ancho y la altura y conviértalos en cadenas de Xs.

ＦＥ+#×Ｎι

Pase sobre los caracteres +y #conviértalos en cadenas de longitud proporcionadas por las dos entradas restantes. Luego pase sobre esas dos cuerdas.

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

Prefijo y sufijo de la pintura con las cuerdas para la estera y el enmarcado.

Ｅη⪫⭆θ⌊⟦ιλ⟧ 

Pase por las cadenas, tome el mínimo de los caracteres horizontales y verticales, y luego doble espacio entre las filas, imprimiendo implícitamente cada fila en su propia línea.

05AB1E (heredado) / 05AB1E --no-lazy , 32 31 bytes

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

Toma la entrada en el orden height, width, matte, frame. Si el orden de entrada especificado en el desafío es estricto (aún esperando en el OP para la verificación), sse puede agregar un inicio (intercambio) para +1 byte.

Se requiere el --no-lazyindicador del compilador Elixir en la nueva versión de 05AB1E, ya que Elixir tiene un comportamiento extraño debido a la evaluación diferida de mapas / bucles anidados ( aquí el resultado sin este indicador ).

Pruébelo en línea en la versión heredada de 05AB1E.
Pruébelo en línea en la nueva versión de 05AB1E con un --no-lazyindicador agregado .

Explicación:

и              # 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)

Jalea , 17 bytes

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

Pruébalo en línea!

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

Lienzo , 24 bytes.

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

Pruébalo aquí!

Debería ser 5 bytes más corto, pero no porque Canvas tenga errores.

R , 119 bytes

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)

Pruébalo en línea!

Python 3.8 (pre-release) , 116 115 113 bytes

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

Pruébalo en línea!

Primer intento de golf, se mejorará pronto. aes ancho, balto, cancho mate y dancho de marco.

-1 bytes utilizando el :=operador para definir hcomoe * d

-2 bytes gracias a Jo King sugiriéndome que elimine los parámetros e y f

EXPLICACIÓN:

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 bytes

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

Probablemente se pueda recortar un poco

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 bytes

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

Pruébalo en línea!

Este es un puerto de la respuesta Python de xnor .

Perl 6 , 115 bytes

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

Pruébalo en línea!

Bloqueo de código anónimo más o menos golfizado utilizando la asignación de lista multidimensional de Perl 6. Por ejemplo, @a[1;2] = 'X';asignará 'X'al elemento con índice 2 de la lista con índice 1, y @a[1,2,3;3,4,5]='X'xx 9;reemplazará todos los elementos con índices 3,4,5de las listas con índices 1,2,3con 'X'.

Explicación:

En primer lugar, inicializar la lista como una a+2*(c+d)de b+2*(c+d)rectángulo del #s.

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

Luego asignamos el rectángulo interno de +s

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

Finalmente, el rectángulo más interno de Xs.

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

Gelatina , 35 31 28 24 bytes

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

Pruébalo en línea!

Toma la entrada en el marco de orden, mate, ancho, alto; separado por comas. Emite la imagen de arte ASCII con marco y mate. Si el orden de entrada es estricto, necesitaría agregar más bytes (según mi publicación original).

Un par de campos de golf basados ​​en la respuesta de @ EriktheOutgolfer; Me di cuenta de que los personajes estaban en orden ASCII, pero no había pensado en la mejor manera de aprovechar eso, y me había olvidado G. ¡Sin embargo, la suya sigue siendo una mejor respuesta!

Perl 5, 115 bytes

$_=(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 bytes

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

Pruébalo en línea!