Os quebra-cabeças de programação e o Code Golf estão prestes a conquistar um novo moderador , Dennis ! Esse desafio é uma homenagem a ele e a outros moderadores ativos (ou recentemente ativos): Maçaneta da porta , Martin Büttner e Chris Jester-Young . O título do desafio deve ser lido na música da música Pepto Bismol .

Basicamente, nós vamos tratá-los todos a pizza no século XIX mordida Pizzeria , mas precisamos ter certeza de que eles compartilhá-lo bastante, porque alguns dos mods são conhecidos por serem viciados de pizza!

As pizzas vendidas pela pizzaria são todos blocos retangulares de texto. A largura e o comprimento de uma pizza podem ser números inteiros não negativos, desde que o produto seja divisível por quatro. Cada espaço da grade no bloco de pizza de texto representa uma fatia, portanto, é sempre possível dividir as fatias em quatro grupos iguais.

Os mods pedirão coletivamente uma única pizza, fornecendo seus parâmetros de largura e comprimento ao servidor em qualquer formato razoável, como [width],[length]. Pouco antes da pizza chegar à mesa, você precisa rotular cada fatia com a inicial do mod que a come para garantir que todas compartilhem de maneira justa. Todos devem obter o mesmo número de fatias.

• E é para Dennis
• D é para maçaneta
• M é para Martin
• C é para Chris

Os mods são um pouco persnickety, no entanto, e exigem que seus respectivos conjuntos de fatias estejam conectados ao caminho , ou seja, que todas as fatias possam ser alcançadas uma da outra movendo-se para cima, para baixo, para a esquerda e para a direita, sem cruzar as de outras pessoas. fatias (e não se movem na diagonal). O não se importa como você faz isso, desde que seja feito.

Depois de rotular cada fatia com precisão, entregue a pizza aos mods com uma nova linha opcional à direita.

Sua etiquetadora pode ser um programa ou uma função e pode imprimir ou devolver a pizza etiquetada. O marcador mais curto em mordidas vence.

Exemplos

Exemplo 1

Ordem: 4,1

Algumas possíveis pizzas rotuladas:

EDMC

MEDC

CDEM

Exemplo 2

Ordem: 4,4

Algumas possíveis pizzas rotuladas:

MMMM
CCCC
DDDD
EEEE

DEMC
DEMC
DEMC
DEMC

CCCC
DEEM
DEEM
DDMM

Exemplo 3

Ordem: 8,3

Algumas possíveis pizzas rotuladas:

MMMMMMCC
DDDDCCCC
DDEEEEEE

DDDCMMMM
DCDCMEEE
DCCCMEEE

Exemplo 4

Ordem: 20,5

Uma possível pizza rotulada:

DDDDDDDDDDDDMCCCCCCCCCCC
DEEEEEEEEEEDMMMMMMMCCCCC
DEEEEEEEEEEDMMMCCCCCCCCC
DEEEEEEEEEEDMMMMMMMMCCCC
DDDDDDDDDDDDMMMMMMMMMMMC

(Os Daqui não estão simplesmente conectados, mas tudo bem.)

CJam, 20 bytes

q~1$*4/"CEDM"e*/:$N*

Eu acho que isso deve funcionar :)

Experimente online

Explicação:

Isso faz uma pizza rotulada como CC… EE… DD… MM… da esquerda para a direita e de cima para baixo e depois classifica cada linha em ordem alfabética. As únicas desconexões podem ocorrer entre a borda CE e a borda ED ou a borda ED e a borda DM (se elas caírem nas linhas adjacentes). Mas a classificação garante que os E's vão para o lado direito e os D's para o lado esquerdo, como C <E> D <M, para que os E's e os Ds permaneçam conectados.

q~          read and evaluate the input
1$          copy the width
*4/         multiply with the height and divide by 4
"CEDM"e*    repeat each letter in "CEDM" that many times
/           split into rows of the given width
:$          sort each row
N*          join with newlines

Pitão, 30 25 bytes

jb.eu_GkbceQs*R/*FQ4"EDMC

Demonstração ao vivo e todos os casos de teste .

Corte 5 bytes graças a @Jakube!

O mesmo algoritmo da minha resposta K ... mas muito mais curto.

Versão de 30 bytes:

jb.e?%k2_bbcjkm*/*FQ4d"EDMC"hQ

Demonstração ao vivo e todos os casos de teste para a versão de 50 bytes .

K, 61 bytes

{[a;b]{((+:;|:)@x!2)[r@x]}'!#r:(b;a)#,/{(_(a*b)%4)#x}'"EDMC"}

Exemplos:

ryan@DevPC-LX:~/golf$ rlwrap k2
K 2.8 2000-10-10 Copyright (C) 1993-2000 Kx Systems
Evaluation. Not for commercial use. 
\ for help. \\ to exit.

  `0:{[a;b]{((+:;|:)@x!2)[r@x]}'!#r:(b;a)#,/{(_(a*b)%4)#x}'"EDMC"}[4;1]
EDMC
  `0:{[a;b]{((+:;|:)@x!2)[r@x]}'!#r:(b;a)#,/{(_(a*b)%4)#x}'"EDMC"}[4;4]
EEEE
DDDD
MMMM
CCCC
  `0:{[a;b]{((+:;|:)@x!2)[r@x]}'!#r:(b;a)#,/{(_(a*b)%4)#x}'"EDMC"}[8;3]
EEEEEEDD
MMMMDDDD
MMCCCCCC
  `0:{[a;b]{((+:;|:)@x!2)[r@x]}'!#r:(b;a)#,/{(_(a*b)%4)#x}'"EDMC"}[20;5]
EEEEEEEEEEEEEEEEEEEE
DDDDDDDDDDDDDDDEEEEE
DDDDDDDDDDMMMMMMMMMM
CCCCCMMMMMMMMMMMMMMM
CCCCCCCCCCCCCCCCCCCC

ryan@DevPC-LX:~/golf$ 

Eu odiaria ser a pessoa que tem que cortar essas coisas ...

Pitão, 20 bytes

VceQs*L/*FQ4"CEDM"SN

Usa o truque de classificação do @ aditsu.

Demonstração.

Eu vim com um grande número de programas alternativos do mesmo comprimento ao tentar jogar isso:

VceQs*L/*FQ4"CEDM"SN
VceQsCm"CEDM"/*FQ4SN
VceQs*L*FQ"CEDM"%4SN
VceQ%4s*L*FQ"CEDM"SN
VcQs*L/*Qvz4"CEDM"SN    (Newline separated input)
jbSMceQs*L/*FQ4"CEDM
Vcs*L/*FQ4"CEDM"hQSN

Preso , 42 33

Volta! E de forma terrivelmente longa. :( - Eu roubei a ideia de classificação do aditsu para salvar 9 bytes :)

t;g*4/[4*"CEDM"z"];F*":j0GK'$:Nj

Explicação:

t;g*4/                              # Take |-separated input,
                                    #   store the first value in var stack,
                                    #   multiply the two numbers and divide by 4.
      [4*"CEDM"z                    # Wrap that value in an array, make 3 copies
                                    #   to get a list of length 4, zip with "EDMC"
                "];F*":j0GK         # For each item, multiply letter by value to
                                    #   to get string, join the result, split into
                                    #   segments the size of the saved variable.
                            '$:Nj   # For each item, sort so the letters are in the correct
                                    #   order, join by newline, print.

Exemplo de entrada:

20|5

Exemplo de saída:

CCCCCCCCCCCCCCCCCCCC
CCCCCEEEEEEEEEEEEEEE
DDDDDDDDDDEEEEEEEEEE
DDDDDDDDDDDDDDDMMMMM
MMMMMMMMMMMMMMMMMMMM

Rev 1 C, 74

i;f(w,h){for(i=w*h;i--;i%w||puts(""))putchar(h-i/w*2==1^"CDEM"[i*4/w/h]);}

Para economizar 1 byte, esta versão reverte (apenas) a linha do meio das fatias para qualquer número ímpar de linhas.

Rev 0 C, 75

i;f(w,h){for(i=w*h;i--;i%w||puts(""))putchar(h==3&i/w==1^"CDEM"[i*4/w/h]);}

Muitas respostas aqui estão em zigue-zague, mas na maioria dos casos, apenas a saída das letras em ordem (da esquerda para a direita, de cima para baixo) funciona bem:

Não há necessidade de ziguezague para alturas 1,2 ou 4

Não há necessidade de zigue-zague para alturas superiores a 4 (a ração de pizza de cada mod será distribuída).

Portanto, só precisamos ziguezague quando a altura é 3 e, em seguida, precisamos apenas reverter a linha do meio.

Acontece que Dennis e Maçaneta da porta são os únicos mods nessa linha. E eles podem ser trocados por XORing seus códigos ASCII com 1.

Isso é útil, pois não há maneira fácil de reverter uma string em C.

Ungolfed in program program

i;
f(w,h){
  for(i=w*h;i--;i%w||puts(""))            //loop through all squares. puts inserts a newline at the END of each line.
  putchar(h==3&i/w==1^"CDEM"[i*4/w/h]);   //put the letter, XORing D and E for the middle row of height 3.
}

W,H;
main(){
  scanf("%d%d",&W,&H);
  f(W,H);
} 

JavaScript (ES6) 107

Solução em zigue-zague. Usando a sequência de modelo, a nova linha é significativa e contada.

Teste a execução do snippet com o FireFox.

f=(w,h)=>{for(i=o=r='',z=l=1;--l?l:c='CDEM'[l=w*h/4,i++];r[w-1]&&(o+=r+`
`,r='',z=!z))r=z?r+c:c+r;return o}


//TEST

(test=_=>([w,h]=I.value.match(/\d+/g),O.innerHTML=f(w,h)))()

<input id=I value='8 3'><button onclick='test()'>-></button>
<pre id=O></pre>

Retina , 83 bytes

Os recursos usados ​​nesta resposta são mais recentes que esse desafio (não que isso importe ...). A contagem de bytes assume a codificação ISO 8859-1.

\d+
$*#
#(?=.*¶(.+))
$1
\G####
CDEM
S_`((.)+?(?=.*¶(?<-2>#)+$))|\D
O`.
T`DE`ED
O%`.

Experimente online!

Isso implementa a solução do aditsu, que agora é viável graças aos novos estágios de classificação.