Tipo de números

21

Dentro dos recessos dos caracteres Unicode, existe um bloco Unicode de (atualmente) 63 caracteres chamado "Number Forms", que consiste em caracteres que possuem valores numéricos como o número romano Ⅻ, frações vulgares como ⅑ ou ↉ ou estranhas como ↊ (10) ou ↈ (100000).

Sua tarefa é escrever um programa ou função que, ao receber uma lista de caracteres Unicode atribuídos nesse bloco, classifique a lista pelos valores numéricos de cada caractere.

Uma lista (classificável) de caracteres e valores pode ser encontrada na página da Wikipedia .

Para ser independente, aqui está uma lista dos pontos de código e seus valores:

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

Casos de teste:

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

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

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

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

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

Observe que quatro dos símbolos (os usados ​​no último caso) não são números unicode, embora ainda tenham um valor numérico, portanto, verifique antes de postar um built-in.

Regras:

  • Se mais caracteres forem atribuídos a esse bloco no futuro, você não precisará atualizar seu código para suportá-los.
  • A ordem dos caracteres com valores idênticos não importa.
  • IO é flexível .
    • A saída deve ser como os caracteres, não os valores numéricos
  • As brechas padrão são proibidas.
  • Não estou banindo built-ins que podem buscar o valor numérico de um caractere, mas também incentivo a adicionar uma resposta não incorporada, se possível.
  • Isso é , então a resposta mais curta em bytes para cada idioma vence! Boa sorte!
