Hazme un s'more!

19

Hazme un s'more ! Te digo el ancho, la cantidad de galletas Graham, la cantidad de chocolate y la cantidad de malvavisco. Un ejemplo:

Entrada:

Anchura: 10 Graham: 3 Chocolate: 2 Marshmallow: 1.

Salida:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG

¿Es tan fácil? Um ... si.

Tenga en cuenta que la entrada debe ser una lista de argumentos para una función o un programa, no una cadena. Puede elegir que el primero sea Ancho, luego Graham, pero cualquier orden está bien.

Casos de prueba completos si está interesado.

Fragmento de pila (para pruebas, etc.)

Esto es para probar la salida.

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>
Expandir fragmento

Notas:

  • Puede incluir una nueva línea al final de la última línea. También puede usar una en \lugar de una nueva línea.
  • Este es el código de golf .
  • ¿Alguna pregunta? Comenta abajo:
code-golf ascii-art programador 5000
fuente
21
Edité su enlace Let Me Google That For You. Realmente no fue gracioso.
Nivel River St
1
@FelipeNardiBatista sí.
programador
1
Algunas respuestas suponen un orden y formato de entrada flexibles (como es habitual en PPCG), pero el desafío parece requerir un orden específico y descartar cadenas (no estoy seguro de lo que eso significa). ¿Puedes aclarar?
Luis Mendo
2
Gracias por aclararlo. A continuación, debe reformular la frase de la entrada debe ser una lista de argumentos a una función o un programa, no es una cadena, con el primer ser Ancho, a continuación, Graham, etc . Personalmente, diría algo como "El formato de entrada es flexible como siempre"
Luis Mendo
44
@ programmer5000 pero ¿por qué? Si votaron en contra, es 90% probable que sea porque piensan que es un desafío aburrido y trivial. Además, es bastante grosero decirle a la gente que explique o se retracte. Tienen derecho a votar sin comentarios.
Rɪᴋᴇʀ

Respuestas:

2

Jalea , 11 bytes

ṁ4“GCMG”x×Y

Pruébalo en línea!

Cómo funciona

ṁ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
fuente
13

Python 2 , 73 48 bytes

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

Pruébalo en línea!

Crea una versión transpuesta de la respuesta, que la transpone al formato correcto con zip(*l)

Felipe Nardi Batista
fuente
8

05AB1E , 21 19 19 bytes

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

Pruébalo en línea!

-2 gracias a mi descuido y a 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.

(Vea la respuesta de Emigna, es mejor: /codegolf//a/116787/59376 )

Urna de pulpo mágico
fuente
1
Parece que accidentalmente dejaste un ©allí.
Emigna
1
También puede reemplazar ¬¸con Dlos elementos adicionales que se pierden al comprimir.
Emigna
@Emigna Me gusta y odio esa funcionalidad.
Urna de pulpo mágico
Sí, a menudo es muy molesto, pero de vez en cuando (como ahora) se vuelve útil :)
Emigna
8

JavaScript (ES6), 71 bytes

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

¡Woohoo, supera otras 3 respuestas de JavaScript!

Mostrar fragmento de código

Darrylyeo
fuente
Agradable, muy agradable, consigue mi voto.
Shaggy
7

MATL , 17 bytes

'GCMG'iK:)Y"!liX"

El formato de entrada es: primera entrada [G, C, M], segunda entrada W.

Pruébalo en línea!

Explicación con ejemplo

Considere las entradas [3 2 1] y 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
fuente
7

C # , 204 bytes

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

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

Legible sin golf

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

Código completo

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

Lanzamientos

  • v1.0 - 204 bytes- Solución inicial.

Notas

auhmaan
fuente
¡Apreciado! : D
auhmaan
7

05AB1E , 17 16 bytes

1 bytes guardados gracias a la computación caruso .

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

Pruébalo en línea!

El orden de entrada es W, [G,C,M]

Explicación

10, [3,2,1] usado como ejemplo.

