संख्याओं की छँटाई

21

यूनिकोड वर्णों की पुनरावृत्ति के भीतर, "संख्या रूपों" नामक 63 वर्णों का (वर्तमान में) एक यूनिकोड ब्लॉक मौजूद है, जिसमें ऐसे वर्ण शामिल हैं जिनमें संख्यात्मक मान हैं जैसे कि रोमन अंक Ⅻ, अशिष्ट अंश जैसे ⅑ या of, या अजीब जैसे। Or (10) या ↈ (100000)।

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जब इस ब्लॉक के भीतर निर्दिष्ट यूनिकोड वर्णों की एक सूची दी गई है, प्रत्येक वर्ण के संख्यात्मक मानों द्वारा सूची को सॉर्ट करें।

पात्रों और मूल्यों की एक (क्रमबद्ध) सूची विकिपीडिया पृष्ठ पर पाई जा सकती है ।

यद्यपि स्वयं को समाहित किया जाना है, यहाँ कोडपॉइंट्स और उनके मूल्यों की सूची दी गई है:

Hex     Char   Value
0x00BC: ¼   = 1/4 or 0.25
0x00BD: ½   = 1/2 or 0.5
0x00BE: ¾   = 3/4 or 0.75
0x2150: ⅐   = 1/7 or 0.142857
0x2151: ⅑   = 1/9 or 0.111111
0x2152: ⅒   = 1/10 or 0.1
0x2153: ⅓   = 1/3 or 0.333333
0x2154: ⅔   = 2/3 or 0.666667
0x2155: ⅕   = 1/5 or 0.2
0x2156: ⅖   = 2/5 or 0.4
0x2157: ⅗   = 3/5 or 0.6
0x2158: ⅘   = 4/5 or 0.8
0x2159: ⅙   = 1/6 or 0.166667
0x215A: ⅚   = 5/6 or 0.833333
0x215B: ⅛   = 1/8 or 0.125
0x215C: ⅜   = 3/8 or 0.375
0x215D: ⅝   = 5/8 or 0.625
0x215E: ⅞   = 7/8 or 0.875
0x215F: ⅟   = 1
0x2160: Ⅰ   = 1
0x2161: Ⅱ   = 2
0x2162: Ⅲ   = 3
0x2163: Ⅳ   = 4
0x2164: Ⅴ   = 5
0x2165: Ⅵ   = 6
0x2166: Ⅶ   = 7
0x2167: Ⅷ   = 8
0x2168: Ⅸ   = 9
0x2169: Ⅹ   = 10
0x216A: Ⅺ   = 11
0x216B: Ⅻ   = 12
0x216C: Ⅼ   = 50
0x216D: Ⅽ   = 100
0x216E: Ⅾ   = 500
0x216F: Ⅿ   = 1000
0x2170: ⅰ   = 1
0x2171: ⅱ   = 2
0x2172: ⅲ   = 3
0x2173: ⅳ   = 4
0x2174: ⅴ   = 5
0x2175: ⅵ   = 6
0x2176: ⅶ   = 7
0x2177: ⅷ   = 8
0x2178: ⅸ   = 9
0x2179: ⅹ   = 10
0x217A: ⅺ   = 11
0x217B: ⅻ   = 12
0x217C: ⅼ   = 50
0x217D: ⅽ   = 100
0x217E: ⅾ   = 500
0x217F: ⅿ   = 1000
0x2180: ↀ   = 1000
0x2181: ↁ   = 5000
0x2182: ↂ   = 10000
0x2183: Ↄ   = 100
0x2184: ↄ   = 100
0x2185: ↅ   = 6
0x2186: ↆ   = 50
0x2187: ↇ   = 50000
0x2188: ↈ   = 100000
0x2189: ↉   = 0
0x218A: ↊   = 10
0x218B: ↋   = 11

परीक्षण के मामलों:

['½','ↆ','ↂ','⅒','Ⅽ','⅑','ⅷ'] -> ['⅒','⅑','½','ⅷ','ↆ','Ⅽ','ↂ']

['¼','↋','↉','ↅ','⅐','⅟','Ⅻ','ⅺ'] -> ['↉','⅐','¼','⅟','ↅ','↋','ⅺ','Ⅻ']

['¼','½','¾','⅐','⅑','⅒','⅓','⅔','⅕','⅖','⅗','⅘','⅙','⅚','⅛','⅜','⅝','⅞','⅟'] -> ['⅒','⅑','⅛','⅐','⅙','⅕','¼','⅓','⅜','⅖','½','⅗','⅝','⅔','¾','⅘','⅚','⅞','⅟']

'⅞ⅾ↊ↄⅨⅮⅺↁⅸⅰⅩⅱⅶ¾ⅧↅↃ↋ↆ⅔ⅼⅲ⅘⅒ⅽⅦ⅕ⅤⅭⅳↂⅪⅬⅯↇⅠⅷ⅛Ⅵ½ⅵ¼ⅻ⅐Ⅱ⅜⅗⅝⅚Ⅳ⅓ⅴ↉ⅿⅫⅹↀↈ⅙⅑Ⅲ⅖⅟' -> '↉⅒⅑⅛⅐⅙⅕¼⅓⅜⅖½⅗⅝⅔¾⅘⅚⅞⅟ⅠⅰⅡⅱⅢⅲⅣⅳⅤⅴⅥⅵↅⅦⅶⅧⅷⅨⅸⅩⅹ↊Ⅺⅺ↋ⅫⅻⅬⅼↆⅭⅽↄↃⅮⅾⅯⅿↀↁↂↇↈ'

['Ↄ','ↄ','↊','↋'] -> ['↊','↋','ↄ','Ↄ']

ध्यान दें कि चार प्रतीकों (अंतिम मामले में उपयोग किए गए) यूनिकोड संख्या नहीं हैं, हालांकि उनके पास अभी भी एक संख्यात्मक मूल्य है, इसलिए केवल बिल्ट-इन पोस्ट करने से पहले जांचना सुनिश्चित करें।

नियम:

  • यदि भविष्य में कोई और वर्ण इस ब्लॉक को सौंपा गया है, तो आपको उनका समर्थन करने के लिए अपने कोड को अपडेट करने की आवश्यकता नहीं होगी।
  • समान मूल्यों वाले वर्णों का क्रम मायने नहीं रखता।
  • IO लचीला है ।
    • आउटपुट वर्णों के रूप में होना चाहिए, हालांकि संख्यात्मक मान नहीं
  • मानक ढीले निषिद्ध हैं।
  • मैं बिल्ट-इन पर प्रतिबंध नहीं लगा रहा हूं जो किसी चरित्र के संख्यात्मक मूल्य को प्राप्त कर सकते हैं, लेकिन मैं संभव के रूप में एक गैर-निर्मित उत्तर को भी जोड़ने के लिए प्रोत्साहित करता हूं।
  • यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा के लिए बाइट्स में सबसे कम उत्तर जीतता है! सौभाग्य!
code-golf  sorting  unicode 
— मजाक कर रहा है
स्रोत
9
RIP मोनोस्पेसिंग :(
— जो किंग

जवाबों:

6

पायथन 3 , 216 213 बाइट्स

TF बाइट के लिए -3 बाइट्स 

lambda l:sorted(l,key='⅒⅑⅐⅙⅕¼⅓⅖½⅗⅔¾⅘⅚⅟ⅠⅰⅡⅱⅢⅲⅣⅳⅤⅴⅥⅵↅⅦⅶⅧⅷⅨⅸⅩⅹ↊Ⅺⅺ↋ⅫⅻⅬⅼↆⅭⅽↃↄ⅛⅜Ⅾⅾ⅝⅞Ⅿⅿↀↁↂↇↈ'.find)

इसे ऑनलाइन आज़माएं!

अंतर्निहित उस संख्यात्मक मूल्य के साथ, 111 बाइट्स

lambda l:sorted(l,key=lambda c:[10,11,100,100,0]['↊↋Ↄↄ'.find(c)]or numeric(c))
from unicodedata import*

इसे ऑनलाइन आज़माएं!

— छड़ी
स्रोत
4
आप ↉स्ट्रिंग से हटाकर 3 बाइट्स बचा सकते हैं (रिटर्न खोजें -1जो सबसे छोटा है)
— TFeld
4

पर्ल 6 , 57 बाइट्स

*.sort: {%(<Ↄ 100 ↄ 100 ↊ 10 ↋ 11>){$_}//.unival}

इसे ऑनलाइन आज़माएं!

बस एक हैश में चार असाधारण पात्रों को देखता है, या बिल्ट-इन univalविधि पर वापस आता है ।

— शॉन
स्रोत
बृहदान्त्र के बाद आपको स्थान की आवश्यकता नहीं है। इसके अलावा, आपका लिंक अभी भी एक कोड ब्लॉक में है जो एक लैम्बडा के बजाय
— जो किंग
4

05AB1E (विरासत) , 192 74 63 61 बाइट्स

Σ•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ
,λ₂ϦP(Ì•65в₂+sÇт%k

-118 बाइट केवल 05AB1E के कोड पेज के पात्रों का उपयोग करके, इसलिए हमें UTF-8 एन्कोडिंग का उपयोग करने की आवश्यकता नहीं है।
-11 बाइट्स @ @ अदनान को धन्यवाद ।
-2 बाइट्स @Grimy को धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Σ            # Sort the input by:
 •Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ
 ,λ₂ϦP(Ì•65в₂+
             #  List of ASCII values modulo-100 of the characters we want to sort
 sÇ          #  Get the ASCII value of the current input-character
   т%        #  Take modulo 100 of this ASCII value
 k           #  And get the index in the list of ASCII values, as sorting order

तो क्या है •Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ\n,λ₂ϦP(Ì•65в₂+?

वर्ण modulo-100 के क्रम के आधार पर हमें निम्नलिखित सूची मिलती है:

[85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84]

ये निम्नलिखित कार्यक्रम द्वारा उत्पन्न होते हैं:

"↉⅒⅑⅛⅐⅙⅕¼⅓⅜⅖½⅗⅝⅔¾⅘⅚⅞⅟ⅠⅰⅡⅱⅢⅲⅣⅳⅤⅴⅥⅵↅⅦⅶⅧⅷⅨⅸⅩⅹ↊Ⅺⅺ↋ⅫⅻⅬⅼↆⅭⅽↃↄⅮⅾⅯⅿↀↁↂↇↈ"Çт%

इसे ऑनलाइन आज़माएं।

•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ\n,λ₂ϦP(Ì•65в₂+संपीड़ित संख्या लेकर इस सूची का एक छोटा रूपांतर है 1485725021600091112740267145165274006958935956446028449609419704394607952161907963838640094709317691369972842282463, फिर इसे बेस -65 में परिवर्तित करना और फिर प्रत्येक में 26 जोड़ना।

इसे ऑनलाइन आज़माएँ और सत्यापित करें कि सूचियाँ समान हैं ।

— केविन क्रूज़सेन
स्रोत
1
हां, उन सभी पात्रों को 05AB1E के एन्कोडिंग में नहीं है, इसलिए यह 192 बाइट्स होगा।
— ओकेक्स
2
हाँ, 68-बाइट फ़ाइल के रूप में इस कोड का प्रतिनिधित्व करना संभव नहीं है, जो हमें यूटीएफ -8 में वापस आने के लिए मजबूर करता है, जो वास्तव में 192 बाइट्स है ।
— अदनान
1
@JoKing तो, अब मैं केवल 05AB1E के कोड पृष्ठ के पात्रों का उपयोग कर रहा हूं। ;) फिर भी एक उबाऊ दृष्टिकोण है, लेकिन देखूंगा कि क्या मैं किसी प्रकार के अंकगणित पैटर्न पा सकता हूं।
— केविन क्रूज़सेन
1
मुझे लगता है कि आप की जगह ले सकता "]&%/$-)`'0*a+1(b,.234D5E6F7G8H9IY:J;K<L=M^>N_?O@PZAQWXBRCSTUV[\"Ç8-साथ•4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91в
— अदनान
1
हम्म, जो एक कोष्ठक को बंद करने के लिए पंजीकरण नहीं करने में एक त्रुटि है। मैं इस पर गौर करूंगा।
— अदनान
3

रेटिना , 1 93 बाइट्स (UTF-8)

2{O`.
T`¼-¾⅐-↋\LI ^]Q@TU\\[ZYWSPNK\HFDB?=;975X\VR\OMJG\ECA><:86432\-)#1%0,*&.(!"$/+'`Ro

इसे ऑनलाइन आज़माएं!स्पष्टीकरण: कोड बिंदु क्रम में वर्णों को सॉर्ट करता है, फिर संख्यात्मक वर्ण और ASCII वर्णों के बीच मानचित्र बनाता है ताकि सबसे कम मान वाले संख्यात्मक वर्ण ASCII वर्णों को निम्नतम कोड बिंदु और इसके विपरीत के साथ मैप करें। फिर अभ्यास दोहराता है, ताकि अक्षर अब इस ASCII मानचित्रण के क्रम में क्रमबद्ध हो जाएं, जो वांछित संख्यात्मक क्रम से मेल खाते हैं, इससे पहले कि वे वापस रूपांतरित हो जाएं। संपादित करें: संख्यात्मक वर्णों के बजाय ASCII वर्णों के क्रम को निर्दिष्ट करके 100 (!) बाइट्स सहेजे गए।

— नील
स्रोत
3

जेली , 55 बाइट्स

O%70‘“$Żz*ṀḢD⁹VṢaʠƝ lẹkƝʋ9⁽ƭXmż4#⁺3ç%|ọṢLxƈ⁽}ÞƇ2’Œ?¤iµÞ

वर्णों की एक सूची को स्वीकार करने वाला एक विचित्र लिंक जो पात्रों की सूची तैयार करता है।

इसे ऑनलाइन आज़माएं!

कैसे?

बहुत आसान से यह लग रहा “$Żz*ṀḢD⁹VṢaʠƝ lẹkƝʋ9⁽ƭXmż4#⁺3ç%|ọṢLxƈ⁽}ÞƇ2’है कि अंकों के रूप में जेली के कोड-पेज का उपयोग करते हुए बेस 250 में एक बड़ी संख्या है, मैं “...’इसके स्थान पर उपयोग करूंगा ।

O%70‘“...’Œ?¤iµÞ - Link: list of characters
               Þ - sort by:
              µ  -   the monadic function (i.e. f(character)):
O                -     get the ordinal value of the character
 %70             -     modulo by 70 (get the remainder after dividing by 70)
                 -       - giving integers in [0,69] excluding [52,58]
    ‘            -     increment (below code pattern can't have anything but '↉' map to 0)
            ¤    -     nilad followed by link(s) as a nilad:
     “...’       -       literal 7826363328008670802853323905140295872014816612737076282224746687856347808481112431487214423845098801
          Œ?     -       get the permutation of natural numbers [1,N] with minimal N such
                 -         that this permutation would reside at the given index in a
                 -         sorted list of all permutations of those same numbers
                 -         -> [46,52,53,54,55,56,57,58,61,60,70,59,68,64,49,62,1,65,50,66,2,63,51,67,69,3,4,5,21,6,22,7,23,8,24,9,25,10,26,42,11,27,12,28,13,29,14,30,47,15,31,48,16,32,17,33,43,18,34,40,41,19,35,20,36,37,38,39,44,45]
             i   -     first index of (the ordinal mod 70 plus 1) in that list

अलग

थोड़े विडंबना यह है कि "बिल्ट-इन एप्रोच का उपयोग करने के लिए निकटतम" मैं कर सकता था 85 बाइट्स , यह एक संकुचित स्ट्रिंग का उपयोग करता है:

from unicodedata import*; copy_to( atoms['
'], numeric( atoms['
'].call()))

जो नई खबरों से अलग है और ⁸पायथन कोड देने के लिए एस के साथ जुड़ गया है:

from unicodedata import*; copy_to( atoms['⁸'], numeric( atoms['⁸'].call()))

जो जेली के दुभाषिया के भीतर निष्पादन योग्य है - यह यूनिकोड चरित्र के संख्यात्मक मान को बाएं तर्क निलाद में रखेगा, ⁸बाद में उपयोग के लिए।

— जोनाथन एलन
स्रोत
3

जाप , 72 बाइट्स

ñ@`'%!x("y#) z$&*+,<-=.>/?0@1aq2b3c4d5ev6fw7g8hr9iop:j;klmn¡`u bXcuL

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं

व्याख्या

ñ@                 :Sort by passing each X through a function
  `...`            :  A compressed string, which itself contains a bunch of unprintables (See below for codepoints of original string)
       u           :  Uppercase
         b         :  Index of
          Xc       :   Charcode of X
            uL     :   Mod 100 and get character at that codepoint

कोड पॉइंट्स

30,29,39,28,37,33,120,31,40,34,121,35,41,32,122,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,97,113,50,98,51,99,52,100,53,101,118,54,102,119,55,103,56,104,114,57,105,111,112,58,106,59,107,108,109,110,115,116

मूल समाधान, 90 89 88 बाइट्स

ñ!b`(&" )#$*!%'+,-=.>/?0@1a2br3c4d5e6fw7gx8h9:jpq;k<lmÍ/`®iv u nLõd)dÃi6'¼ iA'½ iE'¾

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं

व्याख्या

   `...`                                :A compressed string, which itself contains a bunch of unprintables (See below for codepoints of original string)
        ®                               :Map
         iv                             :  Prepend "v"
            u                           :  Convert to uppercase
               Lõ                       :  Range [1,100]
                 d                      :  Characters at those codepoints
              n   )                     :  Convert from that base to base-10
                   d                    :  Get the character at that codepoint
                    Ã                   :End map
                     i6'¼               :Insert "¼" at (0-based) index 6
                          iA'½          :Insert "½" at index 10
                               iE'¾     :Insert "¾" at index 14
ñ                                       :Sort the input array
 !b                                     :  By finding the index of the current element in the string above

कोड पॉइंट्स

31,30,40,29,38,34,32,41,35,36,42,33,37,39,43,44,45,61,46,62,47,63,48,64,49,97,50,98,114,51,99,52,100,53,101,54,102,119,55,103,120,56,104,57,105,115,58,106,112,113,59,107,60,108,109,110,111,116,117
— झबरा
स्रोत
3

05AB1E, 56 53 51 50 49 48 बाइट्स

ΣÇ©1ö•Ω‘~Èr–Õî5®Î¼ÓÂ∍_OûR•42в•мjāl†£•₂°*S>ÅΓ®Íè+

इसे ऑनलाइन आज़माएं!

इस समाधान के मूल में एक सॉर्टिंग कुंजी के लिए यूनिकोड कोड पॉइंट्स की एक संकुचित सूची मैपिंग है। समान संख्या के अनुरूप वर्ण एक ही कुंजी से मैप किए जाते हैं, इसलिए हमें केवल 40 अलग-अलग कुंजी की आवश्यकता होती है।

70 सबसे छोटी संख्या है जिसके द्वारा हम सभी इनपुट कोडपॉइंट्स को संशोधित कर सकते हैं और अलग-अलग परिणाम प्राप्त कर सकते हैं। चूंकि 05AB1E में इंडेक्सिंग चारों ओर घूमती है, हमें स्पष्ट रूप से इसकी आवश्यकता नहीं है70% , बस यह सुनिश्चित करें कि सूची की लंबाई 70 है।

ध्यान दें कि लगातार कुंजी के साथ लगातार कोड बिंदुओं के लंबे खंड होते हैं। इस प्रकार, एन्कोडिंग (कुंजी - कोडपॉइंट) केवल (कुंजी) के बजाय समान संख्याओं के लंबे खंड देता है, जिसे रन-लंबाई एन्कोड किया जा सकता है। हालांकि, कोड बिंदुओं की सीमा बहुत बड़ी है (उन 0xBC .. 0xBE पर लानत है), जो एक मुद्दा होगा। इसलिए (की - कोडपॉइंट) के बजाय, हम एनकोड करते हैं (की - सम_ऑफ_डिजिट्स (कोडपॉइंट)), जो दुर्भाग्य से स्ट्रेच लेंथ को 10 तक सीमित कर देता है, लेकिन एन्कोडेड वैल्यू की रेंज को कम करने में काफी अच्छा करता है। (अन्य कार्य निश्चित रूप से संभव हैं, जैसे कोडपॉइंट% स्थिर, लेकिन अंकों का योग सर्वोत्तम परिणाम देता है)।

इसके अतिरिक्त, यह रन-लेंथ एन्कोडिंग के साथ सूची को 2 नाटकों को अच्छी तरह से घुमाता है, इसलिए हम अनुक्रमण से पहले कोडपॉइंट से 2 घटाते हैं।

•Ω‘~Èr–Õî5®Î¼ÓÂ∍_OûR•42в    # compressed list [25, 34, 27, 36, 30, 38, 29, 35, 41, 0, 28, 16, 19, 31, 7, 4, 11, 17, 22, 13, 16, 17, 20, 8, 19, 4, 18, 21]
•мjāl†£•                    # compressed integer 79980000101007
        ₂°*                 # times 10**26
           S                # split to a list of digits
            >               # add 1 to each
             ÅΓ             # run-length decode, using the first list as elements and the second list as lengths

Σ                           # sort by
 Ç©1ö                       # sum of digits of the codepoint
           +                # plus
     ...  è                 # the element of the run-length decoded list
        ®Í                  # with index (codepoint - 2) % 70
— ग्रिमी
स्रोत
1

टी-एसक्यूएल, 207 बाइट्स

SELECT*FROM t ORDER BY
CHARINDEX(c,N'⅒⅑⅛⅐⅙⅕¼⅓⅜⅖½⅗⅝⅔¾⅘⅚⅞⅟ⅠⅰⅡⅱⅢⅲⅣⅳⅤⅴⅥ
              ⅵↅⅦⅶⅧⅷⅨⅸⅩⅹ↊Ⅺⅺ↋ⅫⅻⅬⅼↆⅭⅽↃↄⅮⅾⅯⅿↀↁↂↇↈ'COLLATE Thai_BIN)

स्ट्रिंग के बीच में वापसी केवल पठनीयता के लिए है। मुझे लगता है कि मुझे बाइट काउंट सही मिला (3 में से न्यूमेरिक कैरेक्टर 1-बाइट हैं, बाकी 2 बाइट्स हैं), कैरेक्टर काउंट 148 है।

मैंने स्ट्रिंग को आरोही क्रम में पूर्व-क्रमबद्ध किया, जिससे बाहर निकल गया ↉ दिया, जो अन्य उत्तरों द्वारा सुझाए गए (जो 0 लौटाता है)।

कोई भी बाइनरी कॉलेशन काम करेगा, मैंने उपयोग किया Thai_BIN क्योंकि इसका सबसे छोटा नाम है। (एसक्यूएल में एक टकराव यह बताता है कि वर्ण छँटाई / तुलना कैसे की जाती है, मुझे बाइनरी की आवश्यकता है इसलिए प्रत्येक वर्ण केवल स्वयं से मेल खाता है।)

हमारे आईओ मानकों के अनुसार , इनपुट पूर्व मौजूदा तालिका के माध्यम से लिया जाता है टी के साथ NCHAR(1)क्षेत्र ग ।

यदि आप बाइनरी कॉलेशन का उपयोग करते हुए इनपुट टेबल को स्वयं परिभाषित करते हैं, तो आप 16 बाइट्स को बचाने के लिए उसे छोड़ सकते हैं:

CREATE TABLE t(c NCHAR(1) COLLATE Thai_BIN)
— BradC
स्रोत
यदि आप बाइनरी कॉलेशन का उपयोग नहीं करते हैं तो कौन से वर्ण एक दूसरे से मेल खाते हैं?
— नील
1
@ नील ठीक है, इस बात पर निर्भर करता है कि वास्तव में आप कौन सा अन्य उपयोग करते हैं! :)। सबसे स्पष्ट एक जो मैंने देखा (SQL_Latin1_General_SP1_CI_AS के मेरे सर्वर डिफ़ॉल्ट का उपयोग करते हुए) यह था कि ऊपरी और निचले रोमन अंक एक दूसरे से मेल खाते हैं। कौन सा .... हम्म ... वास्तव में काम हो सकता है के लिए मुझे यहाँ है, क्योंकि वे एक ही नंबर के लिए हल। लेकिन अगर कोलाज नाम इतना लंबा है, तो यह बचत का प्रतिकार करता है। BRB, कुछ और परीक्षण करेंगे ...
— ब्रैडक
1
@ नील नोप, अच्छा नहीं। गैर-द्विआधारी collations के साथ, 10 कम सामान्य वर्ण ( ⅐⅑⅒Ↄↄↅↆↇↈ↉↊↋यदि आप उत्सुक हैं) सभी एक-दूसरे से मेल खाते हैं।
— ब्रैडेक
आह, यह शर्म की बात है, लेकिन मुझे बताने के लिए धन्यवाद!
— नील
1

रूबी , 77 बाइट्स

अक्षरों के सभी वर्णों को बदलता है जो संख्यात्मक मानों का प्रतिनिधित्व करते हैं और उनके द्वारा क्रमबद्ध होते हैं।

->a{a.sort_by{|e|e.tr'¼-¾⅐-↋','HLPECBIOGKMQFRDJNSaa-pa-ppqrnnfmstAjk'}}

इसे ऑनलाइन आज़माएं!

— मूल्य स्याही
स्रोत
1

पर्ल 6 , 13 52 बाइट्स

*.sort:{%(<Ↄ 99 ↄ 99 ↊ 10 ↋ 11>){$_}//.EVAL}

इसे ऑनलाइन आज़माएं!

— bb94
स्रोत
2
Eval का उपयोग करना धोखा नहीं है, लेकिन यह केवल चुनौती को हल नहीं करता है। 52 जो वास्तव में काम करता है:*.sort:{%(<Ↄ 99 ↄ 99 ↊ 10 ↋ 11>){$_}//.EVAL}
— ग्रिम्मी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.