Mach mich zum S'more!

19

Mach mich zum S'more ! Ich sage dir die Breite, die Menge Graham Cracker, die Menge Schokolade und die Menge Marshmallow. Ein Beispiel:

Eingang:

Breite: 10 Graham: 3 Schokolade: 2 Eibisch: 1.

Ausgabe:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG

Ist es so einfach Ähm ... ja.

Beachten Sie, dass die Eingabe eine Liste von Argumenten für eine Funktion oder ein Programm sein sollte, keine Zeichenfolge. Sie könnten zuerst Width und dann Graham auswählen, aber jede Reihenfolge ist in Ordnung.

Vollständige Testfälle, wenn Sie interessiert sind.

Stack-Snippet (zum Testen usw.)

Dies dient zum Testen der Ausgabe.

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>
Erweitern Sie das Snippet

Anmerkungen:

  • Sie können am Ende der letzten Zeile eine abschließende neue Zeile einfügen. Sie können auch ein \anstelle eines Zeilenumbruchs verwenden.
  • Das ist Code-Golf .
  • Irgendwelche Fragen? Kommentiere unten:
code-golf  ascii-art 
— programmer5000
quelle
21
Ich habe Ihren Link "Lassen Sie mich Google That For You" bearbeitet. Es war wirklich nicht lustig.
— Level River St
1
@FelipeNardiBatista ja.
— programmer5000
1
Einige Antworten setzen eine flexible Eingabereihenfolge und ein flexibles Eingabeformat voraus (wie in PPCG üblich), die Herausforderung scheint jedoch eine bestimmte Reihenfolge und den Ausschluss von Zeichenfolgen zu erfordern (nicht sicher, was dies bedeutet). Könntest Du das erläutern?
— Luis Mendo
2
Danke fürs klarstellen. Sie sollten dann den Satz umformulieren, bei dem es sich bei der Eingabe um eine Liste von Argumenten für eine Funktion oder ein Programm handeln soll, nicht um eine Zeichenfolge, wobei die erste Width, dann Graham usw. Ist . Persönlich würde ich so etwas wie "Eingabeformat ist wie gewohnt flexibel" sagen
— Luis Mendo
4
@ programmer5000 aber warum? Wenn sie abstimmen, liegt das wahrscheinlich zu 90% daran, dass sie es für eine langweilige und triviale Herausforderung halten. Außerdem ist es ziemlich unhöflich, den Leuten zu sagen, dass sie es erklären oder sich zurückziehen sollen. Sie haben das Recht, ohne Kommentar abzustimmen.
— 17.

Antworten:

2

Jelly , 11 Bytes

ṁ4“GCMG”x×Y

Probieren Sie es online!

Wie es funktioniert

ṁ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.
— Dennis
quelle
8

05AB1E , 21 19 19 Bytes

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

Probieren Sie es online!

-2 danke an mein Versehen und Emigna.

"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.

(Siehe Emignas Antwort, es ist besser: /codegolf//a/116787/59376 )

— Magische Kraken-Urne
quelle
1
Sie scheinen versehentlich einen ©da drin gelassen zu haben .
— Emigna
1
Sie können auch ersetzen ¬¸mit Dals die zusätzlichen Elemente verloren gehen , wenn Sie sehen lassen.
— Emigna
@Emigna Ich mag und hasse diese Funktionalität.
— Magic Octopus Urn
Ja, es ist oft sehr ärgerlich, aber ab und zu (wie jetzt) ​​wird es nützlich :)
— Emigna
8

JavaScript (ES6), 71 Byte

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

Woohoo, schlagen Sie 3 andere JavaScript-Antworten!

Code-Snippet anzeigen

— darrylyeo
quelle
Schön, sehr schön - bekommt meine Stimme.
— Shaggy,
7

MATL , 17 Bytes

'GCMG'iK:)Y"!liX"

Das Eingabeformat ist: erste Eingabe [G, C, M], zweite Eingabe W.

Probieren Sie es online!

Erklärung mit Beispiel

Betrachten Sie Eingaben [3 2 1] und 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
— Luis Mendo
quelle
7

C # , 204 Bytes

Golf gespielt

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

Ungolfed lesbar

// 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 );
};

Vollständiger Code

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

Releases

  • v1.0 - 204 bytes- Anfangslösung.

Anmerkungen

— auhmaan
quelle
Geschätzt! : D
— auhmaan
7

05AB1E , 17 16 Bytes

Dank Carusocomputing 1 Byte gespart .

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

Probieren Sie es online!

Eingabereihenfolge ist W, [G,C,M]

Erläuterung

10, [3,2,1] als Beispiel verwendet.

