Ingresso:

L'input è un array randomizzato di noci (nella tua lingua), le possibili noci seguono. Il tuo programma deve avere un modo di rappresentare ogni tipo di dado, come un codice intero. Il programma deve essere in grado di gestire array di qualsiasi dimensione di qualsiasi configurazione di dadi.

Noci possibili:

Kola nut
Macadamia
Mamoncillo
Maya nut
Mongongo
Oak acorns
Ogbono nut
Paradise nut
Pili nut
Pistachio
Walnut

Produzione:

L'output deve essere l'array ordinato in modo tale che non vi siano dadi adiacenti dello stesso tipo. Se ciò è impossibile, l'output dovrebbe essere un array vuoto.

Esempio di input (semplificato):

["walnut", "walnut", "pistachio"]

Esempio di output:

["walnut", "pistachio", "walnut"]

Le soluzioni non possono semplicemente mescolare l'array fino a quando non diventa unico per caso. Il tipo impiegato deve essere deterministico

GolfScript, 42 41 37 38 caratteri

~.`{\`{=}+%1-,}+$.,)2//zip[]*.2<..&=*p

Il codice prevede l'immissione su STDIN e stampa i risultati su STDOUT, ad esempio:

> ["walnut" "walnut" "walnut" "macadamia" "pistachio"]
["walnut" "macadamia" "walnut" "pistachio" "walnut"]

> ["walnut" "walnut" "walnut" "macadamia" "walnut"]
[]

La sceneggiatura è diventata più lunga del previsto, ma suppongo che ci sia spazio per miglioramenti.

Modifica: il caso di un elenco con un singolo oggetto mi costa 1 carattere (il miglior confronto che potrei trovare è lo stesso di quello di Peter).

GolfScript, 32 caratteri

~:x{]x\-,}$.,)2//zip[]*.2<..&=*`

Stesso formato di input e output della soluzione Howard.

Brachylog v2, 10 byte

p.¬{s₂=}∨Ė

Provalo online!

Soluzione a forza bruta. (Questa è una funzione, consentita perché la sfida non dice "programma completo".) È anche principalmente una traduzione diretta delle specifiche (l'unica vera sottigliezza è che sono riuscito a sistemare le cose in modo che tutti i vincoli impliciti arrivassero esattamente nel posti giusti, quindi non è necessario alcun personaggio in più per chiarirli).

Si noti che questo è un algoritmo generico per riorganizzare qualsiasi tipo di elenco in modo che non abbia due elementi toccanti; può gestire rappresentazioni di stringhe degli elementi e può gestire anche codici interi. Quindi non importa davvero come "Il tuo programma deve avere un modo di rappresentare ogni tipo di noce, come un codice intero". il requisito della domanda viene interpretato.

Spiegazione

p.¬{s₂=}∨Ė
p            Find a permutation of {the input}
  ¬{   }     which does not have the following property:
    s₂         it contains a pair of adjacent elements
      =        that are equal
        ∨    {no constraint on what value the equal elements can have}
 .           If you find such a permutation, output it.
        ∨    If no permutation is found, ignore the input and
         Ė     {output} an empty list

J, 80 caratteri

]`_:@.(0<2&([:+/=/\))({.~-:@#),((],.|.)~>.@-:@#)<"1;(\:#&.>)(</.])[;.1' ',1!:1[1

Non proprio nella stessa lega di Golfscript su questo. Ho il sospetto che ci siano guadagni da fare, ma i 14 caratteri necessari solo per inserire la lista nel programma [;.1' ',1!:1[1sono un grave handicap.

Fondamentalmente il programma prende in considerazione l'elenco, raggruppa elementi simili, ordina per numero di elementi in ciascun gruppo decrescente e alterna l'output tra la prima metà e la seconda metà dell'elenco. Il resto se il codice elimina gli elementi estranei e decide se l'elenco è un output valido (producendo infinito _se non lo è).

Esempio:

macadamia walnut walnut pistachio walnut

gruppo (</.]):

macadamia walnut walnut walnut pistachio

ordina (\:#&.>):

walnut walnut walnut macadamia pistachio

corvo ((],.|.)~>.@-:@#):

walnut macadamia walnut pistachio walnut

Gelatina , 14 byte

Ġz0UẎḟ0ịµẋ⁻ƝẠ$

Provalo online!

Gli ultimi 6 byte possono essere rimossi se possiamo avere un comportamento indefinito per input non validi.

Stax , 10 byte

│éÿ∞å[zàL⌂

Esegui ed esegui il debug

Ecco lo stesso programma decompresso, ungolf e commentato.

|T      get all permutations
{       block to filter by
  :g_=  after dropping repeated elements, it's still equal
f       execute filter
|c      terminate and pop if falsy (no match)
hJ      take the first permutation, and join with spaces

Esegui questo