चित्र का आउटपुट दृश्य आरेख

Question

एक प्रोग्राम लिखें जो एक पेंटिंग के आयाम, चटाई की चौड़ाई और फ़्रेमयुक्त चित्र के लिए फ्रेम की चौड़ाई का इनपुट करता है। कार्यक्रम उत्पादन एक चित्र प्रतीक का उपयोग करना चाहिए Xचित्रकला के लिए, +चटाई के लिए, और #तैयार करने के लिए। प्रतीकों को अंतरिक्ष-पृथक होना चाहिए। ट्रेलिंग व्हाट्सएप ठीक है, जब तक कि आउटपुट नेत्रहीन रूप से मानदंडों से मेल खाता है। इनपुट्स हो सकते हैं 0।

INPUT: 3 2 1 2 (चौड़ाई, ऊँचाई, मैट चौड़ाई, फ़्रेम चौड़ाई)

उत्पादन:

पाठ के रूप में:

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

जीतने वाला कोड कम से कम संभव बाइट्स में शर्तों को पूरा करता है।

Comments

अच्छी चुनौती! भविष्य की चुनौतियों के लिए आप The Sandbox

— MilkyWay90

क्या आपको लगता है कि इनपुट अलग क्रम में है?

— मृत्युंजय

क्या हम तार की सूची वापस कर सकते हैं?

— मिल्कीवेय 90

क्या कोई भी इनपुट शून्य हो सकता है?

— लकोनी

क्या हमारे पास प्रत्येक पंक्ति के अंत में एक स्थान हो सकता है?

— लुइस मेंडो

Answer 1

पायथन 2 , 98 बाइट्स

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)

इसे ऑनलाइन आज़माएं!

स्पेस-अलग ग्रिड को प्रिंट करता है, कड़ाई से कल्पना का पालन करता है। मैं खुश हूँ कि *=परिवर्तित करने के लिए प्रयोग किया जाता है aऔर bतार करने के लिए नंबर से।

पायथन 3 कुछ बाइट्स को बचा ' '.joinसकता है, शायद एफ-स्ट्रिंग्स और असाइनमेंट एक्सप्रेशन का उपयोग करके। -2 बाइट्स के लिए जो किंग को धन्यवाद।

पायथन 3 , 93 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

Comments

मैं बहक गया हूँ! NIce की नौकरी, बहुत गोल्फ लगती है

— MilkyWay90

अच्छा गोल्फ! बहुत चालाक।

— जॉर्ज हैरिस

Answer 2

जावास्क्रिप्ट (ईएस 6),  118 113  107 बाइट्स

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

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

(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

Answer 3

MATL , 24 बाइट्स

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

इनपुट है: ऊंचाई, चौड़ाई, मैट चौड़ाई, फ़्रेम चौड़ाई।

इसे ऑनलाइन आज़माएं!

व्याख्या

&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

Answer 4

वोल्फ्राम भाषा (गणितज्ञ) , 142 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

चारकोल , 48 47 44 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: अनुगामी स्थान। संपादित करें: अब @ xnor के एल्गोरिथ्म का उपयोग करता है। स्पष्टीकरण:

≔×ＮXθ≔×ＮXη

चौड़ाई और ऊंचाई इनपुट करें और उन्हें Xएस के तारों में परिवर्तित करें ।

ＦＥ+#×Ｎι

पात्रों पर लूप +और #, उन्हें शेष दो इनपुट द्वारा दी गई लंबाई के तारों में परिवर्तित करना। फिर उन दो तारों पर पाश।

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

मैटिंग और फ्रेमिंग के लिए स्ट्रिंग्स के साथ पेंटिंग को उपसर्ग और प्रत्यय दें।

Ｅη⪫⭆θ⌊⟦ιλ⟧ 

तारों पर लूप, क्षैतिज और ऊर्ध्वाधर वर्णों की न्यूनतम ले, और फिर पंक्तियों को डबल-रिक्ति दें, प्रत्येक पंक्ति को अपनी पंक्ति में छापते हुए।

Answer 6

05AB1E (विरासत) / 05AB1E --no-lazy , 32 31 बाइट्स

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

ऑर्डर में इनपुट लेता है height, width, matte, frame। यदि चुनौती में निर्दिष्ट इनपुट आदेश सख्त है (अभी भी सत्यापन के लिए ओपी पर इंतजार कर रहा है), s+1 के लिए एक अग्रणी (स्वैप) जोड़ा जा सकता है।

आवश्यक --no-lazy, 05AB1E के नए संस्करण में अमृत संकलक ध्वज के बाद से अमृत नेस्टेड नक्शे / छोरों के लिए आलसी मूल्यांकन (के कारण कुछ अजीब व्यवहार है यहाँ इस ध्वज के बिना परिणाम )।

इसे 05AB1E के विरासत संस्करण में ऑनलाइन आज़माएं।
जोड़े गए --no-lazyध्वज के साथ 05AB1E के नए संस्करण में इसे ऑनलाइन आज़माएं ।

स्पष्टीकरण:

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

Answer 7

जेली , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

तर्क 1: [Frame width, Matte width]
तर्क 2:[Width, Height]

Answer 8

कैनवस , 24 बाइट्स

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

यहाँ कोशिश करो!

5 बाइट्स कम होनी चाहिए, लेकिन ऐसा नहीं है क्योंकि कैनवस छोटी गाड़ी है।

Answer 9

आर , 119 बाइट्स

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)

इसे ऑनलाइन आज़माएं!

Answer 10

पायथन 3.8 (पूर्व-रिलीज़) , 116 115 113 बाइट्स

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

इसे ऑनलाइन आज़माएं!

गोल्फिंग में पहला प्रयास, जल्द ही सुधार किया जाएगा। aचौड़ाई है, bऊंचाई है, cमैट चौड़ाई है, और dफ्रेम चौड़ाई है।

-1 बाइट्स के रूप में :=परिभाषित करने के लिए ऑपरेटर का उपयोग करhe * d

जो किंग को ई और एफ के मापदंडों को हटाने का सुझाव देते हुए -2 बाइट्स धन्यवाद

व्याख्या:

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

Comments

eअसाइनमेंट को हटाने से आपको दो बाइट्स मिलते हैं, fअसाइनमेंट आपको कुछ भी नहीं बचा रहा है

— Jo King

@JoKing ओह वाह, मैं शॉर्टकट की खोज के बाद eऔर fअसाइनमेंट निकालना भूल गयाg

— मिल्कीवेय

Answer 11

जावास्क्रिप्ट, 158 बाइट्स

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

संभवत: थोड़ा नीचे छंटनी की जा सकती है

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

Answer 12

पर्ल 6 , 98 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह xnor के पायथन उत्तर का एक बंदरगाह है ।

पर्ल 6 , 115 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मोटे तौर पर गोल्फ गुमनाम कोडब्लॉक पर्ल 6 के बहुआयामी सूची असाइनमेंट का उपयोग कर रहा है। उदाहरण के लिए, सूची 1 के साथ सूची 2 से सूचकांक 2 के साथ तत्व @a[1;2] = 'X';को असाइन करेगा 'X', और @a[1,2,3;3,4,5]='X'xx 9;सभी तत्वों को सूचियों 3,4,5के अनुक्रमित के साथ प्रतिस्थापित करेगा।1,2,3 साथ 'X'।

स्पष्टीकरण:

सबसे पहले, हम एक के रूप में सूची आरंभ a+2*(c+d)द्वारा b+2*(c+d)की आयत #रों।

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

फिर हम की आंतरिक आयत आवंटित +रों

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

अंत में, अंतरतम आयत Xs।

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

Answer 13

जेली , 35 31 28 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ऑर्डर फ्रेम, मैट, चौड़ाई, ऊंचाई में इनपुट लेता है; अल्पविराम से अलग। फ्रेम और मैट के साथ ASCII- कला चित्र आउटपुट करता है। यदि इनपुट आदेश सख्त है, तो मुझे अधिक बाइट्स (मेरी मूल पोस्ट के अनुसार) जोड़ने की आवश्यकता होगी।

@ EriktheOutgolfer के उत्तर के आधार पर गोल्फ के युगल; मुझे एहसास हुआ कि अक्षर ASCII के क्रम में थे, लेकिन यह नहीं सोचा था कि इसका लाभ उठाने के लिए सबसे अच्छा कैसे होगा, और इसके बारे में भूल गया था G। उसका जवाब अभी भी एक बेहतर जवाब है!

Comments

मैं कभी भी जेली में कार्यक्रम नहीं करता, लेकिन निश्चित रूप से 43134,43234 को संकुचित किया जा सकता है? संपादित करें: मुझे पढ़ने के लिए सीखने की जरूरत है, आप उल्लेख करते हैं कि वे वास्तव में प्रत्येक 4 बाइट्स में एन्कोडेड हो सकते हैं। लेकिन इन नंबरों को इनकोड किया जा सकता है या नहीं, इसका इनपुट-आर्डर क्या है? : एस

— केविन क्रूज़सेन

@ केविनक्रूजसेन अधिकतम पूर्णांक है जो दो बाइट सिंटैक्स का उपयोग करके एन्कोड किया जा सकता है 32250 है; चूँकि दोनों ही बाइट्स को बचा नहीं सकते हैं। अभी के लिए मैं मान लूंगा कि मैं चीजों को अदला-बदली कर सकता हूं और अगर इसकी अनुमति नहीं है तो वापस कर दूंगा!

— निक केनेडी

आह ठीक है, मैं देख रहा हूं। 431343 एन्कोडिंग वर्णों की आवश्यकता होगी, जिसमें एक प्रमुख / अनुगामी चरित्र सहित यह इंगित करना है कि यह एन्कोडेड है 5 बाइट्स भी होंगे। और क्या जेली के पास किसी प्रकार का डुप्लिकेट है, क्योंकि दूसरी संख्या पहले से 100 बड़ी है? निश्चित नहीं है कि क्रियाएँ 43134 धक्का, डुप्लिकेट, धक्का 100, प्लस, जोड़ी संभव है और जेली में कम है?

— केविन क्रूज़सेन

@ केविनक्रूजसेन I ने मूल रूप से कोशिश की कि +0,100 का उपयोग किया जाए जो किसी भी तरह से नहीं बचा है। मुझे लगता है कि मैं एक निलाद श्रृंखला का उपयोग इस तथ्य का उपयोग करने के लिए कर सकता हूं कि एक निलाद में a 100 है, लेकिन अगर मुझे इनपुट की अनुमति दी जाए तो आधार 250 पूर्णांक बेहतर होते हैं

— निक केनेडी

Answer 14

पर्ल 5, 115 बाइट्स

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

Answer 15

पॉवरशेल , 132 बाइट्स

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

इसे ऑनलाइन आज़माएं!