Biorąc pod uwagę listę dwóch lub więcej wypisanych numerów seryjnych o równej długości większej niż dwa, np

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

posortuj listę według liczb reprezentowanych przez słowa:

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

Możesz wymagać, aby cyfry były pisane małymi lub górnymi, ale nie mieszanymi, wielkimi literami.

Przypadki testowe

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

[["two","seven"],["one","eight"],["two","eight"],["one","eight"],["two","eight"],["four","five"]]
daje
[["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"]]
daje
[["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"]]
daje
[["zero","six","one"],["three","nine","eight"],["four","eight","four"],["eight","zero","three"],["eight","seven","four"],["nine","eight","nine"]]

Łuska , 9 8 bajtów

Ö†€¨tfṡn

Wypróbuj online!

Algorytm „zainspirowany” rekursywną odpowiedzią Staxa (właśnie zmieniłem nieco ciąg odnośnika), idź do niego!

Sztuczka polega na mapowaniu każdej litery do jej pozycji w łańcuchu tfsen(skompresowana na końcu tego programu). Listy Husky są oparte na 1, a brakujące elementy zwracają 0, więc otrzymujemy to mapowanie:

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

Jak widać, listy są idealnie uporządkowane.

Aby być jasnym, oto jak działa porównanie list w Husk (i w wielu innych językach):

1. Jeśli jedna z dwóch list jest pusta, jest to mniejsza.
2. Jeśli pierwsze elementy z dwóch list są różne, ten z mniejszym pierwszym elementem jest mniejszą listą.
3. W przeciwnym razie odrzuć pierwszy element z obu list i wróć do punktu 1.

Stax , 24 22 17 16 14 bajtów

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

Uruchom i debuguj

Ten program przyjmuje tablice małych liter pisowni do wprowadzania. Wyjście jest w ten sposób oddzielone znakiem nowej linii.

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

Ten program sortuje dane wejściowe przy użyciu kolejności uzyskanej w ramach określonej transformacji. Każdy znak w każdym słowie jest zastępowany przez indeks w ciągu "wo thif sen". Oryginalne tablice są sortowane według tej kolejności. Następnie wyniki są drukowane po połączeniu ze spacją.

Spacje nie służą żadnemu celowi, ale w rzeczywistości pozwalają na większą kompresję w literale łańcucha.

Galaretka , 12 bajtów

OḌ%⁽Т%147µÞ

Link monadyczny.

Wypróbuj online! ... lub zobacz zestaw testowy

W jaki sposób?

Konwersja cyfr na liczby porządkowe, a następnie z podstawy 10, a następnie pobranie modułów o wartości 4752, a następnie 147, daje rosnącą kolejność:

 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

Można to następnie wykorzystać jako kluczową funkcję sortowania:

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 bajty

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

Wypróbuj online! ... lub zobacz zestaw testowy

Uwaga:

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

który działa w Pythonie 2 (ale nie 3) jest dłuższy o dwa bajty.

APL (Dyalog Classic) , 12 bajtów

'nesft'∘⍒⌷¨⊂

Wypróbuj online!

W ten sposób znalazłem odpowiedni lewy argument dla dyadic ⍒( ⍋najpierw spróbowałem i mam długość 6):

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

Perl 6 , 37 bajtów

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

Spróbuj

Rozszerzony:

*\     # 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
}

Blok kodu przyjmie wartość formularza ("three","one","four")i przetłumaczy ją na ("3","1","4")wartość, której .sortmożna łatwo użyć.

APL (Dyalog) , 38 bajtów

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

Wypróbuj online!

Na podstawie niesamowitego rozwiązania Jonathana Allana .

Rubinowy, 48 bajtów

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

Nadużywa faktu, że "zero".to_i(35)wynosi 0 (ponieważ „z” nie jest prawidłową cyfrą w bazie 35), więc o wiele łatwiej jest użyć formuły brutalnej dla pozostałych dziewięciu cyfr.

K (ngn / k) , 14 bajtów

{x@<"tfsen"?x}

Wypróbuj online!

JavaScript (Node.js) , 70 bajtów

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

Wypróbuj online!

Ruby , 47 bajtów

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

Wypróbuj online!

Wykorzystuje fakt, że użycie podstawy mniejszej niż maksymalna cyfra daje wynik zerowy (jak wskazał histokrat w swojej odpowiedzi )

Python 2 , 85 81 80 bajtów

Po prostu używa pierwszych dwóch liter każdego słowa do ustalenia liczby, a następnie sortuje każdą listę za pomocą tej funkcji indeksowania jako klucza.

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

Wypróbuj online!

Zaoszczędź 4 bajty dzięki Jonathanowi Allanowi

Rubinowy , 49 bajtów

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

Wypróbuj online!

05AB1E , 27 bajtów

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

Wypróbuj online!

Σ                           # 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 bajtów

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

Nie golfowany:

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 bajtów

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

Wypróbuj online!

Riffing na temat rozwiązania Jonathan Allan Python 3 ...

Java (JDK 10) , 132 bajty

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;}

Wypróbuj online!

Rubinowy , 64 bajty

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

Wypróbuj online!

Lambda akceptuje tablicę ciągów 2D i zwraca tablicę ciągów 2D.

Piggybacking z odpowiedzi mbomb007 na Python 2 dla -26 bajtów mniej od tego, co zamierzałem opublikować.

Perl 5 , 103 bajtów

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

Wypróbuj online!

Retina 0.8.2 , 38 bajtów

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

Wypróbuj online! Link zawiera pakiet testowy. Działa poprzez tymczasowe zastąpienie liter zowithfsenich pozycją w tym ciągu, co pozwala na sortowanie liczbowe.

Galaretka , 30 28 27 bajtów

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

Wypróbuj online!

-1 dzięki Jonathan Allan.

Znajduje indeks każdej cyfry w ciągu „onetwo ... nine”, a następnie sortuje, używając tej funkcji jako klawisza Þ. Nie trzeba uwzględniać 'zero'na początku, ponieważ wyszukiwanie pierwszych dwóch znaków 'zero'nie powiedzie się i 0zostanie zwrócone zamiast indeksu, dzięki czemu 'zero'leksykograficznie „wcześnie”.

Python 3, 141 bajtów

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

Wypróbuj online!

C (brzęk) , 229 bajtów

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

Wypróbuj online!

Nie ma prostego sposobu na przesłanie tablicy tablic ciągów do funkcji C, więc w duchu golfa kodu skorzystałem z niewielkiej swobody w formacie wejściowym.

f()akceptuje tablicę wskaźników do ciągów, gdzie każdy ciąg jest liczbą, reprezentowaną oddzielonymi przecinkami cyframi pisanymi małymi literami. Dodatkowo potrzebuje liczby ciągów w tablicy w drugim parametrze. Mam nadzieję, że jest to do przyjęcia.

f()zastępuje wskaźniki na miejscu w posortowanej kolejności za pomocą qsort().
r()odczytuje numer wejściowy z ciągu liczb oddzielonych przecinkami. Porównuje tylko dwa pierwsze znaki w celu identyfikacji numeru.
c()jest funkcją porównawczą