Programming Puzzles & Code Golf sta per ottenere un nuovo moderatore , Dennis ! Questa sfida è un omaggio a lui e ai nostri altri moderatori attivi (o recentemente attivi): Doorknob , Martin Büttner e Chris Jester-Young . Il titolo della sfida dovrebbe essere letto sulla melodia della canzone di Pepto Bismol .

In sostanza, stiamo andando a trattare tutti alla pizza al The Nineteenth Bite Pizzeria , ma abbiamo bisogno di fare in modo che lo condividono abbastanza perché alcuni dei i mods sono noti per essere tossicodipendenti di pizza!

Le pizze vendute dalla pizzeria sono tutti blocchi di testo rettangolari. La larghezza e la lunghezza di una pizza possono essere numeri interi non negativi purché il loro prodotto sia divisibile per quattro. Ogni spazio della griglia nel blocco di testo pizza rappresenta una sezione, quindi è sempre possibile dividere le sezioni in quattro gruppi uguali.

Le mod ordineranno collettivamente una singola pizza, fornendo i suoi parametri di larghezza e lunghezza al loro server in qualsiasi formato ragionevole come [width],[length]. Appena prima che la pizza arrivi al loro tavolo, devi etichettare ogni fetta con l'iniziale della mod che arriva a mangiarla per assicurarsi che condividano equamente. Tutti dovrebbero ottenere lo stesso numero di sezioni.

• E è per Dennis
• D è per Doorknob
• M è per Martin
• C è per Chris

Le mod sono un po 'persnickety, tuttavia, e richiedono che i rispettivi set di sezioni siano collegati al percorso , ovvero che tutte le loro sezioni possano essere raggiunte l'una dall'altra spostandosi verso l'alto, il basso, a sinistra ea destra, senza incrociare quella di nessun altro sezioni (e non in movimento in diagonale). Non importa come lo fai finché è fatto.

Dopo aver accuratamente etichettato ogni fetta, consegna la pizza alle mod con una nuova riga finale opzionale.

L'etichettatrice può essere un programma o una funzione e può stampare o restituire la pizza etichettata. Vince l'etichettatrice più corta nei morsi.

Esempi

Esempio 1

Ordine: 4,1

Alcune possibili pizze etichettate:

EDMC

MEDC

CDEM

Esempio 2

Ordine: 4,4

Alcune possibili pizze etichettate:

MMMM
CCCC
DDDD
EEEE

DEMC
DEMC
DEMC
DEMC

CCCC
DEEM
DEEM
DDMM

Esempio 3

Ordine: 8,3

Alcune possibili pizze etichettate:

MMMMMMCC
DDDDCCCC
DDEEEEEE

DDDCMMMM
DCDCMEEE
DCCCMEEE

Esempio 4

Ordine: 20,5

Una possibile pizza etichettata:

DDDDDDDDDDDDMCCCCCCCCCCC
DEEEEEEEEEEDMMMMMMMCCCCC
DEEEEEEEEEEDMMMCCCCCCCCC
DEEEEEEEEEEDMMMMMMMMCCCC
DDDDDDDDDDDDMMMMMMMMMMMC

(I Dqui non sono semplicemente collegati ma va bene.)

CJam, 20 byte

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

Penso che dovrebbe funzionare :)

Provalo online

Spiegazione:

Questo prima rende una pizza etichettata CC ... EE ... DD ... MM ... da sinistra a destra e dall'alto verso il basso, quindi ordina ogni riga in ordine alfabetico. Le uniche disconnessioni possono avvenire tra il confine CE e confine ED, oppure confine ED e confine DM (se cadono su file adiacenti). Ma l'ordinamento assicura che le E vanno sul lato destro e le D vanno sul lato sinistro, come C <E> D <M, quindi le E e le D rimangono collegate.

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 byte

jb.eu_GkbceQs*R/*FQ4"EDMC

Demo live e tutti i casi di test .

Taglia 5 byte grazie a @Jakube!

Stesso algoritmo della mia risposta K ... ma molto più breve.

Versione a 30 byte:

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

Demo live e tutti i casi di test per la versione a 50 byte .

K, 61 byte

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

Esempi:

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$ 

Odierei essere la persona che deve tagliare queste cose ...

Pyth, 20 byte

VceQs*L/*FQ4"CEDM"SN

Usa il trucco di smistamento di @aditsu.

Dimostrazione.

Ho provato un gran numero di programmi alternativi della stessa lunghezza mentre cercavo di giocare a 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

Bloccato , 42 33

Ritorna! E in una forma terribilmente lunga. :( - Ho rubato l'idea di aditsu per salvare 9 byte :)

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

Spiegazione:

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.

Esempio di input:

20|5

Esempio di output:

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

Per un salvataggio di 1 byte, questa versione inverte (solo) la riga centrale di sezioni per qualsiasi numero dispari di righe.

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

Molte risposte qui a zig-zag, ma nella maggior parte dei casi, solo l'emissione delle lettere in ordine (da sinistra a destra, dall'alto verso il basso) funziona bene:

Non è necessario zigzag per le altezze 1,2 o 4

Non c'è bisogno di zigzag per altezze superiori a 4 (la razione della pizza di ogni mod andrà a finire).

Pertanto, in realtà abbiamo solo bisogno di zigzag quando l'altezza è 3, e quindi dobbiamo solo invertire la riga centrale.

A quanto pare, Dennis e Doorknob sono le uniche mod di quella fila. E possono essere scambiati XORing i loro codici ASCII con 1.

Questo è utile dato che non esiste un modo semplice per invertire una stringa in C.

Non registrato nel programma di test

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

Soluzione a zigzag. Utilizzando la stringa di modello, la nuova riga è significativa e conteggiata.

Prova a eseguire lo snippet 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 byte

Le funzionalità utilizzate in questa risposta sono più recenti di questa sfida (non che sia importante ...). Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online!

Questo implementa la soluzione di Aditsu che ora è in qualche modo fattibile grazie alle nuove fasi di ordinamento.