Bei einer Liste von zwei oder mehr buchstabierten Seriennummern gleicher Länge größer als zwei, z

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

sortiere die Liste nach den Zahlen, die die Wörter darstellen:

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

Möglicherweise müssen die Zahlen in Groß- oder Kleinschreibung geschrieben sein, jedoch nicht gemischt.

Testfälle

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

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

Schale , 9 8 Bytes

Ö†€¨tfṡn

Probieren Sie es online!

Algorithmus "inspiriert" durch die rekursive Stax-Antwort (ich habe gerade die Suchzeichenfolge ein wenig geändert), stimme ihm zu!

Der Trick besteht darin, jeden Buchstaben seiner Position in der Zeichenfolge zuzuordnen tfsen(am Ende dieses Programms komprimiert). Hüllenlisten basieren auf 1, und fehlende Elemente geben 0 zurück, sodass wir diese Zuordnung erhalten:

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

Wie Sie sehen, sind die Listen perfekt sortiert.

Um klar zu sein, funktioniert der Listenvergleich in Husk (und in vielen anderen Sprachen) wie folgt:

1. Wenn eine der beiden Listen leer ist, ist dies die kleinere.
2. Wenn die ersten Elemente der beiden Listen unterschiedlich sind, ist das mit dem kleineren ersten Element die kleinere Liste.
3. Anderenfalls verwerfen Sie das erste Element aus beiden Listen und kehren zu Punkt 1 zurück.

Stax , 24 22 17 16 14 Bytes

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

Führen Sie es aus und debuggen Sie es

Dieses Programm verwendet Felder mit Kleinbuchstaben zur Eingabe. Die Ausgabe ist wie folgt durch Zeilenumbrüche getrennt.

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

Dieses Programm sortiert die Eingaben anhand der Reihenfolge, die bei einer bestimmten Umwandlung erhalten wurde. Jedes Zeichen in jedem Wort wird durch seinen Index in der Zeichenfolge ersetzt "wo thif sen". Die ursprünglichen Arrays werden nach dieser Reihenfolge sortiert. Anschließend werden die Ergebnisse nach dem Verbinden mit einem Leerzeichen gedruckt.

Die Leerzeichen dienen keinem Zweck, ermöglichen jedoch eine stärkere Komprimierung des String-Literal.

Gelee , 12 Bytes

OḌ%⁽Т%147µÞ

Eine monadische Verbindung.

Probieren Sie es online! ... oder sehen Sie sich die Testsuite an

Wie?

Das Umwandeln der Ziffern in Ordnungszahlen und dann von der Basis 10 zu Modulos mit 4752 und 147 ergibt eine aufsteigende Reihenfolge:

 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

Dies kann dann als Schlüsselfunktion zum Sortieren verwendet werden:

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

Probieren Sie es online! ... oder sehen Sie sich die Testsuite an

Hinweis:

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

Was in Python 2 (aber nicht in 3) funktioniert, ist um zwei Bytes länger.

APL (Dyalog Classic) , 12 Byte

'nesft'∘⍒⌷¨⊂

Probieren Sie es online!

So habe ich ein passendes linkes Argument für dyadisch gefunden ⍒(ich habe es zuerst versucht ⍋und Länge 6):

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}

Versuch es

Erweitert:

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

Der Codeblock nimmt einen Wert des Formulars ("three","one","four")und übersetzt ihn in ("3","1","4")einen Wert, der .sortleicht verwendet werden kann.

APL (Dyalog) , 38 Bytes

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

Probieren Sie es online!

Basierend auf Jonathan Allans großartiger Lösung .

Ruby, 48 Bytes

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

Missbraucht die Tatsache, dass "zero".to_i(35)0 ist (da 'z' keine gültige Ziffer in Basis 35 ist), so ist es viel einfacher, eine Formel für die anderen neun Ziffern zu erzwingen.

K (ngn / k) , 14 Bytes

{x@<"tfsen"?x}

Probieren Sie es 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))

Probieren Sie es online!

Ruby , 47 Bytes

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

Probieren Sie es online!

Nutzt die Tatsache, dass die Verwendung einer Basis, die kleiner als die maximale Ziffer ist, ein Ergebnis von Null ergibt (wie von Histokraten in ihrer Antwort hervorgehoben ).

Python 2 , 85 81 80 Bytes

Verwenden Sie einfach die ersten beiden Buchstaben jedes Wortes, um die Nummer zu bestimmen, und sortieren Sie dann jede Liste mit dieser Indexierungsfunktion als Schlüssel.

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

Probieren Sie es online!

4 Bytes gespart, dank Jonathan Allan

Ruby , 49 Bytes

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

Probieren Sie es online!

05AB1E , 27 Bytes

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

Probieren Sie es 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])

Probieren Sie es online!

Riffing über Jonathan Allans Python 3-Lösung ...

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

Probieren Sie es online!

Ruby , 64 Bytes

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

Probieren Sie es online!

Ein Lambda, das ein 2D-Array von Zeichenfolgen akzeptiert und ein 2D-Array von Zeichenfolgen zurückgibt.

Huckepack von mbomb007's Python 2 Antwort für -26 Bytes von dem, was ich gerade posten wollte.

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

Probieren Sie es online!

Retina 0.8.2 , 38 Bytes

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

Probieren Sie es online! Link enthält Testsuite. Ersetzt vorübergehend die Buchstaben zowithfsendurch ihre Position in der Zeichenfolge, sodass die Zahlen lexikalisch sortiert werden können.

Jelly , 30 28 27 Bytes

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

Probieren Sie es online!

-1 Danke an Jonathan Allan.

Findet den Index jeder Ziffer in der Zeichenfolge 'onetwo ... nine' und sortiert diese mit Þ. Muss nicht 'zero'am Anfang eingeschlossen werden, da die Suche nach den ersten beiden Zeichen von 'zero'fehlschlägt und 0anstelle eines Index zurückgegeben wird, wodurch 'zero'lexikographisch "früh" wird.

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

Probieren Sie es 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);}

Probieren Sie es online!

Es gibt keine einfache Möglichkeit, ein Array von Strings an C-Funktionen zu senden, daher habe ich mir im Sinne von Code-Golf eine kleine Freiheit im Eingabeformat genommen.

f()Akzeptiert ein Array von Zeigern auf Zeichenfolgen, wobei jede Zeichenfolge eine Zahl ist, die durch durch Kommas getrennte, in Kleinbuchstaben geschriebene Ziffern dargestellt wird. Darüber hinaus benötigt es die Anzahl der Zeichenfolgen im Array im zweiten Parameter. Ich hoffe das ist akzeptabel.

f()ersetzt die vorhandenen Zeiger in sortierter Reihenfolge mit qsort().
r()Liest die eingegebene Nummer aus einer durch Kommas getrennten Zeichenfolge. Es werden nur die ersten beiden Zeichen verglichen, um die Nummer zu identifizieren.
c()ist Vergleichsfunktion