เราทุกคนรู้ถึงอัลกอริธึมการเรียงลำดับแฟนซีที่แตกต่างกัน แต่ไม่มีสิ่งใดที่จะบอกตัวเลขในวิธีที่ง่ายต่อการออกเสียง เพื่อแก้ไขสิ่งนี้ฉันเสนอให้ใช้ PronunciationSort ™วิธีที่เป็นธรรมชาติที่สุดในการเรียงลำดับรายการตัวเลข

การออกเสียง

กฎอย่างเป็นทางการสำหรับตัวเลขการออกเสียง (ในการท้าทายนี้) คือตัวเลขจะออกเสียงทีละตัวและสตริงผลลัพธ์จะเรียงตามลำดับพจนานุกรม เป็นตัวอย่างซึ่งหมายความว่าตัวเลข845นั้นออกเสียง"eight four five"และควรเรียงตาม

ตัวเลขติดลบ

ตัวเลขลบจะออกเสียงโดยการเติมคำ"minus"นั้น ดังนั้นจะออกเสียงเป็น-23 "minus two three"โปรดทราบว่าสิ่งนี้ทำให้ตัวเลขติดลบจบลงตรงกลางของเอาต์พุตขวาระหว่างตัวเลขที่ขึ้นต้นด้วย4(สี่) และ9(เก้า)

คำแนะนำอย่างเป็นทางการของคำศัพท์สำหรับ PronunciationSort ™คือ:

• แปด
• ห้า
• สี่
• ลบ
• เก้า
• หนึ่ง
• เจ็ด
• หก
• สาม
• สอง
• ศูนย์

นั่นคือ,

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

อินพุต

รายการจำนวนเต็มในช่วงที่มีองค์ประกอบมากที่สุด 100 รายการ ไม่อนุญาตให้ป้อนข้อมูลเป็นรายการสตริง หากภาษาของคุณไม่รองรับการป้อนข้อมูลเป็นรายการอนุญาตให้ป้อนเป็นจำนวนเต็มแยกได้$[-999, 999]$

ข้อมูลที่ป้อนจะไม่มีตัวเลขที่ไม่ถูกต้องหรือหมายเลขใด ๆ ที่ขึ้นต้นด้วย 0 (ยกเว้นตัวเลข 0 เอง) การป้อนข้อมูลโดยทั่วไปจะไม่ถูกจัดเรียงก็สามารถได้รับในลำดับใด ๆ

เอาท์พุต

จำนวนเต็มเดียวกันในลำดับ PronunciationSort ™ โปรดทราบว่าตัวเลขควรถูกแปลงเป็นการออกเสียงเพื่อรับการเรียงลำดับเอาต์พุตไม่ควรมีสตริงใด ๆ

ตัวอย่าง

สำหรับตัวอย่างขั้นตอนกลาง (ห่อในวงเล็บ) ทำหน้าที่เป็นแนวทางเท่านั้นและไม่ได้เป็นส่วนหนึ่งของผลลัพธ์

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

นอกจากนี้ยังมีสคริปต์ในการตรวจสอบผลลัพธ์ของคุณ

05AB1E (ดั้งเดิม) 15 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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

Haskell , 57 ไบต์

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

ลองออนไลน์!

เยลลี่ ,  15  13 ไบต์

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

ลองออนไลน์!

ลิงก์ monadic ยอมรับรายการจำนวนเต็มซึ่งให้รายการของจำนวนเต็ม

อย่างไร?

เรียงตามค่าเลขลำดับของตัวเลขของจำนวนเต็ม (ซึ่ง-เป็น "หลัก" ของ -1) แปลงเป็นสตริงโดยใช้ตัวอักษรที่ดัชนี 1-based & โมดูลาร์ในสตริงมายากล "murgeon lix"

การเรียงลำดับนั้นเป็นตัวอักษรอย่างมีประสิทธิภาพโดยที่พื้นที่นั้นถือว่าน้อยกว่าตัวอักษรใด ๆ

สตริงมายากล "murgeon lix" ถูกค้นพบโดยการตรวจสอบพจนานุกรมของ Jelly ที่ใช้ในการบีบอัด ไม่มีคำพูดใด ๆ 11 ตัวอักษรที่ตรงตามข้อกำหนด (และไม่มีอีกต่อไปที่จะทำซ้ำ) เนื่องจากช่องว่างจัดเรียงก่อนตัวอักษรตัวเลือกที่ชัดเจนที่สุดถัดไปคือคำที่มีความยาวเจ็ดแล้วตามด้วยช่องว่างตามด้วยคำสามความยาว "murgeon" และ "lix" เป็นเพียงการรวมกันที่น่าพอใจแม้ไม่มีที่ว่างอื่น ๆ อาจทำได้ (เช่น“£Py:ƥ»"murgeonalix" ซึ่งใช้งานได้กับจำนวนไบต์เดียวกัน)

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

ก่อนหน้า @ 15 ไบต์ :

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

ที่นี่“¡Zo⁶’Œ?¤พบว่าการเปลี่ยนแปลงครั้งแรกของตัวเลขธรรมชาติซึ่งจะอาศัยอยู่ที่ดัชนี 21340635 เมื่อพีชคณิตทั้งหมดของตัวเลขที่มีการเรียง lexicographically - [6,10,9,3,2,8,7,1,5,4,11]ซึ่งเป็น ( “¡Zo⁶’เป็นข้อมูลพื้นฐาน 250 รายการจาก 21340635 ขณะที่Œ?การคำนวณและ¤จัดกลุ่มคำแนะนำเหล่านี้เข้าด้วยกัน)

Perl 6 , 30 ไบต์

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

ลองออนไลน์!

พอร์ตของโซลูชัน Ruby ของ GB

เวอร์ชัน 35 ไบต์ดั้งเดิม

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

ลองออนไลน์!

แปลงตัวเลขแต่ละตัวให้เป็นสตริงรับชื่อ Unicode ของอักขระแต่ละตัวตัดคำแรก ("DIGIT" หรือ "HYPHEN") แล้วเรียงลำดับ

JavaScript (SpiderMonkey) , 69 ไบต์

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

ลองออนไลน์!

K (ngn / k) , 21 20 ไบต์

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

ลองออนไลน์!

{ } ฟังก์ชั่นที่มีข้อโต้แย้ง x

$ จัดรูปแบบเป็นสตริง

"... "?ค้นหาดัชนีของอักขระแต่ละตัวในสตริงที่กำหนด (หรือสำหรับ "not found" - โปรดสังเกตว่า the หายไป)$-2^{63}$"8"

< คำนวณการเรียงลำดับจากน้อยไปหามาก

x@ อาร์กิวเมนต์ที่ดัชนีเหล่านั้น

Python 3, 68 ไบต์ 67 ไบต์ 64 ไบต์

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

ใช้sortedฟังก์ชันในตัวพร้อมแลมบ์ดานิรนามสำหรับคีย์ เขียนโค้ดลำดับการจัดเรียงและเปรียบเทียบตัวเลขแต่ละตัวในแต่ละค่าในรายการอินพุตกับตำแหน่งในรายการลำดับการเรียง

แก้ไข: บันทึก 1 ไบต์โดยลบออก8จากรายการเรียงลำดับเพื่อใช้ประโยชน์จากการstr.findส่งคืน-1เมื่อไม่พบพารามิเตอร์ ขอบคุณ maxb

แก้ไข 2: บันทึกไว้ 3 ไบต์โดยใช้ไวยากรณ์การเปิดออกที่ติดดาวในlistตัวอักษรแทนที่จะเป็นตัวlistสร้าง

ลองออนไลน์!

Pyth, 17 16 ไบต์

