[Question]
  [
## Challenge
Given a list of **unique** colour names as input, sort them in the order that they first appear in [Joseph's Amazing Technicolour Dreamcoat](https://youtu.be/snYP49EAIWg?t=2m51s).
---
## Example
```
Input:  green, blue, red, brown
Output: red, green, brown, blue
```
The full list of colours, in order, is:
```
 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
```
Or as an array of strings:
```
["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"]
```
---
## Rules
* You may take input by any reasonable, convenient means (e.g., an array of strings, a delimited string, individual strings) as long as it's permitted by [our standard I/O rules](https://codegolf.meta.stackexchange.com/q/2447/58974), but please specify your input method in your answer.
* You may do the same for your output.
* The input will only ever contain colours from the above list.
* Your solution should be able to handle empty inputs.
* You may choose whether all words in the input are consistently uppercase, lowercase or title case but your output's casing *must* match your input's.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so lowest byte count in each language wins.
* As always, [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
---
## Test cases
```
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"]
```
  
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~262~~ ~~155~~ ~~151~~ ~~127~~ ~~125~~ 95 bytes
```
$args|sort{"rlyegwbrscbrocpyrvo lvnfaldgccvmacmcvseraolsrygpptwkpnoeb".indexof((-join$_[3,0]))}
```
[Try it online!](https://tio.run/##JcVRCsIwDADQq8gYdAMVweOISJdmtZo2JRmdRT17Hfh@XuYVRe9I1FpvxetHWZZ3J1TRr5MoTMKQqxTeUUmzJecBSrQQoSiKZVKpPudlfebEOHXHkBy@eB6Gw4ND6m@X8/50Hcdva814Jme2BOs/TNsgISon8wM "PowerShell – Try It Online")
~~Naive approach.~~ PowerShell `sort-object` can sort based on a script block that gets executed for every object. Here we're simply getting the `.IndexOf()` the color from a string, which will assign a numerical value to each color, and then sorts based on those numbers. The string is constructed from the fourth and first letters of each color to ensure uniqueness. Output is implicit.
*-4 bytes thanks to Shaggy.*  
*-2 bytes thanks to mazzy.*  
*A whopping -30 bytes thanks to KGlasier.*
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), ~~104~~ 101 bytes
*"When in doubt, just hash the bloody input."*
```
a=>a.sort((a,b)=>(g=s=>'mgo0dakbrfs0h0000j9c412603e870500p0l0niq'[parseInt(s,36)%657%53%42])(a)>g(b))
```
[Try it online!](https://tio.run/##jZPLbsIwEEX3fAWKhGpLlLrl0YcU9u2iXXSJWEyMk7g4tmsnIPrzNNg4CaIPssnE9tyZOdf5gA1Yargur63mK2YKJddst0/jPcRzGFllSoRgmOB4jrLYxvOrIlNkBevEpJbkpH4@Hunk9m5GxuzhnkwJ0UQQyT@vFhqMZc@yRHY4nuHBbHo/mI4Hk7slRoDnGUow3lMlrRJsJFSGXt7fXke2NFxmPN2hFC2WGOPezU3/rSp1VT71F8te7@@MKDOMyWjYjxJRscPbsJX7NGorozPBsN2muXMh/4J6SgSBXSt0XqcpcJLwv76pklo32jEh1LYOXL/H5N@GCYf7x@yLi3V6882m4GFsc146mvBVGY9VWeYxAV0fAl0ZLdySMiAzF1kuNsx0GwmuCF7nHYL68hVWuSKay7VfYlC4Q6zwO6aylpVdzErwjRPa8Hoet1VA5ZdorqgS4BtuWWgGND@xWNHcD2MpmKPKAeEFYM/vS0ejYdIUaGoHDj/0H1g3aIIbJ/O0UwZKHYId3kd7Gr/@YNk619gcrGit9L/D/hs "JavaScript (SpiderMonkey) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 28 bytes
```
“½Ṗ©cƘʂẒẹMMỤẓHP’Œ?“ðÑþQ’,ḥµÞ
```
[Try it online!](https://tio.run/##PU@xSsRAEO3zFfMB/oOtIAdaWm72xmS9zU7YvU2I1XGNtSeIglhpIViIKNzl0CJBC/9i8yNxkhObgTfvzXtvzlDrqu@7xV3zETbXzZP8vvlZhnoV6s1kErYPob46OOoWt1@rfRa1L@1l@3nMeC@sH5v39r4P2zcI69du@QztxTAPh3HS91FiEQ3E2iNYnEJsqTRRQnoKzFQw0pH1cQUVt6ByVA3Uv4jPT0VpoEzVHEGce8tW5JBNhZxB7m2uEcgKkyA4pQu0MBqOoVqxCqRVmSMDuTIzBigy0JjxwnrncL7rQloVCIUizZtMeAYyJUlacO5fuxyFTHdfAMmUqzgp7HDAvX8B "Jelly – Try It Online")
### How it works
`µ` turns everything to its left into a monadic chain, which `Þ` maps over the input array and sorts the input according to the generated values. 
`“½Ṗ©cƘʂẒẹMMỤẓHP’` sets the return value to 176073885534954276199526358143331.
`Œ?` generates the 176073885534954276199526358143331th permutation of the positive integers (without the sorted tail), yielding \$\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’` yields 391695582; `,` prepends it to the permutation. Then, `ḥ`c ompute Jelly's 391695582th hash function, mapping the
 resulting buckets to the integers of the permutation.
The magic constant 391695582 was found by [Jelly's utils](https://github.com/DennisMitchell/jellylanguage/tree/master/utils "jellylanguage/utils at master · DennisMitchell/jellylanguage").
```
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
```
[Answer]
# [Python 3](https://docs.python.org/3/), 93 bytes
```
lambda r:sorted(r,key=lambda s:'iV^ZzwnFM@pYuOobXGAKyf[tUR]E'.find(chr(int(s,36)%127%60+64)))
```
[Try it online!](https://tio.run/##ZVFNS8QwEL37K0phaaNF1JUVFhb0oB5EBEFZ7VZI02kbNk3CpB90/3xtky4reJrJmzfvzUx0X5dKLodisxsErdKMerg2CmvIQoz20G9m1KwD/vnzfejk0@u9/mreVLp9fnjp87j@eE8eg8ucyyxkJYZc1qGJliuyuL65W6yuLla3hJBB41Q4D4uwJV6u0Gs9Lr04TqIzL/YLBJB@5PmpaGCKCJl9ouqkP3OUsNjI7ecIxxo26Yj5PQihujGx7Y75r9kZ5bSzsSt5bR3poUFnrQy4USjbT4luUAsLKaSysJnhogW0dGt9mlzwsW9KGPLKKGuiudw7CGhlSVC5CjbGQP13LSV4a4VaroQrVbRxECsVU4K6gY/LjvJAWXk61yQy/oSbk1GcVaabJAmJDOhNsJMBGX4B "Python 3 – Try It Online")
Reads each color as a base-36 `int`. Brute-forced the moduli and chose an arbitrary offset among the 19 that didn't require escapes.
[Answer]
# Powershell, ~~124~~ ~~120~~ ~~124~~ ~~119~~ ~~118~~ 102 bytes
```
$args|sort{$c=$_
'bluOrPiWPuG*yRusLeARoSiCriCrMCGoLFVOlRuPOBlSBGYR'-csplit'(?=[A-Z])'|%{$c-like"$_*"}}
```
[Try It Online!](https://tio.run/##fVNha9swEP3uXyFUd7aL8wcGYWkLy5eOhBQ2tjGKolxtEcXyJCteluS3p5JsyS6ECuM7n969072zatGCVCVwfolf0RQdLzGRhTopIZtjTKfxS5SsuV7IJfux1PO7w0qrJ7hfiWf2KM3z7XEunr5@X/CVXi4e@PPD/OcqmVBVc9Yk6Zfp7/vJrz9Zcro1ZBPOtoDjlzt8Pl/OUTRLI2RWnqJZmuX2hTIfSZNCAlRJjmx5sFbCxn1K0VaJwac@MiDdlk8Zs@FC8A3OETbYQ2@hwpald21sjHmXLfXaZOGDkUm0xjGFzbvDWQr3jcI@6hOuUY2KdFVfSetsW7IGrEP@a@kcKZSza07o1jq1ljV3ISFJVThPMb4HOa5pm7eWM5NnHSrZTglXpGbVtgsB2TkQ7LodqZWCZiyR4GzviPZM8G5rR3QXoqWggpPuwEPbNRBaujPYSTgSWnbNKEpkz2LVynIniVlX1AvaBJpRdlAjUIeqXoErJ/cqB1H8HN51MvTn9RlpN1K6H0yY1AcqDjMLA/ZDGIboRmZ/kwyd0C06Om1iVtV5DP9qoA1szN00d9HFJSjNGxP4ZK7szKAQukHmxpGmYVXhMDhOcY/DE/iLAw3OPnsCHJ0vbw)
Explanation:
1. The data string contains the first significant letters of the color labels in descending order. Except for the `Grey` label - `G*y` is shorter.
2. `-csplit'(?=[A-Z])'` splits the data string to the array `(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"$_*"}` maps the string array to the array of boolean. Where `True` means "a color label starts from this string" (like is case-insensitive operator, csplit - case-sensitive. [see doc](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_comparison_operators)).
4. `sort{}` sorts a color lables by the arrays of boolean in [ascending order](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/sort-object).
The sorting by array is a very interesting feature in the Powershell. In this script all arrays have the same length and contain Boolean values only. This sorting is performed in the lexographic order of boolean arrays.
Therefore, the string can contain one-letter abbreviations for the last labels. If there is a match at the beginning of the array, the matches at the end have no effect.
```
       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
```
Where `T` is `true` and `-` is `false`.
---
Test script:
```
$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"
}
```
Output:
```
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
```
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~121~~ 119 bytes
```
#define j(i)index(".MH^>SALcD8Z!)3TF(RNe*aQU<,'",(**i^377)%75+30)
s(**a,**b){return j(a)-j(b);}f(*t,n){qsort(t,n,8,s);}
```
[Try it online!](https://tio.run/##lZRdb9MwFIbv@yuMUYWdejCaVp3ohoSEEBeAxNcN0ya57snq4djFTlq2qr@9OLZbmm6oIjd@fXLO@xwfRxEnQnF9s9k8nUIhNaBbIqnUU/hN8POP769ff33zQbw9@/GE5t/ekS@fIOOfv5@zZ5iRLJPX@WhEu6NhLz@lHecjnGXZhK4sVLXV3ovTk1syoeN1QbKKabr65YytiJfsjDkf3yyMnKKllRUQMeM2Q5qXwFDQGRJGGesYkrryutYVRasOQnPrAwXBXfcKs1BBxz5cGItIkyovTsdInocKL3o96t/@LUNd58ui96W8CrXzunIEY6/XnU5oqgJX/U9PjcGulXgiLLUP71gs5YdeycNYKrLgavV4VavLkktNIjy22XT88vIKXaAVWjfp4Qg4hL1dWBly8h5MQcKOohfbfbCg3rll1092@MYCaG@CJ6qGZrUwDVtrlhof4voJ12/h@kdx@Q5nVLD32Lu0wkNMnjB5C5MfxQy2GFtPvD2@A6XM0otwqAg9ZA0Sa9BiDY6yhlsWv68txAly8XN/lHGGXoiZ8XfOqxAVFngZhSydCQkFj4l744m3EucUvvLDBysoY7WSntyIkteLwDBiFnsySqaI9b@DoObAxSwIqUO789rO1f7dW@PgX9A42WZ1DpqPGTvBrUpSqgXYRi2kSbHlTMZzp8s4nP8wzX/Ymv/wsfmvN38A "C (clang) – Try It Online")
-2 bytes thanks ceilingcat!
[Answer]
*I will improve the string compression in a while*
# [Japt](https://github.com/ETHproductions/japt), ~~88~~ ~~78~~ 71 bytes
```
ñ@`äŠâwrÒ.cÖ¨acru½ivo¤faØngoÒqauvœamsolv€osz¨e¶s gœrpl–tpˆ„g½u`bXé4 ¯3
```
[Try it online!](https://tio.run/##y0osKPn///BGh4TDSw51HZpweFF50eFJesmHpx1akZhcVHpob2ZZ/qElaYmHZ@Sl5x@eVJhYWnZoTmJucX5O2aGG/OKqQytSD20rPrQg/dCcooKcQ9NKCg51HGpJP7S3NCEp4vBKE4VD643//49WSs/PSVHSUVBKL0qthNKpeUqxAA "Japt – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 186 bytes
```
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)]
```
[Try it online!](https://tio.run/##fVPbrpswEHwuXzFCOhKoqFL7GClfQnkwzhLcY2xkQ3Loz6e@xIa0R31ALN7Znd0ZPG/LqNWPx3D@@ZBs6i8M7NRuGLTBR7NBKFhtFrpU1cQ@qhIbroYIvYHl6CWD5pgJZu2hJW4YIAWuGnzEBG7IPQJWwGgwSA@0vsOGecUds4Aj6uWK8tsg1MURvFmUb7w9ia/fu9qPIZpffgxS60SGLVTxum54SHGfYHX3WMguFme0RdV2TdF2dVO4sPSzqrJB6SjIvw1dwqfRd1V6ZDrZkSGVSnIjLRNs2@GhQa58waRCJ4wrKDeSUt9dEOiekAN9yuNZ8FeXQ@vINbA45H0US1iM/V5N3FBbiuMz/u6DeTWzDEfaMHUNkRXyRuZIlwSSwtX5wPk2WR1IZqHe4xGxKYBoihnnpqXlKIyW4hYa3YSWMTWxNR7xUXMtWRx433gmxscX6TUf4zKWM/Ps4oX6XLF/rTuUZRlyz0yXVv9k5CRvViMZ8LLCvlgS5iDaQeKnI9mi/8i3m5WdTerv7uU/sysKfw3839/AkF3l4m9EuA2n4stshFowVP67blJwPkfk4w8 "Python 2 – Try It Online")
Finds all matches for progressive character substrings (Ex: "green" will check for "g", "gr", "gre", "gree", and "green") in the identifier string, and keeps the maximum index. "red" is always first, anf find() returns -1 for missing matches, so there is no identifier for red specifically.
Once the colors are turned into (index, color) pairs, sorts array on first item of pair and then discards first item of each pair.
[Answer]
# Wolfram Language ~~255 213~~ 199 bytes
Fourteen bytes saved by Dennis, who avoided the " marks, using symbols instead of strings.
```
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~#&]&
```
[Try It Online!](https://tio.run/##dVLBbsIwDL3vK6wiceILJiFNO3BG4og4hOC10dK6clOqDsGvd7ZDN4a0S@Mkz6/vPad2qcLapeDdtIHX9bQjTu/jfrHaJQ5NuWtjSG@XYsQYaYCSERs4Mg0NdN5xxATH6PwnkK8YoUXnK@D@OALFcEY4B1LMh5OGGAQJJcUT@Io8RZcQatcLzDO6Wr6h7kiYQzwjA1OH4L564Y1Yyzn3XSdkImKEtuc2IgxVEJI2NKKAXVOiyOmxuN621IUUqLktlofltBUvab/ZX66Hw8vPpjA7xQoKa5KV8WRbNVg8YUW33unf7ys@Y9S43uW0Hgit6V@@rEEz0tUsaWHWjUSCyColaS2yea2yaa1yaAa/q5hNWe5a3PM1BkksH0nwBtKEc7eG/OjUJqlFHqZWNjXrnwf517a9g98klUTfh@nMz2YOR0KZvgE)
[Answer]
# [Python 3](https://docs.python.org/3/), 130 bytes
```
lambda*a:sorted(a,key=lambda c:("r,ylgebwsrtbcorpcryovvlfnlagdccamvca cmnsvrearlorsgyppwtpkonbe".find(c[::3]+" "*(c=="cream")),c))
```
[Try it online!](https://tio.run/##JVDLbsQgEDs3X4E4wTZatdpbpHzJdlUBmSRogUFDHkp/PgVy8sh4bA/xWGYMj3Psf06nvB7UTXUJaYFBqPYNR3@xzHSCU3u4CfSeaNEGKRo6cNvcGJyaBmOU30wW@pA2AkUOKU1HjPsS3xg08PtowyDMs@ser0/O@E2Yvucmaz2XsjVSntbHnM1IhQF90yjWsycnGHjLD3AO9zxMBBAyasK9YDI5C5bCOGXeGdHMBBkjKDNnpFUfhXZ2K/Rm8dKPqho4m/eKMboSZGY06NRSpF6tdeUqWdD6hDXVug2omGMqCvW31kwHvr7TmlINyXVLeFwpuiLYZ1utow21a751glp@Bf5qGp1vVs8uTyMS@2U2sCoR31@yaz6ur7mneR1HB0LL5iOSDYsYxU1L1udlef4D "Python 3 – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~321~~ ~~219~~ ~~210~~ ~~161~~ ~~159~~ 138 bytes
```
n=>n.OrderBy(a=>a!="grey"?"yelgrebroscablaochperuboliviofawlilgolchomaucrecrisilrosazulemruspurwhipinorablu".IndexOf(a.Substring(0,3)):65)
```
[Try it online!](https://tio.run/##TY5PS8QwEMXP7aeoOaXQLYLowd1WUBQWFvbgwXOaTttZ0qRMkv5R/Ow1dRE8vQfz3ryftDtpcY3jxhAI2fFRUHJJUCcz1zAlJ7TuYB2hbssv1gs/AstYpfwmsjPSKOE23xIsQQhq9p2mcRS9GG2NgvyD0MEJNfBLuo@j2DrhUCZvXsvD/@/Z8Uw1hP6r9j2QqBT8ncq5WHVR6vw38bxwUZTiprhuPrEFVHAVGStDSxjZDUC@MgpHNI2YFKrWqAAb8CWBJLSoQlp8egU9eTt4mjocUJtt1rP8qGuYzw0X@buvrhD8NrtL08eH@3Tdrz8 "C# (Visual C# Interactive Compiler) – Try It Online")
*-3 bytes thanks to Shaggy, -18 thanks to TheLethalCoder*
Takes input as a `List<string>`, returns an `IOrderedEnumerable<string>`
How this works is that it orders the list by each string's index in the original string. The original string has every color except for grey turned to it's first three letters. Grey is not there, since green and grey would cause ambiguity. Red isn't there either, since `IndexOf` returns -1 if the string doesn't appear.
# Shorter version taking IOrderedEnumerable as input, 137 bytes
```
n=>n.ThenBy(a=>a!="grey"?"yelgrebroscablaochperuboliviofawlilgolchomaucrecrisilrosazulemruspurwhipinorablu".IndexOf(a.Substring(0,3)):65)
```
Takes advantage of the fact that `ThenBy` is 1 byte shorter than `OrderBy`, but `ThenBy` only operates on `IOrderedEnumerable`s though.
[Try it online!](https://tio.run/##dY9PS8QwEMXP209Re0qglgXRg7utoCgsLOxBwXOaTttZ0qRMkv5R/Ow1dfG4p/dg5vF7T9pbaXGJotoQCNmyQVB8jlHHE9Mwxke0bm8doW6K76QTfoAkTUrlV5GtkUYJt/qGYA5CUCU/2YkqoOeZybzYcs6jzebFaGsUZJ@EDo6ogZ35LtpE1gmHMn7zWu4PfzGoXrXvgESp4J@cXj8VU77ovNDZRws6IEVeiJv8UucpmUEFV5KxMoSEkW0P5EujcEBTi1GhaowKO8IySSAJLarwLb68go687T2NLfaozUr1SXbQFUynmons3ZeXDmyb3nH@@HDPl93yCw "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~69~~ ~~68~~ ~~63~~ ~~56~~ 52 bytes
```
Ｆ⪪”&⌊Oτe¿k⟲ⅈζLbψ#>φuＣ№ς…Ｘ◧9gF→G⌈Ｈ≡M*e{-”²Φθ⁼ι⁺§κ⁰§κ³
```
[Try it online!](https://tio.run/##TcyxDsIgFEDRXyFMkGBidHRy0MStiWPTAShF0legD0rt16N18m5nufolUQcJtQ4BCXtGcJlRxA2sUWtCpQNGjVsoBQYP0vZaT0VLPaWCRiIETHaLcc1xDF4ZKsiJc9Kg85ndHWSDbBbkNi8SEnOCNLAkds0P35s3GwU5ckH@eOZ7l1rbllo0xn@HVMGyjyma/kcMq6ddVw8FPg "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Now a port of @Sok's Pyth answer.
```
Ｆ⪪”&⌊Oτe¿k⟲ⅈζLbψ#>φuＣ№ς…Ｘ◧9gF→G⌈Ｈ≡M*e{-”²
```
Take the compressed string `rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe` and loop over each substring of length 2.
```
Φθ⁼ι⁺§κ⁰§κ³
```
For each substring print those input strings whose first and fourth (cyclically) characters equal the substring.
[Answer]
# Pyth, 66 [bytes](https://mothereff.in/byte-counter#oxc.%22ay%1C%C3%87%C3%A6%C2%82%C2%A3%C3%B0%C2%98%04%C3%90%C2%A5%7E%40%C2%87iF%5B2%C2%9B%C2%9EB%C3%8D%C3%90%3A%C2%98Y%C3%AB%29%5EksTT%C3%A3%1A%222s%40LN%2C03)
```
oxc."ayÇæ£ðÐ¥~@iF[2BÍÐ:Yë)^ksTTã"2s@LN,03
```
Try it online [here](https://pyth.herokuapp.com/?code=oxc.%22ay%1C%C3%87%C3%A6%C2%82%C2%A3%C3%B0%C2%98%04%C3%90%C2%A5%7E%40%C2%87iF%5B2%C2%9B%C2%9EB%C3%8D%C3%90%3A%C2%98Y%C3%AB%29%5EksTT%C3%A3%1A%222s%40LN%2C03&input=%5B%22ruby%22%2C%22yellow%22%2C%22red%22%2C%22grey%22%5D&debug=0), or verify all the test cases at once [here](https://pyth.herokuapp.com/?code=oxc.%22ay%1C%C3%87%C3%A6%C2%82%C2%A3%C3%B0%C2%98%04%C3%90%C2%A5%7E%40%C2%87iF%5B2%C2%9B%C2%9EB%C3%8D%C3%90%3A%C2%98Y%C3%AB%29%5EksTT%C3%A3%1A%222s%40LN%2C03&test_suite=1&test_suite_input=%5B%5D%0A%5B%22green%22%2C%20%22blue%22%2C%20%22red%22%2C%20%22brown%22%5D%0A%5B%22gold%22%2C%20%22grey%22%2C%20%22green%22%5D%0A%5B%22ruby%22%2C%22yellow%22%2C%22red%22%2C%22grey%22%5D%0A%5B%22gold%22%2C%20%22green%22%2C%20%22fawn%22%2C%20%22white%22%2C%20%22azure%22%2C%20%22rose%22%2C%20%22black%22%2C%20%22purple%22%2C%20%22orange%22%2C%20%22silver%22%2C%20%22ruby%22%2C%20%22blue%22%2C%20%22lilac%22%2C%20%22crimson%22%2C%20%22pink%22%2C%20%22cream%22%2C%20%22lemon%22%2C%20%22russet%22%2C%20%22grey%22%2C%20%22olive%22%2C%20%22violet%22%2C%20%22mauve%22%2C%20%22chocolate%22%2C%20%22yellow%22%2C%20%22peach%22%2C%20%22brown%22%2C%20%22ochre%22%2C%20%22scarlet%22%2C%20%22red%22%5D&debug=0).
The colours in the list can be uniquely identified by taking the characters at index `0` and `3`, assuming modular indexing. This results in the following mapping:
```
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
```
Full explanation:
```
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
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 48 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Σ.•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•2ôy¬s3è«k
```
Same solution as most other answers. Will try to golf it down from here later.
[Try it online](https://tio.run/##JU67TsQwEPyX0B5IHD0S7f0BAgrHmMTKJhutz4kCDaRC9BSIBoFAhzg6xENCV8SCMuIb8iPB62s8O@OZ0aARsVbj2D9sDef3e@5xaNu/b3edDpdXbuUWefX7fpj1t9v7P3fudbY72@g/h/Zi2j0P7XLibs76j@7JfW368NS9Nd3S7LhF95KN40EEKscimkR1qufKY0xYMyc0TI2GSpE/cmErFkolZOpRks5NSMYgZOYRQQcHkigSPsgao@bsTVEiiNBf6oLNpI79K04tsZiQUlwF2neteeOhUQBY8wopCEIV2Zh/EgTOVxrXcgyWe05E2F5aKiFMkWnol6REHh39Aw) or [verify all test cases](https://tio.run/##XVGxTsMwFPyVKqwBibIxgBjpwoxKBzeYxooTR3acKCAkyITYGRALAoGKKBsqICGGWDBGfEN@JMSO7VZMzz6/e/fuTBgYI9ikzm4U82Sz57i56@zxxFya6n6tPrvbEQ91Ufx@iiu/vrgUX2Iapj/zg6C6Wd//vhUvg63BSvVeF@f98qkuZq64PqneykfxsdqS@@I1L2dsQ0zL56A5dcv5djMcjtze0JlQCCPHdcaYw7ZQeCgvlGSR070TLJG2Le8K1A@UjyWSQ4xJZpmq7x9RzT8CmSyZjxKpA445VXqEQaUOvKCtMacxlgChIJrIA0M4hVR2dnp6T4xaRls9ikJG5OQYRYECIAhlAwwVTDljMFk4IBilckCKCFZ4CLgCPJ94BAO1nTUVQ@D5NpCW7flqbeYB2tGlbeXXCBqHhqIdWh9Gz4xeODAhmBVtBtbD8o7abxe7idOkbeLRpq2fpb27OPUv2TR0vPq3Ft@hfXfpjkZ/).
**Explanation:**
```
Σ          # 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
```
[See this 05AB1E tip (section *How to compress strings not part of the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand how `.•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•` is `"rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe"`.
]