"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
quelle
1
"GCMG"S×vy²Nè.D»Wunder-Zwillingskräfte, aktiviere! Form von, 05AB1E Code! Auch werden Argumente ausgetauscht, aber es ist immer noch 16.
— Magic Octopus Urn
@carusocomputing: Es hat den Vorteil, dass es keinen unbedruckten Müll auf dem Stapel hinterlässt, aber es scheint mir ähnlich irreduzibel.
— Emigna
1
Es ist immer noch 1 Byte weniger und schlägt Ihre Krawatte mit MATL;).
— Magic Octopus Urn
@carusocomputing: Oooh, wann ist das passiert? Ich war mir sicher, dass es 17 war, als ich es sah. Nett! ;)
— Emigna
Ich poste oft dumme Sachen und bearbeite sie 1 Minute, nachdem ich gemerkt habe, dass ich ein Idiot bin.
— Magic Octopus Urn
6

Ruby, 47 Bytes

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

danke an ventero

Ruby, 51 Bytes

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

Rufen Sie wie folgt an:

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

f[10,3,2,1]
— Level River St
quelle
->w,g,c,m{puts r=[?G*w]*g,[?C*w]*c,[?M*w]*m,r} ist etwas kürzer
— Ventero
5

PowerShell , 49 Byte

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

Probieren Sie es online!

Übernimmt die Eingabe als vier Befehlszeilenargumente width graham chocolate marshmallow, speichert das erste in $aund den Rest in $b(implizit als Array). Loops über den Bereich 0,1,2,0. Jede Schleife wird in eine Zeichenfolge indiziert GCM, charals Zeichenfolge neu umgewandelt und mit $a(der Breite) multipliziert. Mit dem Komma-Operator ,wird die Schleife in ein Array umgewandelt, indem der entsprechende Index von $b(dh wie viele) multipliziert wird Lagen). Diese resultierenden String-Arrays verbleiben alle in der Pipeline und die Ausgabe erfolgt implizit mit einer neuen Zeile zwischen den Elementen.

— AdmBorkBork
quelle
5

C 108 105 Bytes

Vielen Dank an @Quentin für das Speichern von 3 Bytes!

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

Probieren Sie es online!

— Steadybox
quelle
1
#define F(i,c)for(;i--;puts(""))for(j=w;j--;)putchar(c); spart drei Bytes :)
— Quentin
@Quentin Danke! Ich frage mich, warum ich das überhaupt verpasst habe :)
— Steadybox
4

Batch, 146 Bytes

@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

Beruht auf dem obskuren Verhalten von, echodass es häufig das Symbol zwischen echound den Text ignorieren kann, der als Echo ausgegeben werden soll, um die vier Schleifen zu einer verschachtelten Schleife zusammenzufassen.

— Neil
quelle
4

V , 22 Bytes

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

Probieren Sie es online!

Hexdump:

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

Eingabereihenfolge ist

Graham, Marshmallow, Chocolate, Width

Erläuterung:

é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
quelle
Könnten Sie eine Erklärung hinzufügen?
— programmer5000
@ programmer5000 Sicher! Siehe meine Bearbeitung
— DJMcMayhem
4

Excel, 104 Bytes

Oh Junge! Eine Formel, die Zeilenumbrüche erfordert.

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

A1hat Breite
A2hat Graham
A3hat Schokolade
A4hat Malve

Wenn eine Vorformatierung zulässig ist, können Sie die Zelle für vertikalen Text formatieren und die Formel auf 65 Byte kürzen:

=REPT(REPT("G",A2)&REPT("C",A3)&REPT("M",A4)&REPT("G",A2)&"
",A1)
— Ingenieur Toast
quelle
4

Jelly , 13 Bytes

“GCM”ẋ"ṁ4Fẋ€Y

Ein dyadisches Programm. Eingaben sind: [Graham's, Chocolates, Marshmallows], Width.

Probieren Sie es online!

Wie?

“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
— Jonathan Allan
quelle
3

PHP, 85 Bytes

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

oder

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

Online-Versionen

PHP, 96 Bytes

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

Online Version

Erweitert

[$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
— Jörg Hülsermann
quelle
3

05AB1E , 14 Bytes

Code:

…GCM‚øü׬)˜S×»

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Erläuterung:

…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
— Adnan
quelle
3

Python 2 ,6757 Bytes

(Bearbeiten: jetzt, da Matrizen erlaubt sind, müssen sie nicht mehr mit einer neuen Zeile verbunden werden.) 

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

C # (150 Bytes)

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));
}
— Rik
quelle
3

Java, 138 Bytes

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;}

Probieren Sie es online!

Erläuterung:

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;
}
— Brenton P.
quelle
— programmer5000
3

Swift, 138 137 134 130 Bytes

7 Bytes dank @Kevin gespart

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

Zwei Funktionen, die den erwarteten Wert zurückgeben: fist eine rHilfsfunktion und ist die eigentliche lamdba-ähnliche Funktion, die die Ausgabe generiert. Verwendung: print(r(10,3,2,1))

Hör zu!

