Alfabetizar Inteiros

Para um determinado conjunto de números, coloque-os em ordem alfabética quando estiverem escritos (por exemplo, 1: um, 2: dois, 90: noventa, 19: dezenove). Seu código deve funcionar para o intervalo [-999999, 999999]. A saída deve ter um delimitador entre os números. Um espaço funcionará, assim como um espaço e uma vírgula, conforme mostrado nos exemplos abaixo. A entrada pode ser uma matriz de números inteiros, uma sequência de números delimitados ou o que você achar melhor. Todos os números inteiros são considerados únicos.

Os números não são hifenizados para os propósitos deste desafio e os espaços são alfabetizados antes de qualquer outro caractere. Os números negativos são assumidos para ser expressa usando a palavra minus. Por exemplo, fourprecederia four thousande o número -40seria classificado usando a sequência minus forty. Suponha que todos os números sejam compostos apenas por palavras numéricas e sem conjunções (por exemplo, use em two thousand forty twovez de two thousand and forty two).

Casos de teste

Inteiros de um dígito:

Entrada:

1, 2, 3, 4, 5

Resultado:

5, 4, 1, 3, 2

Inteiros com vários dígitos:

Entrada:

-1002, 5, 435012, 4, 23, 81, 82

Resultado:

81, 82, 5, 4, 435012, -1002, 23

Espaços entre palavras, sem hífens, vírgulas ou "e":

Entrada:

6, 16, 60, 64, 600, 6000, 60000, 60004, 60008, 60204, 60804

Resultado:

6, 600, 6000, 16, 60, 64, 60000, 60008, 60804, 60004, 60204

Lembre-se, isso é código-golfe , portanto o código com o menor número de bytes vence. Não são permitidas brechas!

JavaScript (ES6), 189 179 186 bytes

let f =

a=>a.sort((x,y)=>!x-!y||(X=q(x),Y=q(y),X>Y)-(X<Y),q=n=>n<0?"L"+q(-n):n>999?q(n/1e3)+"Z"+q(n%1e3):n>99?q(n/100)+"K"+q(n%100):n>19?"  cYHFVSCO"[n/10|0]+q(n%10):"0PdaIGTQAMWDbXJEURBN"[n|0])

let g = a => console.log(`[${f(a)}]`)

g([1,2,3,4,5])
g([-1002,5,435012,4,23,81,82])
g([0,1000,1100])

<input id=I value="1 2 3 4 5"><button onclick="g(I.value.match(/\d+/g)||[])">Run</button>

A idéia básica é converter cada número de entrada em uma sequência curta que esteja na posição lexográfica correta em comparação com todos os outros pares de sequência numérica. Aqui está o dicionário usado: (Não execute o snippet; é usado apenas para ocultar a lista longa.)

A eight
B eighteen
C eighty
D eleven
E fifteen
F fifty
G five
H forty
I four
J fourteen
K hundred
L minus
M nine
N nineteen
O ninety
P one
Q seven
R seventeen
S seventy
T six
U sixteen
V sixty
W ten
X thirteen
Y thirty
Z thousand
a three
b twelve
c twenty
d two

Isso cria uma maneira muito concisa de mapear cada número para sua posição lexograficamente correta. É isso que a qfunção recursiva faz:

