Dada una lista de dos o más números de serie detallados de igual longitud mayor que dos, por ej.

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

ordenar la lista por los números que representan las palabras:

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

Puede requerir que los números se deletreen en mayúsculas o minúsculas, pero no en mayúsculas.

Casos de prueba

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

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

Casco , 9 8 bytes

Ö†€¨tfṡn

Pruébalo en línea!

Algoritmo "inspirado" por la respuesta recursiva de Stax (acabo de cambiar un poco la cadena de búsqueda), ¡vota!

El truco consiste en asignar cada letra a su posición en la cadena tfsen(comprimida al final de este programa). Las listas de cáscaras están basadas en 1, y los elementos faltantes devuelven 0, por lo que obtenemos esta asignación:

"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 puede ver, las listas están perfectamente ordenadas.

Para que quede claro, así es como funciona la comparación de listas en Husk (y en muchos otros idiomas):

1. Si una de las dos listas está vacía, esa es la más pequeña.
2. Si los primeros elementos de las dos listas son diferentes, el que tiene el primer elemento más pequeño es la lista más pequeña.
3. De lo contrario, descarte el primer elemento de ambas listas y regrese al punto 1.

Stax , 24 22 17 16 14 bytes

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

Ejecutar y depurarlo

Este programa toma matrices de dígitos deletreados en minúsculas para la entrada. La salida está separada por nueva línea de esta manera.

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

Este programa clasifica las entradas utilizando el orden obtenido bajo una transformación específica. Cada carácter en cada palabra se reemplaza por su índice en la cadena"wo thif sen" . Las matrices originales se ordenan por este orden. Luego, los resultados se imprimen después de unirlos con un espacio.

Los espacios no sirven para nada, pero en realidad permiten una mayor compresión en la cadena literal.

Jalea , 12 bytes

OḌ%⁽Т%147µÞ

Un enlace monádico.

Pruébalo en línea! ... o ver el pruebas

¿Cómo?

Convirtiendo los dígitos a ordinales y luego desde la base 10, luego tomando módulos por 4752 y luego 147, da un orden ascendente:

 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

Esto se puede usar como una función clave para clasificar:

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

Pruébalo en línea! ... o ver el conjunto de pruebas

Nota:

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

que funciona en Python 2 (pero no 3) es más largo por dos bytes.

APL (Dyalog Classic) , 12 bytes

'nesft'∘⍒⌷¨⊂

Pruébalo en línea!

Así es como encontré un argumento izquierdo adecuado para dyadic ⍒(probé ⍋y longitud 6 primero):

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}

Intentalo

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
}

El bloque de código tomará un valor del formulario ("three","one","four")y lo traducirá a ("3","1","4")un valor que .sortpuede usar fácilmente.

APL (Dyalog) , 38 bytes

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

Pruébalo en línea!

Basado en la increíble solución de Jonathan Allan .

Ruby, 48 bytes

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

Abusa del hecho de que "zero".to_i(35)es 0 (ya que 'z' no es un dígito válido en la base 35), por lo que es mucho más fácil forzar una fórmula para los otros nueve dígitos.

K (ngn / k) , 14 bytes

{x@<"tfsen"?x}

Pruébalo en línea!

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

Pruébalo en línea!

Ruby , 47 bytes

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

Pruébalo en línea!

Utiliza el hecho de que el uso de una base menor que el dígito máximo produce un resultado de cero (como señaló el histocrat en su respuesta )

Python 2 , 85 81 80 bytes

Simplemente usa las dos primeras letras de cada palabra para determinar el número, luego ordena cada lista usando esa función de indexación como clave.

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

Pruébalo en línea!

Guardado 4 bytes, gracias a Jonathan Allan

Ruby , 49 bytes

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

Pruébalo en línea!

05AB1E , 27 bytes

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

Pruébalo en línea!

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

Sin golf:

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

Pruébalo en línea!

Refiriéndose a la solución 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;}

Pruébalo en línea!

Ruby , 64 bytes

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

Pruébalo en línea!

Una lambda que acepta una matriz 2D de cadenas y devuelve una matriz 2D de cadenas.

Aprovechando la respuesta de Python 2 de mbomb007 para -26 bytes de lo que estaba a punto de publicar.

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

Pruébalo en línea!

Retina 0.8.2 , 38 bytes

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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Funciona reemplazando temporalmente las letras zowithfsencon su posición en esa cadena, lo que permite que los números se ordenen léxicamente.

Jalea , 30 28 27 bytes

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

Pruébalo en línea!

-1 gracias a Jonathan Allan.

Encuentra el índice de cada dígito en la cadena 'onetwo ... nueve' y luego ordena usar esto como una función clave con Þ. No es necesario incluir 'zero'al principio porque la búsqueda de los dos primeros caracteres de 'zero'fallará y 0se devolverá en lugar de un índice, lo que 'zero'lexicográficamente es "temprano".

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

Pruébalo en línea!

C (sonido metálico) , 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);}

Pruébalo en línea!

No hay una forma directa de enviar una matriz de series de cadenas a las funciones de C, por lo que, en el espíritu del código golf, me he tomado una libertad menor en el formato de entrada.

f()acepta una matriz de punteros a cadenas, donde cada cadena es un número, representado por dígitos deletreados separados por comas en minúsculas. Además, necesita varias cadenas en la matriz en el segundo parámetro. Espero que esto sea aceptable.

f()reemplaza los punteros en su lugar en orden ordenado usando qsort().
r()lee el número de entrada de una cadena de números separados por comas. Solo compara los dos primeros caracteres para identificar el número.
c()es la función de comparación