Dans les cavités des caractères Unicode, il existe un bloc Unicode de (actuellement) 63 caractères nommé "Number Forms", qui se compose de caractères qui ont des valeurs numériques telles que le chiffre romain Ⅻ, des fractions vulgaires comme ⅑ ou ↉, ou des étranges comme ↊ (10) ou ↈ (100000).

Votre tâche consiste à écrire un programme ou une fonction qui, lorsqu'il reçoit une liste de caractères Unicode attribués dans ce bloc, trie la liste en fonction des valeurs numériques de chaque caractère.

Une liste (triable) de caractères et de valeurs se trouve sur la page Wikipedia .

Pour être autonome, voici une liste des points de code et de leurs valeurs:

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

Cas de test:

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

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

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

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

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

Notez que quatre des symboles (ceux utilisés dans le dernier cas) ne sont pas des numéros unicode, bien qu'ils aient toujours une valeur numérique, alors assurez-vous de vérifier avant de simplement publier une fonction intégrée.

Règles:

• Si d'autres caractères sont attribués à ce bloc à l'avenir, vous n'aurez pas besoin de mettre à jour votre code pour les prendre en charge.
• L'ordre des caractères avec des valeurs identiques n'a pas d'importance.
• IO est flexible .
  • La sortie doit cependant être sous forme de caractères, pas de valeurs numériques
• Les échappatoires standard sont interdites.
• Je n'interdis pas les éléments intégrés qui peuvent récupérer la valeur numérique d'un caractère, mais j'encourage également à ajouter une réponse non intégrée si possible.
• C'est du golf de code , donc la réponse la plus courte en octets pour chaque langue gagne! Bonne chance!

Python 3 , 216 213 octets

^{-3 octets grâce à TFeld}

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

Essayez-le en ligne!

Avec intégré qui récupère la valeur numérique, 111 octets

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

Essayez-le en ligne!

Perl 6 , 57 octets

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

Essayez-le en ligne!

Recherche simplement les quatre personnages exceptionnels dans un hachage, ou revient à la univalméthode intégrée .

05AB1E (hérité) , 192 74 63 61 octets

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

-118 octets en utilisant uniquement les caractères de la page de codes 05AB1E, nous n'avons donc pas besoin d'utiliser le codage UTF-8.
-11 octets grâce à @Adnan .
-2 octets grâce à @Grimy .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Alors c'est quoi •Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ\n,λ₂ϦP(Ì•65в₂+?

En fonction de l'ordre des caractères modulo-100, nous obtenons la liste suivante:

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

Ceux-ci sont générés par le programme suivant:

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

Essayez-le en ligne.

•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ\n,λ₂ϦP(Ì•65в₂+est une variation plus courte de cette liste en prenant le nombre compressé 1485725021600091112740267145165274006958935956446028449609419704394607952161907963838640094709317691369972842282463 , puis en le convertissant en Base-65, puis en ajoutant 26 à chacun.

Essayez-le en ligne et vérifiez que les listes sont les mêmes .

Rétine , 1 93 octets (UTF-8)

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

Essayez-le en ligne! Explication: Trie les caractères dans l'ordre des points de code, puis mappe entre les caractères numériques et les caractères ASCII de sorte que les caractères numériques avec la valeur la plus faible mappent les caractères ASCII avec le point de code le plus bas et vice versa. Répète ensuite l'exercice, de sorte que les caractères sont maintenant triés dans l'ordre de ce mappage ASCII, qui correspond à l'ordre numérique souhaité, avant d'être retransformés. Modifier: 100 octets (!) Enregistrés en spécifiant l'ordre des caractères ASCII plutôt que des caractères numériques.

Gelée , 55 octets

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

Un lien monadique acceptant une liste de caractères qui donne une liste de caractères.

Essayez-le en ligne!

Comment?

Beaucoup plus simple qu'il n'y paraît car il “$Żz*ṀḢD⁹VṢaʠƝ lẹkƝʋ9⁽ƭXmż4#⁺3ç%|ọṢLxƈ⁽}ÞƇ2’n'y a qu'un grand nombre dans la base 250 utilisant la page de codes de Jelly comme chiffres, je vais utiliser “...’à sa place.

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

De côté

Ironiquement, le plus proche d'un "utiliser une approche intégrée" que je pouvais rassembler était de 85 octets , cela utilise une chaîne compressée:

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

qui est divisé sur les nouvelles lignes et joint à ⁸s pour donner le code Python:

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

qui est exécutable dans l'interpréteur de Jelly - il placera la valeur numérique du caractère Unicode dans l'argument de gauche nilad, ⁸pour une utilisation ultérieure.

Japt , 72 octets

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

Essayez-le ou exécutez tous les cas de test

Explication

ñ@                 :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

Codepoints

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

Solution d'origine, 90 89 88 octets

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

Essayez-le ou exécutez tous les cas de test

Explication

   `...`                                :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

Codepoints

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

05AB1E, 56 53 51 50 49 48 octets

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

Essayez-le en ligne!

Au cœur de cette solution se trouve une liste compressée mappant le code unicode pointe vers une clé de tri. Les caractères qui correspondent au même numéro sont mappés sur la même clé, nous n'avons donc besoin que de 40 clés différentes.

70 est le plus petit nombre par lequel nous pouvons modulo tous les points de code d'entrée et obtenir des résultats distincts. Étant donné que l'indexation dans 05AB1E s'enroule, nous n'avons pas besoin de le faire explicitement 70%, assurez-vous simplement que la liste est de longueur 70.

Notez qu'il existe de longues étendues de points de code consécutifs avec des clés consécutives. Ainsi, le codage (clé - point de code) plutôt que simplement (clé) donne de longues étendues de nombres identiques, qui peuvent être codés sur toute la longueur. Cependant, la plage de points de code est très grande (bon sang ceux 0xBC .. 0xBE), ce qui serait un problème. Ainsi, au lieu de (clé - point de code), nous codons (clé - somme_de_digits (point de code)), ce qui limite malheureusement la longueur d'étirement à 10, mais réduit assez bien la plage de valeurs codées. (D'autres fonctions sont bien sûr possibles, comme le point de code% constant, mais la somme des chiffres donne les meilleurs résultats).

De plus, il s'avère que la rotation de la liste de 2 joue bien avec le codage de longueur, donc nous soustrayons 2 du point de code avant l'indexation.

•Ω‘~È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

JavaScript (SpiderMonkey) , 117 octets

a=>a.sort((a,b)=>(g=c=>';<=>GHIJCDEF?@AB/37~15:;8-9+6.24,*)0N(DEH@GMJKLH'[(c.charCodeAt()&127^44)%92%76%60])(a)>g(b))

Essayez-le en ligne!

T-SQL, 207 octets

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

Le retour au milieu de la chaîne est uniquement pour la lisibilité. Je pense que le nombre d'octets est correct (3 des caractères numériques sont à 1 octet, les autres à 2 octets), le nombre de caractères est de 148.

J'ai pré-trié la chaîne dans l'ordre croissant, en laissant de côté ↉(qui renvoie 0) comme suggéré par d'autres réponses.

Tout classement binaire fonctionnera, j'ai utilisé Thai_BINcar il a le nom le plus court. (Un classement en SQL prescrit comment le tri / comparaison des caractères est effectué, j'ai besoin de binaires pour que chaque caractère ne corresponde qu'à lui-même.)

Selon nos normes IO , l'entrée est prise via la table préexistante t avec le NCHAR(1)champ c .

Si vous définissez la table d'entrée elle-même à l'aide d'un classement binaire, vous pouvez laisser cela de côté pour économiser 16 octets:

CREATE TABLE t(c NCHAR(1) COLLATE Thai_BIN)

Rubis , 77 octets

Remplace tous les caractères par des lettres représentant les valeurs numériques et les trie en conséquence.

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

Essayez-le en ligne!

Perl 6 , 13 52 octets

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

Essayez-le en ligne!