Reto

Dada una lista de nombres de colores únicos como entrada, ordénelos en el orden en que aparecen por primera vez en el Amazing Technicolor Dreamcoat de Joseph .

Ejemplo

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

La lista completa de colores, en orden, es:

 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

O como una serie de cadenas:

["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"]

Reglas

• Puede recibir información por cualquier medio razonable y conveniente (por ejemplo, una matriz de cadenas, una cadena delimitada, cadenas individuales) siempre que lo permitan nuestras reglas de E / S estándar , pero especifique su método de entrada en su respuesta.
• Puede hacer lo mismo para su salida.
• La entrada solo contendrá colores de la lista anterior.
• Su solución debería ser capaz de manejar entradas vacías.
• Puede elegir si todas las palabras en la entrada son mayúsculas, minúsculas o mayúsculas, pero la carcasa de su salida debe coincidir con la de su entrada.
• Este es el código de golf, por lo que gana el conteo de bytes más bajo en cada idioma.
• Como siempre, las lagunas estándar están prohibidas.

Casos de prueba

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

Pruébalo en línea!

Enfoque ingenuo. PowerShell sort-objectpuede ordenar en función de un bloque de script que se ejecuta para cada objeto. Aquí simplemente estamos obteniendo el .IndexOf()color de una cadena, que asignará un valor numérico a cada color, y luego se clasifica en función de esos números. La cadena se construye a partir de la cuarta y primera letra de cada color para garantizar la unicidad. La salida es implícita.

-4 bytes gracias a Shaggy.
-2 bytes gracias a mazzy.
La friolera de -30 bytes gracias a KGlasier.

JavaScript (SpiderMonkey) ,  106105104  bytes

"En caso de duda, solo hash la entrada sangrienta".

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

Pruébalo en línea!

Jalea , 28 bytes

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

Pruébalo en línea!

Cómo funciona

µconvierte todo a su izquierda en una cadena monádica, que se Þasigna sobre la matriz de entrada y clasifica la entrada de acuerdo con los valores generados.

“½Ṗ©cƘʂẒẹMMỤẓHP’ establece el valor de retorno en 176073885534954276199526358143331.

Œ?genera la permutación 176073885534954276199526358143331 ^th de los enteros positivos (sin la cola ordenada), produciendo .$\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’rinde 391695582; ,lo antepone a la permutación. Luego, ḥcompute ^la función de hash 391695582 de Jelly , asignando los cubos resultantes a los enteros de la permutación.

La constante mágica 391695582 fue encontrada por las utilidades 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 bytes

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

Pruébalo en línea!

Lee cada color como base-36 int. Bruto forzó los módulos y eligió una compensación arbitraria entre los 19 que no requirieron escapes.

Powershell, 124 120 124 119 118 102 bytes

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

¡Pruébelo en línea!

Explicación:

1. La cadena de datos contiene las primeras letras significativas de las etiquetas de color en orden descendente. Excepto por la Greyetiqueta, G*yes más corta.

2. -csplit'(?=[A-Z])' divide la cadena de datos en la matriz (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"$_*"}asigna la matriz de cadenas a la matriz de boolean. Donde Truesignifica "una etiqueta de color comienza desde esta cadena" (como es un operador que no distingue entre mayúsculas y minúsculas, csplit - mayúsculas y minúsculas. Ver doc ).

4. sort{}ordena las etiquetas de color por las matrices de booleanos en orden ascendente .

La ordenación por matriz es una característica muy interesante en Powershell. En este script, todas las matrices tienen la misma longitud y contienen solo valores booleanos. Esta clasificación se realiza en el orden lexográfico de las matrices booleanas.

Por lo tanto, la cadena puede contener abreviaturas de una letra para las últimas etiquetas. Si hay una coincidencia al comienzo de la matriz, las coincidencias al final no tienen efecto.

       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

Donde Testa truey -esta false.

Script de prueba:

$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"
}

Salida:

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

Mejoraré la compresión de cuerdas en un tiempo

Japt , 88 78 71 bytes

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

Pruébalo en línea!

Wolfram Language 255 213 199 bytes

Dennis guardó catorce bytes, evitando las "marcas", utilizando símbolos en lugar de cadenas.

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~#&]&

¡Pruébelo en línea!

Python 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)]

Pruébalo en línea!

Encuentra todas las coincidencias para las subcadenas de caracteres progresivas (por ejemplo, "verde" verificará "g", "gr", "gre", "gree" y "verde") en la cadena de identificación, y mantiene el índice máximo. "rojo" siempre es primero, y anf find () devuelve -1 para las coincidencias faltantes, por lo que no hay un identificador para rojo específicamente.

Una vez que los colores se convierten en pares (índice, color), ordena la matriz en el primer elemento del par y luego descarta el primer elemento de cada par.

Python 3 , 130 bytes

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 321 219 210 161 159 138 bytes

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

Pruébalo en línea!

-3 bytes gracias a Shaggy, -18 gracias a TheLethalCoder

Toma la entrada como a List<string>, devuelve unIOrderedEnumerable<string>

Cómo funciona esto es que ordena la lista por el índice de cada cadena en la cadena original. La cadena original tiene todos los colores, excepto el gris convertido en sus primeras tres letras. El gris no está allí, ya que el verde y el gris causarían ambigüedad. El rojo tampoco está allí, ya que IndexOfdevuelve -1 si la cadena no aparece.

Versión más corta que toma IOrderedEnumerable como entrada, 137 bytes

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

Aprovecha el hecho de que ThenByes 1 byte más corto que OrderBy, pero ThenBysolo funciona en IOrderedEnumerables.

Pruébalo en línea!

Carbón , 69 68 63 56 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Tome la cuerda comprimida edyeeebrscckhrpeubivvifa99gohomaamrisiosazemuseypuwhpiorluy haga un bucle sobre cada subcadena de longitud 2.

Φθ№κ⎇Σιlilι

Para cada subcadena, imprima las cadenas de entrada que contienen esa subcadena, a menos que la subcadena lo sea 99, en cuyo caso busque en su lillugar. ( lilaces el único color que no tiene una subcadena única de dos letras; oliveincluyeli ; silverincluye ile blackincluye lac. fawny azurese puede detectar con una sola letra, pero eso no ayuda aquí).

Pyth, 66 bytes

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

Pruébalo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

Los colores en la lista se pueden identificar de forma única tomando los caracteres en el índice 0 y 3asumiendo una indexación modular. Esto da como resultado la siguiente asignación:

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

Explicación completa:

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 bytes

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

La misma solución que la mayoría de las otras respuestas. Trataré de jugar golf desde aquí más tarde.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

Σ          # 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

Vea este consejo 05AB1E (sección ¿Cómo comprimir cadenas que no forman parte del diccionario? ) Para comprender cómo .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•es "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe".