ई के साथ पत्र ई

19

आपका कार्य नीचे दिए गए अक्षर "ई" के आकार के ASCII कला को प्रदर्शित करना है, जिसे पांच इनपुट दिए गए हैं।

उदाहरण:

इनपुट: 7,2,+,|,-(नोट: आपको इस सटीक इनपुट प्रारूप का पालन करने की आवश्यकता नहीं है, और यदि आप इसका उपयोग नहीं करते हैं, तो आपको यह बताना होगा कि आपके स्वयं के प्रारूप प्रारूप कैसे हैं)

स्पष्टीकरण:

  • 7 बाएँ और दाएँ किनारे के वर्णों सहित कुल चौड़ाई।

  • 2 ऊर्ध्वाधर वर्णों की संख्या।

  • + वह चरित्र जो किनारों पर प्रदर्शित होना चाहिए।

  • | वह चरित्र जो किनारों के बीच लंबवत प्रदर्शित होना चाहिए।

  • - वह चरित्र जो क्षैतिज रूप से प्रदर्शित होना चाहिए।

उपरोक्त उदाहरण का आउटपुट:

+-----+ 
|
|
+-----+
|
|
+-----+

अन्य उदाहरण:

इनपुट: 7,2,@,|,-

आउटपुट:

@-----@
|
|
@-----@
|
|
@-----@

इनपुट: 7,2,+,|,#

आउटपुट:

+#####+
|
|
+#####+
|
|
+#####+

इनपुट: 8,3,+,|,#

आउटपुट:

+######+
|
|
|
+######+
|
|
|
+######+

इनपुट: 8,3,+,@,#

आउटपुट:

+######+
@
@
@
+######+
@
@
@
+######+

इनपुट: 9,4,^,$,!

आउटपुट:

^!!!!!!!^
$
$
$
$
^!!!!!!!^
$
$
$
$
^!!!!!!!^

धोखा और मानक खामियों की अनुमति नहीं है।

आपका कोड STDERR को कुछ भी प्रिंट नहीं करना चाहिए।

आपका कोड आपके द्वारा चुने गए किसी भी वर्ण एन्कोडिंग को इनपुट के रूप में स्वीकार कर सकता है, लेकिन आपके द्वारा चुने गए किसी भी वर्ण एन्कोडिंग को न्यूनतम के रूप में, सभी 95 मुद्रण योग्य ASCII वर्णों का समर्थन करना चाहिए ।

बाइट्स में सबसे छोटा कोड, जो इस चुनौती को सफलतापूर्वक पूरा करता है, वह जीतने वाला कोड है।

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  ascii-art 
— बफर ओवर पढ़ें
स्रोत
27
मैं 'कोई इनपुट नहीं दिया' के विशेष मामले को नापसंद करता हूं। मेरी राय में, यह चुनौती के लिए कुछ भी नहीं जोड़ता है और कुछ नहीं के लिए बहुत कुछ जटिल करता है।
— यति
3
क्या शीर्षक इसलिए है क्योंकि आप Eइनपुट के रूप में दे सकते हैं , और एस के Eसाथ बना सकते हैं E?
— ट्राइकोप्लाक्स सिप
3
इसके बावजूद कि मैं इसे नापसंद करता हूं, 'नो इनपुट' का वास्तव में क्या मतलब है? यदि आप इनपुट पास नहीं करते हैं तो मेरा फ़्लॉइड समाधान बस अनंत काल तक लटका रहेगा। प्रतिस्पर्धा के लिए मेरे समाधान के लिए, आपको 5 शून्य पास करने होंगे और मुझे यह जांचना होगा कि क्या इनपुट शून्य हैं और तदनुसार उपचार करें ...? -1।
— यति
4
@ TheBitByte मेरी दूसरी टिप्पणी देखें कि मुझे क्या लगता है कि यह वास्तव में गलत है। अब जब कि आपने उसे संपादित किया, +1।
— यति
1
@ केविन यप। मुझे 'कोई इनपुट नहीं' की व्याख्या के साथ थोड़ा भ्रम हो रहा था। खाली स्ट्रिंग मेरे दिमाग में 'नो इनपुट' के बराबर नहीं है। और मुझे एक दुभाषिया के अंदर कोड को चलाने के लिए इस्तेमाल किया गया था, जिस पर मैं सचमुच इनपुट के खिलाए जाने की प्रतीक्षा करता हूं, इसलिए मैंने उसे वहीं फेंक दिया।
— यति

जवाबों:

6

05AB1E , 16 14 बाइट्स

Í×s.ø©|`×`»D®»

व्याख्या

Í×                  # create a string of the correct nr of horizontal chars
  s.ø               # add the corner char on both sides
     ©              # save in register while keeping it on the stack
      |`            # push the remaining inputs to the top of the stack
        ×`          # push the correct nr of vertical chars on the stack
          »         # join on newline (joining the top vertical and horizontal sections)
           D        # duplicate this
            ®       # push the horizontal part again
             »      # join everything on newline

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

अदनान की बदौलत 4 बाइट बच गईं।

— Emigna
स्रोत
1
जिज्ञासा से बाहर, आप ©रजिस्टर का उपयोग क्यों कर रहे हैं : पी?
— अदनान
1
@ अदनान: अच्छी पकड़! मैं जा रहा था, लेकिन इसका इस्तेमाल नहीं किया और इसे हटाने के लिए भूल गया :)
— एमिग्ना
1
@ मड्डीफिश: इस सवाल का स्पष्टीकरण पढ़ना कि वह हिस्सा स्पष्ट नहीं था, इसलिए मैंने इसे याद किया। मुझे बताने के लिए धन्यवाद!
— एमिग्ना
1
यहाँ एक विशेष सराउंड कमांड भी है जो यहाँ काम करता है Í×s.øU×S»X»D»Xr»:।
— अदनान
2
@ अदनान: सही है आप। अच्छी सोच! मैंने पहले कभी इसका इस्तेमाल नहीं किया है :)
— Emigna
6

पायथन, 53 51 55 बाइट्स

lambda a,b,c,d,e:d.join("\n"*-~b).join([c+e*(a-2)+c]*3)

+4 बाइट्स @ धन्यवाद करने के लिए धन्यवाद

अनाम लंबू फ़ंक्शन, इसे कॉल करने के लिए, f=इसके पहले लिखें । उदाहरण:

>>> print f(4,1,"€","|","-")
€--€
|
€--€
|
€--€

वैकल्पिक, 53 बाइट्स

lambda a,b,c,d,e:((c+e*a+c+"\n"+(d+"\n")*b)*3)[:-b*2]

कोई इनपुट के विशेष मामले के साथ पुराना संस्करण, 69 65 63 बाइट्स

चुनौतियों को मध्य चुनौती में बदलने के लिए ...

lambda a=1,b=1,(c,d,e)="+|-":d.join("\n"*-~b).join([c+e*a+c]*3)
— KarlKastor
स्रोत
2
छोटा बग: पहला तर्क ( 2आपके उदाहरण में) कोनों सहित लाइन की कुल लंबाई है, इसलिए आपके आकार के लिए सही इनपुट है f(4,1 ...)।
— nimi
@ टिप के लिए धन्यवाद। (+4 बाइट्स :() ओप्स पहला उदाहरण थोड़ा भ्रमित करने वाला है। (कुछ अन्य जवाबों में यह बग
— अस्वस्थ है
4

सी, 167 161 159 बाइट्स

हाँ। 

#define p putchar
i,j;g(a,c,e){p(c);for(i=2;i++<a;)p(e);p(c);p(10);}h(b,d){for(i=0;i++<b;){p(d);p(10);}}f(a,b,c,d,e){g(a,c,e);h(b,d);g(a,c,e);h(b,d);g(a,c,e);}

कुछ परीक्षण मामलों के साथ, आइडोन पर इसे आज़माएं

— betseg
स्रोत
2
डालता है ("") -> p ('\ n')? या यहां तक ​​कि पी (10) अगर वह काम करेगा
— रियाद
मुझसे यह चूक कैसे हुई! धन्यवाद, @RiaD।
— betseg
यदि आप 2 के साथ लूप शुरू करते हैं, तो आप अधिक बाइट्स में
— बचाएंगे
3

रूबी, 54 45 42 बाइट्स

->x,y,c,v,h{[c+h*~-~-x+c+$/]*3*((v+$/)*y)}

यह एक अनाम फ़ंक्शन है जो इनपुट के अलग-अलग हिस्से को अलग-अलग मापदंडों के रूप में लेता है और परिणाम को एक पूर्ण स्ट्रिंग के रूप में देता है।

उदाहरण के लिए,

f=->x,y,c,v,h{[c+h*~-~-x+c+$/]*3*((v+$/)*y)}
puts f[6, 2, 'Ø', 'V', '>']

प्रिंट 

Ø>>>>Ø
V
V
Ø>>>>Ø
V
V
Ø>>>>Ø
— daniero
स्रोत
3

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

(h,v,e,V,H)=>(v=(h=e+H.repeat(h-2)+e)+`
${V}`.repeat(v)+`
`)+v+h

उदाहरण

let f =
(h,v,e,V,H)=>(v=(h=e+H.repeat(h-2)+e)+`
${V}`.repeat(v)+`
`)+v+h

console.log(f(8,3,'+','@','#'))
स्निपेट का विस्तार करें

— Arnauld
स्रोत
क्या यह बिना इनपुट के विशेष मामले को संभालता है?
— कॉनर ओ'ब्रायन
{ "message": "Script error.", "filename": "", "lineno": 0, "colno": 0 }जब इनलाइन चलाते हैं।
— no --zɐɹƆ
@AgentCrazyPython - IE पर चलाएं? यह कोई समर्थन हासिल है के लिए.repeat()
— Arnauld
@ अर्नुलद नवा, सफारी
— noɐɹƆzɐɹƆ
ओह, यह ES6 है ...
— no it'szɐɹƆ
3

आर, 80 बाइट्स

बहुत दोहराव:

function(h,v,a,b,c)cat(t<-c(a,rep(c,h),a,"\n"),d<-rep(c(b,"\n"),v),t,d,t,sep="")

अधूरा:

function(h,v,a,b,c)

cat(t<-c(a,rep(c,h),a,"\n"),
    d<-rep(c(b,"\n"),v),
    t,d,t,
    sep="")
— फ़्रेडरिक
स्रोत
2

पायथ, 19 बाइट्स

jP*3,++Jw*-E2wJj*Ew

एक प्रोग्राम जो कोने के चरित्र के एसटीडीआईएन पर अलग-अलग इनपुट लेता है, क्षैतिज वर्णों की संख्या, क्षैतिज वर्ण, ऊर्ध्वाधर वर्णों की संख्या और ऊर्ध्वाधर चरित्र, और परिणाम प्रिंट करता है।

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

यह काम किस प्रकार करता है

jP*3,++Jw*-E2wJj*Ew  Program.
       Jw            Get the corner character. Store in J
           E         Get the number of horizontal characters
          - 2        -2
         *   w       Get the horizontal character and repeat it that many times
      +              Add J at the beginning of that
     +         J     and at the end
                 E   Get the number of vertical characters
                * w  Get the vertical character and repeat it that many times
               j     Join the above on newlines
    ,                Construct a 2-element list from the horizontal and vertical strings
  *3                 Repeat it 3 times
 P                   Everything except the last element
j                    Join the above on newlines
                     Implicitly print
— TheBikingViking
स्रोत
2

MATLAB, 95 92 91 85 81 बाइट्स

MATLAB 'E' फ़ंक्शन। (संपादित करें: ऑक्टेव पर काम नहीं करता है)

function a=e(n,m,c,h,v);a(1:n)=h;a=[c a c];a(2:m+1,1)=v;a=[a;a;a];a=a(1:3+2*m,:);

और अपुष्ट:

function a=e(n,m,c,h,v); %Declare the function
a(1:n)=h;                %Initialise return with top line excluding the corners
a=[c a c];               %Then add corner pieces
a(2:m+1,1)=v;            %Next add the first vertical part
a=[a;a;a];               %Repeat three times vertically to get an E with a tail
a=a(1:3+2*m,:);          %And then lop off the tail

समारोह को बुलाया जाना चाहिए:

e(5,2,'*','-','|')

जो लौटेगा:

+-----+
|      
|      
+-----+
|      
|      
+-----+

यह शायद थोड़ा सा सरल हो सकता है, मैं इस पर काम करता रहूंगा। मुझे इनपुट प्राप्त करने के लिए संपूर्ण फ़ंक्शन की घोषणा पसंद नहीं है, इसलिए मैं देखूंगा कि क्या मैं इसमें सुधार कर सकता हूं।

  • पहली पंक्ति की पीढ़ी को सरल बनाते हुए 3 बाइट्स को पहले कोनों के बिना रेखा बनायें और फिर कोनों को जोड़ें क्योंकि इससे कई बार अनुक्रमण की संख्या कम हो जाती है।

  • पहले कोने से शुरू करके एक और बाइट बचाई गई।

  • के repmat(a,3,1)साथ कॉल की जगह 6 और बाइट्स [a;a;a]।

  • aविशिष्ट आरंभ के बिना 4 बाइट्स सहेजे गए (यह पहले से ही फ़ंक्शन घोषणा में घोषित है) - धन्यवाद @LuisMendo

— टॉम बढ़ई
स्रोत
1
@LuisMendo दिलचस्प है। मैं मूल रूप a=[c a c]से वहाँ था , लेकिन चीजों को सिकोड़ने के लिए इसे हटा दिया क्योंकि आम तौर पर आप एक गैर-मौजूद चर का उपयोग नहीं कर सकते हैं और इसे प्रक्रिया में बना सकते हैं। मैं भूल गया कि यह एक फ़ंक्शन था इसलिए aपहले से ही फ़ंक्शन घोषणा में वापसी मूल्य के रूप में घोषित किया गया है। धन्यवाद :)
— टॉम कारपेंटर
वास्तव में आप इसे तब भी कर सकते हैं जब फ़ंक्शन में नहीं है - गैर-मौजूद चर को अनुक्रमणित करता है। हर दिन नई चीजें सीखें।
— टॉम कारपेंटर
2

पर्ल, 40 + 1 ( -n) = 41 बाइट्स

14 बाइट बचाने और 10 से अधिक प्रविष्टि के साथ काम करने के लिए कार्यक्रम की अनुमति देने के लिए @ टॉन हास्पेल का धन्यवाद ।

/.$/;$,=$/.<>x<>;say+($`.$&x(<>-2).$`)x3

आवश्यकता -nके साथ-साथ -E(या -M5.010) को चलाने के लिए। उदाहरण के लिए : 

perl -nE '/.$/;$,=$/.<>x<>;say+($`.$&x(<>-2).$`)x3' <<< '^$
!
4
9'
— बापू
स्रोत
1
@ TheBitByte ठीक है, बहुत अच्छा हुआ, धन्यवाद।
— दादा
2
यह पहले से ही बहुत अच्छा है। लेकिन आप इनपुट प्रारूप के साथ थोड़ा खेल सकते हैं और इस दोष को भी हल कर सकते हैं कि चुनौती यह नहीं कहती है कि रिपीट एक फाइल में < 10डालकर /(.)(.)/;$,=$' x<>;say+($1.$2x(<>-2).$1.$/)x3(क्योंकि यह उपयोग करता है $') और कॉल के साथ perl -M5.010 -n prog.pl <<< '^!S\n4\n9'(वास्तविक newlines का उपयोग करें) जो 48 बाइट्स के रूप में गिना जाता है (2 अतिरिक्त) बाधा क्योंकि इसे संयुक्त नहीं किया जा सकता है -e)
— टन हास्पेल
@ टोनहोस धन्यवाद। ठीक है, मैंने यह भी नहीं देखा था कि यह संख्याओं के साथ काम नहीं करेगा >10.. इनपुट प्रारूप के साथ महान काम, धन्यवाद।
— दादा
यह इनपुट फॉर्मेट का चयन करने की स्वतंत्रता का हनन करने के करीब perl -nE '/.$/;$,=$/.<>x<>;say+($`.$&x(<>-2).$`)x3' <<< '^$\n!\n4\n9'$'
— पहुंच रहा है
@ टोनहॉस्पेक्टली, मैं आपके पहले सुझाव के बाद उस समाधान के साथ आया था, लेकिन इनपुट प्रारूप के कारण मैं इसके साथ बहुत सहज नहीं था ... चूंकि हम दोनों ने इसके बारे में सोचा था, मैंने अपना उत्तर बदल दिया, लेकिन फिर भी, मुझे ऐसा लगता है यह थोड़ा धोखा है ...
— दादा
2

