19

मुझे एक s'more बनाओ ! मैं आपको चौड़ाई, ग्रैहम पटाखा की मात्रा, चॉकलेट की मात्रा और मार्शमॉलो की मात्रा बताता हूं। एक उदाहरण:

इनपुट:

चौड़ाई: 10 ग्राहम: 3 चॉकलेट: 2 मार्शमैलो 1:।

आउटपुट:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG

क्या यह इतना आसान है? उम ... हाँ।

ध्यान दें कि इनपुट एक फ़ंक्शन या प्रोग्राम के लिए तर्कों की एक सूची होनी चाहिए, न कि एक स्ट्रिंग। आप पहले चौड़ाई, फिर ग्राहम को चुन सकते हैं, लेकिन कोई भी आदेश ठीक है।

पूर्ण परीक्षण के मामले यदि आप रुचि रखते हैं।

स्टैक स्निपेट (परीक्षण आदि के लिए)

यह आउटपुट का परीक्षण करना है।

var smore = function(width, graham, chocolate, marshmallow){
	return ("G".repeat(width) + "\n").repeat(graham) + 
	("C".repeat(width) + "\n").repeat(chocolate) + 
	("M".repeat(width) + "\n").repeat(marshmallow) + 
	("G".repeat(width) + "\n").repeat(graham);
};
Snippetify(smore);

<script src="https://programmer5000.com/snippetify.min.js"></script>
Width: <input type = "number">
Graham: <input type = "number">
Chocolate: <input type = "number">
Marshmallow: <input type = "number">
<button>Try it out!</button>
<pre data-output></pre>

स्निपेट का विस्तार करें

आप अंतिम पंक्ति के अंत में एक अनुगामी न्यूलाइन शामिल कर सकते हैं। आप \एक नई पंक्ति के बजाय भी उपयोग कर सकते हैं ।
यह कोड-गोल्फ है ।
कोई सवाल? नीचे टिप्पणी करें:

code-golf ascii-art

— programmer5000
स्रोत

21

मैंने आपके लेट मी गूगल दैट फॉर यू लिंक को संपादित किया। यह वास्तव में मजाकिया नहीं था।

— लेवल रिवर सेंट

1

@FelipeNardiBatista हाँ।

— प्रोग्रामर

1

कुछ जवाब लचीले इनपुट ऑर्डर और प्रारूप (पीपीसीजी में सामान्य रूप से) मान रहे हैं, लेकिन चुनौती के लिए एक विशिष्ट आदेश की आवश्यकता होती है और स्ट्रिंग्स को नियमबद्ध करना चाहिए (यह सुनिश्चित नहीं है कि इसका क्या मतलब है)। क्या आप स्पष्ट कर सकते हो?

— लुइस मेंडो

2

स्पष्टीकरण देने के लिए धन्यवाद। फिर आपको उस वाक्य को फिर से लिखना चाहिए जो इनपुट में किसी फ़ंक्शन या प्रोग्राम के तर्कों की एक सूची होनी चाहिए, न कि एक स्ट्रिंग के साथ, पहले चौड़ाई, फिर ग्राहम, आदि । व्यक्तिगत रूप से मैं कुछ ऐसा कहूंगा कि "इनपुट प्रारूप हमेशा की तरह लचीला है"

— लुइस मेंडो

4

@ प्रोग्रामर 5000 लेकिन क्यों? अगर वे कम हो गए, तो इसकी संभावना 90% है क्योंकि उन्हें लगता है कि यह एक उबाऊ और तुच्छ चुनौती है। इसके अलावा, लोगों को समझाने या पीछे हटने के लिए कहना काफी अशिष्ट है। उन्हें बिना टिप्पणी के अपमान करने का अधिकार है।

— R

2

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

ṁ4“GCMG”x×Y

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

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

ṁ4“GCMG”x×Y  Main link. Left argument: g, c, m. Right argument: w

ṁ4           Mold 4; repeat g, c, m until length 4 is reached. Yields [g, c, m, g].
  “GCMG”x    Repeat 'G' g times, then 'C' c times, then 'M' m times, and finally
             'G' g times. This yields a string.
         ×   Multiply each character w times. This is essentially a bug, but
             Jelly's × behaves like Python's * (and vectorizes), so it can be
             abused for character repetition.
          Y  Join, separating by linefeeds.

— डेनिस
स्रोत

13

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

lambda w,g,c,m:zip(*['G'*g+'C'*c+'M'*m+'G'*g]*w)

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

उत्तर के ट्रांसपोज़्ड संस्करण बनाता है, की तुलना में इसे सही प्रारूप में स्थानांतरित करता है zip(*l)

— फेलिप नारदी बतिस्ता
स्रोत

8

05AB1E , 21 19 19 बाइट्स

"GCMG"S×|D«‚øvy`.D»

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

-2 मेरी निगाह और एमिगा के लिए धन्यवाद।

"GCMG"S×            # Push GCMG, separate, duplicate n times.
        |D«         # Push rest of inputs, doubled.
           ‚ø       # Wrap GCMG array and input array, then zip them into pairs.
             vy`.D» # For each pair, print n of G/C/M/G.

(देखें एमिग्ना का जवाब, यह बेहतर है: /codegolf//a/116787/59376 )

— जादू ऑक्टोपस Urn
स्रोत

1

आपको लगता है कि गलती ©से वहाँ एक छोड़ दिया है ।

— एमिग्ना

1

तुम भी बदल सकते ¬¸के साथ Dके रूप में अतिरिक्त तत्वों खो रहे हैं जब आप ज़िप।

— एमिग्ना

@Emigna मुझे पसंद है और उस कार्यक्षमता से नफरत है।

— मैजिक ऑक्टोपस Urn

हाँ, यह अक्सर बहुत कष्टप्रद होता है लेकिन अब और फिर (जैसे अब) यह उपयोगी हो जाता है :)

— एमिग्ना

8

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

(W,G,C,M)=>[...'GCMG'].map(X=>`${X.repeat(W)}
`.repeat(eval(X))).join``

Woohoo, 3 अन्य जावास्क्रिप्ट उत्तरों को हरा देता है!

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

f=
(W,G,C,M)=>[...'GCMG'].map(X=>`${X.repeat(W)}
`.repeat(eval(X))).join``

console.log(
    f(10, 3, 2, 1)
)

स्निपेट का विस्तार करें

— darrylyeo
स्रोत

अच्छा, बहुत अच्छा - मेरा वोट मिलता है।

— झबरा

7

MATL , 17 बाइट्स

'GCMG'iK:)Y"!liX"

इनपुट प्रारूप है: पहला इनपुट [G, C, M], दूसरा इनपुट W।

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

उदाहरण सहित व्याख्या

आदानों पर विचार करें [3 2 1] और 10।

'GCMG' % Push this string
       % STACK: 'GCMG'
i      % Take first input: array of three numbers
       % STACK: 'GCMG', [3 2 1]
K:     % Push [1 2 3 4]
       % STACK: 'GCMG', [3 2 1], [1 2 3 4]
)      % Index (modular, 1-based). This repeats the first entry of the input array
       % STACK: 'GCMG', [3 2 1 3]
Y"     % Run-length decoding
       % STACK: 'GGGCCMGGG'
!      % Transpose. Gives a column vector of chars
       % STACK: ['G'; 'G'; 'G'; 'C'; 'C'; 'M'; 'G'; 'G'; 'G']
l      % Push 1
       % STACK: ['G'; 'G'; 'G'; 'C'; 'C'; 'M'; 'G'; 'G'; 'G'], 1
i      % Take second input: number
       % STACK: ['G'; 'G'; 'G'; 'C'; 'C'; 'M'; 'G'; 'G'; 'G'], 1, 10
X"     % Repeat the specified numbers of times along first and second dimensions
       % STACK: ['GGGGGGGGGG';'GGGGGGGGGG';'GGGGGGGGGG';'CCCCCCCCCC';...;'GGGGGGGGGG']
       % Implicitly display

— लुइस मेंडो
स्रोत

7

सी # , 204 बाइट्स

golfed

(w,g,c,m)=>{string G="\n".PadLeft(++w,'G'),C="\n".PadLeft(w,'C'),M="\n".PadLeft(w,'M'),o="".PadLeft(g,'G');o+="".PadLeft(m,'M')+"".PadLeft(c,'C')+o;return o.Replace("G",G).Replace("C",C).Replace("M",M);};

Ungolfed

( w, g, c, m ) => {
   string
      G = "\n".PadLeft( ++w, 'G' ),
      C = "\n".PadLeft( w, 'C' ),
      M = "\n".PadLeft( w, 'M' ),
      o = "".PadLeft( g, 'G' );

   o +=
      "".PadLeft( m, 'M' ) +
      "".PadLeft( c, 'C' ) +
      o;

   return o
      .Replace( "G", G )
      .Replace( "C", C )
      .Replace( "M", M );
};

पढ़ने योग्य अनगढ़

// Function with 4 parameters
//   w : Width
//   g : Graham
//   c : Chocolate
//   m : Marshmallow
( w, g, c, m ) => {

   // Initialization of vars with the contents
   //    of each line, with a new line at the end
   string
      G = "\n".PadLeft( ++w, 'G' ),
      C = "\n".PadLeft( w, 'C' ),
      M = "\n".PadLeft( w, 'M' ),

      // Trick to reduce the byte count
      //   Initialize the output with n 'G's
      o = "".PadLeft( g, 'G' );

   // Add again n 'M's and n 'C's
   //   Append the 'G's at the end.
   o +=
      "".PadLeft( m, 'M' ) +
      "".PadLeft( c, 'C' ) +
      o;

   // Replce every instance of 'G'/'C'/'M'
   //    with the full line
   return o
      .Replace( "G", G )
      .Replace( "C", C )
      .Replace( "M", M );
};

पूर्ण कोड

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<Int32, Int32, Int32, Int32, String> f = ( w, g, c, m ) => {
            string
               G = "\n".PadLeft( ++w, 'G' ),
               C = "\n".PadLeft( w, 'C' ),
               M = "\n".PadLeft( w, 'M' ),
               o = "".PadLeft( g, 'G' );

            o +=
               "".PadLeft( m, 'M' ) +
               "".PadLeft( c, 'C' ) +
               o;

            return o
               .Replace( "G", G )
               .Replace( "C", C )
               .Replace( "M", M );
         };

         List<Tuple<Int32, Int32, Int32, Int32>>
            testCases = new List<Tuple<Int32, Int32, Int32, Int32>>() {
               new Tuple<Int32, Int32, Int32, Int32>( 1, 1, 1, 1 ),
               new Tuple<Int32, Int32, Int32, Int32>( 1, 1, 1, 2 ),
               new Tuple<Int32, Int32, Int32, Int32>( 1, 1, 2, 1 ),
               //
               // ...
               //
               // The link above contains the code ready to run
               //    and with every test from the pastebin link
               //
               // Yes, it contains 342 tests ready to run.
               //
               // I can barely fit every test on a 1080p screen...
               //    ... and there's 6 tests per line... Jebus...
               //
            };

         foreach( var testCase in testCases ) {
            Console.WriteLine( $"Input:\nWidth: {testCase.Item1,3} Graham: {testCase.Item2,3} Chocolate: {testCase.Item3,3} Marshmellow: {testCase.Item4,3}\nOutput:\n{f( testCase.Item1, testCase.Item2, testCase.Item3, testCase.Item4 )}\n" );
         }

         Console.ReadLine();
      }
   }
}

विज्ञप्ति

v1.0 - 204 bytes- प्रारंभिक समाधान।

मेरे सुंदर परीक्षण स्क्रीन की एक तस्वीर के लिए खोज रहे हैं?
एक दूसरे विचार पर, CSharpPad उन परीक्षणों को संभाल नहीं सकता है, यहाँ कम परीक्षणों के साथ एक संस्करण है

— auhmaan
स्रोत

की सराहना की! : डी

— औहामन

7

05AB1E , 17 16 बाइट्स

1 बाइट्स ने कारुसोकोम्प्यूटिंग के लिए धन्यवाद बचाया ।

"GCMG"S×vy²Nè.D»

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

इनपुट ऑर्डर है W, [G,C,M]

व्याख्या

10, [3,2,1] उदाहरण के रूप में इस्तेमाल किया।

"GCMG"S           # push the list ['G','C','M','G']
       ×          # repeat each W times
                  # STACK: ['GGGGGGGGGG', 'CCCCCCCCCC', 'MMMMMMMMMM', 'GGGGGGGGGG']
        v         # for each [string, index] y,N in the list
          ²Nè     # get the amount of layers at index N from the [G,C,M] list
         y   .D   # duplicate the string y that many times
               »  # join strings by newlines

— Emigna
स्रोत

1

"GCMG"S×vy²Nè.D»आश्चर्य-जुड़वाँ शक्तियाँ, सक्रिय! 05AB1E कोड का फॉर्म! इसके अलावा, तर्क की अदला-बदली होती है, लेकिन यह अभी भी 16 है।

— मैजिक ऑक्टोपस Urn

@ क्रूसोकोम्पुटिंग: यह स्टैक पर अनियंत्रित बकवास नहीं छोड़ने का लाभ है, लेकिन यह मेरे लिए समान रूप से अप्रासंगिक लगता है।

— एमिग्ना

1

यह अभी भी 1 बाइट कम है और MATL के साथ आपकी टाई को हरा देगा;)।

— मैजिक ऑक्टोपस Urn

@carusocomputing: ऊह, ऐसा कब हुआ? मुझे यकीन था कि जब मैंने इसे देखा था तो यह 17 साल का था। अच्छा! ;)

— इमिग्ना

मैं अक्सर बेवकूफ चीजें पोस्ट करता हूं और मुझे यह महसूस करने के 1 मिनट बाद संपादन करता है कि मैं एक बेवकूफ हूं।

— मैजिक ऑक्टोपस Urn

6

रूबी, 47 बाइट्स

->w,g,c,m{puts r=[?G*w]*g,[?C*w]*c,[?M*w]*m,r}

वेंचरो को धन्यवाद

रूबी, 51 बाइट्स

->w,g,c,m{(?G*g+?C*c+?M*m+?G*g).chars{|i|puts i*w}}

इस तरह से कॉल करें:

f=->w,g,c,m{(?G*g+?C*c+?M*m+?G*g).chars{|i|puts i*w}}

f[10,3,2,1]

— स्तर नदी सेंट
स्रोत

->w,g,c,m{puts r=[?G*w]*g,[?C*w]*c,[?M*w]*m,r}थोड़ा छोटा है

— वेंटरो

5

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

$a,$b=$args;0..2+0|%{,("$('GCM'[$_])"*$a)*$b[$_]}

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

चार कमांड-लाइन तर्कों के रूप में इनपुट लेता है, width graham chocolate marshmallowपहले $aऔर बाकी को संग्रहीत करता है $b(संक्षेप में एक सरणी के रूप में)। सीमा से अधिक लूप 0,1,2,0। प्रत्येक लूप, हम स्ट्रिंग में इंडेक्स करते हैं GCM, charएक स्ट्रिंग के रूप में फिर से कास्ट करते हैं , और इसे $a(चौड़ाई) से गुणा करते हैं , और फिर कॉमा-ऑपरेटर का उपयोग करते हुए ,, एक सरणी में बदल जाता है, जिसका उपयुक्त इंडेक्स गुणा करके $b(यानी, कितने परतों)। उन परिणामी स्ट्रिंग सरणियों को पाइपलाइन पर छोड़ दिया जाता है और आउटपुट निहित होता है, तत्वों के बीच एक नई रेखा के साथ।

— AdmBorkBork
स्रोत

5

सी, 108 105 बाइट्स

3 बाइट बचाने के लिए @ क्वेंटिन को धन्यवाद!

#define F(i,c)for(;i--;puts(""))for(j=w;j--;)putchar(c);
i,j;f(w,g,c,m){i=g;F(i,71)F(c,67)F(m,77)F(g,71)}

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

— Steadybox
स्रोत

1

#define F(i,c)for(;i--;puts(""))for(j=w;j--;)putchar(c);तीन बाइट्स बचाता है :)

— क्वेंटिन

@ क्वेंटिन धन्यवाद! मुझे आश्चर्य है कि मैंने पहले स्थान पर क्यों याद किया :)

— स्टेडीबॉक्स

4

बैच, 146 बाइट्स

@set s=
@for /l %%i in (1,1,%1)do @call set s=G%%s%%
@for %%w in (%2.%s% %3.%s:G=C% %4.%s:G=M% %2.%s%)do @for /l %%i in (1,1,%%~nw)do @echo%%~xw

इस के अस्पष्ट व्यवहार पर निर्भर करता echoहै कि यह अक्सर बीच के प्रतीक को अनदेखा echoकर सकता है और चार छोरों को एक नेस्टेड लूप में ढहने के लिए पाठ को प्रतिध्वनित किया जा सकता है।

— नील
स्रोत

4

वी , 22 बाइट्स

éGÄÀäjMoC
MÀÄkÀÄHdêÀP

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

Hexdump:

00000000: e947 c4c0 e46a 4d6f 430a 4d1b c0c4 6bc0  .G...jMoC.M...k.
00000010: c448 64ea c050                           .Hd..P

इनपुट ऑर्डर है

Graham, Marshmallow, Chocolate, Width

स्पष्टीकरण:

éG                  " Insert 'G'
  Ä                 " Duplicate this line
   Àäj              " *arg1* times, duplicate this line and the line below it
      M             " Move to the middle line
       o            " Open up a newline, and enter insert mode
        C<cr>M<esc> " Insert 'C\nM'
ÀÄ                  " Make *arg2* copies of this line (Marshmallow)
  k                 " Move up one line
   ÀÄ               " Make *arg3* copies of this line (Chocolate)
     H              " Move to the first line
      dê            " Delete this column
        ÀP          " And paste it horizontally *arg4* times

— DJMcMayhem
स्रोत

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— प्रोग्रामर

@ प्रोग्रामर 5000 ज़रूर! मेरे संपादन देखें

— DJMcMayhem

4

एक्सेल, 104 बाइट्स

