Correspondência de algarismos romanos

19

Desafio

Dada alguma sequência de entrada, retorne um valor truthy se ele representar um numeral romano correto entre 1 (= I) e 3999 (= MMMCMXCIX), e um valor falsey caso contrário.

Detalhes

  • A entrada é uma sequência não vazia que compreende apenas os caracteres IVXLCDM.
  • Os números romanos (que usamos aqui neste desafio) são definidos da seguinte maneira:

Usamos apenas os seguintes símbolos:

Symbol  I   V   X   L   C   D    M
Value   1   5  10  50 100 500 1000

Para definir quais cadeias de caracteres são realmente números romanos válidos, provavelmente é mais fácil fornecer a regra da conversa: Para escrever um número decimal a3 a2 a1 a0(onde cada aium representa um dígito. Por exemplo, para representar 792nós temos a3=0, a2=7, a1=9, a0=2.) Como um número romano, nós o decompomos no poder das dezenas. Os diferentes poderes de dez podem ser escritos da seguinte maneira:

      1-9: I, II, III, IV, V, VI, VII, VIII, IX
    10-90: X, XX, XXX, XL, L, LX, LXX, LXXX, XC
  100-900: C, CC, CCC, CD, D, DC, DCC, DCCC, CM
1000-3000: M, MM, MMM

Começando no lado esquerdo com o dígito mais significativo do, podemos converter o número que cada dígito representa separadamente e concatená-los. Portanto, para o exemplo acima, seria assim:

Digit        a3    a2   a1   a0
Decimal       0     7    9    2
Roman             DCC   XC   II

Portanto, o numeral romano para 792é DCCXCII. Aqui está uma lista completa de todos os algarismos romanos relevantes para este desafio: OEIS a006968.txt

Exemplos

Truthy

MCCXXXIV (1234)
CMLXXXVIII (988)
DXIV (514)
CI (101)

Falsey

MMIXVIII
IVX
IXV
MMMM
XXXVX
IVI
VIV
flawr
fonte
Subconjunto deste desafio de conversão .
Shaggy
Ainda não acho que isso seja qualificado como "subconjunto", pois o conjunto de entradas inválidas é maior. Esse desafio aqui se refere apenas aos números definidos como "bem" usados ​​no OEIS A006968
flawr
2
Por que é MMMMinválido? Existe uma carta para 5000 que deve ser usada em vez de M <letra>?
Skyler
Confira as especificações, não existe essa carta. Os únicos símbolos usados ​​são I,V,X,L,C,D,M.
flawr 12/04

Respostas:

17

Detalhado , 1362 bytes

GET A ROMAN NUMERAL TYPED IN BY THE CURRENT PERSON USING THIS PROGRAM AND PUT IT ONTO THE TOP OF THE PROGRAM STACK
PUT THE NUMBER MMMM ONTO THE TOP OF THE PROGRAM STACK
MOVE THE FIRST ELEMENT OF THE PROGRAM STACK TO THE SECOND ELEMENT'S PLACE AND THE SECOND ELEMENT OF THE STACK TO THE FIRST ELEMENT'S PLACE
DIVIDE THE FIRST ELEMENT OF THE PROGRAM STACK BY THE SECOND ELEMENT OF THE PROGRAM STACK AND PUT THE RESULT ONTO THE TOP OF THE PROGRAM STACK
PUT THE NUMBER V ONTO THE TOP OF THE PROGRAM STACK
GET THE FIRST ELEMENT OF THE PROGRAM STACK AND THE SECOND ELEMENT OF THE PROGRAM STACK AND IF THE SECOND ELEMENT OF THE PROGRAM STACK IS NOT ZERO JUMP TO THE INSTRUCTION THAT IS THE CURRENT INSTRUCTION NUMBER AND THE FIRST ELEMENT ADDED TOGETHER'S RESULT
PUT THE NUMBER I ONTO THE TOP OF THE PROGRAM STACK
GET THE TOP ELEMENT OF THE STACK AND OUTPUT IT FOR THE CURRENT PERSON USING THIS PROGRAM TO SEE
PUT THE NUMBER III ONTO THE TOP OF THE PROGRAM STACK
GET THE FIRST ELEMENT OF THE PROGRAM STACK AND THE SECOND ELEMENT OF THE PROGRAM STACK AND IF THE SECOND ELEMENT OF THE PROGRAM STACK IS NOT ZERO JUMP TO THE INSTRUCTION THAT IS THE CURRENT INSTRUCTION NUMBER AND THE FIRST ELEMENT ADDED TOGETHER'S RESULT
PUT THE NUMBER NULLA ONTO THE TOP OF THE PROGRAM STACK
GET THE TOP ELEMENT OF THE STACK AND OUTPUT IT FOR THE CURRENT PERSON USING THIS PROGRAM TO SEE