दिल्लोग एपीएल , 31 29 बाइट्स

उस क्रम में क्षैतिज-चरित्र, चौड़ाई, जंक्शन-चरित्र, ऊंचाई, ऊर्ध्वाधर-चरित्र के लिए संकेत।

h↓⊃⍪/3/⊂↑(⍞⍴⍨h←⎕),⊂⍞{∊⍺⍵⍺}⎕⍴⍞

⎕⍴⍞इनपुट-क्षैतिज-वर्ण और बार-बार इनपुट-चौड़ाई बार ( and नीचे)

⍞{... }इनपुट-जंक्शन-चरित्र जो हो जाएगा ⍺ समारोह में ...

 ∊⍺⍵⍺ समतल [[जंक्शन], [क्षैतिज], [जंक्शन]]

⊂ एनकैप्सुलेट तो यह एक सूची का हिस्सा हो सकता है

(... प्रस्तुत करें ),...

 h←⎕ इनपुट ऊंचाई

 ⍞⍴⍨ इनपुट-वर्टिकल-कैरेक्टर और इसे कई बार दोहराएं

↑ एक तार तालिका में तार की सूची बनाते हैं

⊂ इनकैप्सुलेट (इसलिए इसे पूरे के रूप में दोहराया जा सकता है)

3/ इसे तीन बार दोहराएं

╻  ╻  ╻
┗━ ┗━ ┗━

