Вызов

Учитывая список уникальных названий цветов в качестве входных данных, сортируйте их в порядке, в котором они сначала появляются в Amazing Technicolor Dreamcoat Джозефа .

пример

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

Полный список цветов по порядку:

 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

Или как массив строк:

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

правила

• Вы можете принимать ввод любым разумным и удобным способом (например, массивом строк, строкой с разделителями, отдельными строками), если это разрешено нашими стандартными правилами ввода / вывода , но, пожалуйста, укажите свой метод ввода в своем ответе.
• Вы можете сделать то же самое для вашего вывода.
• На входе будут только цвета из приведенного выше списка.
• Ваше решение должно быть в состоянии обрабатывать пустые входы.
• Вы можете выбрать, будут ли все слова на входе последовательно прописными, строчными или заглавными, но регистр вашего вывода должен совпадать с регистром ввода.
• Это код-гольф, поэтому выигрывает наименьшее количество байтов на каждом языке.
• Как всегда, стандартные лазейки запрещены.

Контрольные примеры

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 байт

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

Попробуйте онлайн!

Наивный подход. PowerShell sort-objectможет выполнять сортировку на основе блока скрипта, который выполняется для каждого объекта. Здесь мы просто получаем .IndexOf()цвет из строки, которая присваивает числовое значение каждому цвету, а затем сортирует на основе этих чисел. Строка состоит из четвертой и первой букв каждого цвета, чтобы обеспечить уникальность. Вывод неявный.

-4 байта благодаря Шегги.
-2 байта благодаря маззи.
Колоссальные -30 байтов благодаря KGlasier.

JavaScript (SpiderMonkey) ,  106 105  104 байта

«Если есть сомнения, просто хэш кровавый вклад».

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

Попробуйте онлайн!

Желе , 28 байт

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

Попробуйте онлайн!

Как это работает

µпревращает все влево в монадическую цепочку, которая Þотображает входной массив и сортирует входные данные в соответствии с сгенерированными значениями.

“½Ṗ©cƘʂẒẹMMỤẓHP’ устанавливает возвращаемое значение 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’выходы 391695582; ,добавляет его к перестановке. Затем ḥвычислите 391695582- ^ю хеш-функцию Джелли , сопоставив получившиеся сегменты с целыми числами перестановки.

Магическая константа 391695582 была найдена утилитой Желе .

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 байта

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

Попробуйте онлайн!

Читает каждый цвет как основание-36 int. Брут-форс модули и выбрал произвольное смещение среди 19, которые не требуют побегов.

Powershell, 124 120 124 119 118 102 байта

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

Попробуйте онлайн!

Объяснение:

1. Строка данных содержит первые значащие буквы цветовых меток в порядке убывания. За исключением Greyэтикетки - G*yкороче.

2. -csplit'(?=[A-Z])' разбивает строку данных на массив (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"$_*"}отображает массив строк в массив логических значений. Где Trueозначает «цветовая метка начинается с этой строки» (например, оператор без учета регистра, csplit - с учетом регистра. См. Документ ).

4. sort{}сортирует цветные метки по массивам логических значений в порядке возрастания .

Сортировка по массиву - очень интересная функция в Powershell. В этом сценарии все массивы имеют одинаковую длину и содержат только логические значения. Эта сортировка выполняется в лексографическом порядке булевых массивов.

Поэтому строка может содержать однобуквенные сокращения для последних меток. Если есть совпадение в начале массива, совпадения в конце не имеют никакого эффекта.

       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

Где Tэто trueи -есть false.

Тестовый скрипт:

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

Выход:

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

Я улучшу сжатие строк через некоторое время

Japt , 88 78 71 байт

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

Попробуйте онлайн!

Wolfram Language 255 213 199 байт

Четырнадцать байтов спасен Деннисом, который избегал «отметок», используя символы вместо строк.

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

Попробуйте онлайн!

Python 2 , 186 байт

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

Попробуйте онлайн!

Находит все совпадения для прогрессивных символьных подстрок (например, «green» проверит наличие «g», «gr», «gre», «gree» и «green») в строке идентификатора и сохраняет максимальный индекс. «red» всегда первый, anf find () возвращает -1 для пропущенных совпадений, поэтому для красного нет идентификатора.

Как только цвета превращаются в пары (индекс, цвет), сортирует массив по первому элементу пары, а затем отбрасывает первый элемент каждой пары.

Python 3 , 130 байт

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

Попробуйте онлайн!

C # (интерактивный компилятор Visual C #) , 321 219 210 161 159 138 байт

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

Попробуйте онлайн!

-3 байта благодаря Shaggy, -18 благодаря TheLethalCoder

Принимает вход как List<string>, возвращаетIOrderedEnumerable<string>

Как это работает, так это то, что он упорядочивает список по индексу каждой строки в исходной строке. Оригинальная строка имеет все цвета, кроме серого, превращенного в первые три буквы. Серого там нет, так как зеленый и серый вызовут двусмысленность. Красного там тоже нет, так как IndexOfвозвращает -1, если строка не появляется.

Укороченная версия, принимающая IOrderedEnumerable в качестве входных данных, 137 байт

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

Использует тот факт, что ThenByон на 1 байт короче OrderBy, но ThenByработает только на IOrderedEnumerables.

Попробуйте онлайн!

Древесный уголь , 69 68 63 56 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

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

Возьмите сжатую строку edyeeebrscckhrpeubivvifa99gohomaamrisiosazemuseypuwhpiorluи обведите каждую подстроку длиной 2.

Φθ№κ⎇Σιlilι

Для каждой подстроки выведите те входные строки, которые содержат эту подстроку, если только не подстрока 99, в этом случае ищите lilвместо этого. ( lilacэто единственный цвет, который не имеет уникальной двухбуквенной подстроки; oliveвключает li; silverвключает ilи blackвключает lac. fawnи azureможет быть обнаружен с использованием только одной буквы, но здесь это не поможет.)

Pyth, 66 байт

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

Попробуйте онлайн здесь или проверьте все тестовые примеры сразу здесь .

Цвета в списке могут быть однозначно идентифицированы путем взятия символов в индексе 0и 3при условии модульной индексации. Это приводит к следующему отображению:

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

Полное объяснение:

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 байтов

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

То же решение, что и большинство других ответов. Постараюсь сделать это позже.

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

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

См. Этот совет 05AB1E (раздел Как сжимать строки, не являющийся частью словаря? ), Чтобы понять, как .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•это происходит "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe".