¡Programming Puzzles & Code Golf está a punto de obtener un nuevo moderador , Dennis ! Este desafío es un homenaje a él y a nuestros otros moderadores activos (o recientemente activos): Doorknob , Martin Büttner y Chris Jester-Young . El título del desafío está destinado a leerse al son de la canción de Pepto Bismol .

Básicamente, vamos a invitarlos a todos a comer pizza en The Nineteenth Bite Pizzeria , ¡pero debemos asegurarnos de que lo compartan de manera justa porque algunos de los mods son adictos a la pizza!

Las pizzas que vende la pizzería son todos bloques de texto rectangulares. El ancho y la longitud de una pizza pueden ser enteros no negativos siempre que su producto sea divisible por cuatro. Cada espacio de cuadrícula en el bloque de pizza de texto representa una rebanada, por lo que siempre es posible dividir las rebanadas en cuatro grupos iguales.

Los mods ordenarán colectivamente una sola pizza, proporcionando sus parámetros de ancho y largo a su servidor en cualquier formato razonable como [width],[length]. Justo antes de que la pizza llegue a su mesa, debe etiquetar cada rebanada con la inicial del mod que puede comerla para asegurarse de que todos compartan de manera justa. Todos deberían obtener el mismo número de rebanadas.

• E es para Dennis
• D es para pomo de la puerta
• M es para Martin
• C es para Chris

Sin embargo, los mods son un poco perspicaces y requieren que sus respectivos conjuntos de sectores estén conectados a la ruta , es decir, que todos sus sectores se puedan alcanzar unos de otros moviéndose hacia arriba, hacia abajo, hacia la izquierda y hacia la derecha, sin cruzar los de nadie más. rebanadas (y sin movimiento diagonal). No importa cómo lo hagas siempre y cuando esté hecho.

Una vez que haya etiquetado con precisión cada porción, entregue la pizza a los mods con una nueva línea final opcional.

Su etiquetadora puede ser un programa o una función y puede imprimir o devolver la pizza etiquetada. La etiquetadora más corta en mordiscos gana.

Ejemplos

Ejemplo 1

Orden: 4,1

Algunas posibles pizzas etiquetadas:

EDMC

MEDC

CDEM

Ejemplo 2

Orden: 4,4

Algunas posibles pizzas etiquetadas:

MMMM
CCCC
DDDD
EEEE

DEMC
DEMC
DEMC
DEMC

CCCC
DEEM
DEEM
DDMM

Ejemplo 3

Orden: 8,3

Algunas posibles pizzas etiquetadas:

MMMMMMCC
DDDDCCCC
DDEEEEEE

DDDCMMMM
DCDCMEEE
DCCCMEEE

Ejemplo 4

Orden: 20,5

Una posible pizza etiquetada:

DDDDDDDDDDDDMCCCCCCCCCCC
DEEEEEEEEEEDMMMMMMMCCCCC
DEEEEEEEEEEDMMMCCCCCCCCC
DEEEEEEEEEEDMMMMMMMMCCCC
DDDDDDDDDDDDMMMMMMMMMMMC

(Los D's aquí no están simplemente conectados, pero está bien).

CJam, 20 bytes

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

Creo que esto debería funcionar :)

Pruébalo en línea

Explicación:

Esto primero hace una pizza etiquetada CC ... EE ... DD ... MM ... de izquierda a derecha y de arriba a abajo, luego ordena cada fila en orden alfabético. Las únicas desconexiones pueden ocurrir entre el borde CE y el borde ED, o el borde ED y el borde DM (si caen en filas adyacentes). Pero la clasificación asegura que las E van al lado derecho y las D van al lado izquierdo, como C <E> D <M, por lo que las E y las D permanecen conectadas.

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

Pyth, 30 25 bytes

jb.eu_GkbceQs*R/*FQ4"EDMC

Demostración en vivo y todos los casos de prueba .

¡Corte 5 bytes gracias a @Jakube!

El mismo algoritmo que mi respuesta K ... pero mucho más corto.

Versión de 30 bytes:

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

Demostración en vivo y todos los casos de prueba para la versión de 50 bytes .

K, 61 bytes

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

Ejemplos:

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$ 

Odiaría ser la persona que tiene que cortar estas cosas ...

Pyth, 20 bytes

VceQs*L/*FQ4"CEDM"SN

Utiliza el truco de clasificación de @ aditsu.

Demostración.

Se me ocurrió una gran cantidad de programas alternativos de la misma longitud al intentar jugar golf:

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

Atascado , 42 33

¡Vuelve! Y en forma terriblemente larga. :( - Robé la idea de ordenar de aditsu para guardar 9 bytes :)

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

Explicación:

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.

Entrada de ejemplo:

20|5

Salida de ejemplo:

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 un ahorro de 1 byte, esta versión invierte (solo) la fila central de cortes para cualquier número impar de filas.

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

Muchas respuestas aquí en zigzag, pero en la mayoría de los casos, simplemente generar las letras en orden (de izquierda a derecha, de arriba a abajo) funciona bien:

No es necesario zigzaguear para alturas 1,2 o 4

No es necesario zigzaguear para alturas superiores a 4 (la ración de pizza de cada mod se ajustará).

Por lo tanto, solo necesitamos zigzaguear cuando la altura es 3, y luego solo necesitamos invertir la fila del medio.

Como resultado, Dennis y Doorknob son los únicos mods en esa fila. Y pueden intercambiarse XORing sus códigos ASCII con 1.

Esto es útil dado que no hay una manera fácil de invertir una cadena en C.

Sin golf en el programa de prueba

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

Solución en zigzag. Usando una cadena de plantilla, la nueva línea es significativa y contada.

Prueba a ejecutar el fragmento con 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

Las características utilizadas en esta respuesta son más nuevas que este desafío (no es que importe ...). El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Esto implementa la solución de aditsu que ahora es algo factible gracias a las nuevas etapas de clasificación.