⍪/ तीन टुकड़ों को लंबवत रूप से समतल करें

╻
┣━
┣━
┗━

(यह उन्हें भी समझाया जाता है, इसलिए हमें इसकी आवश्यकता है ...)

⊃ इनकैप्सुलेशन हटा दें

h↓पहला एच छोड़ें (पंक्तियाँ)

┏━
┣━
┗━

TryAPL ऑनलाइन!

— एडम
स्रोत
2

सी, 130 बाइट्स

#define p putchar
#define E for(o=0;o++<O;p(10))p(S);
#define W for(p(P),D=0;D++<C-2;)p(_);p(P);p(10);
f(C,O,P,S,_,D,o){W E W E W}

उपयोग:

main(){f(7,2,'+','|','-');}

उत्पादन

+-----+
|
|
+-----+
|
|
+-----+
— जियाकोमो गारबेलो
स्रोत
defineएस में अर्धविरामों को निकालना और इसे जोड़ना f(C,O,P,S,_,D,o){W;E;W;E;W;}एक बाइट बचाता है।
— betseg
2

सी #, 108 बाइट्स

(m,n,e,v,h)=>{string x=e+new string(h,m-2)+e+"\n",y=new string(v,n).Replace(v+"",v+"\n");return x+y+x+y+x;};

बेनामी फ़ंक्शन जो प्रत्येक क्षैतिज और ऊर्ध्वाधर रेखा उत्पन्न करता है और अंतिम आउटपुट बनाता है।

अनप्लग्ड फ़ंक्शन:

(m,n,e,v,h)=>
{
    string x = e + new string(h, m - 2) + e + "\n",
        y = new string(v, n).Replace(v + "", v + "\n");
    return x + y + x + y + x;
};

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;

namespace LetterEWithoutE
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,int,char,char,char,string>f= (m,n,e,v,h)=>{string x=e+new string(h,m-2)+e+"\n",y=new string(v,n).Replace(v+"",v+"\n");return x+y+x+y+x;};

            Console.WriteLine(f(7,2,'+','|','-'));
            Console.WriteLine(f(7,2,'@','|','-'));
            Console.WriteLine(f(7,2,'@','|','#'));
            Console.WriteLine(f(8,3,'+','|','#'));
            Console.WriteLine(f(8,3,'+','@','#'));
            Console.WriteLine(f(9,4,'^','$','!'));
        }
    }
}
— adrianmp
स्रोत
2

MATL , 15 बाइट्स

एक सुधार के लिए @muddyfish को धन्यवाद

2-Y"yv!iiY"!yyy

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

व्याख्या

चुनौती के पहले उदाहरण का उपयोग करते हुए, प्रत्येक चरण के बाद स्टैक सामग्री को स्पष्टता के लिए संकेत दिया जाता है।

2-    % Implicitly input number of repetitions of the char of the horizontal line.
      % Subtract 2
      %   STACK: 5
Y"    % Implicitly input char of the horizontal line. Apply run-length decoding
      %   STACK: '-----' (string)
y     % Implicitly input (from below) the char of the corners. Duplicate onto the top
      %   STACK: '+', '-----', '+'
v!    % Concatenate all the stack horizontally. We now have the horizontal line
      % including the corners
      %   STACK: '+-----+'
iiY"  % Take two inputs: char of the vertical line and number of repetitions
      %   STACK: '+-----+', '||'
!     % Transpose. This tranforms the string into a vertical char array, which
      % gives the vertical line
      %   STACK: '+-----+', ['|';'|'] (vertical char array)
y     % Duplicate from below: this pushes a new copy of the horizontal line
      % onto the top of the stack
      %   STACK: '+-----+', ['|';'|'], '+-----+'
y     % Duplicate from below: this pushes a new copy of the vertical line
      % onto the top of the stack
      %   STACK: '+-----+', ['|';'|'], '+-----+', ['|';'|'],
y     % Duplicate from below: this pushes a new copy of the horizontal line
      % onto the top of the stack
      %   STACK: '+-----+', ['|';'|'], '+-----+', ['|';'|'], '+-----+'
      % Implicitly display
— लुइस मेंडो
स्रोत
1

बैश + कोरुटिल्स, 105 बाइट्स

printf -- "$3`printf -- "$4%.0s" $(seq $1)`$3`printf "\n$5%.0s" $(seq $2)`%.0s\n" {1..3}|sed -n 1,$(($2*2+3))p

जिस फ़ाइल में यह संग्रहीत है उसका नाम मानते हुए A.sh, इसका उपयोग होगा:

bash A.sh <Horizontal Segment Length w/out Edge Chars> <Vertical Segment Length> '<Left/Right Edge Char>' '<Char Between Edges>' '<Vertical Char>'

--की जरूरत है, सिर्फ मामले में चरित्र आदानों की एक एक होता है -, और printfजाहिरा तौर पर एक स्ट्रिंग के बिना डबल डैश बहुत अच्छी की शुरुआत में डैश संभाल नहीं करता है।

व्याख्या

यह मानते हुए कि इनपुट है 5 2 + * |...

  1. $3printf -- "$4%.0s" $(seq $1)$3printf "\n$5%.0s" $(seq $2)

    पहले क्षैतिज खंड और ऊर्ध्वाधर खंड को एक साथ बनाएं। यह परिणाम होगा:

    +*****+
|
|

  2. printf -- "$3printf -- "$4%.0s" $(seq $1)$3printf "\n$5%.0s" $(seq $2)%.0s\n" {1..3}

    पहले बनाए गए भाग को 3बार-बार दोहराएं । अब यह परिणाम है:

    +*****+
|
|
+*****+
|
|
+*****+
|
|

  3. printf -- "$3printf -- "$4%.0s" $(seq $1)$3printf "\n$5%.0s" $(seq $2)%.0s\n" {1..3}|sed -n 1,$(($2*2+3))p

    अंत sedमें पिछले 2 लाइन सेगमेंट से छुटकारा पाने के लिए पिछले आउटपुट को पाइप करें, केवल पहली <Vertical Segment Length>*2+3लाइनों को आउटपुट करके E। हम आखिरकार Eहम चाहते हैं:

    +*****+
|
|
+*****+
|
|
+*****+
— आर। कप
स्रोत
1

PowerShell v2 +, 60 59 बाइट्स

param($a,$b,$c,$d,$e)(,($x="$c$($e*($a-2))$c")+,$d*$b)*2;$x

व्यक्तिगत कमांड-लाइन तर्कों के रूप में इनपुट लेता है। क्षैतिज स्ट्रिंग का निर्माण करता है, जो $xबाद में उपयोग के लिए संग्रहीत करता है , फिर अल्पविराम के साथ एक सरणी में बनाता है ,। सरणी संघनन (यानी, तत्वों को अंत तक जोड़ना) तत्वों $dकी एक सरणी में $bकरता है। बदले में, एक अन्य अल्पविराम ऑपरेटर के साथ दो तत्वों की एक सरणी में तैयार की जाती है, और पाइप लाइन पर छोड़ दिया जाता है। फिर, क्षैतिज $xपाइप लाइन पर छोड़ दिया जाता है। Write-Outputतत्वों के बीच एक नई रेखा डालने के लिए डिफ़ॉल्ट स्वरूपण का दुरुपयोग करता है ।

उदाहरण

PS C:\Tools\Scripts\golfing> .\the-letter-e-without-e.ps1 5 3 "z" "v" "d"
zdddz
v
v
v
zdddz
v
v
v
zdddz
— AdmBorkBork
स्रोत
1

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

एक समारोह

def p(a,b,c,d,e):q=c+e*(a-2)+c;return(q+'\n'+(d+'\n')*b)*2+q

परीक्षण का मामला

>>> print(p(8,2,'+','|','#'))
+######+
|
|
+######+
|
|
+######+
— डिग्निसिमस - स्पैमी
स्रोत
आपके पास आउटपुट में 2 बहुत सारे डैश हैं
— ब्लू
1

ब्रेनफ * ck, 147 बाइट्स

,>,>++++++++[<------<------>>-]<<-->>>,>,>,>+++>++>++++++++++<<[-<<<.<<<[->>+>>>.<<<<<]>>[-<<+>>]>.>>>>>.<[-<<<<<<[->+>>.>>>>.<<<<<<<]>[<+>-]]>>>>]

पहले 5 अक्षरों में प्रवेश करते ही स्टडिन से इनपुट लेता है। पहले दो को ASCII कोड से 48 घटाया गया है, इसलिए 0-9 उम्मीद के मुताबिक व्यवहार करते हैं। संख्या> 9 के लिए, संख्या में 48 जोड़ें और संबंधित वर्ण का उपयोग करें। अन्य तीन वर्ण चुनौती में निर्दिष्ट हैं।

मुझे यकीन है कि यह इष्टतम समाधान नहीं है, लेकिन जीवन गोल्फ ब्रेनफ * ck से बहुत कम है।

टिप्पणियों के साथ:

[
    Input: number number corner vertical horizontal
    Numbers are single digits; add 48 and use the ASCII character corresponding
    to the number you want for numbers > 9.
    First number is the number of characters across. Second is the number down.

    Layout: {first number-2} {second number} {temp} {a} {b} {c}
]

,>,>++++++++[<------<------>>-]<<-->>>,>,>,
now we should have the first five cells with the specified layout
the 6th will hold 3 as a counter and the 7th 2 and the 8th 10 '\n'

>+++>++>++++++++++<<
[  while the 6th cell is not 0
    -
    <<<.    print corner
    <<<[->>+>>>.<<<<<]  print horizontal characters
    >>[-<<+>>]         copy temp back to 1st cell
    >.>>>>>.           print corner and newline
    <
    [ If the second counter is not zero
        -
        <<<<<<[->+>>.>>>>.<<<<<<<]  print vertical and newline n times
        >[<+>-]           copy temp back to 2nd cell
    ]
    >>>>
]

उदाहरण रन:

sean@SEANSBOX:~/Dropbox/Code/BF$ ./bf E.b
94^$!
^!!!!!!!^
$
$
$
$
^!!!!!!!^
$
$
$
$
^!!!!!!!^
— सीन मैकबेन
स्रोत
1

PHP, 97 बाइट्स

list(,$w,$h,$c,$v,$r)=$argv;echo$b=str_pad($a=str_pad($c,++$w,$r)."$c\n",--$h*2+$w,"$v\n"),$b,$a;

कोई लूप नहीं, केवल बिल्डिंस।

के साथ भागो php -r '<code>' <parameters>।

— टाइटस
स्रोत
1

जावा 7, 205 129 बाइट्स

String c(int w,int h,String a,char b,char c){String r=a,n="\n",l="";for(;w-->2;r+=c);r+=a+n;for(;h-->0;l+=b+n);return r+l+r+l+r;}

-76 बाइट्स एक अनाम अजनबी के लिए धन्यवाद।
पुनश्च: अगली बार अन्य लोगों के पोस्ट संपादित न करें। यदि आपके पास गोल्फ के लिए कुछ है तो कृपया इसे एक टिप्पणी के रूप में छोड़ दें, या यदि यह पूरी तरह से अलग दृष्टिकोण का उपयोग कर रहा है तो आप अपना जवाब दे सकते हैं। फिर भी इन सभी बाइट्स को दूर करने के लिए धन्यवाद, हालांकि - आप जो भी हैं ..

अनगढ़ और परीक्षण के मामले:

इसे यहाँ आज़माएँ।

class M {
    static String c(int w, int h, String a, char b, char c){
        String r = a,
               n = "\n",
               l = "";
        for(; w-- > 2; r += c);
        r += a+n;
        for( ;h-- > 0; l += b+n);
        return r+l+r+l+r;
    }

    public static void main(String[] a) {
        System.out.print(c(7, 2, "+", '|', '-'));
        System.out.print(c(9, 4, "?", '¡', '¿'));
    }
}

आउटपुट:

+-----+
|    
|    
+-----+
|    
|    
+-----+

?¿¿¿¿¿¿¿?
¡      
¡      
¡      
¡      
?¿¿¿¿¿¿¿?
¡      
¡      
¡      
¡      
?¿¿¿¿¿¿¿?
— केविन क्रूज़सेन
स्रोत
0

रैकेट 124 बाइट्स

(λ(w h a b c)(for((i 3))(display a)(for((i w))(display c))(display a)(when(< i 2)(displayln "")(for((j h))(displayln b)))))

अधिक पठनीय रूप: 

(define(f w h a b c)
  (for((i 3))
    (display a)
    (for((i w))
      (display c))
    (display a)
    (when(< i 2)
      (displayln "")
      (for((j h))
        (displayln b)))))

परिक्षण:

(f 7 2 "+" "|" "-" )

+-------+
|
|
+-------+
|
|
+-------+
— rnso
स्रोत
0

सी ++, 121 बाइट्स

#import<string>
#import<iostream>
#define f(w,h,C,W,H){std::string s(w,W),t;s=C+s+C+"\n";for(int i=h;i--;)t=t+H+"\n";std::cout<<s+t+s+t+s;}

Ungolfed:

#import<string>
#import<iostream>
#define f(w,h,C,W,H){
    std::string s(w,W),t;  //define two strings, one empty, one with horizontal characters
    s = C+s+C+"\n";        //assemble a horizontal bar
    for(int i=h;i--;) 
        t=t+H+"\n";        //assemble a vertical bar
    std::cout<<s+t+s+t+s;  //print
}