ओह यार! एक सूत्र जिसमें लाइन ब्रेक की आवश्यकता होती है।

=REPT(REPT("G",A1)&"
",A2)&REPT(REPT("C",A1)&"
",A3)&REPT(REPT("M",A1)&"
",A4)&REPT(REPT("G",A1)&"
",A2)

A1है चौड़ाई
A2है ग्राहम
A3चॉकलेट है
A4 है, मल्लो है

यदि पूर्व-स्वरूपण की अनुमति है, तो आप कार्यक्षेत्र पाठ के लिए कक्ष को प्रारूपित कर सकते हैं और सूत्र को 65 बाइट्स तक छोटा कर सकते हैं:

=REPT(REPT("G",A2)&REPT("C",A3)&REPT("M",A4)&REPT("G",A2)&"
",A1)

— इंजीनियर टोस्ट
स्रोत

4

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

“GCM”ẋ"ṁ4Fẋ€Y

एक रंग कार्यक्रम। इनपुट्स हैं: [Graham's, Chocolates, Marshmallows], Width।

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

कैसे?

“GCM”ẋ"ṁ4Fẋ€Y - Main link: [g,c,m], w    e.g. [1,2,1], 2
“GCM”         - literal ['G', 'C', 'M']
      "       - zip that and [g,c,m] with the dyadic operation:
     ẋ        -     repeat list               [['G'],['C','C'],['M']]
       ṁ4     - mould like [1,2,3,4]          [['G'],['C','C'],['M'],['G']]
         F    - flatten                       ['G','C','C','M','G']
          ẋ€  - repeat €ach w times           [['G','G'],['C','C'],['C','C'],['M','M'],['G','G']]
            Y - join with line feeds          ['G','G','\n','C','C','\n','C','C','\n','M','M','\n','G','G']
              - implicit print                GG
                                              CC
                                              CC
                                              MM
                                              GG

— जोनाथन एलन
स्रोत

3

PHP, 85 बाइट्स

for($m=$argv;$i++<4;)for($c=$m[_2342[$i]]*$m[1];$c;)echo$c--%$m[1]?"":"\n",_GCMG[$i];

या

for($m=$argv;$i++<4;)for($c=$m[_2342[$i]];$c--;)echo"\n".str_pad("",$m[1],_GCMG[$i]);

ऑनलाइन संस्करण

PHP, 96 बाइट्स

<?[$n,$w,$G,$C,$M]=$argv;for(;$i<4;$i++)for($t=${"$n[$i]"};$t--;)echo"\n".str_pad("",$w,$n[$i]);

ऑनलाइन संस्करण

विस्तारित

[$n,$w,$G,$C,$M]=$argv; # $argv[0] must contain a file beginning with "GCMG"
for(;$i<4;$i++) # Take the first 4 values of the filename
for($t=${"$n[$i]"};$t--;) # How many rows should be printed
echo"\n".str_pad("",$w,$n[$i]); # print $w times the actual letter

— जार्ग हुल्सरमैन
स्रोत

3

05AB1E , 14 बाइट्स

कोड:

…GCM‚øü×¬)˜S×»

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

…GCM              # Push the string "GCM"
    ‚             # Wrap with the input
     ø            # Transpose the array
      ü×          # Compute the string product of each element (['A', 3] --> 'AAA')
        ¬)˜       # Get the last element and append to the list
           S      # Split the list
            ×     # Vectorized string multiplication with the second input
             »    # Join by newlines and implicitly print

— अदनान
स्रोत

3

अजगर २ ,6757 बाइट्स

(संपादित करें: अब जब मैट्रिसेस की अनुमति है, तो इसे नए सिरे से जोड़ने की आवश्यकता नहीं है।)

def s(w,g,c,m):g=['G'*w]*g;print g+['C'*w]*c+['M'*w]*m+g

— rassar
स्रोत

3

C # (150 बाइट्स)

void S(int w,int g,int c,int m){P(w,g,'G');P(w,c,'C');P(w,m,'M');P(w,g,'G');}void P(int w,int i,char c){while(i-->0)Console.Write("\n".PadLeft(w,c));}

Ungolfed:

void SMores(int w, int g, int c, int m)
{
    Print(w,g,'G');
    Print(w,c,'C');
    Print(w,m,'M');
    Print(w,g,'G');
}
void Print(int w, int i, char c)
{
    while(i-->0)
        Console.Write("\n".PadLeft(w,c));
}

— रिक
स्रोत

3

जावा, 138 बाइट्स

String s(int w,int g,int c,int m){String b="";int i=-g-c,j;for(;i++<g+m;){for(j=0;j++<w;)b+=i<=-c|i>m?'G':i<=0?'C':'M';b+="\n";}return b;}

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

स्पष्टीकरण:

String s(int w, int g, int c, int m) {
    String b = "";
    int i = -g - c, j;              // i is the layer
    for (; i++ < g + m;) {          // Repeat (G+C+M+G) times, starting from -g-c to m+g 
                                    //Layer 0 is the last chocolate layer

        for (j = 0; j++ < w;) {     // Repeat W times
            b += 
                i <= -c | i > m ? 'G': //If before the chocolate or after the marshmellow, output a G
                i <= 0 ? 'C' :      // Else if equal or before last chocolate layer output C
                'M';                //Otherwise output an M
        }
        b += "\n";
    }
    return b;
}

— ब्रेंटन पी।
स्रोत

बुरा नहीं है ... जावा के लिए!

— प्रोग्रामर

3

स्विफ्ट, 138 137 134 130 बाइट्स

^{सहेजे गए 7 बाइट्स @ केविन के लिए धन्यवाद}

let f=String.init(repeating:count:)
let r={w,g,c,m in f(f("G",w)+"\n",g)+f(f("C",w)+"\n",c)+f(f("M",w)+"\n",m)+f(f("G",w)+"\n",g)}

दो फ़ंक्शन जो अपेक्षित मान लौटाते हैं: fएक सहायक फ़ंक्शन है और rवास्तविक लाम्बा-जैसा फ़ंक्शन है जो आउटपुट उत्पन्न करता है। उपयोग: print(r(10,3,2,1))

इसकी जांच - पड़ताल करें!

— श्री Xcoder
स्रोत

आप सीधे स्ट्रिंग इनिशियलाइज़र को संदर्भित करके कई अक्षर बचा सकते हैं ( var f=String.init(repeating:count:);)। और यह आपको किसी भी चरित्र को नहीं बचाता है, लेकिन इसकी कोई कीमत नहीं है, इसलिए उन्हें वास्तव में दोनों होना चाहिए let।

— केविन

और r( let r={f(f("G",$0)+"\n",$1)+f(f("C",$0)+"\n",$2)+f(f("M",$0)+"\n",$3)+f(f("G",$0)+"\n",$1)})

— केविन

@ केविन थैंक्स, मुझे नहीं पता था कि आप इस तरह से किसी चीज़ की वैल्यू इनिशियलाइज़ कर सकते हैं: f=String.init(repeating:count:)...

— मिस्टर एक्सकोडर

@ केविन जब आपके दूसरे सुझाव की बात आती है, तो ऐसा लगता है कि यह UTF-8 में बाइट्स की संख्या से अधिक है, TIO पर बाइट की गिनती की जाँच करें, पता नहीं क्यों

— श्री Xcoder

2

उत्तल , 20 बाइट्स

"GCM"f*]z{~N+*}%(_@@

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

— GamrCorps
स्रोत

2

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

जिसमें अनुगामी न्यूलाइन शामिल है।

f=

(w,g,c,m)=>(b=(`G`[r=`repeat`](w)+`
`)[r](g))+(`C`[r](w)+`
`)[r](c)+(`M`[r](w)+`
`)[r](m)+b

console.log(f(10,3,2,1))

स्निपेट का विस्तार करें

— झबरा
स्रोत

2

जेएस (ईएस 6), 87 बाइट्स

x=(w,g,c,m)=>(f=>f`Gg`+f`Cc`+f`Mm`+f`Gg`)(([[x,y]])=>(x.repeat(w)+`
`).repeat(eval(y)))

xएक स्टैंडअलोन लैम्बडा फ़ंक्शन के रूप में कार्य करता है। परिणाम एक अनुगामी newline है।

स्निपेट में आज़माएं:

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

x=(w,g,c,m)=>(f=>f`Gg`+f`Cc`+f`Mm`+f`Gg`)(([[x,y]])=>(x.repeat(w)+`
`).repeat(eval(y)))

function doTheThing() {
  document.getElementById("target").innerText = x(
    document.getElementById("width").value,
    document.getElementById("graham").value,
    document.getElementById("chocolate").value,
    document.getElementById("marshmallow").value,
  )
}

Width: <input id='width' value='10'>
Graham: <input id='graham' value='3'>
Chocolate: <input id='chocolate' value='2'>
Marshmallow: <input id='marshmallow' value='1'>
<pre id='target'></pre>
<button onclick='doTheThing()'>Do the thing</button>

स्निपेट का विस्तार करें

— फ्लोरी
स्रोत

2

सी, 90 बाइट्स (आधारित) Steadybox के उत्तर )

