Herausforderung

Sortieren Sie die Namen anhand einer Liste eindeutiger Farbnamen in der Reihenfolge, in der sie zuerst in Josephs Amazing Technicolor Dreamcoat erscheinen .

Beispiel

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

Die vollständige Liste der Farben in der angegebenen Reihenfolge lautet:

 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

Oder als eine Reihe von Zeichenfolgen:

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

Regeln

• Sie können Eingaben auf jede vernünftige und bequeme Weise vornehmen (z. B. durch ein Array von Zeichenfolgen, eine durch Trennzeichen getrennte Zeichenfolge oder einzelne Zeichenfolgen), sofern dies nach unseren Standard-E / A-Regeln zulässig ist. Geben Sie jedoch in Ihrer Antwort Ihre Eingabemethode an.
• Sie können dasselbe für Ihre Ausgabe tun.
• Die Eingabe enthält immer nur Farben aus der obigen Liste.
• Ihre Lösung sollte in der Lage sein, leere Eingaben zu verarbeiten.
• Sie können wählen, ob alle Wörter in der Eingabe konsistent in Groß-, Klein- oder Titelbuchstaben geschrieben werden sollen, die Schreibweise Ihrer Ausgabe muss jedoch mit der Eingabe übereinstimmen.
• Dies ist Codegolf, daher gewinnt die niedrigste Bytezahl in jeder Sprache.
• Standardlücken sind wie immer verboten.

Testfälle

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

Probieren Sie es online!

Naiver Ansatz. PowerShell sort-objectkann anhand eines Skriptblocks sortieren, der für jedes Objekt ausgeführt wird. Hier erhalten wir einfach .IndexOf()die Farbe aus einer Zeichenfolge, die jeder Farbe einen numerischen Wert zuweist und dann basierend auf diesen Zahlen sortiert. Die Zeichenfolge besteht aus dem vierten und ersten Buchstaben jeder Farbe, um die Eindeutigkeit zu gewährleisten. Die Ausgabe ist implizit.

-4 Bytes dank Shaggy.
-2 Bytes dank mazzy.
Satte -30 Bytes dank KGlasier.

JavaScript (SpiderMonkey) ,  106 105  104 Bytes

"Wenn Sie Zweifel haben, haben Sie nur den blutigen Input."

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

Probieren Sie es online!

Gelee , 28 Bytes

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

Probieren Sie es online!

Wie es funktioniert

µwandelt alles nach links in eine monadische Kette um, die Þüber das Eingabearray abgebildet und die Eingabe nach den generierten Werten sortiert.

“½Ṗ©cƘʂẒẹMMỤẓHP’ Setzt den Rückgabewert auf 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’ergibt 391695582; ,stellt es der Permutation voran. Dann ḥc ompute Jelly 391695582 ^th Hashfunktion, Abbilden der resultierenden Eimer zu den ganzen Zahlen der Permutation.

Die magische Konstante 391695582 wurde gefunden Jelly utils .

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

Probieren Sie es online!

Liest jede Farbe als Base-36 int. Die Module wurden brutal gezwungen und es wurde ein willkürlicher Versatz unter den 19 gewählt, für den keine Flucht erforderlich war.

Powershell, 124 120 124 119 118 102 Bytes

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

Probieren Sie es online!

Erläuterung:

1. Die Datenzeichenfolge enthält die ersten signifikanten Buchstaben der Farbetiketten in absteigender Reihenfolge. Mit Ausnahme des GreyEtiketts -G*y ist kürzer.

2. -csplit'(?=[A-Z])' Teilt die Datenzeichenfolge in das Array auf (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"$_*"}Ordnet das Zeichenfolgenarray dem Array von boolean zu. Wobei True"ein Farbetikett von dieser Zeichenfolge ausgeht" (Groß- / Kleinschreibung wird nicht berücksichtigt, csplit - Groß- / Kleinschreibung wird berücksichtigt. Siehe Dokument ).

4. sort{}Sortiert die Farbetiketten nach den Arrays von Boolean in aufsteigender Reihenfolge .

