Défi

Étant donné une liste de noms de couleurs uniques en entrée, triez-les dans l'ordre dans lequel ils apparaissent pour la première fois dans Amazing Technicolor Dreamcoat de Joseph .

Exemple

Input:  green, blue, red, brown
Output: red, green, brown, blue

La liste complète des couleurs, dans l'ordre, est la suivante:

 1. red
 2. yellow
 3. green
 4. brown
 5. scarlet
 6. black
 7. ochre
 8. peach
 9. ruby
10. olive
11. violet
12. fawn
13. lilac
14. gold
15. chocolate
16. mauve
17. cream
18. crimson
19. silver
20. rose
21. azure
22. lemon
23. russet
24. grey
25. purple
26. white
27. pink
28. orange
29. blue

Ou comme un tableau de chaînes:

["red","yellow","green","brown","scarlet","black","ochre","peach","ruby","olive","violet","fawn","lilac","gold","chocolate","mauve","cream","crimson","silver","rose","azure","lemon","russet","grey","purple","white","pink","orange","blue"]

Règles

• Vous pouvez prendre des entrées par tout moyen raisonnable et pratique (par exemple, un tableau de chaînes, une chaîne délimitée, des chaînes individuelles) tant que cela est autorisé par nos règles d'E / S standard , mais veuillez spécifier votre méthode d'entrée dans votre réponse.
• Vous pouvez faire de même pour votre sortie.
• L'entrée ne contiendra que les couleurs de la liste ci-dessus.
• Votre solution doit pouvoir gérer les entrées vides.
• Vous pouvez choisir si tous les mots de l'entrée sont toujours en majuscules, en minuscules ou en majuscules, mais la casse de votre sortie doit correspondre à celle de votre entrée.
• C'est le code-golf donc le nombre d'octets le plus bas dans chaque langue gagne.
• Comme toujours, les failles standard sont interdites.

Cas de test

Input:  []
Output: []

Input:  ["green", "blue", "red", "brown"]
Output: ["red", "green", "brown", "blue"]

Input:  ["gold", "grey", "green"]
Output: ["green", "gold", "grey"]

Input:  ["ruby","yellow","red","grey"]
Output: ["red", "yellow", "ruby", "grey"]

Input:  ["gold", "green", "fawn", "white", "azure", "rose", "black", "purple", "orange", "silver", "ruby", "blue", "lilac", "crimson", "pink", "cream", "lemon", "russet", "grey", "olive", "violet", "mauve", "chocolate", "yellow", "peach", "brown", "ochre", "scarlet", "red"]
Output: ["red", "yellow", "green", "brown", "scarlet", "black", "ochre", "peach", "ruby", "olive", "violet", "fawn", "lilac", "gold", "chocolate", "mauve", "cream", "crimson", "silver", "rose", "azure", "lemon", "russet", "grey", "purple", "white", "pink", "orange", "blue"]

PowerShell , 262 155 151 127 125 95 bytes

$args|sort{"rlyegwbrscbrocpyrvo lvnfaldgccvmacmcvseraolsrygpptwkpnoeb".indexof((-join$_[3,0]))}

Essayez-le en ligne!

Approche naïve. PowerShell sort-objectpeut trier en fonction d'un bloc de script qui est exécuté pour chaque objet. Ici, nous obtenons simplement .IndexOf()la couleur d'une chaîne, qui attribuera une valeur numérique à chaque couleur, puis trie en fonction de ces nombres. La chaîne est construite à partir des quatrième et première lettres de chaque couleur pour garantir l'unicité. La sortie est implicite.

-4 octets grâce à Shaggy.
-2 octets grâce à mazzy.
Un énorme -30 octets grâce à KGlasier.

JavaScript (SpiderMonkey) ,  106 105  104 104 octets

"En cas de doute, hachez juste l'entrée sanglante."

a=>a.sort((a,b)=>(g=s=>'i0008bar5dj60007f3001p09mseqg0hk40cnl2o'[parseInt(s,36)*50%257%170%40])(a)>g(b))

Essayez-le en ligne!

