Nous connaissons tous différents algorithmes de tri fantaisistes, mais aucun d'eux ne nous donne de chiffres d'une manière facile à prononcer. Pour y remédier, je propose d'utiliser prononciationSort ™, le moyen le plus naturel de trier les listes de numéros.

Prononciation

Les règles officielles pour prononcer les nombres (dans ce défi) sont que les chiffres sont prononcés un par un, et la chaîne résultante est triée dans l'ordre lexicographique. Par exemple, cela signifie que le nombre 845est prononcé "eight four five"et doit être trié en conséquence.

Nombres négatifs

Les nombres négatifs sont prononcés en ajoutant le mot au début "minus". Ainsi, -23est prononcé comme "minus two three". Notez que cela fait que les nombres négatifs se retrouvent au milieu de la sortie, juste entre les nombres commençant par 4(quatre) et 9(neuf).

À titre indicatif, l'ordre officiel des mots pour prononciationSort ™ est:

• huit
• cinq
• quatre
• moins
• neuf
• une
• Sept
• six
• Trois
• deux
• zéro

C'est,

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

Contribution

Une liste d'entiers dans la plage $[-999, 999]$ , contenant au plus 100 éléments. La saisie sous forme de liste de chaînes n'est pas autorisée. Si votre langue ne prend pas en charge la saisie sous forme de liste, il est autorisé de fournir la saisie sous forme d'entiers séparés.

L'entrée ne contiendra aucun numéro non valide, ni aucun numéro commençant par un 0 (à l'exception du numéro 0 lui-même). L'entrée ne sera généralement pas triée, elle peut être donnée dans n'importe quel ordre.

Sortie

Les mêmes entiers, dans l'ordre de prononciationSort ™. Notez que les nombres ne doivent être convertis qu'en leurs prononciations pour obtenir le tri, la sortie ne doit contenir aucune chaîne.

Exemples

Pour les exemples, l'étape intermédiaire (entourée de parenthèses) sert uniquement de guide et ne fait pas partie de la sortie.

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

Il existe également un script pour vérifier vos résultats .

05AB1E (hérité) , 15 octets

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

Essayez-le en ligne!

Explication

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

Haskell , 57 octets

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

Essayez-le en ligne!

Gelée ,  15  13 octets

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

Essayez-le en ligne!

Un lien monadique acceptant une liste d'entiers qui donne une liste d'entiers.

Comment?

Trie par les valeurs ordinales des chiffres des entiers (où -est un "chiffre" de -1) convertis en chaînes en utilisant les caractères à leur index modulaire et basé sur 1 dans la chaîne magique "murgeon lix".

Le tri est effectivement alphabétique lorsqu'un espace est considéré comme inférieur à n'importe quelle lettre.

La chaîne magique "murgeon lix" a été trouvée en inspectant les dictionnaires de Jelly utilisés en compression. Il n'y a pas de mots de 11 lettres qui satisfont aux exigences (et aucun de plus qui le serait lors de la déduplication). puisqu'un espace trie avant les lettres, le prochain choix le plus évident est un mot de longueur sept suivi d'un espace suivi d'un mot de longueur trois. "murgeon" et "lix" est la seule combinaison satisfaisante, bien que sans espace, d'autres peuvent être possibles (par exemple, “£Py:ƥ»"murgeonalix" qui fonctionne pour le même nombre d'octets)

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

Précédent @ 15 octets :

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

Ici “¡Zo⁶’Œ?¤trouve la première permutation de nombres naturels qui résiderait à l'indice 21,340,635 lorsque toutes les permutations des nombres sont triées lexicographiquement - ce qui est [6,10,9,3,2,8,7,1,5,4,11]. ( “¡Zo⁶’est une représentation de base 250 de 21340635, tandis Œ?que le calcul et ¤regroupe ces instructions)

Perl 6 , 30 octets

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

Essayez-le en ligne!

Solution Ruby du port de GB.

Version originale de 35 octets

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

Essayez-le en ligne!

