Dada uma lista de dois ou mais números de série detalhados de igual comprimento maior que dois, por exemplo,

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

classifique a lista pelos números que as palavras representam:

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

Você pode exigir que os números sejam escritos em letras maiúsculas ou minúsculas, mas não mistos.

Casos de teste

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

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

Casca , 9 8 bytes

Ö†€¨tfṡn

Experimente online!

Algoritmo "inspirado" pela resposta Stax da recursiva (acabei de alterar um pouco a string de pesquisa), faça um voto positivo!

O truque é mapear cada letra para sua posição na string tfsen(compactada no final deste programa). As listas de cascas são baseadas em 1 e os itens ausentes retornam 0, então obtemos esse mapeamento:

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

Como você pode ver, as listas estão perfeitamente ordenadas.

Para ficar claro, veja como a comparação de lista funciona no Husk (e em muitos outros idiomas):

1. Se uma das duas listas estiver vazia, é a menor.
2. Se os primeiros elementos das duas listas forem diferentes, aquele com o primeiro elemento menor será a lista menor.
3. Caso contrário, descarte o primeiro elemento de ambas as listas e volte ao ponto 1.

Stax , 24 22 17 16 14 bytes

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

Execute e depure

Este programa utiliza matrizes de dígitos escritos em minúsculas para entrada. A saída é separada por nova linha assim.

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

Este programa classifica as entradas usando a ordem obtida em uma transformação específica. Cada caractere em cada palavra é substituído por seu índice na string"wo thif sen" . As matrizes originais são classificadas por essa ordem. Em seguida, os resultados são impressos após a união com um espaço.

Os espaços não servem para nada, mas na verdade permitem maior compactação na cadeia literal.

Gelatina , 12 bytes

OḌ%⁽Т%147µÞ

Um link monádico.

Experimente online! ... ou veja a suíte de testes

Quão?

Converter os dígitos em ordinais e, em seguida, da base 10 e, em seguida, tomar os módulos por 4752 e 147, fornece uma ordem crescente:

 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

Isso pode ser usado como uma função principal pela qual classificar:

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 bytes

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

Experimente online! ... ou veja a suíte de testes

Nota:

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

que funciona no Python 2 (mas não 3) tem mais dois bytes.

APL (Dyalog Classic) , 12 bytes

'nesft'∘⍒⌷¨⊂

Experimente online!

Foi assim que encontrei um argumento à esquerda adequado para diádico ⍒(tentei ⍋e compri 6 primeiro):

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

Perl 6 , 37 bytes

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

Tente

Expandido:

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

O bloco de código pega um valor do formulário ("three","one","four")e o converte para ("3","1","4")um valor que .sortpode ser usado facilmente.

APL (Dyalog) , 38 bytes

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

Experimente online!

Baseado na incrível solução de Jonathan Allan .

Ruby, 48 bytes

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

Abusa do fato de que "zero".to_i(35)é 0 (já que 'z' não é um dígito válido na base 35), por isso é muito mais fácil aplicar uma fórmula de força bruta para os outros nove dígitos.

K (ngn / k) , 14 bytes

{x@<"tfsen"?x}

Experimente online!

JavaScript (Node.js) , 70 bytes

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

Experimente online!

Ruby , 47 bytes

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

Experimente online!

Utiliza o fato de que o uso de uma base menor que o dígito máximo gera um resultado zero (conforme apontado pelo histocrata na resposta )

Python 2 , 85 81 80 bytes

Simplesmente usa as duas primeiras letras de cada palavra para determinar o número e classifica cada lista usando essa função de indexação como chave.

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

Experimente online!

Guardado 4 bytes, graças a Jonathan Allan

Ruby , 49 bytes

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

Experimente online!

05AB1E , 27 bytes

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

Experimente 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 bytes

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 bytes

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

Experimente online!

Riffing na solução Python 3 de Jonathan Allan ...

Java (JDK 10) , 132 bytes

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

Experimente online!

Ruby , 64 bytes

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

Experimente online!

Um lambda que aceita uma matriz 2D de cadeias e retorna uma matriz 2D de cadeias.

Pegando carona na resposta Python 2 do mbomb007 para -26 bytes do que eu estava prestes a postar.

Perl 5 , 103 bytes

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

Experimente online!

Retina 0.8.2 , 38 bytes

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

Experimente online! O link inclui o conjunto de testes. Funciona substituindo temporariamente as letras zowithfsencom sua posição nessa sequência, o que permite que os números sejam classificados lexicamente.

Geléia , 30 28 27 bytes

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

Experimente online!

-1 graças a Jonathan Allan.

Localiza o índice de cada dígito na string 'onetwo ... nine' e classifica usando-o como uma função-chave com Þ. Não é necessário incluir 'zero'no início, porque a pesquisa pelos dois primeiros caracteres de 'zero'falhará e 0será retornada em vez de um índice, tornando 'zero'lexicograficamente "precoce".

Python 3, 141 bytes

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

Experimente online!

C (clang) , 229 bytes

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

Experimente online!

Não existe uma maneira direta de enviar matriz de matriz de caracteres para funções C, portanto, no espírito do código-golfe, tomei uma pequena liberdade no formato de entrada.

f()aceita uma matriz de ponteiros para seqüências de caracteres, onde cada sequência é um número, representado por dígitos ortográficos separados por vírgula em minúsculas. Além disso, ele precisa do número de seqüências de caracteres na matriz no segundo parâmetro. Espero que isso seja aceitável.

f()substitui os ponteiros no lugar na ordem classificada usando qsort().
r()lê o número de entrada da sequência numérica separada por vírgula. Ele compara apenas os dois primeiros caracteres para identificar o número.
c()é função de comparação