— Mr. Xcoder
quelle
Sie können mehrere Zeichen speichern, indem Sie direkt auf den Zeichenfolgeninitialisierer verweisen ( var f=String.init(repeating:count:);). Und es speichert keine Charaktere, aber es kostet keine, also sollten sie beide wirklich sein let.
— Kevin
Und 3 weitere, indem Sie die expliziten Argumente in 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)})
— Kevin
@ Kevin Danke, ich hatte keine Ahnung, dass Sie einen Wert in etwa so initialisieren können: f=String.init(repeating:count:)...
— Mr. Xcoder
@ Kevin, wenn es um Ihren zweiten Vorschlag geht, es scheint, als ob er die Anzahl der Bytes in UTF-8 überschreitet, die Anzahl der Bytes auf TIO überprüft hat, weiß nicht warum
— Mr. Xcoder
2

JavaScript (ES6), 91 Byte

Schließt nachfolgende Newline ein.

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))
Erweitern Sie das Snippet

— Zottelig
quelle
2

JS (ES6), 87 Bytes

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

xWirkt als eigenständige Lambda-Funktion. Das Ergebnis enthält einen nachgestellten Zeilenumbruch.

Versuchen Sie es in einem Snippet:

Code-Snippet anzeigen

— Florrie
quelle
2

C, 90 Bytes (basierend auf der Antwort von Steadybox )

Die Variablen wurden umbenannt und der String-Präprozessor-Operator wurde ausgenutzt, um die Makroparameter zu reduzieren. Ich hoffe, diese Idee zu posten, da ihre eigene Antwort in Ordnung ist :)

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

— QUentin
quelle
Würde upvote, aber traf das Abstimmungslimit :(
— programmer5000
2

F # ( 148 99 Bytes)

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

Verwendung:

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

Ich bin noch neu in F #. Wenn ich also etwas Seltsames oder Dummes getan habe, lass es mich bitte wissen.

— Rik
quelle
Ein Link zu F # wäre schön.
— programmer5000
2

JavaScript ES6, 69 68 66 Bytes

Vielen Dank, @Arnauld, für das Golfen aus einem Byte

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

Probieren Sie es online!

Erläuterung

Erhält Eingaben im Curry-Format (Width)([Graham,Chocolate,Marshmallow])

Mit wird .replace(/./g,...)jedes Zeichen in der Zeichenfolge GCMGdurch den Rückgabewert der Funktion ersetzt(c,i)=>`${c.repeat(a)} `.repeat(b[i%3])

`${c.repeat(a)} `Erstellt jede Zeile des Graham Crackers mit einer angehängten neuen .repeat(b[i%3])Zeile und wiederholt diese Zeile so oft wie erforderlich

— fəˈnəˈtɛk
quelle
Mit replace()würde ein Byte speichern:a=>"GCMG".replace(/./g,(c,i)=>`${c.repeat(a[0])}\n`.repeat(a[1+i%3]))
— Arnauld
1

JS (ES6), 111 Bytes

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
quelle
1

Mathematica 102 Bytes (100 Zeichen)

Ich habe gehört, dass die eingebauten S'Mores erst in Version 12 herauskommen.

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

Ziemlich einfach mit der Idee, zuerst eine Säule aufzubauen. Lange Funktionsnamen verschwenden 35 Byte. Das eine kastenförmige Symbol ist eigentlich ein transponiertes Zeichen und wird in Mathematica eingefügt.

Verwendung: %@{Graham, Chocolate, Marshmallows, Width} zB %@{3, 2, 1, 11}

— Kelly Lowder
quelle
1

Java 7, 226 Bytes

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

ODER (auch 226 Bytes ):

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

Erläuterung:

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)

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
— Kevin Cruijssen
quelle
1
Nicht schlecht ... für Java!
— programmer5000
1
@ programmer5000 Hehe, danke! Ich spiele gerne Golf in Java 7 (und manchmal auch 8), obwohl ich nicht glaube, dass es jemals mit anderen Antworten konkurrieren wird. Das einzige Mal, das mit einer Java-Antwort "etwas konkurriert" hat, war diese 8-Byte-Antwort und diese 19-Byte-Antwort , tatsächlich Python zum ersten Mal outgolfing. ; p Obwohl diese Golfsprachen mit ihren 1 oder 2 Byte Einsendungen Java natürlich immer noch im Staub lassen.
— Kevin Cruijssen
1

Haskell , 91 Bytes

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

Sollte ziemlich selbsterklärend sein. Da in einem Kommentar darauf hingewiesen wurde, dass Zeichenmatrizen zulässig sind, wird in der folgenden 58-Byte- Version eine Liste von Zeichenfolgen (eine für jede Ebene) zurückgegeben:

(#)=replicate
f w g c m=map(w#)$g#'G'++c#'C'++m#'M'++g#'G'
— Julian Wolf
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.