Wir alle kennen verschiedene ausgefallene Sortieralgorithmen, aber keine davon gibt uns Zahlen auf eine Weise, die leicht auszusprechen ist. Um dem abzuhelfen, schlage ich die Verwendung von AusspracheSort ™ vor, der natürlichsten Methode zum Sortieren von Nummernlisten.

Aussprache

Die offiziellen Regeln zum Aussprechen von Zahlen (in dieser Herausforderung) lauten, dass die Ziffern einzeln ausgesprochen werden und die resultierende Zeichenfolge in lexikografischer Reihenfolge sortiert wird. Dies bedeutet beispielsweise, dass die Nummer 845ausgesprochen "eight four five"wird und entsprechend sortiert werden sollte.

Negative Zahlen

Negative Zahlen werden durch Voranstellen des Wortes ausgesprochen "minus". So -23wird ausgesprochen als "minus two three". Beachten Sie, dass negative Zahlen in der Mitte der Ausgabe angezeigt werden, direkt zwischen den Zahlen, die mit 4(vier) und 9(neun) beginnen.

Die offizielle Reihenfolge der Wörter für AusspracheSort ™ lautet:

• acht
• fünf
• vier
• Minus
• neun
• eins
• Sieben
• sechs
• drei
• zwei
• Null

Das ist,

8, 5, 4, -, 9, 1, 7, 6, 3, 2, 0

Eingang

Eine Liste von Ganzzahlen im Bereich , die höchstens 100 Elemente enthält. Die Eingabe als Liste von Zeichenfolgen ist nicht zulässig. Wenn Ihre Sprache die Eingabe als Liste nicht unterstützt, ist es zulässig, die Eingabe als separate Ganzzahlen vorzunehmen.$[-999, 999]$

Die Eingabe enthält keine ungültigen Zahlen oder Zahlen, die mit einer 0 beginnen (mit Ausnahme der Zahl 0 selbst). Die Eingabe wird in der Regel nicht sortiert, sondern kann in beliebiger Reihenfolge erfolgen.

Ausgabe

Dieselben ganzen Zahlen in der Reihenfolge von AusspracheSort ™. Beachten Sie, dass die Zahlen nur in ihre Aussprachen konvertiert werden sollten, um die Sortierung zu erhalten. Die Ausgabe sollte keine Zeichenfolgen enthalten.

Beispiele

In den Beispielen dient der in Klammern gesetzte mittlere Schritt nur als Richtlinie und ist nicht Teil der Ausgabe.

[1, 2, 3] -> (['one', 'two', 'three']) -> [1, 3, 2]
[-1, 0, 1, 2] -> (['minus one', 'zero', 'one', 'two']) -> [-1, 1, 2, 0]
[-100, 45, 96] -> (['minus one zero zero', 'four five', 'nine six']) -> [45, -100, 96]
[11, 12, 13, 134, 135] -> (['one one', 'one two', 'one three', 'one three four', 'one three five']) -> [11, 13, 135, 134, 12]

Es gibt auch ein Skript zur Überprüfung Ihrer Ergebnisse .

05AB1E (Legacy) , 15 Byte

Σε•Koéa₃•'-3ǝsk

Probieren Sie es online!

Erläuterung

Σ                 # sort by
 ε                # apply to each
             sk   # index of the element in
  •Koéa₃•         # "85409176320"
         '-3ǝ     # with "-" inserted at index 3

Haskell , 57 Bytes

import Data.List
sortOn$map(`elemIndex`"54-9176320").show

Probieren Sie es online!

Jelly ,  15 bis  13 Bytes

ṾV€ị“Þ⁽3Z6»µÞ

Probieren Sie es online!

Ein monadischer Link, der eine Liste von ganzen Zahlen akzeptiert, die eine Liste von ganzen Zahlen ergibt.

Wie?

Sortiert nach den Ordnungswerten der Ziffern der ganzen Zahlen (wobei -eine "Ziffer" von -1 ist), konvertiert in Zeichenfolgen unter Verwendung der Zeichen an ihrem 1-basierten und modularen Index in der magischen Zeichenfolge "murgeon lix".

Die Sortierung ist praktisch alphabetisch, wobei ein Leerzeichen weniger als ein Buchstabe ist.

Die magische Zeichenfolge "murgeon lix" wurde gefunden, indem Jellys bei der Komprimierung verwendete Wörterbücher untersucht wurden. Es gibt keine Wörter mit 11 Buchstaben, die den Anforderungen entsprechen (und keine weiteren, die bei der Deduplizierung benötigt würden). da ein Leerzeichen vor Buchstaben sortiert ist, ist die nächste naheliegendste Wahl ein Wort der Länge sieben, gefolgt von einem Leerzeichen, gefolgt von einem Wort der Länge drei. "murgeon" und "lix" sind die einzig befriedigende Kombination, obwohl ohne Leerzeichen andere möglich sein könnten (zB “£Py:ƥ»"murgeonalix", das für die gleiche Byteanzahl arbeitet)

ṾV€ị“Þ⁽3Z6»µÞ - Link: list of integers
            Þ - sort by:
           µ  -   the monadic link: -- i.e. do this for each integer, then sort by that
Ṿ             -     unevaluate  (e.g. -803 -> ['-','8','0','3'])
 V€           -     evaluate each as Jelly code  (e.g. ['-','8','0','3'] -> [-1,8,0,3])
    “Þ⁽3Z6»   -     "murgeon lix" (compression of words in Jelly's dictionary plus a space)
   ị          -     index into (1-indexed & modular) (e.g. [-1,8,0,3] -> "i xr")

Vorherige @ 15 Bytes :

ṾV€ị“¡Zo⁶’Œ?¤µÞ

Hier “¡Zo⁶’Œ?¤findet sich die erste Permutation natürlicher Zahlen, die sich am Index 21.340.635 befinden würde, wenn alle Permutationen der Zahlen lexikographisch sortiert wären - das ist [6,10,9,3,2,8,7,1,5,4,11]. ( “¡Zo⁶’Ist eine Basis-250-Darstellung von 21340635, während Œ?die Berechnung und ¤Gruppierung dieser Anweisungen erfolgt.)

Perl 6 , 30 Bytes

*.sort:{TR/0..9-/a5982176043/}

Probieren Sie es online!

Port der Ruby-Lösung von GB.

Ursprüngliche 35-Byte-Version

*.sort: (~*).uninames».&{S/\w*.//}

Probieren Sie es online!

Konvertieren Sie jede Zahl in eine Zeichenfolge, ermitteln Sie den Unicode-Namen jedes Zeichens, entfernen Sie das erste Wort ("DIGIT" oder "HYPHEN") und sortieren Sie es.

JavaScript (SpiderMonkey) , 69 Byte

a=>a.sort((a,b)=>(g=n=>[...n+''].map(c=>':598217604'[c]||3))(a)>g(b))

Probieren Sie es online!

K (NGN / k) , 21 20 Bytes

{x@<"54-9176320"?$x}

Probieren Sie es online!

{ } Funktion mit Argument x

$ Format als Zeichenfolgen

"... "?Indizes einzelner Zeichen in der angegebenen Zeichenfolge suchen (oder für "nicht gefunden" - beachten Sie, dass das fehlt)$-2^{63}$"8"

< berechne sortiere aufsteigende Permutation

x@ das Argument bei diesen Indizes

Python 3, 68 Bytes 67 Bytes 64 Bytes

lambda x:sorted(x,key=lambda y:[*map('54-9176320'.find,str(y))])

Verwendet die eingebaute sortedFunktion mit einem anonymen Lambda für den Schlüssel. Codieren Sie die Sortierreihenfolge fest und vergleichen Sie jede Ziffer in jedem Wert in der Eingabeliste mit ihrer Position in der Sortierreihenfolge.

Bearbeiten: 1 Byte durch Entfernen 8aus der Sortierliste gespeichert , um die str.findRückgabe zu nutzen, -1wenn der Parameter nicht gefunden wird. Vielen Dank an maxb.

Edit2: Speichert 3 Bytes, indem die markierte Entpackungssyntax in einem listLiteral anstelle eines listKonstruktors verwendet wird

Probieren Sie es online!

Pyth, 17 16 Bytes

oxL"54-9176320"`

Versuchen Sie es online hier oder überprüfen alle Testfälle auf einmal hier .

oxL"54-9176320"`NQ   Implicit: Q=eval(input())
                     Trailing N, Q inferred
o                Q   Order the elements of Q, as N, using...
               `N      Convert N to string
 xL                    Get the index of each character of that string...
   "54-9176320"        ... in the lookup ordering
                       (if character missing, returns -1, so 8 is still sorted before 5)

1 Byte dank @ngn und ihrer K-Antwort gespeichert , indem 8 am Anfang der Wörterbuchzeichenfolge weggelassen wurde

Japt, 19 Bytes

ñ_s ®n"54-9176320

Versuch es

• Sparen Sie 2 Bytes dank ETHproductions .

Retina 0,8,2 , 36 Bytes

T`-d`3:598217604
O`
T`3:598217604`-d

Probieren Sie es online! Link enthält Testsuite. Erläuterung:

T`-d`3:598217604

Übersetzen Sie das Minuszeichen und die Ziffern in der Aussprachereihenfolge an ihre Position, wobei Sie :für die zehnte Position verwenden.

O`

In der Reihenfolge der Aussprache sortieren.

T`3:598217604`-d

Übersetzen Sie die Bestellung zurück in das ursprüngliche Minuszeichen und die Ziffern.

Ruby , 50 Bytes

->a{a.sort_by{|x|x.to_s.tr('0-9-','a5982176043')}}

Probieren Sie es online!

R , 58 Bytes

function(x)x[order(mapply(chartr,"-0-9","dkfjicbhgae",x))]

Probieren Sie es online!

Die Eingabe ist eine Liste von Zahlen, die implizit als Zeichenfolge konvertiert wird chartr. orderverwendet dann die lexigografische Reihenfolge, um die Reihenfolge abzurufen, nach der die ursprüngliche Liste sortiert werden soll.

Java (JDK 10) , 123 Byte

l->l.sort(java.util.Comparator.comparing(n->{var r="";for(var c:(""+n).split(""))r+=11+"54-9176320".indexOf(c);return r;}))

Probieren Sie es online!

Dies ist eine naive Java-Implementierung. Sollte viel Golf sein.

Credits

• 3 Bytes gespart dank Kevin Cruijssen

JavaScript (SpiderMonkey) , 87 73 Bytes

a=>a.sort((p,q,F=b=>[...""+b].map(x=>"54-9176320".search(x)))=>F(p)>F(q))

Probieren Sie es online!

Vielen Dank an @Arnauld für den Hinweis, dass die Sortierung in SpiderMonkey stabil ist, sodass das ||-(F(q)>F(p))Teil endgültig gelöscht werden kann.

Rot , 114 Bytes

func[n][g: func[a][collect[foreach c form a[keep index? find"854-9176320"c]]]sort/compare n func[x y][(g x)< g y]]

Probieren Sie es online!

Besser lesbar:

f: func [ n ] [
    g: func [ a ] [
        collect [ 
            foreach c form a [ 
                keep index? find "854-9176320" c
            ]
        ]
    ]
    sort/compare n func [ x y ] [ (g x) < g y ]
]

C ++, 353 Bytes

Dies ist eine Art Comedy-Eintrag, aber ich habe Zeit verschwendet und ihn geschrieben, daher kann ich ihn nicht veröffentlichen.

#include<algorithm>
#include<iostream>
#include<iterator>
#include<numeric>
#include<string>
using namespace std;auto f(int i){auto s=to_string(i);for(auto&c:s)c='A'+"854-9176320"s.find(c);return s;}int main(){int a[100];auto b=begin(a);auto e=end(a);iota(b,e,-50);sort(b,e,[](int l,int r){return f(l)<f(r);});copy(b,e,ostream_iterator<int>(cout," "));}

Ausgabe:

8 5 4 48 45 44 49 41 47 46 43 42 40 -8 -5 -50 -4 -48 -45 -44 -49 -41 -47 -46 -43 -42 -40 -9 -1 -18 -15 - 14 -19 -11 -17 -16 -13 -12 -10 -7 -6 -3 -38 -35 -34 -39 -31 -37 -36 -33 -32 -30 -2 -28 -25 -24 - 29 -21 -27 -26 -23 -22 -20 9 1 18 15 14 19 11 17 16 13 12 10 7 6 3 38 35 34 39 31 37 33 32 30 2 28 25 24 29 21 27 26 23 22 20 0

Mathematica, 68 Bytes

SortBy[If[# < 0,"m ",""]<>StringRiffle@IntegerName@IntegerDigits@#&]

Funktion. Nimmt eine Liste von Ganzzahlen als Eingabe und gibt die sortierte Liste als Ausgabe zurück. Nur trennt die Ziffern von jeder Nummer mit IntegerDigits, wandelt jede Ziffer "zero", "one"etc. mit IntegerName, mit der Liste in eine durch Leerzeichen getrennte Zeichenfolge konvertiert StringRiffle, prepends ein , "m "wenn die Zahl negativ ist, und Sortierungen auf dieser Zeichenfolge basiert. In der Tat war dies der kürzeste Ansatz, den ich finden kann, da Mathematica die lexikografische Sortierung nur für Listen gleicher Länge verwendet. Ein Ansatz, der darauf basiert 854-9176320, benötigt mehr Bytes, da Zeichenfolgenfunktionen so teuer sind.

05AB1E , 15 14 Bytes

Σ•ĆU‘•…54-ìsSk

-1 Byte dank @Emigna .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Σ                 # Sort by:
 •ĆU‘•            #  Push the compressed integer 9176320
      …54-        #  Push the string "54-"
          ì       #  Prepend this string before the integer: "54-9176320"
           s      #  Swap so the current number to sort is at the top of the stack
            S     #  Convert it to a list of characters
             k    #  Check for each its index in the string (resulting in -1 for '8')

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Komprimieren großer Ganzzahlen ) an, um zu verstehen, warum dies so •ĆU‘•ist 9176320.