As saídas Ipara números romanos válidos no intervalo I-MMMCMXCIXe NULLA(0) ou informam que a entrada do usuário não é um número romano válido.

Dados expirados
fonte
12
Não consigo decidir se essa é a ferramenta certa para o trabalho ou não.
Vaelus 11/04
5
Essa é a ferramenta certa para qualquer trabalho?
omzrs 11/04
8

C # (compilador interativo do Visual C #) , 79 109 bytes

Parece um desafio Regex, tenho certeza de que uma solução mais curta pode ser encontrada ...

s=>System.Text.RegularExpressions.Regex.IsMatch(s,"^M{0,3}(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$")

Experimente online!

Innat3
fonte
Você não poderia encurtar {0,3}a {,3}?
flawr 11/04
@flawr parece não capturar nada então
Innat3 11/04
1
Desculpe, apenas coisas como {5,}trabalho, mas não {,5}.
flawr 11/04
2
Em vez disso, você pode adicioná-lo como sinalizador de compilador, portanto, é de 72 bytes e o idioma deve ser alterado para C # (Visual C # Interactive Compiler) com sinalizador/u:System.Text.RegularExpressions.Regex , como esta resposta :)
Kevin Cruijssen
3
Regex alternativo: ^M?M?M?(C[MD]|D?C?C?C?)(X[CL]|L?X?X?X?)(I[XV]|V?I?I?I?)$. Mesmo comprimento, mas parece mais estranho (qual é o objetivo, certo?)
Modalidade de Ignorância
8

Wolfram Language (Mathematica) , 35 bytes

Check[FromRomanNumeral@#<3999,1<0]&

Experimente online!

5 bytes salvos, graças a @attinat

a limitação [1,3999]unfortunateley custa 7 bytes ...
aqui está o código para qualquer número romano

Wolfram Language (Mathematica) , 28 bytes

Check[FromRomanNumeral@#,F]&

Experimente online!

o código acima funciona para qualquer número, não apenas [1,3999]

J42161217
fonte
2
@ExpiredData "A entrada é uma string não vazia que compreende apenas os caracteres IVXLCDM."
mathmandan 11/04
35 bytes . Booletambém é mais curto (em um byte) do que usado Ifdessa maneira.
attinat 11/04
8

Montagem CP-1610 ( Intellivision ),  52 ... 48  47 DECLEs 1 = 59 bytes

Vamos tentar isso em um sistema que antecede o Perl por uns bons 7 anos. :-)

Leva um ponteiro para uma seqüência de caracteres NULL-Terminated em R4 . Define o sinalizador Zero se a entrada for um número romano válido ou o limpa de outra forma.

                ROMW    10              ; use 10-bit ROM width
                ORG     $4800           ; map this program at $4800

                ;; ------------------------------------------------------------- ;;
                ;;  test code                                                    ;;
                ;; ------------------------------------------------------------- ;;
4800            EIS                     ; enable interrupts

4801            SDBD                    ; R5 = pointer into test case index
4802            MVII    #ndx,     R5
4805            MVII    #$214,    R3    ; R3 = backtab pointer
4807            MVII    #11,      R0    ; R0 = number of test cases

4809  loop      SDBD                    ; R4 = pointer to next test case
480A            MVI@    R5,       R4
480B            PSHR    R0              ; save R0, R3, R5 onto the stack
480C            PSHR    R3
480D            PSHR    R5
480E            CALL    isRoman         ; invoke our routine
4811            PULR    R5              ; restore R5 and R3
4812            PULR    R3

4813            MVII    #$1A7,    R0    ; use a white 'T' by default
4815            BEQ     disp

4817            MVII    #$137,    R0    ; or a white 'F' is the Z flag was cleared

4819  disp      MVO@    R0,       R3    ; draw it
481A            INCR    R3              ; increment the backtab pointer

481B            PULR    R0              ; restore R0
481C            DECR    R0              ; and advance to the next test case, if any
481D            BNEQ    loop

481F            DECR    R7              ; loop forever

                ;; ------------------------------------------------------------- ;;
                ;;  test cases                                                   ;;
                ;; ------------------------------------------------------------- ;;
4820  ndx       BIDECLE test0, test1, test2, test3
4828            BIDECLE test4, test5, test6, test7, test8, test9, test10

                ; truthy
4836  test0     STRING  "MCCXXXIV", 0
483F  test1     STRING  "CMLXXXVIII", 0
484A  test2     STRING  "DXIV", 0
484F  test3     STRING  "CI", 0

                ; falsy
4852  test4     STRING  "MMIXVIII", 0
485B  test5     STRING  "IVX", 0
485F  test6     STRING  "IXV", 0
4863  test7     STRING  "MMMM", 0
4868  test8     STRING  "XXXVX", 0
486E  test9     STRING  "IVI", 0
4872  test10    STRING  "VIV", 0

                ;; ------------------------------------------------------------- ;;
                ;;  routine                                                      ;;
                ;; ------------------------------------------------------------- ;;
      isRoman   PROC

4876            PSHR    R5              ; push the return address

4877            MOVR    R7,       R2    ; R2 = dummy 1st suffix
4878            MOVR    R2,       R5    ; R5 = pointer into table
4879            ADDI    #@tbl-$+1,R5

487B  @loop     MVI@    R5,       R1    ; R1 = main digit (M, C, X, I)
487C            MVI@    R5,       R3    ; R3 = prefix or 2nd suffix (-, D, L, V)

487D            MVI@    R4,       R0    ; R0 = next digit

487E            CMPR    R0,       R3    ; if this is the prefix ...
487F            BNEQ    @main

4881            COMR    R2              ; ... disable the suffixes
4882            COMR    R3              ; by setting them to invalid values
4883            MVI@    R4,       R0    ; and read R0 again

4884  @main     CMPR    R0,       R1    ; if R0 is not equal to the main digit,
4885            BNEQ    @back           ; assume that this part is over

4887            MVI@    R4,       R0    ; R0 = next digit
4888            CMPR    R0,       R1    ; if this is a 2nd occurrence
4889            BNEQ    @suffix         ; of the main digit ...

488B            CMP@    R4,       R1    ; ... it may be followed by a 3rd occurrence
488C            BNEQ    @back

488E            MOVR    R2,       R0    ; if so, force the test below to succeed

488F  @suffix   CMPR    R0,       R2    ; otherwise, it may be either the 1st suffix
4890            BEQ     @next
4892            CMPR    R0,       R3    ; or the 2nd suffix (these tests always fail
4893            BEQ     @next           ; if the suffixes were disabled above)

4895  @back     DECR    R4              ; the last digit either belongs to the next
                                        ; iteration or is invalid

4896  @next     MOVR    R1,       R2    ; use the current main digit
                                        ; as the next 1st suffix

4897            SUBI    #'I',     R1    ; was it the last iteration? ...
4899            BNEQ    @loop

489B            CMP@    R4,       R1    ; ... yes: make sure that we've also reached
                                        ; the end of the input

489C            PULR    R7              ; return

489D  @tbl      DECLE   'M', '-'        ; table format: main digit, 2nd suffix
489F            DECLE   'C', 'D'
48A1            DECLE   'X', 'L'
48A3            DECLE   'I', 'V'

                ENDP

Quão?

A expressão regular pode ser reescrita como 4 grupos com a mesma estrutura, desde que # qualquer caractere inválido garantido não esteja presente na sequência de entrada.

                 +-------+---> main digit
                 |       |
(M[##]|#?M{0,3})(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})
                   ||  |
                   |+--+-----> prefix or second suffix
                   |
                   +---------> first suffix

NN-1(main_digit,second_suffix)

Nossa rotina tenta analisar o caractere da string de entrada por caractere de acordo com esses padrões e, eventualmente, verifica se o fim da string é atingido.

Resultado

resultado

captura de tela do jzIntv


1. Um código de operação CP-1610 é codificado com um valor de 10 bits, conhecido como 'DECLE'. Essa rotina tem 47 DECLEs, começando em US $ 4876 e terminando em US $ 48A4 (incluído).

Arnauld
fonte
esse não seria um dos poucos lugares em que bytes fracionários são válidos
somente ASCII
@ Somente ASCII eu pensava assim, mas não sei ao certo. Veja os comentários desta resposta para obter algumas dicas sobre isso.
Arnauld
@ Somente ASCII Além disso, acabei de encontrar este post na meta que tende a confirmar que provavelmente é melhor arredondar para bytes inteiros.
Arnauld
ah, então são apenas 10 bits quando está na RAM?
somente ASCII
O programa nunca é armazenado na RAM, apenas na ROM. Portanto, depende dos chips de memória usados ​​no cartucho. A CPU foi projetada para acessar ROM de 10 ou 16 bits. A diretiva "ROMW 10" força o compilador a gerar código no formato de 10 bits.
Arnauld
7

Java 8, 70 bytes

s->s.matches("M{0,3}(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})")

Porto da resposta em C # da @ Innat3 , certifique-se de vomitá-lo!

Experimente online.

Explicação:

s->                // Method with String parameter and boolean return-type
  s.matches("...") //  Check if the string matches the regex fully
                   //  (which implicitly adds a leading "^" and trailing "$")

M{0,3}             // No, 1, 2, or 3 adjacent "M"
(     |        )   // Followed by either:
 C[MD]             //  A "C" with an "M" or "D" after it
      |            // or:
       D?          //  An optional "D"
         C{0,3}    //  Followed by no, 1, 2, or 3 adjacent "C"
(     |        )   // Followed by either:
 X[CL]             //  An "X" with a "C" or "L" after it
      |            // or:
       L?          //  An optional "L"
         X{0,3}    //  Followed by no, 1, 2, or 3 adjacent "X"
(     |        )   // Followed by either:
 I[XV]             //  An "I" with an "X" or "V" after it
      |            // or:
       V?          //  An optional "V"
         I{0,3}    //  Followed by no, 1, 2, or 3 adjacent "I"
Kevin Cruijssen
fonte
5

R , 74 71 56 bytes

Obrigado a @RobinRyder, @Giuseppe e @MickyT por suas sugestões de como usar o grep efetivamente com os R's incorporados as.roman.

sub("^M(.+)","\\1",scan(,""))%in%paste(as.roman(1:2999))

Experimente online!

CT Hall
fonte
as.romande qualquer maneira, não funcionará, pois só funciona 3899por algum motivo.
Giuseppe
Eu realmente deveria ler melhor a documentação, provavelmente porque 4000 não tem uma representação definida em romano, então como se faz 3900. Isso é semelhante ao 390 e agora encontrei um problema no meu grep, onde eu teria que ancorar o padrão.
CT Hall
@ Giuseppe, endereçado, usando o mesmo regex que as outras respostas.
CT Hall
2
66 bytes usando as.roman: primeiro retire a inicial, Mse houver, e verifique se o resultado está as.roman(1:2999). Isso requer tratamento especial do caso em que a entrada está M.
Robin Ryder
1
Minha última pergunta é: quem diabos decidiu que romansseria uma coisa útil para colocar em R ??? Foi adicionado em 2.5.0 (abril de 2007) ...
Giuseppe
2

Geléia ,  48 47 46  44 bytes

-1 graças a Nick Kennedy

5Żo7;“ÆæC‘ð“IVXLCDM”ṃ@3Ƥm2”MẋⱮ3¤ṭŻ€ṚŒpF€ḟ€0ċ

IVXLCDM1139990

Experimente online! Ou veja a suíte de testes .

Quão?

5Żo7;“ÆæC‘ð“IVXLCDM”ṃ@3Ƥm2”MẋⱮ3¤ṭŻ€ṚŒpF€ḟ€0ċ  - Main Link: list of characters S

5Żo7;“ÆæC‘  - chain 1: f(S) -> X
5Ż          - zero range of five = [0,1,2,3,4,5]
  o7        - OR seven             [7,1,2,3,4,5]
     “ÆæC‘  - list of code-page indices        [13,22,67]
    ;       - concatenate          [7,1,2,3,4,5,13,22,67]

          ð - start a new dyadic chain...

“IVXLCDM”ṃ@3Ƥm2”MẋⱮ3¤ṭŻ€ṚŒpF€ḟ€0ċ - chain 2: f(X,S) -> isValid
“IVXLCDM”                         - list of characters, IVXLCDM
           3Ƥ                     - for infixes of length three:
                                  - (i.e. IVX VXL XLC LCD CDM)
         ṃ@                       -   base decompression with swapped arguments
                                  -   (i.e. use characters as base-3 digits of X's values)
                                  -   (e.g. IVX -> VI I V IX II IV III VII VIII)
             m2                   - modulo two slice (results for IVX XLC and CDM only)
                    ¤             - nilad followed by link(s) as a nilad:
               ”M                 -   character 'M'
                  Ɱ3              -   map across [1,2,3] with:
                 ẋ                -     repeat -> M MM MMM
                     ṭ            - tack
                      Ż€          - prepend a zero to each
                        Ṛ         - reverse
                                  -   -- now we have the table: 
                                  -    0 M MM MMM
                                  -    0 DC C D CM CC CD CCC DCC DCCC
                                  -    0 LX X L XC XX XL XXX LXX LXXX
                                  -    0 VI I V IX II IV III VII VIII
                         Œp       - Cartesian product   [[0,0,0,0],...,["M","CM",0,"IV"],...]
                           F€     - flatten €ach  [[0,0,0,0],...,['M','C','M',0,'I','V'],...]
                             ḟ€0  - filter out the zeros from €ach       ["",...,"MCMIV",...]
                                ċ - count occurrences of S
Jonathan Allan
fonte
Parece haver um espaço redundante na primeira linha. Outro byte. Outro byte pode ser salvo usando uma primeira linha mais simples. Experimente online!
Nick Kennedy
Obrigado, eu salvei mais um.
Jonathan Allan
1

Perl 5 ( -p), 57 bytes

$_=/^M*(C[MD]|D?C*)(X[CL]|L?X*)(I[XV]|V?I*)$/&!/(.)\1{3}/

TIO

  • usa quase a mesma expressão regular, exceto o {0,3}quantificador foi alterado por*
  • &!/(.)\1{3}/ para garantir que o mesmo caractere não ocorra quatro vezes seguidas.
  • não pode ser golfed com -/(.)\1{3}/porque daria -1para IIIIVI, por exemplo,
Nahuel Fouilleul
fonte
1

Python 2 , 81 bytes

import re
re.compile('M{,3}(D?C{,3}|C[DM])(L?X{,3}|X[LC])(V?I{,3}|I[VX])$').match

Experimente online!

Vejamos a última parte da regex, que corresponde aos números romanos até 9 (incluindo a string vazia)

V?I{,3}|I[VX]

Isso tem duas alternativas separadas por |:

  • V?I{,3}: Um opcional Vseguido por até 3 I's. Isto corresponde a seqüência vazia I, II, III, V, VI, VII, VIII.
  • I[VX]: An Iseguido por um Vou X. Isso corresponde IVe IX.

O mesmo ocorre com a X,L,Ccorrespondência das dezenas, com C,D,Mas centenas e, finalmente, ^M{,3}permite até 3 M'(milhares) no início.

Tentei gerar o modelo para cada trio de personagens em vez de escrevê-lo três vezes, mas isso foi muito mais longo.

xnor
fonte
Não há necessidade da ^âncora no início; matchjá implica que ele corresponde no início da string.
ShadowRanger
@ShadowRanger Obrigado, eu removi o ^.
xnor 12/04
Embora eu ache que você tenha estragado a contagem na edição; deve ser 83, não 81.
ShadowRanger
@ShadowRanger A contagem é 81 porque f=não está incluída no código, pois funções anônimas são permitidas. É apenas para o TIO.
xnor 12/04
1
Ah, faz sentido. Irritante, não há como organizá-lo para ocultar isso no cabeçalho ou no rodapé, mas sim, lambdas não atribuídos são legais, portanto métodos vinculados não atribuídos de regex compilado também devem ser bons.
ShadowRanger
1

Retina , 56 51 bytes

(.)\1{3}
0
^M*(C[MD]|D?C*)(X[CL]|L?X*)(I[XV]|V?I*)$

Porto da resposta Perl 5 de @NahuelFouilleul , por isso não deixe de votar nele!

Experimente online ou verifique todos os casos de teste .

Explicação:

(.)\1{3}        # If four adjacent characters can be found which are the same
0               # Replace it with a 0

^...$           # Then check if the string matches the following fully:
 M*             #  No or any amount of adjacent "M"
 (     |    )   #  Followed by either:
  C[MD]         #   A "C" with an "M" or "D" after it
       |        #  or:
        D?      #   An optional "D"
          C*    #   Followed by no or any amount of adjacent "C"
 (     |    )   #  Followed by either:
  X[CL]         #   An "X" with a "C" or "L" after it
       |        #  or:
        L?      #   An optional "L"
          X*    #   Followed by no or any amount of adjacent "X"
 (     |    )   #  Followed by either:
  I[XV]         #   An "I" with an "X" or "V" after it
       |        #  or:
        V?      #   An optional "V"
          I*    #   Followed by no or any amount of adjacent "I"
Kevin Cruijssen
fonte
1

05AB1E , 61 9 8 bytes

ŽF¯L.XIå

Enorme -52 bytesgraças a @Adnan , porque aparentemente o número romano de 05AB1E embutido não foi documentado, haha ​​.. xD

Experimente online ou verifique todos os casos de teste .

Explicação:

ŽF¯       # Push comressed integer 3999
   L      # Create a list in the range [1,3999]
    .X    # Convert each integer in this list to a roman number string
      Iå  # Check if the input is in this list
          # (and output the result implicitly)

Veja esta minha dica 05AB1E (seção Como comprimir números inteiros grandes? ) Para entender por que ŽF¯é 3999.


Resposta original de 61 bytes:

•1∞Γ'иÛnuÞ\₂…•Ž8вв€SÐ)v.•6#&‘нδ•u3ôNèyè}'M3L×)Rεõš}`3Fâ}€˜JIå

Experimente online ou verifique todos os casos de teste .

Explicação:

1∞Γ'иÛnuÞ\₂…•             '# Push compressed integer 397940501547566186191992778
              Ž8в           # Push compressed integer 2112
                 в          # Convert the integer to Base-2112 as list:
                            #  [1,11,111,12,2,21,211,2111,10]
S                          # Convert each number to a list of digits
  Ð                         # Triplicate this list
   )                        # And wrap it into a list of lists (of lists)
    v                       # Loop `y` over each these three lists:
     .•6#&‘нδ•              #  Push compressed string "xivcxlmcd"
              u             #  Uppercased
               3ô           #  And split into parts of size 3: ["XIV","CXL","MCD"]
     Nè                     #  Use the loop index to get the current part
       yè                   #  And index the list of lists of digits into this string
    }'M                    '# After the loop: push "M"
       3L                   # Push list [1,2,3]
         ×                  # Repeat the "M" that many times: ["M","MM","MMM"]
          )                 # Wrap all lists on the stack into a list:
                            # [[["I"],["I","I"],["I","I","I"],["I","V"],["V"],["V","I"],["V","I","I"],["V","I","I","I"],["I","X"]],[["X"],["X","X"],["X","X","X"],["X","L"],["L"],["L","X"],["L","X","X"],["L","X","X","X"],["X","C"]],[["C"],["C","C"],["C","C","C"],["C","D"],["D"],["D","C"],["D","C","C"],["D","C","C","C"],["C","M"]],["M","MM","MMM"]]
           R                # Reverse this list
            εõš}            # Prepend an empty string "" before each inner list
                `           # Push the four lists onto the stack
                 3F         # Loop 3 times:
                   â        #  Take the cartesian product of the two top lists
                    }€˜     # After the loop: flatten each inner list
                       J    # Join each inner list together to a single string
                        Iå  # And check if the input is in this list
                            # (after which the result is output implicitly)

Veja este 05AB1E ponta do meu (seções Como cordas compressa não faz parte do dicionário? , Como comprimir grandes inteiros? E Como listas inteiras compressa? ) Para entender o porquê:

  • •1∞Γ'иÛnuÞ\₂…• é 397940501547566186191992778
  • Ž8в é 2112
  • •1∞Γ'иÛnuÞ\₂…•Ž8вв é [1,11,111,12,2,21,211,2111,10]
  • .•6#&‘нδ• é "xivcxlmcd"
Kevin Cruijssen
fonte
1
Não sei por que .Xnão está documentado, mas acho que isso deve funcionar:3999L.XQO
Adnan
@ Adnan Haha, -52 bytes ali. Esqueci completamente que você realmente nos contou sobre a adição de um número romano embutido. Pedirá ao @ Mr.Xcoder no chat para adicioná-lo aos documentos. Faltam outros comandos? ;) PS: salvou outro byte compactando 3999. :)
Kevin Cruijssen
0