oxL"54-9176320"`

ลองออนไลน์ได้ที่นี่หรือตรวจสอบทุกกรณีการทดสอบในครั้งเดียวที่นี่

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 ไบต์ต้องขอบคุณ @ngn และคำตอบ Kโดยไม่ต้องใส่ 8 ตั้งแต่เริ่มต้นของสตริงพจนานุกรม

Japt, 19 ไบต์

ñ_s ®n"54-9176320

ลองมัน

• บันทึก 2 ไบต์ขอบคุณที่ETHproductions

เรติน่า 0.8.2 , 36 ไบต์

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

ลองออนไลน์! การเชื่อมโยงรวมถึงชุดทดสอบ คำอธิบาย:

T`-d`3:598217604

แปลเครื่องหมายลบและตัวเลขไปยังตำแหน่งของพวกเขาตามลำดับการออกเสียงโดยใช้:สำหรับตำแหน่งที่ 10

O`

เรียงตามลำดับการออกเสียง

T`3:598217604`-d

แปลคำสั่งกลับไปเป็นเครื่องหมายลบและตัวเลข

Ruby , 50 ไบต์

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

ลองออนไลน์!

R , 58 ไบต์

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

ลองออนไลน์!

chartrการป้อนข้อมูลเป็นรายการของตัวเลขที่จะถูกแปลงเป็นสตริงโดยปริยายใช้ orderจากนั้นใช้คำสั่ง lexigographic เพื่อดึงลำดับที่ควรเรียงลำดับรายการดั้งเดิม

Java (JDK 10) , 123 ไบต์

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

ลองออนไลน์!

นี่เป็นการใช้งาน Java ที่ไร้เดียงสา ควรเล่นกอล์ฟได้มาก

เครดิต

• บันทึก 3 ไบต์ด้วยKevin Cruijssen

JavaScript (SpiderMonkey) , 87 73 ไบต์

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

ลองออนไลน์!

ขอบคุณ @Arnauld ที่บอกว่าการเรียงลำดับใน SpiderMonkey นั้นมีความเสถียรดังนั้นใน||-(F(q)>F(p))ที่สุดก็สามารถปล่อยชิ้นส่วนได้

สีแดง 114 ไบต์

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

ลองออนไลน์!

อ่านเพิ่มเติมได้:

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 ไบต์

นี่เป็นรายการตลกประเภทหนึ่ง แต่ฉันเสียเวลาและเขียนมันดังนั้นฉันไม่สามารถโพสต์มันได้ ... เพลิดเพลินกับหัวเราะหึๆและแจ้งให้เราทราบหากมีช่องว่างใด ๆ

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

เอาท์พุท:

8 5 4 48 45 44 49 41 47 46 43 42 40 -8 -5 -50 -4 -48 -45 -44 -49 -49 -41 -47 -46 -46 -43 -42 -42 -40 -9 -1 -18 -15 - 14 -19 -11 -17 -16 -13 -12 -10 -7 -6 -3 -38 -35 -35 -34 -39 -31 -37 -37 -36 -33 -32 -30 -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

Mathematica, 68 ไบต์

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

ฟังก์ชัน รับรายการจำนวนเต็มเป็นอินพุตและส่งคืนรายการที่เรียงลำดับเป็นเอาต์พุต เพียงแค่แยกตัวเลขของแต่ละหมายเลขด้วยIntegerDigitsแปลงแต่ละหลักเป็น"zero"และ"one"อื่น ๆ ด้วยIntegerNameแปลงรายการให้เป็นสตริงที่คั่นด้วยช่องว่างด้วยจะStringRiffleเป็นการเตรียม"m "ว่าตัวเลขนั้นเป็นลบและเรียงตามสตริงนี้ อันที่จริงนี่เป็นวิธีที่สั้นที่สุดที่ฉันสามารถหาได้เนื่องจาก Mathematica ใช้การเรียงลำดับพจนานุกรมสำหรับรายการที่มีความยาวเท่ากัน ดังนั้นวิธีการที่ขึ้นอยู่กับ854-9176320การใช้ไบต์มากขึ้นเนื่องจากฟังก์ชั่นสตริงมีราคาแพงมาก

05AB1E , 15 14 ไบต์

Σ•ĆU‘•…54-ìsSk

-1 ขอบคุณไบต์@Emigna

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

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

ดู 05AB1E นี้เคล็ดลับของฉัน (ส่วนวิธีการบีบอัดจำนวนเต็มขนาดใหญ่ ) จะเข้าใจว่าทำไมเป็น•ĆU‘•9176320