22

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.

code-golf ascii-art

— George Harris
quelle

2

Schöne Herausforderung! Für zukünftige Herausforderungen können Sie The Sandbox

— MilkyWay90

2

Stört es Sie, wenn die Eingabe in einer anderen Reihenfolge erfolgt?

— Vityavv

1

Können wir eine Liste von Zeichenketten zurückgeben?

— MilkyWay90

5

Kann einer der Eingänge Null sein?

— Laikoni

1

Können wir am Ende jeder Zeile ein Leerzeichen setzen?

— Luis Mendo

5

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!

— xnor
quelle

Ich war überfordert! Schöner Job, scheint ziemlich Golf zu spielen

— MilkyWay90

Schönes Golf! Sehr schlau.

— George Harris

4

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

— Arnauld
quelle

3

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

— Luis Mendo
quelle

2

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!

— J42161217
quelle

2

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.

— Neil
quelle

2

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)

— Kevin Cruijssen
quelle

2

Gelee , 17 Bytes

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

Probieren Sie es online!

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

— Erik der Outgolfer
quelle

1

Canvas , 24 Byte

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

Probieren Sie es hier aus!

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

— dzaima
quelle

1

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!

— Giuseppe
quelle

1

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

— MilkyWay90
quelle

Wenn Sie die eZuweisung entfernen, sparen Sie zwei Bytes, die fZuweisung spart Ihnen nichts

— Jo King

@JoKing Oh wow, ich habe vergessen, die eund fZuordnungen zu entfernen, nachdem ich die gVerknüpfung entdeckt habe

— MilkyWay90

0

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

Erweitern Sie das Snippet

— vityavv
quelle

0

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 + # #
# # + + + + + # #
# # # # # # # # #
# # # # # # # # #

— Scherzen
quelle

0

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!

— Nick Kennedy
quelle

Ich programmiere nie in Jelly, aber kann sicher 43134,43234 komprimiert werden? EDIT: Ich muss lernen zu lesen, Sie erwähnen, dass sie in der Tat in jeweils 4 Bytes codiert werden können. Aber was hat die Eingabereihenfolge damit zu tun, ob diese Zahlen verschlüsselt werden können oder nicht? : S

— Kevin Cruijssen

@KevinCruijssen Die maximale Ganzzahl, die mit der Zwei-Byte-Syntax codiert werden kann, ist 32250. da beide das überschreiten kann ich die bytes nicht speichern. Im Moment gehe ich davon aus, dass ich Dinge austauschen und zurücksetzen kann, wenn es nicht erlaubt ist!

— Nick Kennedy

Ah ok, ich verstehe. 43134Benötigt 3 Kodierungszeichen, einschließlich eines führenden / nachfolgenden Zeichens, um anzuzeigen, dass es kodiert ist, werden auch 5 Bytes benötigt. Und hat Jelly vielleicht eine Art Duplikat, da die zweite Zahl 100 größer ist als die erste? Sind Sie nicht sicher, ob die Aktionen " 43134", "Duplizieren", "100" und "Plus" drücken oder "Pair" in "Jelly" möglich und kürzer sind?

— Kevin Cruijssen

@ KevinCruijssen Ich habe ursprünglich versucht, mit +0,100, die keine speichert. Ich denke, ich könnte eine Niladenkette verwenden, um die Tatsache zu verwenden, dass in einem Nilad ³ 100 ist, aber wenn ich Eingaben neu ordnen darf, sind die Basis-250-Ganzzahlen besser

— Nick Kennedy

0

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

— Nahuel Fouilleul
quelle

0

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!

— mazzy
quelle

Visuelles Diagramm des Bildes ausgeben

Python 2 , 98 Bytes

JavaScript (ES6), 118 113 107 Byte

Kommentiert

MATL , 24 Bytes

Erläuterung

Wolfram Language (Mathematica) , 142 Bytes

Kohle , 48 47 44 Bytes

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

Gelee , 17 Bytes

Canvas , 24 Byte

R , 119 Bytes

Python 3.8 (Vorabversion) , 116 115 113 Byte

Javascript, 158 Bytes

Perl 6 , 98 Bytes

Perl 6 , 115 Bytes

Erläuterung:

Jelly , 35 31 28 24 Bytes

Perl 5, 115 Bytes

PowerShell , 132 Byte

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