perl -MRegexp :: Common -pe, 34 bytes

$_=/^$RE{num}{roman}$/&!/(.)\1{3}/

o &!/(.)\1{3}/ parte é necessária, porque Regexp::Commonpermite quatro (mas não cinco) dos mesmos caracteres seguidos. Dessa forma, ele corresponde aos números romanos usados ​​nas faces do relógio, onde IIIIé frequentemente usado para 4.


fonte
0

Python 3 , 116 113 109 107 105 106 bytes

import re
lambda n:re.match(r'(M{,3}(C(M|CC?|D)?|DC{,3}))(X(C|XX?|L)?|(LX{,3}))?(I(X|II?|V)?|VI{,3})?$',n)

Experimente online!

-1 byte graças a ShadowRanger

Noodle9
fonte
2
Como mencionei na resposta Py2, a liderança ^ é desnecessária, pois matchapenas corresponde ao início de uma string.
ShadowRanger
O @ShadowRanger adicionou âncoras durante a depuração e depois não tentou novamente sem elas. Vou lembrar disso agora - obrigado! :)
Noodle9
Bem, só para esclarecer, o rastreamento $é necessário ( fullmatchimplica apenas âncoras nas duas extremidades e, obviamente, isso custaria mais do que a $).
ShadowRanger
@ShadowRanger Ah! Isso explica porque eu precisava de âncoras! Não sabia que só precisava ancorar o fim. Obrigado novamente.
Noodle9
0

Ruby , ( -n) 56 bytes

p~/^M{,3}(D?C{,3}|CM|CD)(L?X{,3}|XC|XL)(V?I{,3}|IV|IX)$/

Experimente online!

Saídas 0 (verdade) ou nulo (falsidade).

Restabelecer Monica - notmaynard
fonte