PrononciationSort ™

24

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 .

maxb
la source
5
Pourquoi "un" (prononcé "gagné") ne vient-il pas après deux et avant zéro?
Ben Miller - Reinstate Monica
3
@BenMiller Je ne me souviens pas si c'est vous qui avez commenté dans le bac à sable, mais ce commentaire m'a donné du déjà vu. Pour y répondre ici, je l'ai envisagé, mais je suis allé avec l'orthographe pour éviter les discussions d'orthographe (par exemple "deux" vs "aussi", "gagné" ou "wan")
max
17
Il s'agit donc en fait plus de "tri orthographique" que de "tri de prononciation" :-)
Paŭlo Ebermann
3
décevant. J'espérais qu'ils seraient triés en fonction de leur difficulté à prononcer ...
NH.
2
Ce défi devrait vraiment être renommé, car le tri ici n'a pratiquement rien à voir avec la prononciation. Ce serait énormément plus complexe s'il était basé sur la prononciation (par exemple, quatre pourraient précéder cinq si vous triez la monophthong ⟨ɔː⟩ avant la diphtongue ⟨aɪ⟩, mais cinq avant quatre si vous triez -a⟩ dérivé d'un avant o -dérivé ⟨ɔ⟩ - il n'y a, à ma connaissance, aucun ordre de tri établi pour la prononciation, ni dans l'IPA ni dans aucun autre schéma).
Janus Bahs Jacquet

Réponses:

8

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
Emigna
la source
Il semble y avoir un bogue dans l'entier compressé •ĆU‘•. Il ajoute une nouvelle ligne pendant le mappage / tri pour une raison quelconque. Σ•ĆU‘•"54-ÿ"sSkaurait pu être une alternative de 15 octets sur laquelle je travaillais, sans ce bug bizarre .. Si je change •ĆU‘•pour le littéral, 9176320 cela fonctionne très bien ..
Kevin Cruijssen
1
@KevinCruijssen: C'est bizarre. Le vôtre aurait 14 ans avec …54-ìmême
Emigna
@KevinCruijssen: Vous pourriez faire Σ•RT‹•Á…54-ìsSkpour le 15
Emigna
•t∍ýJ•'-ìÁÁfonctionnerait également
Emigna
8

Haskell , 57 octets

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

Essayez-le en ligne!

Vincent
la source
1
C'est tellement propre et lisible! Certainement le gagnant en termes de facilité de compréhension.
Stephen Belden
8

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)

Jonathan Allan
la source
Même avec l'explication, je ne me sens pas très intelligent. Super solution!
max
La version plus courte est probablement aussi plus facile à comprendre!
Jonathan Allan
7

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.

nwellnhof
la source
6

JavaScript (SpiderMonkey) , 69 octets

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

Essayez-le en ligne!

Arnauld
la source
Il semble que vous puissiez supprimer le +'', car vous prenez l'entrée comme un tableau de chaînes.
Shaggy
@Shaggy, je ne prends plus de cordes, car je ne sais pas si cela est autorisé ici.
Arnauld
Ah ... tu as raison. Ça va ajouter quelques octets à ma solution.
Shaggy
6

K (ngn / k) , 21 20 octets

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

Essayez-le en ligne!

{ } fonction avec argument x

$ format sous forme de chaînes

""?263"8"

< calculer la permutation de tri croissant

x@ l'argument à ces indices

ngn
la source
6

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!

mypetlion
la source
1
Pourriez-vous supprimer les 8 premiers de la chaîne? Comme Python renvoie -1 si la sous-chaîne n'est pas trouvée.
max
@maxb Bonne prise. Édité.
mypetlion
2
Le port Python 2 est 58:lambda x:sorted(x,key=lambda y:map('54-9176320'.find,`y`))
Jonathan Allan
5

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

Sok
la source
4

Japt, 19 octets

ñ_s ®n"54-9176320

Essayez-le

Hirsute
la source
Bonne solution! La saisie sous forme de liste de chaînes n'est malheureusement pas autorisée.
max
Vous pouvez en sauvegarder en abusant S.n(s): ñ_s ®n"54-9176320(apparemment S.n(s)c'est exactement la même chose que s.b(S)pour la Slongueur 1, sauf qu'il revient 0à la place de -1)
ETHproductions
Belle astuce, @ETHproductions, merci :) Je vais devoir me souvenir de celle-là pour l'avenir.
Shaggy
3

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.

Neil
la source
3

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.

JayCe
la source
3

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

Olivier Grégoire
la source
1
Modification du .chars-IntStream et .reduceà une boucle régulière permet d' économiser 2 octets: n->{var r="";for(var c:(""+n).split(""))r+=10+"854-9176320".indexOf(c);return r;}. De plus, un octet de plus peut être enregistré en changeant 10+"85en 20+"5, car le .indexOfchiffre for 8entraînerait alors -1. Essayez-le en ligne 123 octets
Kevin Cruijssen
2

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.

Shieru Asakoto
la source
2

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 ]
]
Galen Ivanov
la source
2

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

underscore_d
la source
Je vois que vous vivez également selon la devise "si je
n'appuie
1
Hé, je ne peux pas me permettre un espace frivole dans cette langue! C'est drôle d'avoir à le faire, vu que le reste du temps, peu de choses me mettent en colère comme ouvrir le code des autres, qui pensent apparemment qu'écrire un mur monolithique horrible les rendra plus intelligents et / ou sont activement payés pour chaque nouvelle ligne qu'ils tapent.
underscore_d
1
Bonjour! Comptez votre solution à 195 caractères
Max Yekhlakov
@MaxYekhlakov Cool, merci d'avoir réfléchi! Je me rends compte après avoir lu un peu plus; il semble que je n'ai pas nécessairement fourni un programme compilable complet, mais seulement les fonctions qui traiteraient l'entrée et la sortie spécifiées. Oh!
underscore_d
2

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.

LegionMammal978
la source
Faites toujours confiance à mathématique pour avoir une combinaison de fonctions intégrées. Solution intelligente!
max
1

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.

Kevin Cruijssen
la source