Brincadeira
fonte
9
Monospacing RIP :(
Jo King

Respostas:

6

Python 3 , 216 213 bytes

-3 bytes graças ao TFeld

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

Experimente online!

Com o built-in que busca o valor numérico, 111 bytes

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

Experimente online!

Cajado
fonte
4
Você pode salvar 3 bytes através da remoção do string (encontrar retornos -1que é menor)
TFeld
4

Perl 6 , 57 bytes

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

Experimente online!

Apenas procura os quatro caracteres excepcionais em um hash ou volta ao univalmétodo interno.

Sean
fonte
Você não precisa do espaço após os dois pontos. Além disso, seu link ainda está em um bloco de código e não em um lambda Whatever
Jo King
4

05AB1E (legado) , 192 74 63 61 bytes

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

-118 bytes usando apenas caracteres da página de código do 05AB1E, portanto, não precisamos usar a codificação UTF-8.
-11 bytes graças a @Adnan .
-2 bytes graças a @Grimy .

Experimente online ou verifique todos os casos de teste .

Explicação:

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

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

Com base na ordem dos caracteres módulo 100, obtemos a seguinte lista:

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

Eles são gerados pelo seguinte programa:

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

Experimente online.

•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ\n,λ₂ϦP(Ì•65в₂+é uma variação mais curta dessa lista, pegando o número compactado 1485725021600091112740267145165274006958935956446028449609419704394607952161907963838640094709317691369972842282463 , convertendo-o em Base-65 e adicionando 26 a cada um.

Experimente online e verifique se as listas são as mesmas .

Kevin Cruijssen
fonte
1
Sim, nem todos esses caracteres estão na codificação de 05AB1E, portanto, seriam 192 bytes.
Okx 24/07/18
2
Sim, não é possível representar esse código como um arquivo de 68 bytes, o que nos força a voltar ao UTF-8, que é de fato 192 bytes .
Adnan
1
@JoKing Então, agora estou usando apenas caracteres da página de códigos do 05AB1E. ;) Ainda é uma abordagem chata, mas vou ver se consigo encontrar algum tipo de padrão aritmético.
Kevin Cruijssen
1
Eu acho que você pode substituir "]&%/$-)`'0*a+1(b,.234D5E6F7G8H9IY:J;K<L=M^>N_?O@PZAQWXBRCSTUV[\"Ç8-por•4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91в
Adnan
1
Hmm, isso parece ser um erro de análise ao não registrar o colchete de fechamento. Eu vou olhar para isso.
Adnan
3

Retina , 1 93 bytes (UTF-8)

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

Experimente online! Explicação: Classifica os caracteres na ordem do ponto de código e mapeia entre os caracteres numéricos e caracteres ASCII para que os caracteres numéricos com o valor mais baixo mapeiem os caracteres ASCII com o ponto de código mais baixo e vice-versa. Em seguida, repita o exercício, para que os caracteres agora sejam classificados na ordem desse mapeamento ASCII, que corresponde à ordem numérica desejada, antes de serem transformados novamente. Editar: salvou 100 bytes! Especificando a ordem dos caracteres ASCII em vez dos caracteres numéricos.

Neil
fonte
3

Geléia , 55 bytes

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

Um link monádico que aceita uma lista de caracteres que gera uma lista de caracteres.

Experimente online!

Quão?

Muito mais simples do que parece, uma vez que “$Żz*ṀḢD⁹VṢaʠƝ lẹkƝʋ9⁽ƭXmż4#⁺3ç%|ọṢLxƈ⁽}ÞƇ2’é apenas um grande número na base 250 usando a página de código de Jelly como dígitos, usarei “...’em seu lugar.

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

a parte, de lado

Um pouco ironicamente, o mais próximo de uma "usar uma abordagem interna" que eu poderia reunir era de 85 bytes , isso usa uma string compactada:

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

que é dividido em novas linhas e associado a s para fornecer o código Python:

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

que é executável no intérprete de Jelly - ele colocará o valor numérico do caractere Unicode no argumento esquerdo nilad, para uso posterior.

Jonathan Allan
fonte
3

Japonês , 72 bytes

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

Experimente ou execute todos os casos de teste


Explicação

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

Solução original, 90 89 88 bytes

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

Experimente ou execute todos os casos de teste


Explicação

   `...`                                :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
Shaggy
fonte
3

05AB1E, 56 53 51 50 49 48 bytes

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

Experimente online!

No centro desta solução está um código unicode de mapeamento de lista compactado que aponta para uma chave de classificação. Os caracteres que correspondem ao mesmo número são mapeados para a mesma chave, portanto, precisamos apenas de 40 chaves diferentes.

70 é o menor número pelo qual podemos modular todos os pontos de código de entrada e obter resultados distintos. Como a indexação no 05AB1E é completa, não precisamos explicitamente 70%, apenas verifique se a lista tem o comprimento 70.

Observe que há longos trechos de pontos de código consecutivos com chaves consecutivas. Assim, a codificação (chave - ponto de código), em vez de simplesmente (chave), fornece longos trechos de números idênticos, que podem ser codificados em toda a extensão. No entanto, o intervalo de pontos de código é muito grande (que seja 0xBC .. 0xBE), o que seria um problema. Então, em vez de (key - codepoint), codificamos (key - sum_of_digits (codepoint)), que infelizmente limita o comprimento do alongamento a 10, mas se sai muito bem em reduzir o intervalo de valores codificados. (Outras funções são obviamente possíveis, como codepoint% constante, mas a soma dos dígitos fornece os melhores resultados).

Além disso, a rotação da lista em 2 vezes é boa com a codificação de execução, então subtraímos 2 do ponto de código antes da indexação.

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

T-SQL, 207 bytes

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

O retorno no meio da sequência é apenas para legibilidade. Acho que obtive a contagem de bytes correta (3 dos caracteres numéricos são 1 byte, o restante é 2 bytes), a contagem de caracteres é 148.

Eu pré-classifiquei a sequência em ordem crescente, deixando de fora (que retorna 0) como sugerido por outras respostas.

Qualquer agrupamento binário funcionará, eu usei, Thai_BINpois ele tem o nome mais curto. (Um agrupamento no SQL prescreve como a classificação / comparação de caracteres é feita, preciso de binário para que cada caractere corresponda apenas a si mesmo.)

De acordo com nossos padrões de IO , a entrada é obtida através da tabela t existente com o NCHAR(1)campo c .

Se você definir a própria tabela de entrada usando um agrupamento binário, poderá deixar isso de fora para salvar 16 bytes:

CREATE TABLE t(c NCHAR(1) COLLATE Thai_BIN)
BradC
fonte
Quais caracteres corresponderiam se você não usasse agrupamento binário?
Neil
1
@ Neil Bem, depende de qual outro agrupamento você usa, na verdade! :). O mais óbvio que notei (usando o SQL_Latin1_General_SP1_CI_AS do meu servidor) foi que os números romanos maiúsculos e minúsculos coincidem. O que .... hmm ... pode realmente funcionar para mim aqui, uma vez que eles resolvem o mesmo número. Mas se o nome do agrupamento for muito mais longo, isso neutraliza a economia. BRB, tenho que testar um pouco mais ...
BradC
1
@ Neil Nope, não é bom. Com agrupamentos não binários, 10 dos caracteres menos comuns ( ⅐⅑⅒Ↄↄↅↆↇↈ↉↊↋se você estiver curioso) combinam entre si.
BradC
Ah, isso é uma pena, mas obrigado por me avisar!
Neil
1

Ruby , 77 bytes

Altera todos os caracteres para letras que representam os valores numéricos e as classificações por isso.

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

Experimente online!

Value Ink
fonte
1

Perl 6 , 13 52 bytes

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

Experimente online!

bb94
fonte
2
Usar eval não é trapaça, mas isso simplesmente não resolve o desafio. 52 que realmente funciona:*.sort:{%(<Ↄ 99 ↄ 99 ↊ 10 ↋ 11>){$_}//.EVAL}
Grimmy