q(-X)        => "L" + q(X)
q(XYYY)      => q(X) + "Z" + q(YYY)
q(XYY)       => q(X) + "K" + q(YY)
q(XY >= 20)` => "  cYHFVSCO"[X] + q(Y)
q(X)         => "0PdaIGTQAMWDbXJEURBN"[X]

O 0início da string é para garantir que, por exemplo, 100 ( one hundredconvertido em PK0) seja classificado antes 101( one hundred oneconvertido em PKP). Isso cria um cenário ímpar, em que 0 ( zero) é classificado na frente da matriz, para contornar isso, na função de classificação, primeiro ordenamos os zeros à direita !x-!y||(....

Informar 7, 214 201 118 bytes

O Inform 7 é uma linguagem absolutamente terrível para o golfe, então eu queria dar uma chance aqui.

O recuo deve usar \tcaracteres tab ( ), mas o HTML não gosta deles. Por outro lado, o Inform não gosta de espaços para recuo, portanto, você precisará substituir os espaços por tabulações se copiar e colar o código daqui para testá-lo. Ou apenas copie e cole da fonte Markdown.

Golfe:

Para X:
    repita na Tabela 1:
        agora a entrada Q é "[entrada R em palavras]";
    classifique a Tabela 1 em ordem Q;
    diga "[R na Tabela 1]".

A entrada deve ser uma tabela Inform, da seguinte forma (com \tentre as colunas):

tabela 1
R (número) Q (texto)
-1002
5
435012
4
23
81
82

Resultado:

81, 82, 5, 4, 435012, -1002, 23

Esta função percorre a tabela uma vez, adicionando uma representação textual de cada número em uma nova coluna. Em seguida, classifica as linhas da tabela de acordo com a coluna de texto; no Inform, as strings são classificadas lexicograficamente. Por fim, imprime a coluna original no novo pedido. Convenientemente, o formato "bruto, mas às vezes útil" do Inform 7 para imprimir colunas da tabela é separado por vírgula, exatamente como solicitado.

Ungolfed, com clichê mostrando como chamar a função:

Para imprimir os números em ordem alfabética:
    repita na Tabela de Números Classificáveis:
        agora a entrada do nome é "[a entrada do índice em palavras]";
    classifique a tabela de números classificáveis ​​em ordem de nome;
    diga "[a coluna do índice na Tabela de Números Classificáveis]".

Tabela de Números Classificáveis
nome do índice (número) (texto)
-1002
5
435012
4
23
81
82

Há um quarto.
Quando a reprodução começar: imprima os números em ordem alfabética.

Mathematica, 67 bytes

SortBy[#,#~IntegerName~"Words"~StringReplace~{","->"","-"->""}&]&

Função sem nome, tendo uma lista de números inteiros como argumento e retornando uma lista de números inteiros como seu valor. #~IntegerName~"Words"é um interno que altera um número inteiro para seu nome em inglês. IntegerNameàs vezes tem vírgulas e hífens em sua saída, então a StringReplacechamada se livra deles. (Infelizmente, o hífen é realmente o caractere de 3 bytes, 8208, em UTF-8.) Em seguida, SortByclassifica a lista original em ordem alfabética de acordo com o valor do nome inteiro modificado.

Uma boa coincidência: IntegerNameusa em negativevez de minusem sua saída - mas nenhuma palavra que apareça nos nomes de nenhum dos números permitidos está alfabeticamente entre essas duas palavras; portanto, nenhuma substituição é necessária!

(Gorjeta para ngenisis por me lembrar Sortby.)

Bash + utilitários GNU + bsdgames, 52

• 4 bytes salvos graças ao @izabera.

sed 's/.*/echo `echo &|number`:&/e'|sort|sed s/.*://

E / S são linhas delimitadas por nova linha.

• A primeira expressão sed substitui cada número numérico por um comando shell que exibe a forma da palavra do número (conforme fornecido pelo utilitário bsdgamesnumber ), seguida por uma :forma numérica do número.
• Isto é então sorted.
• Em seguida, a segunda sedtira os caracteres iniciais até e inclusive o :, deixando a forma numérica classificada conforme necessário.

numberlida corretamente com "menos" e sua saída é próxima o suficiente do formato especificado para que sortfuncione conforme necessário. Ele produz "quarenta e quatro" em vez de "quarenta e quatro", mas isso não deve importar da perspectiva da classificação.

O pacote bsdgames pode precisar de instalação:

sudo apt-get install bsdgames

Os utilitários sede sortjá estão quase certamente na sua distribuição.

Python + flexão, 97 91 89 bytes

from inflect import*
a={x:engine().number_to_words(x)for x in words}
sorted(a,key=a.get)

Utilizou a inflectbiblioteca para transformar a wordsmatriz de números inteiros em sua representação fonética / string. Armazenado em um dicionário de pares k / v em que as chaves eram a representação numérica e os valores eram a representação em cadeia. Retornou a lista de chaves conforme classificada por valores.

EDIT: Salvo 5 e 3 bytes, graças a ETHproductions e Alex.S!

Mathematica, 30 bytes

A resposta abaixo gera uma função pura que pega uma lista de números inteiros como entrada e os classifica pelo nome alfabético. Exatamente o que o médico pediu;)

SortBy[#~IntegerName~"Words"&]

Aqui está a versão não destruída:

SortBy[IntegerName[#, "Words"]&]

E aqui está um exemplo de uso:

SortBy[#~IntegerName~"Words"&][{0,1,2,3,4,5,6,7,8,9,10}]

O que também pode ser escrito como

SortBy[#~IntegerName~"Words"&]@{0,1,2,3,4,5,6,7,8,9,10}

Eles produzem saídas idênticas - no mathematica, f[x]é equivalente a f@x.

Outputs: {8, 5, 4, 9, 1, 7, 6, 10, 3, 2}

Há uma resposta muito mais longa que outro usuário postou no Mathematica. Essa resposta tenta corrigir algumas pequenas diferenças entre a maneira como o mathematica alphebatiza os números para melhor se adaptar à maneira como os números declarados do OP devem ser alfabetizados, no entanto, as coisas que eles corrigem não afetam a ordem de classificação, e minha resposta é idêntica à deles:

MyF = SortBy[#~IntegerName~"Words"&];
TheirF = SortBy[#, #~IntegerName~"Words"~ StringReplace~{"," -> "", "-" -> ""} &] &;
MyF[Range[-999999, 999999]] == TheirF[Range[-999999, 999999]]
(*Outputs True*)

Lisp comum, 113 bytes

Nenhuma biblioteca externa necessária.

(print(mapcar #'cdr(sort(loop for i in x collect(cons(format()"~r"i)i))(lambda(y z)(string-lessp(car y)(car z))))))

Saída se xfor '(1 2 3 4 5):

(5 4 1 3 2)