Дан список из двух или более прописанных серийных номеров одинаковой длины, превышающих два, например

[[ "three" , "one"  , "four"  ],
 [ "one"   , "five" , "nine"  ],
 [ "two"   , "six"  , "five"  ],
 [ "three" , "five" , "eight" ]]

отсортировать список по номерам, которые представляют слова:

[[ "one"   , "five" , "nine"  ],
 [ "two"   , "six"  , "five"  ],
 [ "three" , "one"  , "four"  ],
 [ "three" , "five" , "eight" ]]

Вы можете потребовать, чтобы числа были написаны в нижнем или верхнем, но не в смешанном регистре.

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

[["three","one","four"],["one","five","nine"],["two","six","five"],["three","five","eight"]]
дает
[["one","five","nine"],["two","six","five"],["three","one","four"],["three","five","eight"]]

[["two","seven"],["one","eight"],["two","eight"],["one","eight"],["two","eight"],["four","five"]]
дает
[["one","eight"],["one","eight"],["two","seven"],["two","eight"],["two","eight"],["four","five"]]

[["one","four","one","four","two"],["one","three","five","six","two"],["three","seven","three","zero","nine"]]
дает
[["one","three","five","six","two"],["one","four","one","four","two"],["three","seven","three","zero","nine"]]

[["zero","six","one"],["eight","zero","three"],["three","nine","eight"],["eight","seven","four"],["nine","eight","nine"],["four","eight","four"]]
дает
[["zero","six","one"],["three","nine","eight"],["four","eight","four"],["eight","zero","three"],["eight","seven","four"],["nine","eight","nine"]]

Шелуха , 9 8 байт

Ö†€¨tfṡn

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

Алгоритм, "вдохновленный" ответом Stax рекурсива (я только что немного изменил строку поиска), поднимите его!

Хитрость заключается в отображении каждой буквы в ее положение в строке tfsen(сжато в конце этой программы). Списки шелухи основаны на 1, а отсутствующие элементы возвращают 0, поэтому мы получаем следующее отображение:

"one"        [0,5,4]
"two"        [1,0,0]
"three"      [1,0,0,4,4]
"four"       [2,0,0,0]
"five"       [2,0,0,4]
"six"        [3,0,0]
"seven"      [3,4,0,4,5]
"eight"      [4,0,0,0,1]
"nine"       [5,0,5,4]

Как видите, списки идеально упорядочены.

Для ясности, вот как работает сравнение списков в Husk (и во многих других языках):

1. Если один из двух списков пуст, это меньший.
2. Если первые элементы двух списков отличаются, то тот, у которого первый элемент меньше, будет меньшим списком.
3. В противном случае отбросьте первый элемент из обоих списков и вернитесь к пункту 1.

Stax , 24 22 17 16 14 байт

▄Ωφ▐╧Kìg▄↕ñ▼!█

Запустите и отладьте его

Эта программа принимает массивы строчных букв для ввода. Вывод разделен новой строкой, вот так.

one five nine
two six five
three one four
three five eight

Эта программа сортирует входные данные, используя порядок, полученный при определенном преобразовании. Каждый символ в каждом слове заменяется своим индексом в строке"wo thif sen" . Исходные массивы отсортированы по этому порядку. Затем результаты печатаются после объединения с пробелом.

Пробелы не служат цели, но на самом деле позволяют большее сжатие в строковом литерале.

Желе , 12 байт

OḌ%⁽Т%147µÞ

Монадическая ссылка.

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

Как?

Преобразование цифр в порядковые и затем из базы 10, затем взятие по модулю 4752, затем 147 дает восходящий порядок:

 zero            , one         , two         , three               , four
[122,101,114,111],[111,110,101],[116,119,111],[116,104,114,101,101],[102,111,117,114]
 133351          , 12301       , 12901       , 1276511             , 114384
 295             , 2797        , 3397        , 2975                , 336
 1               , 4           , 16          , 35                  , 42

 five            , six         , seven               , eight               , nine
[102,105,118,101],[115,105,120],[115,101,118,101,110],[101,105,103,104,116],[110,105,110,101]
 113781          , 12670       , 1263920             , 1126456             , 121701
 4485            , 3166        , 4640                , 232                 , 2901
 75              , 79          , 83                  , 85                  , 108

Затем его можно использовать в качестве ключевой функции для сортировки:

OḌ%⁽Т%147µÞ - Link: list of lists of lists of characters
          µÞ - sort (Þ) by the mondadic chain to the left (µ):
O            -   ordinals of the characters
 Ḍ           -   convert from base 10
   ⁽Т       -   literal 4752
  %          -   modulo
      %147   -   modulo by 147

Python , 62 байта

lambda m:sorted(m,key=lambda r:[int(s,36)%6779%531for s in r])

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

Замечания:

lambda m:sorted(m,key=lambda r:[map("trfsen".find,s)for s in r])

который работает в Python 2 (но не 3) длиннее на два байта.

APL (Dyalog Classic) , 12 байт

'nesft'∘⍒⌷¨⊂

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

Вот как я нашел подходящий левый аргумент для двоичного ⍒( ⍋сначала я попытался и длина 6):

A←⊖a←↑'zero' 'one' 'two' 'three' 'four' 'five' 'six' 'seven' 'eight' 'nine'
{(a≡a[⍵⍒a;])∧A≡a[⍵⍒A;]:⎕←⍵}¨,⊃∘.,/5⍴⊂∪∊a

Perl 6 , 37 байт

*.sort:{('digit 'X~$_)».parse-names}

Попытайся

