Kita semua tahu tentang algoritma pengurutan mewah yang berbeda, tetapi tidak ada yang memberikan angka dengan cara yang mudah diucapkan. Untuk mengatasinya, saya usulkan menggunakan PengucapanSort ™, cara paling alami untuk mengurutkan daftar angka.

Pengucapan

Aturan resmi untuk mengucapkan angka (dalam tantangan ini) adalah bahwa angka diucapkan satu per satu, dan string yang dihasilkan diurutkan dalam urutan leksikografis. Sebagai contoh, ini berarti bahwa jumlahnya 845diucapkan "eight four five", dan harus diurutkan sesuai.

Angka negatif

Angka negatif diucapkan dengan mengawali kata "minus". Jadi, -23dilafalkan sebagai "minus two three". Perhatikan bahwa ini menyebabkan angka negatif berakhir di tengah-tengah output, tepat di antara angka-angka yang dimulai dengan 4(empat) dan 9(sembilan).

Sebagai panduan, urutan kata resmi untuk PengucapanSort ™ adalah:

• delapan
• lima
• empat
• minus
• sembilan
• satu
• tujuh
• enam
• tiga
• dua
• nol

Itu adalah,

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

Memasukkan

Daftar bilangan bulat dalam rentang $[-999, 999]$ , berisi paling banyak 100 elemen. Masukan sebagai daftar string tidak diizinkan. Jika bahasa Anda tidak mendukung input sebagai daftar, maka diperbolehkan untuk memberikan input sebagai bilangan bulat terpisah.

Input tidak akan berisi angka yang tidak valid, atau angka apa pun yang dimulai dengan 0 (kecuali angka 0 itu sendiri). Input umumnya tidak akan diurutkan, itu dapat diberikan dalam urutan apa pun.

Keluaran

Bilangan bulat yang sama, dalam urutan PengucapanSort ™. Perhatikan bahwa angka-angka hanya harus dikonversi ke pengucapannya untuk mendapatkan penyortiran, output tidak boleh mengandung string.

Contohnya

Sebagai contoh, langkah tengah (dibungkus dengan tanda kurung) hanya berfungsi sebagai panduan, dan bukan bagian dari 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]

Ada juga skrip untuk memverifikasi hasil Anda .

05AB1E (warisan) , 15 byte

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

Cobalah online!

Penjelasan

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

Cobalah online!

Jelly ,  15  13 byte

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

Cobalah online!

Tautan monadik yang menerima daftar bilangan bulat yang menghasilkan daftar bilangan bulat.

Bagaimana?

Urutkan oleh nilai-nilai ordinal digit bilangan bulat (di mana -"digit" -1) dikonversi menjadi string menggunakan karakter pada indeks modular & berbasis-1 dalam string ajaib "murgeon lix".

Pengurutan ini secara alfabet efektif di mana spasi dianggap kurang dari huruf apa pun.

String sihir "murgeon lix" ditemukan dengan memeriksa kamus Jelly yang digunakan dalam kompresi. Tidak ada kata-kata dari 11 huruf yang memenuhi persyaratan (dan tidak ada yang lebih dari itu pada saat duplikasi). karena spasi memilah sebelum huruf, pilihan berikutnya yang paling jelas adalah kata dengan panjang tujuh diikuti oleh spasi diikuti oleh kata dengan panjang tiga. "murgeon" dan "lix" adalah satu-satunya kombinasi yang memuaskan, walaupun tanpa spasi yang lain dimungkinkan (mis. “£Py:ƥ»adalah "murgeonalix" yang bekerja untuk byte-count yang sama)

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

Sebelumnya @ 15 byte :

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

Di sini “¡Zo⁶’Œ?¤ditemukan permutasi bilangan asli yang akan berada pada indeks 21.340.635 ketika semua permutasi bilangan diurutkan secara leksikografis - yaitu [6,10,9,3,2,8,7,1,5,4,11]. ( “¡Zo⁶’adalah representasi dasar 250 dari 21340635, sambil Œ?melakukan perhitungan dan ¤mengelompokkan instruksi ini bersama-sama)

Perl 6 , 30 byte

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

Cobalah online!

Port solusi Ruby GB.

Versi 35 byte asli

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

Cobalah online!

Konversikan setiap angka menjadi string, dapatkan nama Unicode dari setiap karakter, lepas kata pertama ("DIGIT" atau "HYPHEN"), lalu urutkan.

JavaScript (SpiderMonkey) , 69 byte

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

Cobalah online!

K (ngn / k) , 21 20 byte

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

Cobalah online!

{ } berfungsi dengan argumen x

$ memformat sebagai string

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

< menghitung permutasi sort-ascending

x@ argumen di indeks tersebut

Python 3, 68 byte 67 byte 64 byte

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

Menggunakan sortedfungsi bawaan dengan lambda anonim untuk kunci. Kode-keras urutan sortir dan bandingkan setiap digit pada setiap nilai dalam daftar input dengan posisinya dalam daftar sortir urutan.

Sunting: Disimpan 1 byte dengan menghapus 8dari daftar sortir untuk mengambil keuntungan dari str.findpengembalian -1ketika parameter tidak ditemukan. Berkat maxb.

Sunting2: Disimpan 3 byte dengan menggunakan sintaks membongkar berbintang dalam listliteral bukan listkonstruktor

Cobalah online!

Pyth, 17 16 byte

oxL"54-9176320"`

Cobalah online sini , atau verifikasi semua uji sekaligus di sini .

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)

Disimpan 1 byte berkat @ngn dan jawaban K mereka , dengan menghilangkan 8 dari awal string kamus

Japt, 19 byte

ñ_s ®n"54-9176320

Cobalah

• Hemat 2 byte berkat produk ETH .

Retina 0.8.2 , 36 byte

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

Cobalah online! Tautan termasuk test suite. Penjelasan:

T`-d`3:598217604

Terjemahkan tanda minus dan digit ke posisi mereka dalam urutan pengucapan, gunakan :untuk posisi ke-10.

O`

Urutkan dalam urutan pengucapan.

T`3:598217604`-d

Terjemahkan urutan kembali ke tanda minus dan angka asli.

Rubi , 50 byte

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

Cobalah online!

R , 58 byte

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

Cobalah online!

Input adalah daftar angka yang secara implisit dikonversi sebagai string menggunakan chartr. orderkemudian menggunakan urutan lexigographic untuk mengambil urutan daftar asli harus diurutkan.

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

Cobalah online!

Ini adalah implementasi Java yang naif. Seharusnya lebih banyak golf.

Kredit

• 3 byte disimpan berkat 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))

Cobalah online!

Terima kasih @Arnauld karena mengatakan bahwa jenis di SpiderMonkey stabil, sehingga ||-(F(q)>F(p))bagian akhirnya dapat dibatalkan.

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

Cobalah online!

Lebih mudah dibaca:

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

Ini semacam entri komedi, tapi saya membuang-buang waktu dan menulisnya, jadi saya tidak bisa mempostingnya ... Nikmati tertawa kecil, dan beri tahu saya jika ada penghemat ruang yang saya lewatkan!

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

Keluaran:

8 5 4 48 45 44 49 41 47 46 43 42 40 -8 -5 -50 -4 -48 -45 -44 -49 -47 -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 -32 -30 -2 -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 0

Mathematica, 68 byte

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

Fungsi. Mengambil daftar bilangan bulat sebagai input dan mengembalikan daftar yang diurutkan sebagai output. Hanya memisahkan digit dari setiap angka dengan IntegerDigits, mengonversi setiap digit ke"zero" ,, "one"dll., Dengan IntegerName, mengubah daftar menjadi string yang dipisahkan oleh spasi StringRiffle, menambahkan sebuah "m "jika angka negatif, dan mengurutkan berdasarkan string ini. Memang, ini adalah pendekatan terpendek yang dapat saya temukan, karena Mathematica hanya menggunakan penyortiran leksikografis untuk daftar dengan panjang yang sama; dengan demikian, sebuah pendekatan berdasarkan pada 854-9176320akhirnya mengambil lebih banyak byte karena fungsi string sangat mahal.

05AB1E , 15 14 byte

Σ•ĆU‘•…54-ìsSk

-1 byte terima kasih kepada @Emigna .

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

Lihat ini ujung 05AB1E saya (bagian Cara kompres bilangan bulat besar ) untuk memahami mengapa •ĆU‘•adalah 9176320.