Sfida

Dato un elenco di nomi di colori unici come input, ordinali nell'ordine in cui compaiono per la prima volta in Amazing Technicolor Dreamcoat di Joseph .

Esempio

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

L'elenco completo dei colori, in ordine, è:

 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 come una matrice di stringhe:

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

Regole

• Puoi accettare input con qualsiasi mezzo ragionevole e conveniente (ad es. Una matrice di stringhe, una stringa delimitata, singole stringhe) purché sia ​​consentito dalle nostre regole I / O standard , ma specifica il metodo di input nella tua risposta.
• Puoi fare lo stesso per il tuo output.
• L'input conterrà sempre e solo i colori dell'elenco precedente.
• La tua soluzione dovrebbe essere in grado di gestire input vuoti.
• È possibile scegliere se tutte le parole nell'input sono maiuscole, minuscole o maiuscole, ma l'involucro dell'output deve corrispondere a quello dell'input.
• Questo è code-golf, quindi vince il conteggio dei byte più basso in ogni lingua.
• Come sempre, le scappatoie standard sono vietate.

Casi 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 byte

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

Provalo online!

Approccio ingenuo. PowerShell sort-objectpuò ordinare in base a un blocco di script che viene eseguito per ogni oggetto. Qui stiamo semplicemente ottenendo il .IndexOf()colore da una stringa, che assegnerà un valore numerico a ciascun colore, e quindi ordinerà in base a quei numeri. La stringa è costruita con la quarta e la prima lettera di ogni colore per garantire unicità. L'output è implicito.

-4 byte grazie a Shaggy.
-2 byte grazie a mazzy.
Un enorme -30 byte grazie a KGlasier.

JavaScript (SpiderMonkey) ,  106 105  104 byte

"In caso di dubbio, esegui l'hash di input maledetto."

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

Provalo online!

Gelatina , 28 byte

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

Provalo online!

Come funziona

µtrasforma tutto alla sua sinistra in una catena monadica, che Þmappa sull'array di input e ordina l'input in base ai valori generati.

“½Ṗ©cƘʂẒẹMMỤẓHP’ imposta il valore restituito su 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’rese 391695582; ,lo antepone alla permutazione. Poi, ḥ391695582 di c ompute Jelly ^esima funzione di hash, mappando i secchi risultanti ai numeri interi della permutazione.

La costante magica 391695582 è stata trovata dai programmi di utilità di 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 byte

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

Provalo online!

Legge ogni colore come base-36 int. Brute-force i moduli e ha scelto un offset arbitrario tra i 19 che non ha richiesto scappatoie.

Powershell, 124 120 124 119 118 102 byte

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

Provalo online!

Spiegazione:

1. La stringa di dati contiene le prime lettere significative delle etichette colorate in ordine decrescente. Ad eccezione Greydell'etichetta, G*yè più breve.

2. -csplit'(?=[A-Z])' divide la stringa di dati nell'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"$_*"}associa l'array string all'array booleano. Dove Truesignifica "un'etichetta di colore inizia da questa stringa" (come l'operatore senza distinzione tra maiuscole e minuscole, csplit - con distinzione tra maiuscole e minuscole. Vedi doc ).

4. sort{}ordina un colore lables dagli array di booleani in ordine crescente .

L'ordinamento per array è una funzionalità molto interessante in Powershell. In questo script tutti gli array hanno la stessa lunghezza e contengono solo valori booleani. Questo ordinamento viene eseguito nell'ordine lexografico delle matrici booleane.

Pertanto, la stringa può contenere abbreviazioni di una lettera per le ultime etichette. Se c'è una corrispondenza all'inizio dell'array, le partite alla fine non hanno effetto.

       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

Dove Tsi trova truee -si trova false.

Script di prova:

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

Produzione:

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

Migliorerò la compressione delle stringhe tra un po '

Japt , 88 78 71 byte

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

Provalo online!

Lingua Wolfram 255 213 199 byte

Quattordici byte salvati da Dennis, che evitò i "segni", usando simboli invece di stringhe.

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

Provalo online!

Python 2 , 186 byte

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

Provalo online!

Trova tutte le corrispondenze per sottostringhe di caratteri progressivi (ad es. "Verde" verificherà la presenza di "g", "gr", "gre", "gree" e "verde") nella stringa dell'identificatore e mantiene l'indice massimo. "rosso" è sempre il primo, anf find () restituisce -1 per le corrispondenze mancanti, quindi non esiste un identificatore specifico per il rosso.

Una volta che i colori vengono trasformati in coppie (indice, colore), ordina la matrice sul primo elemento della coppia e quindi scarta il primo elemento di ciascuna coppia.

Python 3 , 130 byte

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

Provalo online!

C # (compilatore interattivo Visual C #) , 321 219 210 161 159 138 byte

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

Provalo online!

-3 byte grazie a Shaggy, -18 grazie a TheLethalCoder

Accetta input come a List<string>, restituisce anIOrderedEnumerable<string>

Come funziona è che ordina l'elenco in base all'indice di ogni stringa nella stringa originale. La stringa originale ha tutti i colori tranne il grigio trasformato nelle sue prime tre lettere. Il grigio non c'è, poiché il verde e il grigio causerebbero ambiguità. Neanche il rosso c'è, poiché IndexOfrestituisce -1 se la stringa non viene visualizzata.

Versione più breve che accetta IOrderedEnumerable come input, 137 byte

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

Sfrutta il fatto che ThenByè 1 byte più corto di OrderBy, ma ThenByfunziona solo su IOrderedEnumerables però.

Provalo online!

Carbone di legna , 69 68 63 56 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Prendi la stringa compressa edyeeebrscckhrpeubivvifa99gohomaamrisiosazemuseypuwhpiorlue avvolgi ogni sottostringa di lunghezza 2.

Φθ№κ⎇Σιlilι

Per ogni sottostringa stampare quelle stringhe di input che contengono quella sottostringa, a meno che non sia la sottostringa 99, nel qual caso cercare lilinvece. ( lilacè l'unico colore che non ha una sottostringa univoca di due lettere; oliveinclude li; silverinclude ile blackinclude lac. fawne azurepuò essere rilevato usando una sola lettera, ma qui non aiuta.)

Pyth, 66 byte

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

Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

I colori nell'elenco possono essere identificati in modo univoco prendendo i caratteri all'indice 0e 3assumendo l'indicizzazione modulare. Ciò si traduce nella seguente mappatura:

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

Spiegazione 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 byte

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

Stessa soluzione della maggior parte delle altre risposte. Proverò a golf giù da qui più tardi.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questo suggerimento 05AB1E (sezione Come stringhe di comprimere che non fanno parte del dizionario? ) Per capire come .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•è "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe".