Dato un elenco di due o più numeri seriali di uguale lunghezza maggiore di due, ad es

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

ordina l'elenco in base ai numeri che le parole rappresentano:

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

Potrebbe essere necessario scrivere i numeri in maiuscolo o in maiuscolo, ma non mescolati.

Casi test

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

Buccia , 9 8 byte

Ö†€¨tfṡn

Provalo online!

Algoritmo "ispirato" dalla risposta Stax ricorsiva (ho appena cambiato un po 'la stringa di ricerca), votalo!

Il trucco sta nel mappare ogni lettera nella sua posizione nella stringa tfsen(compressa alla fine di questo programma). Gli elenchi Husks sono basati su 1 e gli elementi mancanti restituiscono 0, quindi otteniamo questo mapping:

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

Come puoi vedere, le liste sono perfettamente ordinate.

Per essere chiari, ecco come funziona il confronto degli elenchi in Husk (e in molte altre lingue):

1. Se una delle due liste è vuota, quella è più piccola.
2. Se i primi elementi dei due elenchi sono diversi, quello con il primo elemento più piccolo è l'elenco più piccolo.
3. Altrimenti, scartare il primo elemento da entrambe le liste e tornare al punto 1.

Stax , 24 22 17 16 14 byte

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

Esegui ed esegui il debug

Questo programma prende matrici di cifre scritte in minuscolo per l'input. L'output è separato da newline in questo modo.

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

Questo programma ordina gli input usando l'ordinamento ottenuto con una trasformazione specifica. Ogni carattere in ogni parola è sostituito dal suo indice nella stringa "wo thif sen". Le matrici originali sono ordinate in base a questo ordine. Quindi i risultati vengono stampati dopo l'unione con uno spazio.

Gli spazi non servono a nulla, ma in realtà consentono una maggiore compressione nella stringa letterale.

Gelatina , 12 byte

OḌ%⁽Т%147µÞ

Un collegamento monadico.

Provalo online! ... o vedi la suite di test

Come?

La conversione delle cifre in ordinali e quindi dalla base 10, quindi prendendo i moduli da 4752, quindi 147 dà un ordine 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

Questo può quindi essere usato come una funzione chiave con cui ordinare:

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 byte

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

Provalo online! ... o vedi la suite di test

Nota:

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

che funziona in Python 2 (ma non 3) è più lungo di due byte.

APL (Dyalog Classic) , 12 byte

'nesft'∘⍒⌷¨⊂

Provalo online!

Ecco come ho trovato un argomento sinistro adatto per diadico ⍒(ho provato prima ⍋e lunghezza 6):

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

Perl 6 , 37 byte

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

Provalo

Allargato:

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

Il blocco di codice prenderà un valore del modulo ("three","one","four")e lo tradurrà in ("3","1","4")un valore che .sortpuò essere facilmente utilizzato.

APL (Dyalog) , 38 byte

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

Provalo online!

Basato sulla fantastica soluzione di Jonathan Allan .

Rubino, 48 byte

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

Abusa del fatto che "zero".to_i(35)è 0 (poiché "z" non è una cifra valida nella base 35), quindi è molto più facile forzare una formula per le altre nove cifre.

K (ngn / k) , 14 byte

{x@<"tfsen"?x}

Provalo online!

JavaScript (Node.js) , 70 byte

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

Provalo online!

Rubino , 47 byte

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

Provalo online!

Utilizza il fatto che l'utilizzo di una base inferiore alla cifra massima produce un risultato pari a zero (come sottolineato dall'istocratico nella loro risposta )

Python 2 , 85 81 80 byte

Usa semplicemente le prime due lettere di ogni parola per determinare il numero, quindi ordina ogni elenco usando quella funzione di indicizzazione come chiave.

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

Provalo online!

Salvato 4 byte, grazie a Jonathan Allan

Rubino , 49 byte

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

Provalo online!

05AB1E , 27 byte

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

Provalo 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 byte

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 byte

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

Provalo online!

Riffing sulla soluzione Python 3 di Jonathan Allan ...

Java (JDK 10) , 132 byte

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

Provalo online!

Rubino , 64 byte

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

Provalo online!

Un lambda che accetta un array 2D di stringhe e restituisce un array 2D di stringhe.

Escludendo la risposta di Python 2 di mbomb007 per -26 byte di sconto su ciò che stavo per pubblicare.

Perl 5 , 103 byte

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

Provalo online!

Retina 0.8.2 , 38 byte

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

Provalo online! Il link include la suite di test. Funziona sostituendo temporaneamente le lettere zowithfsencon la loro posizione in quella stringa, che consente di ordinare i numeri in modo lessicale.

Gelatina , 30 28 27 byte

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

Provalo online!

-1 grazie a Jonathan Allan.

Trova l'indice di ogni cifra nella stringa "onetwo ... nine", quindi ordina usando questa come funzione chiave con Þ. Non è necessario includerlo 'zero'all'inizio perché la ricerca dei primi due caratteri di 'zero'fallirà e 0verrà restituita al posto di un indice, rendendo 'zero'lessicograficamente "precoce".

Python 3, 141 byte

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

Provalo online!

C (clang) , 229 byte

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

Provalo online!

Non esiste un modo semplice per inviare array di array di stringhe alle funzioni C, quindi in spirito di code-golf ho preso una piccola libertà nel formato di input.

f()accetta una matrice di puntatori alle stringhe, in cui ogni stringa è un numero, rappresentato da cifre separate da virgole in caratteri minuscoli. Inoltre, necessita del numero di stringhe nell'array nel secondo parametro. Spero sia accettabile

f()sostituisce i puntatori in posizione nell'ordine ordinato usando qsort().
r()legge il numero di input dalla stringa numerica separata da virgola. Confronta solo i primi due caratteri per identificare il numero.
c()è la funzione di confronto