Conosciamo tutti diversi algoritmi di ordinamento, ma nessuno di questi ci fornisce numeri in un modo facile da pronunciare. Per ovviare a questo, propongo di usare PronunciaSort ™, il modo più naturale di ordinare elenchi di numeri.

Pronuncia

Le regole ufficiali per pronunciare i numeri (in questa sfida) è che le cifre sono pronunciate una per una e la stringa risultante è ordinata in ordine lessicografico. Ad esempio, ciò significa che il numero 845è pronunciato "eight four five"e deve essere ordinato di conseguenza.

Numeri negativi

I numeri negativi vengono pronunciati anteponendo la parola "minus". Pertanto, -23si pronuncia come "minus two three". Notare che ciò causa la fine di numeri negativi nel mezzo dell'output, tra i numeri che iniziano con 4(quattro) e 9(nove).

Come guida, l'ordine ufficiale delle parole per PronoSort ™ è:

• otto
• cinque
• quattro
• meno
• nove
• uno
• Sette
• sei
• tre
• Due
• zero

Questo è,

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

Ingresso

Un elenco di numeri interi nell'intervallo $[-999, 999]$ , contenente al massimo 100 elementi. L'immissione come elenco di stringhe non è consentita. Se la tua lingua non supporta input come elenco, è consentito fornire input come numeri interi separati.

L'input non conterrà numeri non validi o numeri che iniziano con uno 0 (tranne il numero 0 stesso). L'input generalmente non sarà ordinato, può essere dato in qualsiasi ordine.

Produzione

Gli stessi numeri interi, nell'ordine di PronoSort ™. Si noti che i numeri devono essere convertiti solo nelle loro pronunce per ottenere l'ordinamento, l'output non deve contenere stringhe.

Esempi

Per gli esempi, il passaggio centrale (racchiuso tra parentesi) serve solo da guida e non fa parte dell'output.

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

C'è anche uno script per la verifica dei risultati .

05AB1E (legacy) , 15 byte

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

Provalo online!

Spiegazione

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

Haskell , 57 byte

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

Provalo online!

Gelatina ,  15  13 byte

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

Provalo online!

Un collegamento monadico che accetta un elenco di numeri interi che produce un elenco di numeri interi.

Come?

Ordina per i valori ordinali delle cifre dei numeri interi (dove -è una "cifra" di -1) convertite in stringhe usando i caratteri nel loro indice a base 1 e modulare nella stringa magica "murgeon lix".

L'ordinamento è effettivamente alfabetico in cui uno spazio è considerato inferiore a qualsiasi lettera.

La stringa magica "murgeon lix" è stata trovata ispezionando i dizionari di Jelly usati nella compressione. Non ci sono parole di 11 lettere che soddisfano i requisiti (e niente di più che sarebbe de-duplicazione). poiché uno spazio ordina prima delle lettere la scelta più ovvia successiva è una parola di lunghezza sette seguita da uno spazio seguito da una parola di lunghezza tre. "murgeon" e "lix" sono l'unica combinazione soddisfacente, anche se senza uno spazio potrebbero essere possibili altri (ad esempio “£Py:ƥ»è "murgeonalix" che funziona per lo stesso conteggio byte)

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

Precedente @ 15 byte :

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

Qui “¡Zo⁶’Œ?¤trova la prima permutazione dei numeri naturali che risiederebbero nell'indice 21.340.635 quando tutte le permutazioni dei numeri sarebbero ordinate lessicograficamente, ovvero [6,10,9,3,2,8,7,1,5,4,11]. ( “¡Zo⁶’è una rappresentazione di base 250 di 21340635, mentre Œ?esegue il calcolo e ¤raggruppa queste istruzioni)

Perl 6 , 30 byte

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

Provalo online!

Porta della soluzione Ruby di GB.

Versione originale a 35 byte

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

Provalo online!

Converti ogni numero in una stringa, ottieni il nome Unicode di ogni carattere, togli la prima parola ("DIGIT" o "HYPHEN"), quindi ordina.

JavaScript (SpiderMonkey) , 69 byte

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

Provalo online!

K (ngn / k) , 21 20 byte

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

Provalo online!

{ } funzione con argomento x

$ formatta come stringhe

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

< calcolare la permutazione in ordine crescente

x@ l'argomento di quegli indici

Python 3, 68 byte 67 byte 64 byte

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

Utilizza incorporato sorted funzione integrata con un lambda anonimo per la chiave. Ordinare l'ordinamento e confrontare ogni cifra in ciascun valore nell'elenco di input con la sua posizione nell'elenco di ordinamento.

Modifica: salvato 1 byte rimuovendolo 8dall'elenco di ordinamento per sfruttare la possibilità di str.findtornare -1quando il parametro non viene trovato. Grazie a maxb.

Edit2: salvato 3 byte utilizzando la sintassi di decompressione stellata in un valore listletterale anziché in un listcostruttore

Provalo online!

Pyth, 17 16 byte

oxL"54-9176320"`

Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

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)

Salvato 1 byte grazie a @ngn e alla loro risposta K , omettendo 8 dall'inizio della stringa del dizionario

Japt, 19 byte

ñ_s ®n"54-9176320

Provalo

• Risparmia 2 byte grazie a ETHproductions .

Retina 0.8.2 , 36 byte

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

Provalo online! Il link include la suite di test. Spiegazione:

T`-d`3:598217604

Traduci il segno meno e le cifre nella loro posizione in ordine di pronuncia, usando :per la decima posizione.

O`

Ordina in ordine di pronuncia.

T`3:598217604`-d

Traduci nuovamente l'ordine con il segno meno e le cifre originali.

Rubino , 50 byte

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

Provalo online!

R , 58 byte

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

Provalo online!

L'input è un elenco di numeri che viene convertito implicitamente come stringa utilizzando chartr. orderutilizza quindi l'ordine lexigografico per recuperare l'ordine in base al quale deve essere ordinato l'elenco originale.

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;}))

Provalo online!

Questa è un'implementazione ingenua di Java. Dovrebbe essere molto golfabile.

Crediti

• 3 byte salvati grazie a Kevin Cruijssen

JavaScript (SpiderMonkey) , 87 73 byte

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

Provalo online!

Grazie @Arnauld per aver detto che l'ordinamento in SpiderMonkey è stabile, quindi la ||-(F(q)>F(p))parte può finalmente essere abbandonata.

Rosso , 114 byte

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

Provalo online!

Più leggibile:

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 byte

Questa è una specie di commedia, ma stavo perdendo tempo e l'ho scritto, quindi non posso non pubblicarlo ... Goditi una risatina e fammi sapere se ci sono salvaspazio che mi sono perso!

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

Produzione:

8 5 4 48 45 44 49 41 47 46 43 42 40-8-5-550-4-48-45-44-49-41-47-46-43-42-40-9 -1-18-18-15 - 14-19-11-17-17-16-13-12-7-6-3-38-35-34-39-31-37-36-33-32-30 -2-28 -25-24-24 - 29-21-22-26-22 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 byte

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

Funzione. Prende un elenco di numeri interi come input e restituisce l'elenco ordinato come output. Solo separa le cifre di ciascun numero con IntegerDigits, converte ogni cifra "zero", "one"ecc, con IntegerName, converte la lista in una stringa separata da spazi conStringRiffle , antepone un "m "se il numero è negativo e ordina in base a questa stringa. In effetti, questo è stato l'approccio più breve che posso trovare, dal momento che Mathematica utilizza nativamente l'ordinamento lessicografico solo per elenchi della stessa lunghezza; quindi, un approccio basato su 854-9176320prende più byte poiché le funzioni di stringa sono così costose.

05AB1E , 15 14 byte

Σ•ĆU‘•…54-ìsSk

-1 byte grazie a @Emigna .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questo suggerimento 05AB1E mio (sezione Come comprimere grandi numeri interi ) per capire il motivo per cui •ĆU‘•è 9176320.