Làm cho tôi một s'more ! Tôi nói với bạn về chiều rộng, lượng graham cracker, lượng sô cô la và lượng marshmallow. Một ví dụ:

Đầu vào:

Chiều rộng: 10 Graham: 3 Sôcôla: 2 Marshmallow : 1.

Đầu ra:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG

Có dễ không? Ừm ... vâng.

Lưu ý rằng đầu vào phải là một danh sách các đối số cho một hàm hoặc một chương trình, không phải là một chuỗi. Bạn có thể chọn chiều rộng đầu tiên, sau đó là Graham, nhưng mọi thứ tự đều ổn.

Trường hợp thử nghiệm đầy đủ nếu bạn quan tâm.

Đoạn trích (để thử nghiệm, v.v.)

Điều này là để kiểm tra đầu ra.

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>

Ghi chú:

• Bạn có thể bao gồm một dòng mới ở cuối dòng cuối cùng. Bạn cũng có thể sử dụng \thay vì một dòng mới.
• Đây là mã golf .
• Có câu hỏi nào không? Bình luận dưới đây:

Thạch , 11 byte

ṁ4“GCMG”x×Y

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Python 2 , 73 48 byte

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

Hãy thử trực tuyến!

Tạo một phiên bản chuyển đổi của câu trả lời, hơn là chuyển nó sang định dạng đúng với zip(*l)

05AB1E , 21 19 19 byte

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

Hãy thử trực tuyến!

-2 nhờ sự giám sát của tôi và 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.

(Xem câu trả lời của Emigna, tốt hơn: /codegolf//a/116787/59376 )

JavaScript (ES6), 71 byte

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

Woohoo, đánh bại 3 câu trả lời JavaScript khác!

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

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

MATL , 17 byte

'GCMG'iK:)Y"!liX"

Định dạng đầu vào là: đầu vào đầu tiên [G, C, M], đầu vào thứ hai W.

Hãy thử trực tuyến!

Giải thích với ví dụ

Xem xét đầu vào [3 2 1] và 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

C # , 204 byte

Chơi gôn

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

Bị đánh cắp

( 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 có thể đọc được

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

Mã đầy đủ

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

Phát hành

• v1.0 - 204 bytes- Giải pháp ban đầu.

Ghi chú

• Tìm kiếm một hình ảnh của màn hình thử nghiệm đẹp của tôi ?
• Về ý nghĩ thứ hai, CSharpPad không thể xử lý các thử nghiệm đó, đây là phiên bản có ít thử nghiệm hơn

05AB1E , 17 16 byte

1 byte được lưu nhờ vào tính toán carusocomputing .

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

Hãy thử trực tuyến!

Thứ tự đầu vào là W, [G,C,M]

Giải trình

10, [3,2,1] dùng làm ví dụ.

"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

Ruby, 47 byte

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

cảm ơn ventero

Ruby, 51 byte

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

Gọi như thế này:

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

f[10,3,2,1]

PowerShell , 49 byte

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

Hãy thử trực tuyến!

Đưa đầu vào thành bốn đối số dòng lệnh width graham chocolate marshmallow, lưu trữ đầu tiên vào $avà phần còn lại vào $b(ngầm định là một mảng). Vòng lặp từ trên phạm vi 0,1,2,0. Mỗi vòng lặp, chúng ta lập chỉ mục thành chuỗi GCM, tái tạo chuỗi đó charthành một chuỗi và nhân nó ra $a(chiều rộng), sau đó sử dụng toán tử dấu phẩy ,, biến nó thành một mảng bằng cách nhân chỉ số thích hợp của $b(ví dụ: có bao nhiêu các lớp). Tất cả các mảng chuỗi kết quả là tất cả còn lại trên đường ống và đầu ra là ẩn, với một dòng mới giữa các phần tử.

C, 108 105 byte

Cảm ơn @Quentin đã lưu 3 byte!

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

Hãy thử trực tuyến!

Mẻ, 146 byte

@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

Dựa vào hành vi tối nghĩa của echonó, nó thường có thể bỏ qua biểu tượng giữa echovà văn bản được lặp lại để thu gọn bốn vòng lặp thành một vòng lặp lồng nhau.

V , 22 byte

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

Hãy thử trực tuyến!

Hexdump:

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

Thứ tự đầu vào là

Graham, Marshmallow, Chocolate, Width

Giải trình:

é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

Excel, 104 byte

Oh Boy! Một công thức yêu cầu ngắt dòng.

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

A1Có chiều rộng
A2có Graham
A3có Chocolate
A4có Mallow

Nếu định dạng trước được cho phép, thì bạn có thể định dạng ô cho Văn bản dọc và rút ngắn công thức thành 65 byte:

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

Thạch , 13 byte

“GCM”ẋ"ṁ4Fẋ€Y

Một chương trình dyadic. Đầu vào là: [Graham's, Chocolates, Marshmallows], Width.

Hãy thử trực tuyến!

Làm sao?

“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

PHP, 85 byte

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

hoặc là

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

Phiên bản trực tuyến

PHP, 96 byte

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

Phiên bản trực tuyến

Mở rộng

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

05AB1E , 14 byte

Mã số:

…GCM‚øü׬)˜S×»

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Giải trình:

…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

Python 2 ,6757 byte

(Chỉnh sửa: bây giờ ma trận được cho phép, không cần phải nhập dòng mới.)

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

C # (150 byte)

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

Ung dung:

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

Java, 138 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Swift, 138 137 134 130 byte

^{Đã lưu 7 byte nhờ @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)}