"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
fuente
1
"GCMG"S×vy²Nè.D»poderes gemelos maravilla, activar! Forma de código 05AB1E! Además, los argumentos se intercambian, pero todavía son 16.
Urna de pulpo mágico
@carusocomputing: tiene el beneficio de no dejar basura sin imprimir en la pila, pero me parece igualmente irreducible.
Emigna
1
Todavía es 1 byte menos y superará su empate con MATL;).
Urna de pulpo mágico
@carusocomputing: Oooh, ¿cuándo sucedió eso? Estaba seguro de que tenía 17 años cuando lo vi. ¡Agradable! ;)
Emigna
A menudo publico cosas estúpidas y las edito 1 minuto después de darme cuenta de que soy un idiota.
Magic Octopus Urn
6

Ruby, 47 bytes

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

gracias a ventero

Ruby, 51 bytes

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

Llame así:

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
fuente
->w,g,c,m{puts r=[?G*w]*g,[?C*w]*c,[?M*w]*m,r}es un poco más corto
Ventero
5

PowerShell , 49 bytes

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

Pruébalo en línea!

Toma la entrada como cuatro argumentos de línea de comandos, width graham chocolate marshmallowalmacena el primero en $ay el resto en $b(implícitamente como una matriz). Bucles de más de la gama 0,1,2,0. Cada ciclo, lo indexamos en una cadena GCM, lo relanzamos charcomo una cadena y lo multiplicamos por $a(el ancho), y luego, usando el operador de coma ,, lo convierte en una matriz multiplicando el índice apropiado de $b(es decir, cuántos capas). Esas matrices de cadenas resultantes se dejan en la tubería y la salida es implícita, con una nueva línea entre los elementos.

AdmBorkBork
fuente
5

C, 108105 bytes

¡Gracias a @Quentin por guardar 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)}

Pruébalo en línea!

Steadybox
fuente
1
#define F(i,c)for(;i--;puts(""))for(j=w;j--;)putchar(c);ahorra tres bytes :)
Quentin
@Quentin Gracias! Me pregunto por qué me perdí eso en primer lugar :)
Steadybox
4

Lote, 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

Se basa en el comportamiento oscuro de echoque a menudo puede ignorar el símbolo entre echoy el texto que se repetirá para colapsar los cuatro bucles en un bucle anidado.

Neil
fuente
4

V , 22 bytes

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

Pruébalo en línea!

Hexdump:

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

El orden de entrada es

Graham, Marshmallow, Chocolate, Width

Explicación:

é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
fuente
¿Podría agregar una explicación?
programador
@ programmer5000 ¡Seguro! Ver mi edición
DJMcMayhem
4

Excel, 104 bytes

¡Oh chico! Una fórmula que requiere saltos de línea.

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

A1tiene Ancho
A2tiene Graham
A3tiene Chocolate
A4tiene Malva

Si se permite el formateo previo, puede formatear la celda para Texto vertical y acortar la fórmula a 65 bytes:

=REPT(REPT("G",A2)&REPT("C",A3)&REPT("M",A4)&REPT("G",A2)&"
",A1)
Tostadas de ingeniero
fuente
4

Jalea , 13 bytes

“GCM”ẋ"ṁ4Fẋ€Y

Un programa diádico. Las entradas son: [Graham's, Chocolates, Marshmallows], Width.

Pruébalo en línea!

¿Cómo?

“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
fuente
3

PHP, 85 bytes

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

o

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

Versiones en linea

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

Versión en línea

Expandido

[$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
fuente
3

05AB1E , 14 bytes

Código:

…GCM‚øü׬)˜S×»

Utiliza la codificación CP-1252 . Pruébalo en línea!

Explicación:

…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
fuente
3

Python 2 ,6757 bytes

(Editar: ahora que las matrices están permitidas, no es necesario unirse a una nueva línea). 

def s(w,g,c,m):g=['G'*w]*g;print g+['C'*w]*c+['M'*w]*m+g
rassar
fuente
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));}

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

Pruébalo en línea!

Explicación:

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.
fuente
No está mal ... para Java!
programmer5000
3

Swift, 138 137 134 130 bytes

Guardado 7 bytes gracias a @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)}

Dos funciones que devuelven el valor esperado: fes una función auxiliar y res la función real tipo lamdba que genera la salida. Uso: print(r(10,3,2,1))

¡Echale un vistazo!

Sr. Xcoder
fuente
Puede guardar varios caracteres simplemente haciendo referencia al inicializador de cadena directamente ( var f=String.init(repeating:count:);). Y no te ahorra ningún personaje, pero no cuesta ninguno, por lo que ambos deberían serlo let.
Kevin
Y 3 más al soltar los argumentos explícitos en 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 Gracias, no tenía idea de que puede inicializar un valor para algo como esto: f=String.init(repeating:count:)...
Sr. Xcoder
@Kevin cuando se trata de su segunda sugerencia, parece que excede el número de bytes en UTF-8, verificó el recuento de bytes en TIO, no sé por qué
Sr. Xcoder
2

JavaScript (ES6), 91 bytes

Incluye la nueva línea final.

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

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

xActúa como una función lambda independiente. El resultado tiene una nueva línea final.

Probar en un fragmento:

Mostrar fragmento de código

Florrie
fuente
2

C, 90 bytes (según la respuesta de Steadybox )

Cambió el nombre de las variables y explotó el operador del preprocesador de stringificación para reducir los parámetros de macro. Espero publicar esta idea ya que su propia respuesta 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)}

Enlace TIO

Quentin
fuente
Votaría, pero alcanzó el límite de votos :(
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)))

Uso:

s 10 [2;3;4]

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

Todavía soy nuevo en F #, así que si hice algo extraño o estúpido, avíseme.

Rik
fuente
Un enlace a F # estaría bien.
programmer5000
2

JavaScript ES6, 69 68 66 bytes

Gracias @Arnauld por jugar golf en un byte

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

Pruébalo en línea!

Explicación

Recibe entradas en formato curry (Width)([Graham,Chocolate,Marshmallow])

El uso .replace(/./g,...)reemplaza cada carácter en la cadena GCMGcon el valor de retorno de la función(c,i)=>`${c.repeat(a)} `.repeat(b[i%3])

`${c.repeat(a)} `crea cada línea de la galleta Graham con una nueva línea agregada .repeat(b[i%3])repite esta línea la cantidad requerida de veces

fəˈnɛtɪk
fuente
Usar replace()ahorraría un byte: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)
programador 5000
fuente
1

Mathematica 102 Bytes (100 caracteres)

Escuché que los s'mores incorporados no saldrán hasta V12.

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

Bastante sencillo usando la idea de construir una columna primero. Los nombres de función largos desperdician 35 bytes. El símbolo de un cuadro es en realidad un carácter de transposición y se pegará perfectamente en Mathematica.

Uso: %@{Graham, Chocolate, Marshmallows, Width} por ejemplo %@{3, 2, 1, 11}

Kelly Lowder
fuente
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";}

O (también 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";}

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

Código de prueba:

Pruébalo aquí

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

Salida:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
Kevin Cruijssen
fuente
1
No está mal ... para Java!
programmer5000
1
@ programmer5000 Jeje, gracias! Me gusta jugar al golf en Java 7 (y, a veces, 8), aunque no creo que pueda competir con otras respuestas. El único momento en que "compitió" con una respuesta de Java fue con esta respuesta de 8 bytes y esta respuesta de 19 bytes. , realmente superando a Python por primera vez. ; p Aunque esos idiomas de golf con sus envíos de 1 o 2 bytes todavía dejan a Java en el polvo, por supuesto.
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'

Debería ser bastante autoexplicativo. Como se señaló en un comentario que las matrices de caracteres están permitidas, aquí hay una versión de 58 bytes que devuelve una lista de cadenas (una para cada capa):

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