Die Sortierung nach Array ist ein sehr interessantes Feature in der PowerShell. In diesem Skript haben alle Arrays dieselbe Länge und enthalten nur Boolesche Werte. Diese Sortierung wird in der lexographischen Reihenfolge der Booleschen Arrays durchgeführt.

Daher kann die Zeichenfolge Ein-Buchstaben-Abkürzungen für die letzten Bezeichnungen enthalten. Wenn sich am Anfang des Arrays eine Übereinstimmung befindet, haben die Übereinstimmungen am Ende keine Auswirkung.

       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

Wo Tist trueund -ist false.

Testskript:

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

Ausgabe:

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

Ich werde die Saitenkomprimierung in einer Weile verbessern

Japt , 88 78 71 Bytes

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

Probieren Sie es online!

Wolfram Language 255 213 199 Bytes

Vierzehn Bytes wurden von Dennis gespeichert, der die "Markierungen" vermieden, indem er Symbole anstelle von Zeichenfolgen verwendete.

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

Probieren Sie es 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)]

Probieren Sie es online!

Findet alle Übereinstimmungen für progressive Zeichensubstrings (Beispiel: "green" sucht nach "g", "gr", "gre", "gree" und "green") in der Bezeichnerzeichenfolge und behält den maximalen Index bei. "rot" steht immer an erster Stelle, anf find () gibt -1 für fehlende Übereinstimmungen zurück, daher gibt es keinen speziellen Bezeichner für rot.

Sobald die Farben in (Index-, Farb-) Paare umgewandelt wurden, sortieren Sie das Array nach dem ersten Element des Paares und verwerfen Sie dann das erste Element jedes Paares.

Python 3 , 130 Bytes

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

Probieren Sie es online!

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

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

Probieren Sie es online!

-3 Bytes dank Shaggy, -18 dank TheLethalCoder

Nimmt Eingaben als ein List<string>, gibt ein zurückIOrderedEnumerable<string>

Das funktioniert so, dass die Liste nach dem Index jeder Zeichenfolge in der ursprünglichen Zeichenfolge sortiert wird. Die ursprüngliche Zeichenfolge hat alle Farben mit Ausnahme von Grau, die in die ersten drei Buchstaben umgewandelt wurden. Grau ist nicht da, da Grün und Grau Mehrdeutigkeiten verursachen würden. Rot ist da auch nichtIndexOf -1 zurückgegeben wird, wenn die Zeichenfolge nicht angezeigt wird.

Kürzere Version mit IOrderedEnumerable als Eingabe, 137 Byte

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

Nutzt die Tatsache, dass ThenBy1 Byte kürzer ist als OrderBy, arbeitet aber ThenBynur mit IOrderedEnumerables.

Probieren Sie es online!

Charcoal , 69 68 63 56 Bytes

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

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung:

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

Nimm den komprimierten String edyeeebrscckhrpeubivvifa99gohomaamrisiosazemuseypuwhpiorlu und durchlaufen Sie jede Teilzeichenfolge der Länge 2.

Φθ№κ⎇Σιlilι

Geben Sie für jede Teilzeichenfolge die Eingabezeichenfolgen aus, die diese Teilzeichenfolge enthalten, sofern dies nicht der 99Fall ist. Suchen Sie in diesem Fall nach lil. ( lilacist die einzige Farbe, die keine eindeutige Unterzeichenfolge mit zwei Buchstaben hat; oliveenthält li; silverenthält ilund blackenthält lac. fawnund azurekann mit nur einem Buchstaben erkannt werden, aber das hilft hier nicht.)

Pyth, 66 Bytes

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

Probieren Sie es hier online aus oder überprüfen Sie alle Testfälle auf einmal hier .

Die Farben in der Liste können eindeutig identifiziert werden, indem die Zeichen am Index verwendet werden 0und 3eine modulare Indizierung vorausgesetzt wird. Daraus ergibt sich folgende Zuordnung:

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

Vollständige Erklärung:

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

Gleiche Lösung wie die meisten anderen Antworten. Ich werde versuchen, es später von hier aus zu spielen.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Sehen Sie diese 05AB1E Spitze (Abschnitt Wie Kompresse Strings nicht Teil des Wörterbuchs? ) Zu verstehen , wie .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•ist "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe".