Contribution:

L'entrée est un tableau aléatoire de noix (dans votre langue), les noix possibles suivent. Votre programme doit avoir un moyen de représenter chaque type d'écrou, tel qu'un code entier. Le programme doit être capable de gérer n'importe quelle taille de tableau de n'importe quelle configuration d'écrous.

Noix possibles:

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

Production:

La sortie doit être le tableau trié de manière à ce qu'il n'y ait pas d'écrous adjacents du même type. Si cela est impossible, la sortie doit être un tableau vide.

Exemple d'entrée (simplifié):

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

Exemple de sortie:

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

Les solutions ne peuvent pas simplement mélanger la baie jusqu'à ce qu'elle devienne unique par hasard. Le type utilisé doit être déterministe

GolfScript, 42 41 37 38 caractères

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

Le code attend l'entrée sur STDIN et imprime le résultat sur STDOUT, par exemple:

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

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

Le script est devenu plus long que prévu, mais je suppose qu'il y a place à amélioration.

Edit: Le cas d'une liste avec un seul élément me coûte 1 caractère (la meilleure comparaison que j'ai pu trouver est la même que celle de Peter).

GolfScript, 32 caractères

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

Même format d'entrée et de sortie que la solution d'Howard.

Brachylog v2, 10 octets

p.¬{s₂=}∨Ė

Essayez-le en ligne!

Solution de force brute. (Il s'agit d'une fonction, autorisée car le défi ne dit pas "programme complet".) C'est aussi principalement une traduction directe de la spécification (la seule vraie subtilité est que j'ai réussi à arranger les choses pour que toutes les contraintes implicites arrivent exactement dans le bons endroits, donc pas besoin de caractères supplémentaires pour les désambiguïser).

Notez qu'il s'agit d'un algorithme générique pour réorganiser toute sorte de liste afin qu'elle ne comporte pas deux éléments tactiles; il peut gérer des représentations sous forme de chaîne des éléments, et il peut également gérer des codes entiers. Donc, peu importe comment "votre programme doit avoir un moyen de représenter chaque type d'écrou, comme un code entier". l'exigence de la question est interprétée.

Explication

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 caractères

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

Pas vraiment dans la même ligue que Golfscript sur celui-ci. Je soupçonne qu'il y a des gains à faire, mais les 14 caractères nécessaires juste pour mettre la liste dans le programme[;.1' ',1!:1[1 sont un handicap majeur.

Fondamentalement, le programme prend la liste, regroupe les éléments similaires, trie par nombre d'éléments dans chaque groupe décroissant et alterne la sortie entre la première moitié et la seconde moitié de la liste. Le reste si le code se débarrasse des éléments superflus et décide si la liste est une sortie valide (sortie infinie _si ce n'est pas le cas).

Exemple:

macadamia walnut walnut pistachio walnut

groupe (</.]):

macadamia walnut walnut walnut pistachio

trier (\:#&.>):

walnut walnut walnut macadamia pistachio

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

walnut macadamia walnut pistachio walnut

Gelée , 14 octets

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

Essayez-le en ligne!

Les 6 derniers octets peuvent être supprimés si nous pouvons avoir un comportement indéfini pour les entrées non valides.

Stax , 10 octets

│éÿ∞å[zàL⌂

Exécuter et déboguer

Voici le même programme décompressé, non golfé et commenté.

|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

Exécutez celui-ci