Hai hàm trả về giá trị mong đợi: flà hàm trợ giúp và rlà hàm giống như lamdba thực tế tạo ra đầu ra. Sử dụng: print(r(10,3,2,1))

Kiểm tra nó ra!

Lồi , 20 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 91 byte

Bao gồm dòng mới.

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

JS (ES6), 87 byte

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

xhoạt động như một chức năng lambda độc lập. Kết quả có một dòng mới.

Hãy thử trong một đoạn:

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>

C, 90 byte (dựa trên câu trả lời của Steadybox )

Đổi tên các biến và khai thác toán tử tiền xử lý chuỗi để cắt giảm các tham số macro. Tôi hy vọng đăng ý tưởng này như câu trả lời của riêng mình là tốt :)

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

Liên kết TIO

F # ( 148 99 byte)

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ử dụng:

s 10 [2;3;4]

Ung dung:

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

Tôi vẫn chưa quen với F #, vì vậy nếu tôi làm bất cứ điều gì kỳ lạ hoặc ngu ngốc, xin vui lòng cho tôi biết.

JavaScript ES6, 69 68 66 byte

Cảm ơn @Arnauld vì đã chơi golf một byte

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

Hãy thử trực tuyến!

Giải trình

Nhận đầu vào ở định dạng curried (Width)([Graham,Chocolate,Marshmallow])

Sử dụng .replace(/./g,...)thay thế từng ký tự trong chuỗi GCMGbằng giá trị trả về từ hàm(c,i)=>`${c.repeat(a)} `.repeat(b[i%3])

`${c.repeat(a)} `tạo mỗi dòng của cracker graham với một dòng mới được nối .repeat(b[i%3])lại lặp lại dòng này với số lần cần thiết

JS (ES6), 111 byte

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)

Toán học 102 byte (100 ký tự)

Nghe nói các sores được tích hợp sẵn sẽ không xuất hiện cho đến V12.

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

Khá đơn giản bằng cách sử dụng ý tưởng xây dựng một cột đầu tiên. Tên hàm dài lãng phí 35 byte. Biểu tượng một hộp trông thực sự là một ký tự chuyển vị và sẽ dán vào Mathicala tốt.

Cách sử dụng: %@{Graham, Chocolate, Marshmallows, Width} vd %@{3, 2, 1, 11}

Java 7, 226 byte

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

HOẶC (cũng 226 byte ):

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

Giải trình:

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)

Mã kiểm tra:

Hãy thử nó ở đây.

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

Đầu ra:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG

Haskell , 91 byte

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

Nên khá tự giải thích. Vì nó đã được ghi nhận trong một nhận xét rằng ma trận ký tự được cho phép, đây là phiên bản 58 byte trả về danh sách các chuỗi (một cho mỗi lớp):

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