Desafio

Dada uma lista de nomes de cores exclusivos como entrada, classifique-os na ordem em que aparecem pela primeira vez no Amazing Technicolor Dreamcoat de Joseph .

Exemplo

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

A lista completa de cores, em ordem, é:

 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 como uma matriz de 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"]

Regras

• Você pode receber informações por qualquer meio razoável e conveniente (por exemplo, uma matriz de cadeias, uma cadeia delimitada, cadeias individuais), desde que seja permitido por nossas regras de E / S padrão , mas especifique seu método de entrada em sua resposta.
• Você pode fazer o mesmo pela sua saída.
• A entrada sempre conterá cores da lista acima.
• Sua solução deve ser capaz de lidar com entradas vazias.
• Você pode escolher se todas as palavras da entrada são consistentemente maiúsculas, minúsculas ou maiúsculas, mas a caixa da saída deve corresponder à da entrada.
• Isso é código-golfe, e a contagem de bytes mais baixa em cada idioma vence.
• Como sempre, as brechas padrão são proibidas.

Casos de teste

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

Experimente online!

Abordagem ingênua. O PowerShell sort-objectpode classificar com base em um bloco de script que é executado para cada objeto. Aqui, estamos simplesmente obtendo a .IndexOf()cor de uma sequência, que atribuirá um valor numérico a cada cor e, em seguida, classifique com base nesses números. A sequência é construída a partir da quarta e primeira letras de cada cor para garantir a exclusividade. A saída está implícita.

-4 bytes graças a Shaggy.
-2 bytes graças ao mazzy.
A -30 bytes graças ao KGlasier.

JavaScript (SpiderMonkey) ,  106 105  104 bytes

"Em caso de dúvida, basta digitar a entrada sangrenta."

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

Experimente online!

Gelatina , 28 bytes

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

Experimente online!

Como funciona

µtransforma tudo à sua esquerda em uma cadeia monádica, que Þmapeia a matriz de entrada e classifica a entrada de acordo com os valores gerados.

“½Ṗ©cƘʂẒẹMMỤẓHP’ define o valor de retorno para 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’rendimento 391695582; ,o anexa à permutação. Em seguida, ḥelimine ^a função de hash 391695582 da Jelly , mapeando os buckets resultantes para os números inteiros da permutação.

A constante mágica 391695582 foi encontrada pelos utilitários 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)))

Experimente online!

Lê cada cor como uma base-36 int. Brute forçou os módulos e escolheu uma compensação arbitrária entre os 19 que não exigiam escapadas.

Powershell, 124 120 124 119 118 102 bytes

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

Experimente Online!

Explicação:

1. A sequência de dados contém as primeiras letras significativas dos rótulos das cores em ordem decrescente. Exceto pelo Greyrótulo - G*yé mais curto.

2. -csplit'(?=[A-Z])' divide a sequência de dados na 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"$_*"}mapeia a matriz de strings para a matriz de booleano. Onde Truesignifica "um rótulo colorido começa nessa sequência" (como o operador que não diferencia maiúsculas de minúsculas, csplit - diferencia maiúsculas de minúsculas. Consulte o documento ).

4. sort{}classifica uma etiqueta de cor pelas matrizes booleanas em ordem crescente .

A classificação por matriz é um recurso muito interessante no Powershell. Nesse script, todas as matrizes têm o mesmo comprimento e contêm apenas valores booleanos. Essa classificação é realizada na ordem lexográfica de matrizes booleanas.

Portanto, a cadeia pode conter abreviações de uma letra para os últimos rótulos. Se houver uma correspondência no início da matriz, as correspondências no final não terão efeito.

       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

Onde Testá truee -está false.

Script de teste:

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

Saída:

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

Vou melhorar a compressão da string daqui a pouco

Japt , 88 78 71 bytes

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

Experimente online!

Wolfram Language 255 213 199 bytes

Quatorze bytes salvos por Dennis, que evitou as marcas ", usando símbolos em vez de 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~#&]&

Experimente Online!

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

Experimente online!

Localiza todas as correspondências para substrings de caracteres progressivos (Ex: "verde" verifica "g", "gr", "gre", "gree" e "green") na cadeia de caracteres do identificador e mantém o índice máximo. "red" é sempre o primeiro; anf find () retorna -1 para correspondências ausentes, portanto, não há identificador para vermelho especificamente.

Depois que as cores são transformadas em pares (índice, cor), classifica a matriz no primeiro item do par e descarta o primeiro item de cada par.

Python 3 , 130 bytes

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

Experimente online!

C # (Compilador interativo do Visual C #) , 321 219 210 161 159 138 bytes

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

Experimente online!

-3 bytes graças a Shaggy, -18 graças a TheLethalCoder

Pega a entrada como a List<string>, retorna umIOrderedEnumerable<string>

Como isso funciona é que ele ordena a lista pelo índice de cada string na string original. A sequência original tem todas as cores, exceto o cinza, que está nas três primeiras letras. O cinza não está lá, pois o verde e o cinza causariam ambiguidade. O vermelho também não está lá, pois IndexOfretorna -1 se a string não aparecer.

Versão mais curta usando IOrderedEnumerable como entrada, 137 bytes

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

Aproveita o fato de que ThenByé 1 byte menor que OrderBy, mas ThenBysó opera em IOrderedEnumerables.

Experimente online!

Carvão , 69 68 63 56 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Pegue a corda compactada edyeeebrscckhrpeubivvifa99gohomaamrisiosazemuseypuwhpiorlue faça um loop sobre cada substring de comprimento 2.

Φθ№κ⎇Σιlilι

Para cada substring, imprima as seqüências de entrada que contêm essa substring, a menos que a substring seja 99, nesse caso, procure lil. ( lilacé a única cor que não possui uma substring exclusiva de duas letras; oliveinclui li; silverinclui ile blackinclui lac. fawne azurepode ser detectada usando apenas uma única letra, mas isso não ajuda aqui.)

Pitão, 66 bytes

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

Experimente online aqui ou verifique todos os casos de teste de uma vez aqui .

As cores da lista podem ser identificadas de forma exclusiva, pegando os caracteres no índice 0e 3assumindo a indexação modular. Isso resulta no seguinte mapeamento:

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

Explicação 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

Mesma solução que a maioria das outras respostas. Tentará jogar golfe daqui mais tarde.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Consulte esta dica 05AB1E (seção Como compactar seqüências de caracteres que não fazem parte do dicionário? ) Para entender como .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•é "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe".