Schreiben Sie ein Programm, das die Abmessungen eines Gemäldes, die Mattierungsbreite und die Rahmenbreite für ein gerahmtes Porträt eingibt. Das Programm sollte ein Diagramm mit dem Symbol Xfür das Gemälde, +für die Mattierung und #für die Rahmung ausgeben . Die Symbole müssen durch Leerzeichen getrennt sein. Das nachgestellte Leerzeichen ist in Ordnung, solange die Ausgabe den Kriterien visuell entspricht. Die Eingänge können sein 0.

EINGANG: 3 2 1 2 (Breite, Höhe, Mattbreite, Rahmenbreite)

AUSGABE:

In Textform:

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

Der Gewinncode vervollständigt die Bedingungen in den kleinstmöglichen Bytes.

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)

Probieren Sie es online!

Druckt ein durch Leerzeichen getrenntes Raster unter strikter Einhaltung der Spezifikation. Ich bin amüsiert, dass *=zum Konvertieren aund bvon Zahlen in Zeichenfolgen verwendet wird.

Python 3 kann einige Bytes einsparen, indem es vermeidet ' '.join, möglicherweise mehr, indem es f-Strings und Zuweisungsausdrücke verwendet. Danke an Jo King für -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]

Probieren Sie es online!

JavaScript (ES6),  118 113  107 Byte

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

Probieren Sie es online!

Kommentiert

(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

Die Eingabe ist: Höhe, Breite, Mattbreite, Rahmenbreite.

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Kohle , 48 47 44 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Hinweis: Leerzeichen am Ende. Bearbeiten: Verwendet jetzt den @ xnor-Algorithmus. Erläuterung:

≔×ＮXθ≔×ＮXη

Geben Sie die Breite und Höhe ein und konvertieren Sie sie in Zeichenfolgen von Xs.

ＦＥ+#×Ｎι

Durchlaufen Sie die Zeichen +und #konvertieren Sie sie in Zeichenfolgen mit der Länge, die von den verbleibenden zwei Eingaben vorgegeben wird. Dann schleife über diese beiden Saiten.

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

Präfix und Suffix des Gemäldes mit den Zeichenfolgen für die Mattierung und Rahmung.

Ｅη⪫⭆θ⌊⟦ιλ⟧ 

Führen Sie eine Schleife über die Zeichenfolgen aus, nehmen Sie das Minimum der horizontalen und vertikalen Zeichen und doppelten Abstand zwischen den Zeilen. Drucken Sie dabei implizit jede Zeile in einer eigenen Zeile.

05AB1E (legacy) / 05AB1E --no-lazy , 32 31 Bytes

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

Übernimmt die Eingabe in der Reihenfolge height, width, matte, frame. Wenn die in der Abfrage angegebene Eingabereihenfolge streng ist (noch auf die Verifizierung des OP wartet), skann für +1 Byte ein führender Wert (Swap) hinzugefügt werden.

Benötigte das --no-lazyElixir-Compiler-Flag in der neuen Version von 05AB1E, da Elixir aufgrund der verzögerten Auswertung für verschachtelte Maps / Loops ein merkwürdiges Verhalten aufweist ( hier das Ergebnis ohne dieses Flag ).

Probieren Sie es online in der Vorgängerversion von 05AB1E aus.
Probieren Sie es online in der neuen Version von 05AB1E mit hinzugefügtem --no-lazyFlag aus.

Erläuterung:

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

Gelee , 17 Bytes

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

Probieren Sie es online!

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

Canvas , 24 Byte

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

Probieren Sie es hier aus!

Sollte 5 Bytes kürzer sein, liegt aber nicht daran, dass Canvas fehlerhaft ist.

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)

Probieren Sie es online!

Python 3.8 (Vorabversion) , 116 115 113 Byte

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

Probieren Sie es online!

Erster Golfversuch, wird demnächst verbessert. aist die Breite, bdie Höhe, cdie matte Breite und ddie Rahmenbreite.

-1 Bytes mit dem :=Operator halse * d

-2 Bytes dank Jo King, der mir vorschlug, die Parameter e und f zu entfernen

ERLÄUTERUNG:

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)

Kann wahrscheinlich ein wenig gekürzt werden

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")}

Probieren Sie es online!

Dies ist eine Portierung der Python-Antwort von 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("
")}

Probieren Sie es online!

Anonymer Codeblock mit grobem Golfspiel unter Verwendung der mehrdimensionalen Listenzuweisung von Perl 6. Beispielsweise @a[1;2] = 'X';wird 'X'dem Element mit Index 2 aus der Liste mit Index 1 zugewiesen und @a[1,2,3;3,4,5]='X'xx 9;werden alle Elemente mit Indizes 3,4,5der Listen durch Indizes ersetzt1,2,3 mit ersetzt 'X'.

Erläuterung:

Zunächst initialisieren wir die Liste als a+2*(c+d)byb+2*(c+d) Rechteck #s.

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

Dann ordnen wir das innere Rechteck von + s zu

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

Schließlich ist das innerste Rechteck von Xs.

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

Jelly , 35 31 28 24 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe in der Reihenfolge Frame, Matte, Breite, Höhe; Komma getrennt. Gibt das ASCII-Kunstbild mit Rahmen und Matt aus. Wenn die Eingabereihenfolge streng ist, müsste ich mehr Bytes hinzufügen (gemäß meinem ursprünglichen Beitrag).

Ein paar Golfplätze basierend auf der Antwort von @ EriktheOutgolfer; Ich hatte festgestellt, dass die Zeichen in ASCII-Reihenfolge waren, aber nicht überlegt, wie ich das am besten nutzen könnte, und hatte es vergessen G. Seine Antwort ist immer noch besser!

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 Byte

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

Probieren Sie es online!