वैरिएबल का नाम बदला और मैक्रो मापदंडों पर कटौती करने के लिए स्ट्रिंग प्रिप्रेशर ऑपरेटर का शोषण किया। मुझे उम्मीद है कि इस विचार को अपने स्वयं के उत्तर के रूप में पोस्ट करना ठीक है :)

#define F(x)for(i=x;i--;puts(""))for(j=w;j--;)printf(#x);
i,j;f(w,G,C,M){F(G)F(C)F(M)F(G)}

TIO लिंक

— क्वेंटिन
स्रोत

उत्थान होगा, लेकिन हिट वोट की सीमा :(

— प्रोग्रामर

2

एफ # ( 148 99 बाइट्स)

let s w q="GCMG"|>Seq.iteri(fun i c->for j in 1..(q|>Seq.item(i%3))do printf"%A"("".PadLeft(w,c)))

उपयोग:

s 10 [2;3;4]

Ungolfed:

let smores width quantities =
    "GCMG"
    |>Seq.iteri(fun i char ->
        for j in 1..(quantities|>Seq.nth(i%3))
            do printf "%A" ("".PadLeft(width,char)))

मैं अभी भी F # नया हूं, इसलिए अगर मैंने कुछ अजीब या बेवकूफी की, तो कृपया मुझे बताएं।

— रिक
स्रोत

F # का लिंक अच्छा होगा।

— प्रोग्रामर

2

जावास्क्रिप्ट ईएस 6, 69 68 66 बाइट्स

धन्यवाद @Arnauld एक बाइट को बंद करने के लिए

a=>b=>"GCMG".replace(/./g,(c,i)=>`${c.repeat(a)}
`.repeat(b[i%3]))

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

व्याख्या

करी प्रारूप में इनपुट प्राप्त करता है (Width)([Graham,Chocolate,Marshmallow])

.replace(/./g,...)स्ट्रिंग में प्रत्येक वर्ण को प्रतिस्थापित करने का उपयोग करनाGCMGफ़ंक्शन से वापसी मान के साथ(c,i)=>`${c.repeat(a)} `.repeat(b[i%3])

`${c.repeat(a)} `ग्रैहम पटाखा की प्रत्येक पंक्ति को एक नई पंक्ति के साथ बनाता है जो .repeat(b[i%3])इस पंक्ति को कई बार आवश्यक संख्या में दोहराता है

— fənɛtɪk
स्रोत

उपयोग करने से replace()एक बाइट बचती है:a=>"GCMG".replace(/./g,(c,i)=>`${c.repeat(a[0])}\n`.repeat(a[1+i%3]))

— अरनौलड

1

जेएस (ईएस 6), 111 बाइट्स

n=`
`,G="G",C="C",M="M",r=(s,t)=>s.repeat(t),(w,g,c,m)=>r(r(G,w)+n,g)+r(r(C,w)+n,c)+r(r(M,w)+n,m)+r(r(G,w)+n,g)

— programmer5000
स्रोत

1

गणितज्ञ 102 बाइट्स (100 वर्ण)

सुना है कि s'mores बिल्ट-इन T12 V12 नहीं निकल रहा है।

s=StringRepeat;StringReplace[s@@@({Characters@"GCMG",#/.#[[4]]->#[[1]]})<>"",x_:>x~s~#[[4]]<>"\n"]&

पहले एक स्तंभ के निर्माण के विचार का उपयोग करते हुए बहुत सीधा। लंबे फ़ंक्शन नाम 35 बाइट बर्बाद करते हैं। एक बॉक्स-दिखने वाला प्रतीक वास्तव में एक पारगमन चरित्र है और मैथेमेटिका में बस ठीक-ठाक चिपक जाएगा।

उपयोग: %@{Graham, Chocolate, Marshmallows, Width} उदाहरण के लिए %@{3, 2, 1, 11}

— केली लोवदर
स्रोत

1

जावा 7, 226 बाइट्स

String c(int w,int g,int c,int m){return x(w,'G',g)+x(w,'C',c)+x(w,'M',m)+x(w,'G',g);}String x(int w,char c,int x){String r="";for(;x-->0;r+=x(w,c));return r;}String x(int w,char c){String r="";for(;w-->0;r+=c);return r+"\n";}

या (भी 226 बाइट्स ):

String c(int w,int g,int c,int m){return x(w,71,g)+x(w,67,c)+x(w,77,m)+x(w,71,g);}String x(int...a){String r="";for(;a[2]-->0;r+=x(a[0],(char)a[1]));return r;}String x(int w,char c){String r="";for(;w-->0;r+=c);return r+"\n";}

स्पष्टीकरण:

String c(int w,int g,int c,int m){  // Main method with four integer parameters and String return-type
  return x(w,'G',g)                 //  Return all Graham-rows
        +x(w,'C',c)                 //   plus all Chocolate-rows
        +x(w,'M',m)                 //   Plus all Marshmallon-rows
        +x(w,'G',g);                //   Plus all Graham-rows again
}                                   // End of main method

String x(int w,char c,int x){       // Separate method (1) with two integers & character parameters and String return-type
  String r="";                      //  Result-String
  for(;x-->0;                       //  For the given amount of rows of a certain type
             r+=x(w,c)              //   Append the result-String with a row of the given character
  );                                //  End of for-loop (implicit / no body)
  return r;                         //  Return the result-String
}                                   // End of separate method (1)

String x(int w,char c){             // Separate method (2) with integer and character parameters and String return-type
  String r="";                      //  Result-String
  for(;w-->0;                       //  For the amount given as width
             r+=c                   //   Append the character to the row
  );                                //  End of for-loop (implicit / no body)
  return r+"\n";                    //  Return the result-String including a new-line
}                                   // End of separate method (2)

टेस्ट कोड:

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

class M{
  String c(int w,int g,int c,int m){return x(w,'G',g)+x(w,'C',c)+x(w,'M',m)+x(w,'G',g);}String x(int w,char c,int x){String r="";for(;x-->0;r+=x(w,c));return r;}String x(int w,char c){String r="";for(;w-->0;r+=c);return r+"\n";}

  public static void main(String[] a){
    System.out.print(new M().c(10,3,2,1));
  }
}

आउटपुट:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG

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

1

बुरा नहीं है ... जावा के लिए!

— प्रोग्रामर

1

@ प्रोग्रामर 5000 हे, धन्यवाद! मुझे जावा 7 (और कभी-कभी 8) में गोल्फिंग पसंद है, हालांकि मुझे नहीं लगता कि यह कभी भी अन्य उत्तरों के साथ प्रतिस्पर्धा करेगा .. केवल एक बार जावा उत्तर के साथ 'कुछ हद तक प्रतिस्पर्धा' इस 8 बाइट उत्तर के साथ थी और यह 19 बाइट का उत्तर था। , वास्तव में पहली बार अजगर को पछाड़ रहा है। ; पी हालांकि उनके 1 या 2 बाइट प्रस्तुतियाँ के साथ गोल्फ की भाषाएं अभी भी जावा को निश्चित रूप से धूल में छोड़ती हैं।

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

1

हास्केल , 91 बाइट्स

import Data.List
(#)=replicate
f w g c m=intercalate"\n"$map(w#)$g#'G'++c#'C'++m#'M'++g#'G'

बहुत आत्म-व्याख्यात्मक होना चाहिए। चूंकि यह एक टिप्पणी में उल्लेख किया गया था कि चरित्र की अनुमति है, यहां 58 बाइट संस्करण है जो तार की सूची (प्रत्येक परत के लिए एक) लौटाता है:

(#)=replicate
f w g c m=map(w#)$g#'G'++c#'C'++m#'M'++g#'G'

— जूलियन वुल्फ
स्रोत

मुझे एक s'more बनाओ!

स्टैक स्निपेट (परीक्षण आदि के लिए)

टिप्पणियाँ:

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

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

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

05AB1E , 21 19 19 बाइट्स

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

MATL , 17 बाइट्स

उदाहरण सहित व्याख्या

सी # , 204 बाइट्स

golfed

Ungolfed

पढ़ने योग्य अनगढ़

पूर्ण कोड

विज्ञप्ति

टिप्पणियाँ

05AB1E , 17 16 बाइट्स

रूबी, 47 बाइट्स

रूबी, 51 बाइट्स

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

सी, 108 105 बाइट्स

बैच, 146 बाइट्स

वी , 22 बाइट्स

एक्सेल, 104 बाइट्स

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

कैसे?

PHP, 85 बाइट्स

PHP, 96 बाइट्स

05AB1E , 14 बाइट्स

अजगर २ ,6757 बाइट्स

C # (150 बाइट्स)

जावा, 138 बाइट्स

स्विफ्ट, 138 137 134 130 बाइट्स

उत्तल , 20 बाइट्स

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

जेएस (ईएस 6), 87 बाइट्स

सी, 90 बाइट्स (आधारित) Steadybox के उत्तर )

एफ # ( 148 99 बाइट्स)

जावास्क्रिप्ट ईएस 6, 69 68 66 बाइट्स

व्याख्या

जेएस (ईएस 6), 111 बाइट्स

गणितज्ञ 102 बाइट्स (100 वर्ण)

जावा 7, 226 बाइट्स

हास्केल , 91 बाइट्स