Todos conocemos diferentes algoritmos de clasificación sofisticados, pero ninguno de estos nos da números de una manera fácil de pronunciar. Para remediar esto, propongo usar PronunciaciónSort ™, la forma más natural de ordenar listas de números.

Pronunciación

Las reglas oficiales para pronunciar números (en este desafío) es que los dígitos se pronuncian uno por uno, y la cadena resultante se ordena en orden lexicográfico. Como ejemplo, esto significa que el número 845se pronuncia "eight four five"y debe clasificarse en consecuencia.

Números negativos

Los números negativos se pronuncian anteponiendo la palabra "minus". Por lo tanto, -23se pronuncia como "minus two three". Tenga en cuenta que esto hace que los números negativos terminen en el medio de la salida, justo entre los números que comienzan con 4(cuatro) y 9(nueve).

Como guía, el orden oficial de las palabras para PronunciaciónSort ™ es:

• ocho
• cinco
• cuatro
• menos
• nueve
• uno
• Siete
• seis
• Tres
• dos
• cero

Es decir,

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

Entrada

Una lista de enteros en el rango$[-999, 999]$ , que contiene como máximo 100 elementos. La entrada como una lista de cadenas no está permitida. Si su idioma no admite la entrada como lista, es permisible dar entrada como enteros separados.

La entrada no contendrá ningún número inválido, o cualquier número que comience con un 0 (excepto el número 0 en sí). La entrada generalmente no se ordenará, se puede dar en cualquier orden.

Salida

Los mismos enteros, en el orden de PronunciaciónSort ™. Tenga en cuenta que los números solo deben convertirse a sus pronunciaciones para obtener la clasificación, la salida no debe contener cadenas.

Ejemplos

Para los ejemplos, el paso intermedio (entre paréntesis) solo sirve como guía y no es parte de la salida.

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

También hay un script para verificar sus resultados .

05AB1E (heredado) , 15 bytes

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Jalea ,  15  13 bytes

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

Pruébalo en línea!

Un enlace monádico que acepta una lista de enteros que produce una lista de enteros.

¿Cómo?

Ordena por los valores ordinales de los dígitos de los enteros (donde -es un "dígito" de -1) convertidos en cadenas usando los caracteres en su índice basado en 1 y modular en la cadena mágica "murgeon lix".

El tipo es efectivamente alfabético donde un espacio se considera menos que cualquier letra.

La cadena mágica "murgeon lix" se encontró inspeccionando los diccionarios de Jelly utilizados en la compresión. No hay palabras de 11 letras que cumplan los requisitos (y ninguna más que lo haría en caso de deduplicación). Dado que un espacio se ordena antes de las letras, la siguiente opción más obvia es una palabra de longitud siete seguida de un espacio seguido de una palabra de longitud tres. "murgeon" y "lix" es la única combinación satisfactoria, aunque sin un espacio otros pueden ser posibles (por ejemplo, “£Py:ƥ»es "murgeonalix" que funciona para el mismo número de bytes)

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

Anterior @ 15 bytes :

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

Aquí se “¡Zo⁶’Œ?¤encuentra la primera permutación de números naturales que residiría en el índice 21,340,635 cuando todas las permutaciones de los números se ordenan lexicográficamente, que es [6,10,9,3,2,8,7,1,5,4,11]. ( “¡Zo⁶’es una representación de base 250 de 21340635, mientras Œ?realiza el cálculo y ¤agrupa estas instrucciones)

Perl 6 , 30 bytes

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

Pruébalo en línea!

Puerto de la solución Ruby de GB.

Versión original de 35 bytes

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

Pruébalo en línea!

Convierta cada número en una cadena, obtenga el nombre Unicode de cada carácter, quite la primera palabra ("DIGIT" o "HYPHEN"), luego ordene.

JavaScript (SpiderMonkey) , 69 bytes

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

Pruébalo en línea!

K (ngn / k) , 21 20 bytes

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

Pruébalo en línea!

{ } funcionar con argumento x

$ formatear como cadenas

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

< calcular permutación ascendente

x@ el argumento en esos índices

Python 3, 68 bytes 67 bytes 64 bytes

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

Utiliza la sortedfunción integrada con una lambda anónima para la clave. Codifique el orden de clasificación y compare cada dígito en cada valor de la lista de entrada con su posición en la lista de clasificación.

Editar: se guardó 1 byte al eliminarlo 8de la lista de clasificación para aprovechar el str.findretorno -1cuando no se encuentra el parámetro. Gracias a maxb.

Edit2: guardado 3 bytes usando la sintaxis destacada de desempaquetado en un listliteral en lugar de listconstructor

Pruébalo en línea!

Pyth, 17 16 bytes

oxL"54-9176320"`

Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

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)

Se guardó 1 byte gracias a @ngn y su respuesta K , al omitir 8 desde el comienzo de la cadena del diccionario

Japt, 19 bytes

ñ_s ®n"54-9176320

Intentalo

• Ahorre 2 bytes gracias a ETHproductions .

Retina 0.8.2 , 36 bytes

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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

T`-d`3:598217604

Traslade el signo menos y los dígitos a su posición en el orden de pronunciación, utilizando :para la décima posición.

O`

Ordenar en orden de pronunciación.

T`3:598217604`-d

Vuelva a traducir el pedido al signo menos original y a los dígitos.

Ruby , 50 bytes.

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

Pruébalo en línea!

R , 58 bytes

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

Pruébalo en línea!

La entrada es una lista de números que se convierte implícitamente como una cadena usando chartr. orderluego usa el orden lexigográfico para recuperar el orden por el cual se debe ordenar la lista original.

Java (JDK 10) , 123 bytes

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

Pruébalo en línea!

Esta es una ingenua implementación de Java. Debería ser mucho golfable.

Créditos

• 3 bytes guardados gracias a 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))

Pruébalo en línea!

Gracias @Arnauld por decir que el tipo en SpiderMonkey es estable, por lo que la ||-(F(q)>F(p))parte finalmente se puede descartar.

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

Pruébalo en línea!

Más legible:

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

Esta es una especie de entrada de comedia, pero estaba perdiendo el tiempo y la escribí, así que no puedo no publicarla ... ¡Disfruta de una risita y avísame si me perdí algún ahorrador de espacio!

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

Salida:

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-18-15 - 14-19-11-17-17-16-13-12-10-7-6-338-35-34-39-31-37-36-33-32-30-2-28-25-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 bytes

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

Función. Toma una lista de enteros como entrada y devuelve la lista ordenada como salida. Simplemente separa los dígitos de cada número con IntegerDigits, convierte cada dígito en "zero", "one"etc., con IntegerName, convierte la lista en una cadena separada por espacios con StringRiffle, antepone un "m "si el número es negativo y se ordena según esta cadena. De hecho, este fue el enfoque más corto que pude encontrar, ya que Mathematica solo utiliza de forma nativa la clasificación lexicográfica para listas de la misma longitud; así, un enfoque basado en 854-9176320termina tomando más bytes ya que las funciones de cadena son muy caras.

05AB1E , 15 14 bytes

Σ•ĆU‘•…54-ìsSk

-1 byte gracias a @Emigna .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Ver este consejo 05AB1E mío (sección Cómo comprimir grandes números enteros ) para entender por qué •ĆU‘•es 9176320.