C ++ में इसके सी के रूप में टाइप के बिना फ़ंक्शन घोषित करने की अनुमति नहीं है। लेकिन फ़ंक्शन की तरह व्यवहार करने वाले मैक्रोज़ पूरी तरह से संभव हैं। यह भी ध्यान दें कि जब तक आप प्रत्येक "लेकिन" मैक्रो की अंतिम पंक्ति नहीं जोड़ते हैं, तब तक ungolfed संस्करण संकलित नहीं होगा। आप {} को हटाकर दो अतिरिक्त बाइट्स बचा सकते हैं, लेकिन फिर आप एक पंक्ति में दो बार मैक्रो का उपयोग नहीं कर सकते।

उपयोग:

int main() {
    f(4,2,'+','-','|')
    f(2,1,'@','#','i')
    return 0;
}

आउटपुट:

+----+
|
|
+----+
|
|
+----+
@##@
i
@##@
i
@##@

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

— Anedar
स्रोत
0

सीजेएम , 23 बाइट्स

riri)N*r2*\r*\@r**a3*\*

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

इनपुट दिए गए क्रम में है, लेकिन कॉमा का उपयोग करने के बजाय अलग होना चाहिए। सीजेएम के ऑपरेशन में शामिल होने के* लिए कुछ कठिनाई इनपुट को सही क्रम दे रही है ; तुलना के लिए इनपुट को पुनर्व्यवस्थित करने से 4 बाइट्स बचाए जा सकते हैं ।

यदि इनपुट को डब किया जाता है, A B C D Eतो प्रोग्राम कुछ इस तरह से काम करता है:

ri     e# get A as integer
ri)N*  e# create B+1 newlines
r2*    e# create 2 Cs
\r*    e# join newlines with D (hereafter ND)
\@     e# bring A & Cs to the front
r*     e# create A Es
*      e# join, puts Es between Cs (hereafter CEC)
a3*    e# makes 3 copies of CEC strings
\*     e# join, puts NDs between CECs
— लीनुस
स्रोत
0

लूआ (5.2), 144 बाइट्स

k,a,p,q=loadstring,arg,io.write,print l,d=k"for i=3,a[1]do p(a[5])end",k"for i=1,a[2]do q(a[4])end"b=a[3]p(b)l()q(b)d()p(b)l()q(b)d()p(b)l()p(b)

इसे ऑनलाइन आज़माएं! (कोडिंग ग्राउंड)

यह कुछ इस तरह उत्पादन करना चाहिए:

+@@@@@+
l
l
+@@@@@+
l
l
+@@@@@+

खुद का इनपुट: 7 2 + l @

आप इनपुट को प्रोजेक्ट में बदल सकते हैं-> विकल्पों को संकलित करें और मानों को बदल दें, प्रत्येक मान उदाहरण के रूप में लेकिन अल्पविराम से नहीं बल्कि रिक्त स्थान से अलग किया गया है।

— Lycea
स्रोत
0

QBIC, 44 बाइट्स

::;;;X=A[q,a-2|X=X+C]X=X+A ?X[1,2|[1,b|?B]?X

व्याख्या

::;;;                 Get the input parameters, 2 numbers and 3 strings
X=A[q,a-2|X=X+C]X=X+A Build the horizontal string: The corner string, x-2 times the filler string and another corner
?X                    Print the horizontal string
[1,2|                 Do the next thing twice
[1,b|?B]?X            Print the right number of vertical strings, then the horizontal string.
— steenbergh
स्रोत
0

PHP, 94 बाइट्स

<?list($v,$h,$p,$d,$r)=$_GET[a];for($h++;$i<=2*$h;)echo$i++%$h?$d:str_pad($p,$v-1,$r).$p,"\n";

सुझाए गए स्ट्रिंग के समान क्रम में एक सरणी को इनपुट स्वरूपित करें

— जार्ग हुल्सरमैन
स्रोत
यदि आप ,"\n"इसके बजाय का उपयोग करते हैं ."\n", तो आप टेर्नेरी के लिए परनों को गिरा सकते हैं।
— टाइटस
for($h++;$i<=2*$h;)और $i++%$hएक और बाइट बचाता है।
— टाइटस
$v-1के लिए केवल 3 क्षैतिज वर्ण देता है [5,2,+,|,-]। क्षैतिज वर्णों की संख्या, बाएं और दाएं किनारे के वर्ण शामिल नहीं हैं
— टाइटस
@ सही है कि, मैं अपने संपादन रोलबैक है। 5 क्षैतिज का मतलब 2 अक्षरों के साथ 3 वर्ण = 5. प्रश्न को देखो। और अन्य विचारों के लिए धन्यवाद
— Jörg Hülsermann
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.