좀 더 만들어 줘!

19

나 메이크업 s'more ! 너비, 그레이엄 크래커 양, 초콜릿 양, 마시멜로 양을 알려줍니다. 예를 들면 :

입력:

폭 : 10 그레이엄 : 3 초콜릿 : 2 마시멜로 : 1.

산출:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG

그것은인가 가 쉽게 사용할 수 있나요? 음 ... 네

입력은 문자열이 아니라 함수 또는 프로그램에 대한 인수 목록이어야합니다. 첫 번째는 너비를 선택한 다음 그레이엄을 선택할 수 있지만 순서는 괜찮습니다.

관심이 있다면 전체 테스트 사례.

스택 스 니펫 (테스트 등)

출력을 테스트하기위한 것입니다.

var smore = function(width, graham, chocolate, marshmallow){
	return ("G".repeat(width) + "\n").repeat(graham) + 
	("C".repeat(width) + "\n").repeat(chocolate) + 
	("M".repeat(width) + "\n").repeat(marshmallow) + 
	("G".repeat(width) + "\n").repeat(graham);
};
Snippetify(smore);
<script src="https://programmer5000.com/snippetify.min.js"></script>
Width: <input type = "number">
Graham: <input type = "number">
Chocolate: <input type = "number">
Marshmallow: <input type = "number">
<button>Try it out!</button>
<pre data-output></pre>
스 니펫 확장

노트:

  • 마지막 줄 끝에 후행 줄 바꿈을 포함 할 수 있습니다. \줄 바꿈 대신에 사용할 수도 있습니다 .
  • 이것은 code-golf 입니다.
  • 질문 있습니까? 아래의 코멘트 :
code-golf  ascii-art 
— 프로그래머 5000
소스
21
Let Me Google That For You 링크를 편집했습니다. 정말 재미 있지 않았습니다.
— Level River St
1
@FelipeNardiBatista 예.
— programmer5000
1
일부 답변은 유연한 입력 순서 및 형식 (PPCG에서 평소와 같이)을 가정하지만 도전 과제는 특정 순서가 필요하고 문자열을 배제하는 것으로 보입니다 (무엇을 의미하는지 확실하지 않음). 당신은 명확히 할 수 있습니까?
— Luis Mendo
2
설명해 주셔서 감사합니다. 그런 다음 입력은 문장 이 아니라 함수 또는 프로그램에 대한 인수 목록이어야합니다. 첫 번째는 Width, Graham 등 입니다. 개인적으로 "입력 형식은 평소처럼 유연합니다"
— Luis Mendo
4
@ programmer5000 그러나 왜? 그들이 다운 보트를했다면, 그것이 지루하고 사소한 도전이라고 생각하기 때문일 가능성이 90 %입니다. 또한 사람들에게 설명하거나 철회하라고 말하는 것은 무례합니다. 그들은 의견없이 공감할 권리가 있습니다.
— Rɪᴋᴇʀ

답변:

2

젤리 , 11 바이트

ṁ4“GCMG”x×Y

온라인으로 사용해보십시오!

작동 원리

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

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

05AB1E , 21 19 19 바이트

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

온라인으로 사용해보십시오!

내 감독과 에미 냐 덕분에 -2.

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

(Emigna의 답변을 참조하십시오. /codegolf//a/116787/59376 )

— 매직 문어 항아리
소스
1
당신은 실수 ©로 거기에 남아있는 것 같습니다 .
— Emigna
1
또한 대체 할 수 ¬¸와 함께 D당신이 압축 할 때 여분의 요소가 손실되어있다.
— Emigna
@Emigna 나는 그 기능을 좋아하고 싫어한다.
— Magic Octopus Urn
그렇습니다, 그것은 종종 매우 성가
— 시지만
8

자바 스크립트 (ES6), 71 바이트

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

Woohoo, 3 개의 다른 JavaScript 답변을 이겼습니다!

코드 스 니펫 표시

— 대릴 녀
소스
좋아, 아주 좋아-내 투표를 가져옵니다.
— Shaggy
7

MATL , 17 바이트

'GCMG'iK:)Y"!liX"

입력 형식은 첫 번째 입력 [G, C, M], 두 번째 입력 W입니다.

온라인으로 사용해보십시오!

예를 들어 설명

입력 [3 2 1] 과를 고려하십시오 10.

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

C # , 204 바이트

골프

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

언 골프

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

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

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

언 골프 가능

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

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

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

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

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

전체 코드

using System;
using System.Collections.Generic;

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

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

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

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

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

         Console.ReadLine();
      }
   }
}

자료

  • V1.0 - 204 bytes- 초기 솔루션입니다.

노트

— 아우 만
소스
감사합니다! : D
— auhmaan
7

05AB1E , 17 16 바이트

carusocomputing 덕분에 1 바이트가 절약 되었습니다 .

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

온라인으로 사용해보십시오!

입력 순서는 W, [G,C,M]

설명

10, [3,2,1] 예제로 사용됩니다.

"GCMG"S           # push the list ['G','C','M','G']
       ×          # repeat each W times
                  # STACK: ['GGGGGGGGGG', 'CCCCCCCCCC', 'MMMMMMMMMM', 'GGGGGGGGGG']
        v         # for each [string, index] y,N in the list
          ²Nè     # get the amount of layers at index N from the [G,C,M] list
         y   .D   # duplicate the string y that many times
               »  # join strings by newlines
— 에미 냐
소스
1
"GCMG"S×vy²Nè.D»원더 트윈 파워, 활성화! 05AB1E 코드의 형태! 또한 논쟁은 바뀌었지만 여전히 16입니다.
— Magic Octopus Urn
@ carusocomputing : 스택에 인쇄되지 않은 쓰레기를 남기지 않는 이점이 있지만 나에게는 비슷하게 되돌릴 수없는 것 같습니다.
— Emigna
1
여전히 1 바이트가 적으며 MATL로 넥타이를 이길 것입니다.).
— Magic Octopus Urn
@carusocomputing : 우, 언제 그런 일이 있었나요? 나는 그것을 볼 때 17 살이라고 확신했다. 좋은! ;)
— Emigna
나는 바보 같은 것을 게시하고 내가 바보임을 깨닫고 1 분 후에 편집합니다.
— Magic Octopus Urn
6

루비, 47 바이트

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

벤 테로 덕분에

루비, 51 바이트

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

이런 식으로 전화하십시오 :

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

f[10,3,2,1]
— 레벨 리버 스트리트
소스
->w,g,c,m{puts r=[?G*w]*g,[?C*w]*c,[?M*w]*m,r}조금 짧습니다
— Ventero
5

PowerShell , 49 바이트

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

온라인으로 사용해보십시오!

입력을 네 개의 명령 줄 인수 width graham chocolate marshmallow로 사용 $a하고 첫 번째 와 나머지를 $b(암시 적으로 배열로) 저장합니다. 범위에서 반복됩니다 0,1,2,0. 각 루프는 string으로 색인화하고 문자열 GCM로 다시 캐스트하고 (너비)를 char곱한 $a다음 쉼표 연산자를 사용 ,하여 적절한 색인 $b(즉, 층). 결과 문자열 배열은 모두 파이프 라인에 남겨지고 요소 사이에 줄 바꿈이있는 출력이 암시 적입니다.

— AdmBorkBork
소스
5

C, 108105 바이트

3 바이트를 절약 한 @Quentin에게 감사드립니다!

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

온라인으로 사용해보십시오!

— 스테디 박스
소스
1
#define F(i,c)for(;i--;puts(""))for(j=w;j--;)putchar(c);세 바이트를 절약 :)
— Quentin
@Quentin 감사합니다! 나는 왜 내가 처음부터 그것을 그리워했는지 궁금합니다 :)
— Steadybox
4

배치, 146 바이트

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

4 개의 루프를 중첩 된 루프로 축소하기 위해 에코 될 텍스트와 echo사이의 기호를 무시할 수 있다는 모호한 동작에 의존 echo합니다.

— 닐
소스
4

V , 22 바이트

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

온라인으로 사용해보십시오!

16 진 덤프 :

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

입력 순서는

Graham, Marshmallow, Chocolate, Width

설명:

éG                  " Insert 'G'
  Ä                 " Duplicate this line
   Àäj              " *arg1* times, duplicate this line and the line below it
      M             " Move to the middle line
       o            " Open up a newline, and enter insert mode
        C<cr>M<esc> " Insert 'C\nM'
ÀÄ                  " Make *arg2* copies of this line (Marshmallow)
  k                 " Move up one line
   ÀÄ               " Make *arg3* copies of this line (Chocolate)
     H              " Move to the first line
      dê            " Delete this column
        ÀP          " And paste it horizontally *arg4* times
— DJMcMayhem
소스
설명을 추가해 주시겠습니까?
— programmer5000
@ programmer5000 물론입니다! 내 편집 내용보기
— DJMcMayhem
4

엑셀, 104 바이트

오 소년! 줄 바꿈이 필요한 수식입니다.

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

A1폭
A2은 그레이엄
A3초콜릿
A4은 맬로

사전 서식이 허용되면 세로 텍스트에 대한 셀의 서식을 지정하고 수식을 65 바이트로 줄일 수 있습니다.

=REPT(REPT("G",A2)&REPT("C",A3)&REPT("M",A4)&REPT("G",A2)&"
",A1)
— 엔지니어 토스트
소스
4

젤리 , 13 바이트

“GCM”ẋ"ṁ4Fẋ€Y

이색적인 프로그램. 입력은 다음 [Graham's, Chocolates, Marshmallows]과 같습니다. , Width.

온라인으로 사용해보십시오!

어떻게?

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

PHP, 85 바이트

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

또는

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

온라인 버전

PHP, 96 바이트

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

온라인 버전

넓히는

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

05AB1E , 14 바이트

암호:

…GCM‚øü׬)˜S×»

용도 CP-1252 인코딩을. 온라인으로 사용해보십시오!

설명:

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

파이썬 2 ,6757 바이트

(편집 : 지금 행렬이 허용되는지에 필요를 줄 바꿈은 조인되지 않습니다.) 

def s(w,g,c,m):g=['G'*w]*g;print g+['C'*w]*c+['M'*w]*m+g
— 라스 사
소스
3

C 번호 (150 바이트)

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

언 골프 드 :

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

자바, 138 바이트

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

온라인으로 사용해보십시오!

설명:

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

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

스위프트 138 137 134 130 바이트

@Kevin 덕분에 7 바이트 절약

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

예상 값을 반환하는 두 가지 함수 f는 도우미 함수이며 r출력을 생성하는 실제 lamdba와 같은 함수입니다. 용법: print(r(10,3,2,1))

확인 해봐!

— 미스터 Xcoder
소스
문자열 이니셜 라이저를 직접 참조하여 여러 문자를 저장할 수 있습니다 ( var f=String.init(repeating:count:);). 그리고 그것은 당신에게 어떤 문자도 저장하지 않지만 어떤 비용도 들지 않으므로 둘 다 정말로이어야 let합니다.
— Kevin
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 감사합니다, 나는 당신이 이런 식으로 값을 초기화 할 수 있다는 것을 몰랐습니다 : f=String.init(repeating:count:)...
— Mr. Xcoder
이 UTF-8 바이트 수를 초과하는 것처럼 두 번째 제안에 관해서 @Kevin, 그 이유를 모르겠어, TIO의 바이트 수를 체크 보인다
— 씨 Xcoder
2

자바 스크립트 (ES6), 91 바이트

후행 줄 바꿈을 포함합니다.

f=

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

console.log(f(10,3,2,1))
스 니펫 확장

— 얽히고 설킨
소스
2

JS (ES6), 87 바이트

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

x독립형 람다 함수로 작동합니다. 결과에는 줄 바꿈이 있습니다.

스 니펫을 사용해보십시오.

코드 스 니펫 표시

— 플로리
소스
2

C, 90 바이트 (기준 Stadybox의 답변을 함) )

변수의 이름을 바꾸고 문자열 화 전 처리기 연산자를 사용하여 매크로 매개 변수를 줄였습니다. 이 아이디어를 자체 답변으로 게시하는 것이 좋습니다. :)

#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 링크

— 쿠엔틴
소스
upvote에,하지만 인기 투표 제한 :( 것
— programmer5000
2

F # ( 148 99 바이트)

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

용법:

s 10 [2;3;4]

언 골프 드 :

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

나는 여전히 F #을 처음 사용하기 때문에 이상하거나 어리석은 짓을했다면 알려주십시오.

— 릭
소스
F 번호에 대한 링크가 좋은 것입니다.
— programmer5000
2

자바 스크립트 ES6, 69 (68) 66 바이트

덕분에 한 바이트 떨어져 골프에 대한 @Arnauld

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

온라인으로 사용해보십시오!

설명

카레 형식의 입력을 접수 (Width)([Graham,Chocolate,Marshmallow])

를 사용 .replace(/./g,...)하면 문자열의 각 문자 GCMG가 함수의 반환 값으로 바뀝니다.(c,i)=>`${c.repeat(a)} `.repeat(b[i%3])

`${c.repeat(a)} `줄 바꿈이 추가 된 그레이엄 크래커의 각 줄을 .repeat(b[i%3])이 줄을 필요한 횟수만큼 반복합니다.

— fəˈnɛtɪk
소스
를 사용 replace()하면 바이트를 절약 할 수 있습니다.a=>"GCMG".replace(/./g,(c,i)=>`${c.repeat(a[0])}\n`.repeat(a[1+i%3]))
— Arnauld
1

JS (ES6), 111 바이트

n=`
`,G="G",C="C",M="M",r=(s,t)=>s.repeat(t),(w,g,c,m)=>r(r(G,w)+n,g)+r(r(C,w)+n,c)+r(r(M,w)+n,m)+r(r(G,w)+n,g)
— 프로그래머 5000
소스
1

Mathematica 102 바이트 (100 자)

스 모어 내장이 V12까지 나오지 않는다고 들었습니다.

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

먼저 기둥을 쌓는 아이디어를 사용하면 매우 간단합니다. 긴 함수 이름은 35 바이트를 낭비합니다. 하나의 상자 모양의 심볼은 실제로 전치 문자이며 Mathematica에 붙여 넣습니다.

사용법 : %@{Graham, Chocolate, Marshmallows, Width} 예 %@{3, 2, 1, 11}

— 켈리 로우더
소스
1

자바 7, 226 바이트

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

OR (또한 226 바이트 ) :

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

설명:

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

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

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

테스트 코드 :

여기에서 시도하십시오.

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

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

산출:

GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
CCCCCCCCCC
CCCCCCCCCC
MMMMMMMMMM
GGGGGGGGGG
GGGGGGGGGG
GGGGGGGGGG
— 케빈 크루이 센
소스
1
나쁘지 않은 ... 자바!
— programmer5000
1
@ programmer5000 Hehe, 감사합니다! 내가 이제까지 심지어 다른 답변과 경쟁 할 것이라고 생각하지 않지만 자바 7 (때로는 8)에서 골프와 같은 I .. 자바 대답 '다소 경쟁'유일한 시간 함께했다 이 8 바이트 응답 및 이 19 바이트 대답 실제로 처음으로 파이썬을 능가합니다. ; p 1 바이트 또는 2 바이트 제출이 포함 된 골프 언어는 여전히 Java를 그대로두고 있습니다.
— Kevin Cruijssen
1

하스켈 , 91 바이트

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

꽤 설명이 필요합니다. 주석에서 문자 행렬이 허용된다고 언급되었으므로 다음은 문자열 목록을 반환하는 58 바이트 버전입니다 (각 계층 당 하나씩).

(#)=replicate
f w g c m=map(w#)$g#'G'++c#'C'++m#'M'++g#'G'
— 줄리안 울프
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.