Faire correspondre les chiffres romains

19

Défi

Étant donné une chaîne d'entrée, renvoyez une valeur véridique si elle représente un chiffre romain correct entre 1 (= I) et 3999 (= MMMCMXCIX), et une valeur falsey sinon.

Détails

  • L'entrée est une chaîne non vide qui ne comprend que les caractères IVXLCDM.
  • Les chiffres romains (que nous utilisons ici dans ce défi) sont définis comme suit:

Nous utilisons uniquement les symboles suivants:

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

Pour définir quelles chaînes sont réellement des chiffres romains valides, il est probablement plus facile de fournir la règle de conversation: pour écrire un nombre décimal a3 a2 a1 a0(où chacun aireprésente un chiffre. Donc, par exemple, pour représenter 792nous avons a3=0, a2=7, a1=9, a0=2.) Comme un chiffre romain, nous le décomposons dans la puissance de dizaines. Les différents pouvoirs de dix peuvent s'écrire comme suit:

      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

En commençant à gauche par le chiffre le plus significatif de la, nous pouvons convertir le nombre que chaque chiffre représente séparément et les concaténer. Ainsi, pour l'exemple ci-dessus, cela ressemblerait à ceci:

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

Par conséquent, le chiffre romain de 792est DCCXCII. Voici une liste complète de tous les chiffres romains pertinents pour ce défi: OEIS a006968.txt

Exemples

Truthy

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

Falsey

MMIXVIII
IVX
IXV
MMMM
XXXVX
IVI
VIV
flawr
la source
Sous-ensemble de ce défi de conversion .
Shaggy
Je ne pense toujours pas que cela soit considéré comme un "sous-ensemble" car l'ensemble des entrées invalides est plus grand. Ce défi se réfère ici uniquement aux nombres définis par "bien" qui sont utilisés dans OEIS A006968
flawr
2
Pourquoi est MMMMinvalide? Y a-t-il une lettre pour 5000 qui devrait être utilisée à la place pour M <letter>?
Skyler
Consultez les spécifications, il n'y a pas une telle lettre. Les seuls symboles utilisés sont I,V,X,L,C,D,M.
flawr

Réponses:

17

Verbose , 1362 octets

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

Les sorties Ipour les chiffres romains valides dans la plage I-MMMCMXCIXet NULLA(0) ou informe que l'entrée utilisateur n'est pas un chiffre romain valide sinon.

Données expirées
la source
12
Je ne peux pas décider si c'est le bon outil pour le travail ou non.
Vaelus
5
Est-ce le bon outil pour n'importe quel travail?
omzrs
8

C # (Visual C # Interactive Compiler) , 79 109 octets

Cela semble être un défi Regex, je suis sûr qu'une solution plus courte peut être trouvée ...

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})$")

Essayez-le en ligne!

Innat3
la source
Ne pourriez - vous réduire {0,3}à {,3}?
flawr
@flawr ne semble rien capturer alors
Innat3
1
Ah désolé, seulement des choses comme le {5,}travail, mais pas {,5}.
flawr
2
Vous pouvez l'ajouter en tant qu'indicateur de compilateur à la place, c'est donc 72 octets et le langage doit être changé en C # (Visual C # Interactive Compiler) avec indicateur/u:System.Text.RegularExpressions.Regex , comme cette réponse :)
Kevin Cruijssen
3
Autre regex: ^M?M?M?(C[MD]|D?C?C?C?)(X[CL]|L?X?X?X?)(I[XV]|V?I?I?I?)$. Même longueur, mais semble plus étrange (quel est le but, non?)
Incarnation de l'ignorance
8

Wolfram Language (Mathematica) , 35 octets

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

Essayez-le en ligne!

5 octets enregistrés grâce à @attinat

la limitation [1,3999]malheureuse coûte 7 octets ...
voici le code pour tout nombre romain

Wolfram Language (Mathematica) , 28 octets

Check[FromRomanNumeral@#,F]&

Essayez-le en ligne!

le code ci-dessus fonctionne pour n'importe quel nombre, pas seulement [1,3999]

J42161217
la source
2
@ExpiredData "L'entrée est une chaîne non vide qui ne comprend que les caractères IVXLCDM."
mathmandan
35 octets . Booleest également plus court (d'un octet) que l'utilisation Ifde cette manière.
attinat
8

Ensemble CP-1610 ( Intellivision ),  52 ... 48  47 DECLEs 1 = 59 octets

Essayons ceci sur un système qui précède Perl de 7 bonnes années. :-)

Prend un pointeur sur une chaîne terminée par null dans R4 . Définit l' indicateur Zero si l'entrée est un chiffre romain valide, ou l'efface autrement.

                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

Comment?

L'expression régulière peut être réécrite en 4 groupes avec la même structure, à condition que #tout caractère invalide garanti ne soit pas présent dans la chaîne d'entrée.

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

NN1(main_digit,second_suffix)

Notre routine tente d'analyser la chaîne d'entrée caractère par caractère en fonction de ces modèles et vérifie éventuellement si la fin de la chaîne est atteinte.

Production

production

capture d'écran de jzIntv


1. Un opcode CP-1610 est codé avec une valeur de 10 bits, connue sous le nom de «DECLE». Cette routine dure 47 DECLEs, commençant à 4876 $ et se terminant à 48A4 $ (inclus).

Arnauld
la source
cela ne serait-il pas l'un des rares endroits où les octets fractionnaires sont valides
ASCII uniquement le
@ ASCII uniquement, je le pensais, mais je n'en suis pas sûr. Voir les commentaires de cette réponse pour un aperçu à ce sujet.
Arnauld
@ ASCII-only Aussi, je viens de trouver ce post en méta qui tend à confirmer qu'il est probablement préférable d'arrondir à des octets entiers.
Arnauld
ah, donc c'est seulement 10 bits quand c'est en RAM?
uniquement en ASCII
Le programme n'est jamais stocké en RAM, seulement en ROM. Cela dépend donc des puces mémoire utilisées dans la cartouche. Le processeur est conçu pour accéder à la ROM 10 bits ou 16 bits. La directive "ROMW 10" force le compilateur à générer du code au format 10 bits.
Arnauld
7

Java 8, 70 octets

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

Port de la réponse C # @ Innat3 , alors assurez-vous de lui donner un vote positif!

Essayez-le en ligne.

Explication:

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
la source
5

R , 74 71 56 octets

Merci à @RobinRyder, @Giuseppe et @MickyT pour leurs suggestions sur l'utilisation efficace de grep avec les R intégrés as.roman.

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

Essayez-le en ligne!

CT Hall
la source
as.romanne fonctionnera pas de toute façon, car cela ne fonctionne que 3899pour une raison quelconque.
Giuseppe
Je devrais vraiment mieux lire la documentation, probablement parce que 4000 n'a pas de représentation précise en romain, alors comment faire 3900. C'est similaire à 390 et maintenant je viens de trouver un problème avec mon grep où je devrais ancrer le motif.
CT Hall
@Giuseppe, adressé, utilisant le même regex que les autres réponses.
CT Hall
2
66 octets en utilisant as.roman: supprimez d'abord l'initiale Ms'il y en a un, puis vérifiez si le résultat est entré as.roman(1:2999). Cela nécessite une gestion spéciale du cas où l'entrée est M.
Robin Ryder
1
Ma dernière question est, qui diable a décidé que ce romansserait une chose utile à mettre dans R ??? Il a été ajouté en 2.5.0 (avril 2007) ...
Giuseppe
2

Gelée ,  48 47 46  44 octets

-1 merci à Nick Kennedy

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

IVXLCDM1139990

Essayez-le en ligne! Ou consultez la suite de tests .

Comment?

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
la source
Il semble y avoir un espace redondant sur la première ligne. Un autre octet. Un autre octet peut être enregistré en utilisant une première ligne plus simple. Essayez-le en ligne!
Nick Kennedy
Merci, j'en ai sauvé un de plus.
Jonathan Allan
1

Perl 5 ( -p), 57 octets

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

TIO

  • utilise presque la même expression régulière sauf le {0,3}quantificateur a été modifié par*
  • &!/(.)\1{3}/ pour garantir que le même personnage ne puisse pas apparaître 4 fois de suite.
  • ne peut pas être avec golfed -/(.)\1{3}/car donnerait -1pour IIIIVIpar exemple
Nahuel Fouilleul
la source
1

Python 2 , 81 octets

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

Essayez-le en ligne!

Regardons la dernière partie de l'expression régulière, qui correspond aux chiffres romains jusqu'à 9 (y compris la chaîne vide)

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

Cela a deux alternatives séparées par |:

  • V?I{,3}: Une option Vsuivie de 3 au maximum I. Cela correspond à la chaîne vide I, II, III, V, VI, VII, VIII.
  • I[VX]: Un Isuivi d'un Vou X. Cela correspond IVet IX.

Les mêmes choses avec l' X,L,Cappariement des dizaines, avec l' C,D,Mappariement des centaines, et enfin ^M{,3}permet jusqu'à 3M (milliers) au début.

J'ai essayé de générer le modèle pour chaque trio de personnages plutôt que de l'écrire 3 fois, mais c'était beaucoup plus long.

xnor
la source
Pas besoin de l' ^ancre au début; matchimplique déjà qu'il correspond au début de la chaîne.
ShadowRanger
@ShadowRanger Merci, j'ai supprimé le ^.
xnor
Bien que je pense que vous avez foiré le compte lors du montage; devrait être 83, pas 81.
ShadowRanger
@ShadowRanger Le nombre est de 81 car le f=n'est pas inclus dans le code car les fonctions anonynomeuses sont autorisées. C'est juste pour TIO.
xnor
1
Ah, c'est logique. Ennuyeux, il n'y a aucun moyen de l'organiser pour masquer cela dans l'en-tête ou le pied de page, mais oui, non attribuélambda s sont légaux, donc les méthodes liées non affectées de l'expression régulière compilée devraient également être bonnes.
ShadowRanger
1

Rétine , 56 51 octets

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

Port de la réponse Perl 5 de @NahuelFouilleul , alors assurez-vous de voter pour lui!

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

Explication:

(.)\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
la source
1

05AB1E , 61 9 8 octets

ŽF¯L.XIå

Énorme -52 octets grâce à @Adnan , car apparemment le code romain de 05AB1E n'a pas été documenté, haha ​​.. xD

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

Explication:

Ž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)

Voir cette astuce 05AB1E (section Comment compresser les grands nombres entiers? ) Pour comprendre pourquoiŽF¯ est 3999.


Réponse originale de 61 octets:

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

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

Explication:

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)

Voir cette astuce 05AB1E de mes (sections Comment les chaînes Compresser ne fait pas partie du dictionnaire? , Comment compresser les grands entiers? , Et comment les listes entières Compresser? ) Pour comprendre pourquoi:

  • •1∞Γ'иÛnuÞ\₂…• est 397940501547566186191992778
  • Ž8в est 2112
  • •1∞Γ'иÛnuÞ\₂…•Ž8вв est [1,11,111,12,2,21,211,2111,10]
  • .•6#&‘нδ• est "xivcxlmcd"
Kevin Cruijssen
la source
1
Je ne sais pas pourquoi cela .Xn'est pas documenté, mais je pense que cela devrait fonctionner:3999L.XQO
Adnan
@Adnan Haha, -52 octets juste là. Vous avez complètement oublié que vous nous avez en effet dit d'ajouter un numéro romain intégré. Va demander à @ Mr.Xcoder dans le chat de l'ajouter aux documents. Y a-t-il d'autres commandes manquantes? ;) PS: enregistré un autre octet en compressant 3999. :)
Kevin Cruijssen
0

perl -MRegexp :: Common -pe, 34 octets

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

La &!/(.)\1{3}/partie est nécessaire, car Regexp::Commonpermet quatre (mais pas cinq) des mêmes caractères d'affilée. De cette façon, il correspond aux nombres romains utilisés sur les cadrans d'horloge, où il IIIIest souvent utilisé pour 4.


la source
0

Python 3 , 116 113 109 107 105 106 octets

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)

Essayez-le en ligne!

-1 octet grâce à ShadowRanger

Nouilles9
la source
2
Comme je l'ai mentionné dans la réponse Py2, le début ^ n'est pas nécessaire car il matchne correspond déjà qu'au début d'une chaîne.
ShadowRanger
@ShadowRanger a ajouté des ancres lors du débogage, puis n'a pas réessayé sans elles. Je m'en souviendrai maintenant - merci! :)
Noodle9
Eh bien, juste pour être clair, le suivi $est nécessaire ( fullmatchimplique seulement des ancres aux deux extrémités, et cela coûterait évidemment plus qu'un $).
ShadowRanger
@ShadowRanger Ah! Cela explique pourquoi j'avais besoin d'ancres! Je ne savais pas que j'avais seulement besoin d'ancrer la fin. Merci encore.
Noodle9
0

Ruby , ( -n) 56 octets

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

Essayez-le en ligne!

Sorties 0 (vrai) ou nul (faux).

Réintégrer Monica - notmaynard
la source