Faites-moi un s'more!

19

Faites-moi un s'more ! Je vous dis la largeur, la quantité de biscuits Graham, la quantité de chocolat et la quantité de guimauve. Un exemple:

Contribution:

Largeur: 10 Graham: 3 Chocolat: 2 Marshmallow: 1.

Production:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG

C'est aussi simple que ça ? Euh ... oui.

Notez que l'entrée doit être une liste d'arguments d'une fonction ou d'un programme, pas une chaîne. Vous pouvez choisir le premier étant Largeur, puis Graham, mais tout ordre est très bien.

Cas de test complets si vous êtes intéressé.

Extrait de pile (pour les tests, etc.)

C'est pour tester la sortie.

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>
Développer l'extrait

Remarques:

  • Vous pouvez inclure une nouvelle ligne à la fin de la dernière ligne. Vous pouvez également utiliser un \au lieu d'une nouvelle ligne.
  • C'est du code-golf .
  • Des questions? Commentaires ci-dessous:
code-golf ascii-art programmer5000
la source
21
J'ai édité votre lien Let Me Google That For You. Ce n'était vraiment pas drôle.
Level River St
1
@FelipeNardiBatista oui.
programmer5000
1
Certaines réponses supposent un ordre et un format d'entrée flexibles (comme d'habitude dans PPCG), mais le défi semble nécessiter un ordre spécifique et exclure les chaînes (pas sûr de ce que cela signifie). Pouvez-vous clarifier?
Luis Mendo
2
Merci de clarifier. Vous devriez alors reformuler la phrase l'entrée doit être une liste d'arguments à une fonction ou d' un programme, pas une chaîne, le premier étant la largeur, puis Graham, etc . Personnellement, je dirais quelque chose comme "Le format d'entrée est flexible comme d'habitude"
Luis Mendo
4
@ programmer5000 mais pourquoi? S'ils ont voté contre, il est probable à 90% que c'est parce qu'ils pensent que c'est un défi ennuyeux et trivial. De plus, il est assez grossier de dire aux gens d'expliquer ou de se rétracter. Ils ont le droit de voter sans commentaire.
Rɪᴋᴇʀ

Réponses:

2

Gelée , 11 octets

ṁ4“GCMG”x×Y

Essayez-le en ligne!

Comment ça fonctionne

ṁ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
la source
13

Python 2 , 73 48 octets

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

Essayez-le en ligne!

Crée une version transposée de la réponse, puis la transpose au format correct avec zip(*l)

Felipe Nardi Batista
la source
8

05AB1E , 21 19 19 octets

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

Essayez-le en ligne!

-2 grâce à ma surveillance et 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.

(Voir la réponse d'Emigna, c'est mieux: /codegolf//a/116787/59376 )

Urne de poulpe magique
la source
1
Vous semblez avoir accidentellement laissé un ©dedans.
Emigna
1
Vous pouvez également remplacer ¬¸par Dcar les éléments supplémentaires sont perdus lorsque vous zippez.
Emigna
@Emigna J'aime et déteste cette fonctionnalité.
Magic Octopus Urn
Oui, c'est souvent très ennuyeux mais de temps en temps (comme maintenant) ça devient utile :)
Emigna
8

JavaScript (ES6), 71 octets

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

Woohoo, battez 3 autres réponses JavaScript!

Afficher l'extrait de code

darrylyeo
la source
Nice, very nice - obtient mon vote.
Shaggy
7

MATL , 17 octets

'GCMG'iK:)Y"!liX"

Le format d'entrée est: première entrée [G, C, M], deuxième entrée W.

Essayez-le en ligne!

Explication avec exemple

Considérez les entrées [3 2 1] et 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
la source
7

C # , 204 octets

Golfé

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

Non golfé

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

Non lisible non lisible

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

Code complet

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

Communiqués

  • v1.0 - 204 bytes- Solution initiale.

Remarques

auhmaan
la source
Apprécié! : D
auhmaan
7

05AB1E , 17 16 octets

1 octets économisés grâce à carusocomputing .

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

Essayez-le en ligne!

L'ordre d'entrée est W, [G,C,M]

Explication

10, [3,2,1] utilisé comme exemple.

"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
la source
1
"GCMG"S×vy²Nè.D»pouvoirs de merveille, activez! Forme de, code 05AB1E! De plus, les arguments sont échangés, mais il en reste 16.
Magic Octopus Urn
@carusocomputing: Il a l'avantage de ne pas laisser de conneries non imprimées sur la pile, mais il me semble tout aussi irréductible.
Emigna
1
C'est toujours 1 octet de moins et battra votre égalité avec MATL;).
Urne de poulpe magique
@carusocomputing: Oooh, quand est-ce arrivé? J'étais sûr que c'était 17 quand je l'ai vu. Agréable! ;)
Emigna
Je poste souvent des trucs stupides et j'y apporte des modifications 1 minute après avoir réalisé que j'étais un idiot.
Magic Octopus Urn
6

Rubis, 47 octets

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

grâce à ventero

Rubis, 51 octets

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

Appelez comme ceci:

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
la source
->w,g,c,m{puts r=[?G*w]*g,[?C*w]*c,[?M*w]*m,r}est un peu plus court
Ventero
5

PowerShell , 49 octets

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

Essayez-le en ligne!

Prend l'entrée comme quatre arguments de ligne de commande, width graham chocolate marshmallowstocke le premier $aet le reste dans $b(implicitement sous forme de tableau). Boucles sur la plage 0,1,2,0. Chaque boucle, nous l'indexons en chaîne GCM, la recomposons charen chaîne et la multiplions par $a(la largeur), puis en utilisant l'opérateur virgule ,, la transforme en un tableau en multipliant l'index approprié de $b(c.-à-d. Combien couches). Ces tableaux de chaînes résultants sont tous laissés sur le pipeline et la sortie est implicite, avec une nouvelle ligne entre les éléments.

AdmBorkBork
la source
5

C, 108 105 octets

Merci à @Quentin pour avoir économisé 3 octets!

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

Essayez-le en ligne!

Steadybox
la source
1
#define F(i,c)for(;i--;puts(""))for(j=w;j--;)putchar(c);enregistre trois octets :)
Quentin
@Quentin Merci! Je me demande pourquoi j'ai raté ça en premier lieu :)
Steadybox
4

Lot, 146 octets

@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

S'appuie sur le comportement obscur de echoen ce qu'il peut souvent ignorer le symbole entre echoet le texte à reproduire pour réduire les quatre boucles en une boucle imbriquée.

Neil
la source
4

V , 22 octets

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

Essayez-le en ligne!

Hexdump:

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

L'ordre d'entrée est

Graham, Marshmallow, Chocolate, Width

Explication:

é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
la source
Pourriez-vous ajouter une explication?
programmer5000
@ programmer5000 Bien sûr! Voir mon montage
DJMcMayhem
4

Excel, 104 octets

Oh mec! Une formule qui nécessite des sauts de ligne.

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

A1a Largeur
A2a Graham
A3a Chocolat
A4a Mallow

Si le pré-formatage est autorisé, vous pouvez formater la cellule pour le texte vertical et raccourcir la formule à 65 octets:

=REPT(REPT("G",A2)&REPT("C",A3)&REPT("M",A4)&REPT("G",A2)&"
",A1)
Ingénieur Toast
la source
4

Gelée , 13 octets

“GCM”ẋ"ṁ4Fẋ€Y

Un programme dyadique. Les entrées sont: [Graham's, Chocolates, Marshmallows],Width .

Essayez-le en ligne!

Comment?

“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
la source
3

PHP, 85 octets

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

ou

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

Versions en ligne

PHP, 96 octets

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

Version en ligne

Étendu

[$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
la source
3

05AB1E , 14 octets

Code:

…GCM‚øü׬)˜S×»

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Explication:

…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
la source
3

Python 2 ,6757 octets

(Edit: maintenant que les matrices sont autorisées, plus besoin de se joindre à la nouvelle ligne.) 

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

C # (150 octets)

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

Non golfé:

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
la source
3

Java, 138 octets

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

Essayez-le en ligne!

Explication:

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.
la source
Pas mal ... pour Java!
programmer5000
3

Swift, 138 137 134 134 130 octets

7 octets enregistrés grâce à @Kevin

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

Deux fonctions qui renvoient la valeur attendue: fest une fonction d'aide et rest la fonction réelle de type lamdba qui génère la sortie. Usage: print(r(10,3,2,1))

Vérifiez-le!

M. Xcoder
la source
Vous pouvez enregistrer plusieurs caractères en référençant simplement l'initialiseur de chaîne directement ( var f=String.init(repeating:count:);). Et cela ne vous fait économiser aucun personnage mais cela ne coûte aucun donc ils devraient tous les deux être vraiment let.
Kevin
Et 3 de plus en supprimant les arguments explicites dans 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 Merci, je n'avais aucune idée que vous pouvez initialiser une valeur à quelque chose comme ça: f=String.init(repeating:count:)...
M. Xcoder
@Kevin en ce qui concerne votre deuxième suggestion, il semble qu'elle dépasse le nombre d'octets en UTF-8, a vérifié le nombre d'octets sur TIO, je ne sais pas pourquoi
M. Xcoder
2

JavaScript (ES6), 91 octets

Comprend une nouvelle ligne de fin.

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))
Développer l'extrait

Hirsute
la source
2

JS (ES6), 87 octets

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

xagit comme une fonction lambda autonome. Le résultat a une nouvelle ligne de fin.

Essayez dans un extrait:

Afficher l'extrait de code

Florrie
la source
2

C, 90 octets (basé sur la réponse de Steadybox )

Renommé les variables et exploité l'opérateur de préprocesseur de stringification pour réduire les paramètres de macro. J'espère que publier cette idée comme sa propre réponse est bien :)

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

Lien TIO

Quentin
la source
Souhaitez voter, mais atteignez la limite de vote :(
programmer5000
2

F # ( 148 99 octets)

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

Usage:

s 10 [2;3;4]

Non golfé:

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

Je suis encore nouveau sur F #, donc si j'ai fait quelque chose de bizarre ou de stupide, faites-le moi savoir.

Rik
la source
Un lien vers F # serait bien.
programmer5000
2

JavaScript ES6, 69 68 66 octets

Merci @Arnauld d'avoir joué un octet au golf

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

Essayez-le en ligne!

Explication

Reçoit une entrée au format curry (Width)([Graham,Chocolate,Marshmallow])

L'utilisation .replace(/./g,...)remplace chaque caractère de la chaîne GCMGpar la valeur de retour de la fonction(c,i)=>`${c.repeat(a)} `.repeat(b[i%3])

`${c.repeat(a)} `crée chaque ligne du biscuit graham avec une nouvelle ligne ajoutée .repeat(b[i%3])répète cette ligne le nombre de fois requis

fəˈnɛtɪk
la source
L'utilisation replace()sauverait un octet:a=>"GCMG".replace(/./g,(c,i)=>`${c.repeat(a[0])}\n`.repeat(a[1+i%3]))
Arnauld
1

JS (ES6), 111 octets

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
la source
1

Mathematica 102 octets (100 caractères)

J'ai entendu dire que le s'mores intégré ne sortait pas avant la V12.

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

Assez simple en utilisant l'idée de construire d'abord une colonne. Les noms de fonction longs gaspillent 35 octets. Le symbole à une case est en fait un caractère de transposition et se collera très bien dans Mathematica.

Utilisation: %@{Graham, Chocolate, Marshmallows, Width} par exemple %@{3, 2, 1, 11}

Kelly Lowder
la source
1

Java 7, 226 octets

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

OU (également 226 octets ):

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

Explication:

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)

Code de test:

Essayez-le ici.

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

Production:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
Kevin Cruijssen
la source
1
Pas mal ... pour java!
programmer5000
1
@ programmer5000 Hehe, merci! Je aime jouer au golf en Java 7 (et parfois 8), bien que je ne pense pas que ce sera même jamais rivaliser avec d' autres réponses .. La seule fois où « un peu en compétition » avec une réponse Java a été avec cette réponse de 8 octets et cette réponse de 19 octets , déjantant Python pour la première fois. ; p Bien que ces langages de golf avec leurs soumissions de 1 ou 2 octets laissent toujours Java dans la poussière bien sûr.
Kevin Cruijssen
1

Haskell , 91 octets

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

Devrait être assez explicite. Puisqu'il a été noté dans un commentaire que les matrices de caractères sont autorisées, voici une version de 58 octets qui renvoie une liste de chaînes (une pour chaque couche):

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