Convertissez chaque nombre en une chaîne, obtenez le nom Unicode de chaque caractère, supprimez le premier mot ("DIGIT" ou "HYPHEN"), puis triez.

JavaScript (SpiderMonkey) , 69 octets

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

Essayez-le en ligne!

K (ngn / k) , 21 20 octets

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

Essayez-le en ligne!

{ } fonction avec argument x

$ format sous forme de chaînes

""?$-2^{63}$"8"

< calculer la permutation de tri croissant

x@ l'argument à ces indices

Python 3, 68 octets 67 octets 64 octets

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

Utilise la sortedfonction intégrée avec un lambda anonyme pour la clé. Codez en dur l'ordre de tri et comparez chaque chiffre de chaque valeur de la liste d'entrée à sa position dans la liste d'ordre de tri.

Modifier: 1 octet enregistré en supprimant 8de la liste de tri pour profiter du str.findretour -1lorsque le paramètre n'est pas trouvé. Merci à maxb.

Edit2: enregistré 3 octets en utilisant la syntaxe de décompression étoilée dans un listlittéral au lieu d'un listconstructeur

Essayez-le en ligne!

Pyth, 17 16 octets

oxL"54-9176320"`

Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

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 octet sauvegardé grâce à @ngn et leur réponse K , en omettant 8 dès le début de la chaîne du dictionnaire

Japt, 19 octets

ñ_s ®n"54-9176320

Essayez-le

• Économisez 2 octets grâce à ETHproductions .

Retina 0.8.2 , 36 octets

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

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

T`-d`3:598217604

Traduisez le signe moins et les chiffres à leur position dans l'ordre de prononciation, en utilisant :pour la 10ème position.

O`

Trier dans l'ordre de prononciation.

T`3:598217604`-d

Remettez la commande dans le signe moins et les chiffres d'origine.

Rubis , 50 octets

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

Essayez-le en ligne!

R , 58 octets

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

Essayez-le en ligne!

L'entrée est une liste de nombres qui est implicitement convertie en chaîne en utilisant chartr. orderutilise ensuite l'ordre lexigographique pour récupérer l'ordre selon lequel la liste d'origine doit être triée.

Java (JDK 10) , 123 octets

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

Essayez-le en ligne!

Il s'agit d'une implémentation Java naïve. Devrait être beaucoup golfable.

Crédits

• 3 octets économisés grâce à Kevin Cruijssen

JavaScript (SpiderMonkey) , 87 73 octets

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

Essayez-le en ligne!

Merci @Arnauld d'avoir dit que le tri dans SpiderMonkey est stable, donc la ||-(F(q)>F(p))partie peut enfin être supprimée.

Rouge , 114 octets

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

Essayez-le en ligne!

Plus lisible:

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 octets

C'est une sorte de comédie, mais je perdais du temps et je l'ai écrit, donc je ne peux pas ne pas le poster ... Profitez d'un petit rire et faites-moi savoir s'il y a des économiseurs d'espace que j'ai ratés!

#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," "));}

Sortie:

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-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 36 33 32 30 2 28 25 24 29 21 27 26 23 22 20 0

Mathematica, 68 octets

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

Une fonction. Prend une liste d'entiers en entrée et renvoie la liste triée en sortie. Juste les chiffres sépare de chaque numéro avec IntegerDigits, convertit chaque chiffre à "zero", "one"etc., avec IntegerName, convertit la liste en une chaîne séparée par des espaces avec StringRiffle, prepends un "m "si le nombre est négatif et sortes basées sur cette chaîne. En effet, c'était l'approche la plus courte que je puisse trouver, puisque Mathematica n'utilise nativement le tri lexicographique que pour des listes de même longueur; ainsi, une approche basée sur 854-9176320finit par prendre plus d'octets car les fonctions de chaîne sont si chères.

05AB1E , 15 14 octets

Σ•ĆU‘•…54-ìsSk

-1 octet grâce à @Emigna .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Voir cette astuce de la mine de 05AB1E (section Comment compresser les grands entiers ) pour comprendre pourquoi •ĆU‘•est 9176320.