Expanded:

*\     # WhateverCode lambda (this is the parameter)
.sort:
{  # block with implicit parameter ｢$_｣
  (
    'digit ' X~ $_  # concatenate 'digit ' to each named digit
  )».parse-names    # call .parse-names on each
}

Блок кода примет значение формы ("three","one","four")и переведет его в ("3","1","4")значение, которое .sortможно легко использовать.

APL (Dyalog) , 38 байт

{⍵[⍋(531∘⊥⍤1)(531|6779|36⊥9+⎕A⍳⊢)¨↑⍵]}

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

На основе потрясающего решения Джонатана Аллана .

Рубин, 48 байтов

->x{x.sort_by{|y|y.map{|s|s.to_i(35)**2%47394}}}

Используется тот факт, что "zero".to_i(35)0 (поскольку «z» не является действительной цифрой в базе 35), так что намного проще использовать формулу для грубых формул для остальных девяти цифр.

K (нгн / к) , 14 байтов

{x@<"tfsen"?x}

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

JavaScript (Node.js) , 70 байт

a=>a.sort((a,b)=>(g=a=>a.map(c=>99+parseInt(2+c,34)%607%292))(a)>g(b))

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

Рубин , 47 байтов

->x{x.sort_by{|y|y.map{|s|s.to_i(32)%774%538}}}

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

Использует тот факт, что использование основания меньше максимальной цифры дает нулевой результат (как указал гистократ в своем ответе )

Python 2 , 85 81 80 байт

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

lambda _:sorted(_,key=lambda L:['zeontwthfofisiseeini'.find(s[:2])/2for s in L])

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

Сохранено 4 байта, благодаря Джонатану Аллану

Рубин , 49 байтов

->x{x.sort_by{|y|y.map{|s|s.to_i(36)**4%463595}}}

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

05AB1E , 27 байт

Σ“¡×€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“#skJ

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

Σ                           # Sort input by...
 “¡×€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“     # "zero one two three four five size seven eight nine"
                       #    # Split on spaces.
                        sk  # Find index of each input...
                          J # Join up.

Haskell , 133 122 109 107 106 байт

import Data.List
sortOn$abs.read.(>>=show.head.(`elemIndices`words"ze on tw th fo fi si se ei ni").take 2)

Ungolfed:

import Data.List

nums = ["ze","on","tw","th","fo","fi","si","se","ei","ni"]

lookup' :: Eq a => a -> [a] -> Int
lookup' v = head . elemIndices v

wordToInt :: String -> Int
wordToInt (x:y:_) = lookup' [x,y] nums

wordsToInt :: [String] -> Int
wordsToInt = read . concatMap (show . wordToInt)

sortN :: [[String]] -> [[String]]
sortN = sortOn wordsToInt

Python 2 , 59 байт

lambda m:sorted(m,key=lambda r:[hash(s)%2249518for s in r])

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

Опираясь на решение Джонатана Аллана Python 3 ...

Java (JDK 10) , 132 байта

l->{l.sort((a,b)->s(a)-s(b));}
int s(String[]a){int v=0;for(var s:a)v=v*99+"zeontwthfofisiseini".indexOf(s.substring(0,2));return v;}

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

Рубин , 64 байта

->a{a.sort_by{|b|b.map{|n|"zeontwthfofisiseeini".index n[0,2]}}}

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

Лямбда, принимающая 2D-массив строк и возвращающая 2D-массив строк.

Откат от Python 2 от mbomb007 отвечает за -26 байт от того, что я собирался опубликовать.

Perl 5 , 103 байта

sub c{pop=~s%(..)\w+\s*%zeontwthfofisiseeini=~/$1/;$`=~y///c/2%ger}say s/\R//gr for sort{c($a)<=>c$b}<>

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

Сетчатка 0.8.2 , 38 байт

T`z\o\wit\hfsen`d
O`
T`d`z\o\wit\hfsen

Попробуйте онлайн! Ссылка включает тестовый набор. Работает, временно заменяя буквы zowithfsenс их положением в этой строке, что позволяет сортировать цифры лексически.

Желе , 30 28 27 байт

w@€“¡¦ẇṆb~ṇjṚØ%ĖġṘḥḞṾṇJḌ»µÞ

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

-1 спасибо Джонатану Аллану.

Находит индекс каждой цифры в строке 'onetwo ... nine', затем сортирует, используя это как ключевую функцию с Þ. Не нужно включать 'zero'в начале, потому что поиск первых двух символов 'zero'не удастся и 0будет возвращен вместо индекса, что делает 'zero'лексикографически «рано».

Python 3, 141 байт

print(sorted(eval(input()),key=lambda l:int(''.join([str("zero one two three four five six seven eight nine".split().index(i))for i in l]))))

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

C (лязг) , 229 байтов

y,j,k,t[9];char *s="zeontwthfofisiseeini";r(char **x){for(j=y=k=0;k+1<strlen(*x);k+=j,y=y*10+(strstr(s,t)-s)/2)sscanf(*x+k,"%2[^,]%*[^,]%*[,]%n",t,&j);return y;}c(*x,*y){return r(x)-r(y);}f(*x[],l){qsort(&x[0],l,sizeof(x[0]),c);}

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

Не существует простого способа отправки массива массивов строк в функции C, поэтому в духе code-golf я взял небольшую свободу в формате ввода.

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

f()заменяет указатели на месте в отсортированном порядке, используя qsort().
r()читает входной номер из разделенной запятыми числовой строки. Он сравнивает только первые два символа для определения номера.
c()функция сравнения