Gelée , 28 octets

“½Ṗ©cƘʂẒẹMMỤẓHP’Œ?“ðÑþQ’,ḥµÞ

Essayez-le en ligne!

Comment ça marche

µtransforme tout à sa gauche en une chaîne monadique, qui Þmappe le tableau d'entrée et trie l'entrée en fonction des valeurs générées.

“½Ṗ©cƘʂẒẹMMỤẓHP’ définit la valeur de retour sur 176073885534954276199526358143331.

Œ?$\small[20,28,15,3,5,26,18,16,8,30,4,25,2,21,22,11,24,1,23,10,29,12,17,27,14,9,6,13,7,19]$

“ðÑþQ’donne 391695582; ,le ajoute à la permutation. Ensuite, ḥcalculez la fonction de hachage 391695582 ^{e de} Jelly, en mappant les compartiments résultants aux entiers de la permutation.

La constante magique 391695582 a été trouvée par les utils de Jelly .

dennis-home:utils$ time ./findhash 30 29 <<< '["red","yellow","green","brown","scarlet","black","ochre","peach","ruby","olive","violet","fawn","lilac","gold","chocolate","mauve","cream","crimson","silver","rose","azure","lemon","russet","grey","purple","white","pink","orange","blue"]'
391695582

real    0m2.058s
user    0m15.077s
sys     0m0.023s

Python 3 , 93 octets

lambda r:sorted(r,key=lambda s:'iV^ZzwnFM@pYuOobXGAKyf[tUR]E'.find(chr(int(s,36)%127%60+64)))

Essayez-le en ligne!

Lit chaque couleur en tant que base-36 int. Brute-forcé les modules et a choisi un décalage arbitraire parmi les 19 qui ne nécessitent pas d'évasion.

Powershell, 124 120 124 119 119 118 102 octets

$args|sort{$c=$_
'bluOrPiWPuG*yRusLeARoSiCriCrMCGoLFVOlRuPOBlSBGYR'-csplit'(?=[A-Z])'|%{$c-like"$_*"}}

Essayez-le en ligne!

Explication:

1. La chaîne de données contient les premières lettres significatives des étiquettes de couleur dans l'ordre décroissant. À l'exception de l' Greyétiquette - G*yest plus courte.

2. -csplit'(?=[A-Z])' divise la chaîne de données dans le tableau (blu,Or,Pi,W,Pu,G*y,Rus,Le,A,Ro,Si,Cri,Cr,M,C,Go,L,F,V,Ol,Ru,P,O,Bl,S,B,G,Y,R)

3. |%{$c-like"$_*"}mappe le tableau de chaînes au tableau de booléens. Où Truesignifie "une étiquette de couleur commence à partir de cette chaîne" (comme l'opérateur insensible à la casse, csplit - sensible à la casse. Voir la doc ).

4. sort{}trie les étiquettes de couleur par les tableaux de booléens dans l' ordre croissant .

Le tri par tableau est une fonctionnalité très intéressante dans le Powershell. Dans ce script, tous les tableaux ont la même longueur et contiennent uniquement des valeurs booléennes. Ce tri est effectué dans l'ordre lexographique des tableaux booléens.

Par conséquent, la chaîne peut contenir des abréviations d'une lettre pour les dernières étiquettes. S'il existe une correspondance au début du tableau, les correspondances à la fin n'ont aucun effet.

       blu Or Pi W Pu G*y Rus Le A Ro Si Cri Cr M C Go L F V Ol Ru P O Bl S B G Y R
green: -   -  -  - -  -   -   -  - -  -  -   -  - - -  - - - -  -  - - -  - - T - -
gold : -   -  -  - -  -   -   -  - -  -  -   -  - - T  - - - -  -  - - -  - - T - -
grey : -   -  -  - -  T   -   -  - -  -  -   -  - - -  - - - -  -  - - -  - - T - -

     : green < gold < grey

Où Test trueet -est false.

Script de test:

$f = {

$args|sort{$c=$_
'bluOrPiWPuG*yRusLeARoSiCriCrMCGoLFVOlRuPOBlSBGYR'-csplit'(?=[A-Z])'|%{$c-like"$_*"}}

}

@(
    ,( @(), @() )
    ,( ('green', 'blue', 'red', 'brown'), ('red', 'green', 'brown', 'blue') )
    ,( ("gold", "grey", "green"), ("green", "gold", "grey") )
    ,( ("ruby","yellow","red","grey"), ("red", "yellow", "ruby", "grey") )
    ,( ("gold", "green", "fawn", "white", "azure", "rose", "black", "purple", "orange", "silver", "ruby", "blue", "lilac", "crimson", "pink", "cream", "lemon", "russet", "grey", "olive", "violet", "mauve", "chocolate", "yellow", "peach", "brown", "ochre", "scarlet", "red"),
       ("red", "yellow", "green", "brown", "scarlet", "black", "ochre", "peach", "ruby", "olive", "violet", "fawn", "lilac", "gold", "chocolate", "mauve", "cream", "crimson", "silver", "rose", "azure", "lemon", "russet", "grey", "purple", "white", "pink", "orange", "blue") )
) | % {
    $inp,$expected = $_
    $result = &$f @inp  # splatting
    "$("$result"-eq"$expected"): $result"
}

Sortie:

True:
True: red green brown blue
True: green gold grey
True: red yellow ruby grey
True: red yellow green brown scarlet black ochre peach ruby olive violet fawn lilac gold chocolate mauve cream crimson silver rose azure lemon
russet grey purple white pink orange blue

Je vais améliorer la compression des cordes dans un moment

Japt , 88 78 71 octets

ñ@`䊐âwrÒ.cÖ¨acru½ivo¤faØngoÒqauvœamsolv€osz¨e¶s gœrpl–tpˆ„g½u`bXé4 ¯3

Essayez-le en ligne!

Langue Wolfram 255 213 199 octets

Quatorze octets enregistrés par Dennis, qui a évité les "marques", en utilisant des symboles au lieu de chaînes.

SortBy[#,{yellow,green,brown,scarlet,black,ochre,peach,ruby,olive,violet,fawn,lilac,gold,chocolate,mauve,cream,crimson,silver,rose,azure,lemon,russet,grey,purple,white,pink,orange,blue}~Position~#&]&

Essayez-le en ligne!

Python 2 , 186 octets

lambda a:[y for x,y in sorted((max(" y gree br sc bla oc pe rub ol v f li go ch m cre cri si ro a le rus grey pu w pi or blu ".find(" %s "%c[:i+1])for i,j in enumerate(c)),c)for c in a)]

Essayez-le en ligne!

Recherche toutes les correspondances pour les sous-chaînes de caractères progressives (Ex: "vert" vérifiera "g", "gr", "gre", "gree" et "vert") dans la chaîne d'identifiant et conserve l'index maximum. "rouge" est toujours le premier, anf find () renvoie -1 pour les correspondances manquantes, il n'y a donc pas d'identifiant spécifique pour le rouge.

Une fois les couleurs transformées en paires (index, couleur), trie le tableau sur le premier élément de la paire, puis supprime le premier élément de chaque paire.

Python 3 , 130 octets

lambda*a:sorted(a,key=lambda c:("r,ylgebwsrtbcorpcryovvlfnlagdccamvca cmnsvrearlorsgyppwtpkonbe".find(c[::3]+" "*(c=="cream")),c))

Essayez-le en ligne!

C # (Visual C # Compiler Interactive) , 321 219 210 161 159 138 octets

n=>n.OrderBy(a=>a!="grey"?"yelgrebroscablaochperuboliviofawlilgolchomaucrecrisilrosazulemruspurwhipinorablu".IndexOf(a.Substring(0,3)):65)

Essayez-le en ligne!

-3 octets grâce à Shaggy, -18 grâce à TheLethalCoder

Prend l'entrée comme un List<string>, renvoie unIOrderedEnumerable<string>

Comment cela fonctionne, c'est qu'il ordonne la liste par index de chaque chaîne dans la chaîne d'origine. La chaîne d'origine a toutes les couleurs sauf le gris transformé en ses trois premières lettres. Le gris n'est pas là, car le vert et le gris créeraient une ambiguïté. Le rouge n'est pas là non plus, car IndexOfrenvoie -1 si la chaîne n'apparaît pas.

Version plus courte prenant IOrderedEnumerable en entrée, 137 octets

n=>n.ThenBy(a=>a!="grey"?"yelgrebroscablaochperuboliviofawlilgolchomaucrecrisilrosazulemruspurwhipinorablu".IndexOf(a.Substring(0,3)):65)

Profite du fait qu'il ThenByest 1 octet plus court que OrderBy, mais ThenByne fonctionne que sur IOrderedEnumerables.

Essayez-le en ligne!

Charbon de bois , 69 68 63 56 octets

Ｆ⪪”E$↥l∧_∧K⁰ＲY⸿h⊕ψVG⌕gbＷ⟧⁼″5/²H✳<◨Ａ³?ω↗⊘‴⭆1”²Φθ№κ⎇Σιlilι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｆ⪪”E$↥l∧_∧K⁰ＲY⸿h⊕ψVG⌕gbＷ⟧⁼″5/²H✳<◨Ａ³?ω↗⊘‴⭆1”²

Prenez la chaîne compressée edyeeebrscckhrpeubivvifa99gohomaamrisiosazemuseypuwhpiorluet bouclez sur chaque sous-chaîne de longueur 2.

Φθ№κ⎇Σιlilι

Pour chaque sous-chaîne, imprimez les chaînes d'entrée qui contiennent cette sous-chaîne, sauf si la sous-chaîne l'est 99, auquel cas recherchez-la à la lilplace. ( lilacest la seule couleur qui n'a pas de sous-chaîne unique à deux lettres; oliveinclut li; silverinclutil et blackinclut lac. fawnet azurepeut être détectée à l'aide d'une seule lettre, mais cela n'aide pas ici.)

Pyth, 66 octets

oxc."ayÇæ£ðÐ¥~@iF[2BÍÐ:Yë)^ksTTã"2s@LN,03

Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

Les couleurs de la liste peuvent être identifiées de manière unique en prenant les caractères à l'index 0 et 3en supposant une indexation modulaire. Il en résulte le mappage suivant:

rr -> red
yl -> yellow
ge -> green
bw -> brown
sr -> scarlet
bc -> black
or -> ochre
pc -> peach
ry -> ruby
ov -> olive
vl -> violet
fn -> fawn
la -> lilac
gd -> gold
cc -> chocolate
mv -> mauve
ca -> cream
cm -> crimson
sv -> silver
re -> rose
ar -> azure
lo -> lemon
rs -> russet
gy -> grey
pp -> purple
wt -> white
pk -> pink
on -> orange
be -> blue

Explication complète:

oxc."..."2s@LN,03Q   Implicit: Q=eval(input())
                     Trailing Q inferred, dictionary string replaced with ... for brevity
o                Q   Order the elements of Q, as N, using:
              ,03      [0,3]
           @LN         Get the characters at the above indices in N
          s            Concatenate into a string
                         The above is result {1}
   ."..."              The compressed dictionary string
  c      2             Split into chunks of length 2
 x                     Get the index of {1} in the above
                       Implicit print of sorted list

05AB1E , 48 octets

Σ.•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•2ôy¬s3è«k

Même solution que la plupart des autres réponses. J'essaierai de jouer au golf d'ici plus tard.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Σ          # Sort the (implicit) input-list by:
 .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•
           #  Push compressed string "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe"
  2ô       #  Split into parts of size 2
 y         #  Push the current string of the list we're sorting
  ¬        #  Push its head (without popping)
   s       #  Swap so the string is at the top of the stack again
    3è     #  Get the character at index 3 (with automatic wraparound)
      «    #  Merge both characters together
       k   #  And get the index in the compressed string to sort on

Voir cette astuce 05AB1E (section Comment chaînes Compresser ne font pas partie du dictionnaire? ) Pour comprendre comment .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•est "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe".