Abbina numeri romani


19

Sfida

Data una stringa di input, restituisce un valore di verità se rappresenta un numero romano corretto compreso tra 1 (= I) e 3999 (= MMMCMXCIX) e un valore di falso in caso contrario.

Dettagli

  • L'input è una stringa non vuota che comprende solo i caratteri IVXLCDM.
  • I numeri romani (che usiamo qui in questa sfida) sono definiti come segue:

Utilizziamo solo i seguenti simboli:

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

Per definire quali stringhe sono in realtà numeri romani validi, è probabilmente più semplice fornire la regola di conversazione: scrivere un numero decimale a3 a2 a1 a0(dove ognuno airappresenta una cifra. Quindi, per esempio, per rappresentare 792abbiamo a3=0, a2=7, a1=9, a0=2). Come un numero romano, lo scomponiamo nel potere delle decine. I diversi poteri di dieci possono essere scritti come segue:

      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

A partire dalla parte sinistra con la cifra più significativa di, possiamo convertire il numero che ogni cifra rappresenta separatamente e concatenarli. Quindi, per l'esempio dall'alto, sembrerebbe così:

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

Pertanto il numero romano per 792è DCCXCII. Ecco un elenco completo di tutti i numeri romani rilevanti per questa sfida: OEIS a006968.txt

Esempi

Truthy

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

Falsey

MMIXVIII
IVX
IXV
MMMM
XXXVX
IVI
VIV


Continuo a non pensare che questo si qualifichi come un "sottoinsieme" poiché l'insieme di input non validi è più grande. Questa sfida qui si riferisce solo ai numeri "ben" definiti che sono utilizzati in OEIS A006968
flawr

2
Perché MMMMnon è valido? Esiste una lettera per 5000 che dovrebbe essere usata invece per M <letter>?
Skyler,

Dai un'occhiata alle specifiche, non esiste una lettera del genere. Gli unici simboli utilizzati sono I,V,X,L,C,D,M.
flawr

Risposte:


17

Verbose , 1362 byte

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

Le uscite Iper numeri romani validi nell'intervallo I-MMMCMXCIXe NULLA(0) o informa che l'input dell'utente non è un numero romano valido altrimenti.


12
Non riesco a decidere se questo è lo strumento giusto per il lavoro o meno.
Vaelus,

5
È questo lo strumento giusto per qualsiasi lavoro?
om

8

C # (compilatore interattivo Visual C #) , 79 109 byte

Sembra una sfida Regex, sono sicuro che si possa trovare una soluzione più breve ...

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

Provalo online!


Non potreste accorciare {0,3}a {,3}?
flawr

@flawr non sembra catturare nulla allora
Innat3

1
Ah scusa, solo cose come il {5,}lavoro, ma non {,5}.
flawr

2
Puoi invece aggiungerlo come flag del compilatore, quindi è di 72 byte e la lingua dovrebbe essere cambiata in C # (compilatore interattivo Visual C #) con flag/u:System.Text.RegularExpressions.Regex , come questa risposta :)
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?)$. Stessa lunghezza, ma sembra più strano (qual è l'obiettivo, giusto?)
Incarnazione dell'ignoranza l'

8

Wolfram Language (Mathematica) , 35 byte

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

Provalo online!

5 byte salvati, grazie a @attinat

la limitazione [1,3999]sfortunatamente costa 7 byte ...
ecco il codice per qualsiasi numero romano

Wolfram Language (Mathematica) , 28 byte

Check[FromRomanNumeral@#,F]&

Provalo online!

il codice sopra funziona per qualsiasi numero, non solo [1.999]


2
@ExpiredData "L'input è una stringa non vuota che comprende solo i caratteri IVXLCDM."
Mathmandan,

35 byte . Booleè anche più breve (di un byte) rispetto all'utilizzo Ifin quel modo.
attinat

8

CP-1610 assembly ( Intellivision ),  52 ... 48  47 DECLE 1 = 59 byte

Proviamo questo su un sistema che precede Perl di ben 7 anni. :-)

Porta un puntatore a una stringa con terminazione null in R4 . Imposta il flag Zero se l'ingresso è un numero romano valido o lo cancella in altro modo.

                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

Come?

L'espressione regolare può essere riscritta in 4 gruppi con la stessa struttura, a condizione che #sia garantito che qualsiasi carattere non valido non sia presente nella stringa di input.

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

La nostra routine tenta di analizzare la stringa di input carattere per carattere in base a questi schemi e alla fine controlla se viene raggiunta la fine della stringa.

Produzione

produzione

screenshot di jzIntv


1. Un codice operativo CP-1610 è codificato con un valore di 10 bit, noto come "DECLE". Questa routine è lunga 47 DECLE, a partire da $ 4876 e termina a $ 48A4 (incluso).


non sarebbe questo uno dei pochi posti in cui i byte frazionari sono validi
solo ASCII il

@ ASCII-solo lo pensavo, ma non lo so per certo. Vedi i commenti di questa risposta per alcuni approfondimenti al riguardo.
Arnauld,

@ Solo ASCII Inoltre, ho appena trovato questo post in meta che tende a confermare che probabilmente è meglio arrotondare a interi byte.
Arnauld,

ah, quindi sono solo 10 bit quando è nella RAM?
ASCII il

Il programma non è mai memorizzato nella RAM, solo nella ROM. Quindi dipende dai chip di memoria utilizzati nella cartuccia. La CPU è progettata per accedere a ROM a 10 o 16 bit. La direttiva "ROMW 10" impone al compilatore di generare codice in formato a 10 bit.
Arnauld,

7

Java 8, 70 byte

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

Porta della risposta C # di @ Innat3 , quindi assicurati di votarlo!

Provalo online.

Spiegazione:

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"

5

R , 74 71 56 byte

Grazie a @RobinRyder, @Giuseppe e @MickyT per i loro suggerimenti su come usare efficacemente grep con R integrato as.roman.

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

Provalo online!


as.romannon funzionerà comunque, dal momento che funziona solo 3899per qualche motivo.
Giuseppe,

Dovrei davvero leggere meglio la documentazione, probabilmente perché 4000 non ha una rappresentazione definita in romano, quindi come si fa a fare 3900. Questo è simile a 390 e ora ho appena trovato un problema con il mio grep dove dovrei ancorare il modello.
CT Hall

@Giuseppe, indirizzato, usando lo stesso regex delle altre risposte.
CT Hall

2
66 byte usando as.roman: per prima cosa rimuovi l'iniziale Mse ce n'è uno, quindi controlla se il risultato è presente as.roman(1:2999). Ciò richiede una gestione speciale del caso in cui si trova l'input M.
Robin Ryder,

1
La mia ultima domanda è: chi diavolo ha deciso che romanssarebbe stata una cosa utile mettere in R ??? È stato aggiunto in 2.5.0 (aprile 2007) ...
Giuseppe,


2

Gelatina ,  48 47 46  44 byte

-1 grazie a Nick Kennedy

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

IVXLCDM1139990

Provalo online! Oppure vedi la suite di test .

Come?

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

Sembra esserci uno spazio ridondante sulla prima riga. Un altro byte. Un altro byte può essere salvato utilizzando una prima riga più semplice. Provalo online!
Nick Kennedy,

Grazie, ne ho salvato un altro.
Jonathan Allan,

1

Perl 5 ( -p), 57 byte

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

TIO

  • usa quasi la stessa espressione regolare, tranne per il fatto che il {0,3}quantificatore è stato modificato*
  • &!/(.)\1{3}/ per garantire che lo stesso personaggio non possa apparire 4 volte di seguito.
  • non può essere giocato a golf con -/(.)\1{3}/quanto darebbe -1per IIIIVIesempio

1

Python 2 , 81 byte

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

Provalo online!

Diamo un'occhiata all'ultima parte della regex, che corrisponde ai numeri romani fino a 9 (compresa la stringa vuota)

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

Questo ha due alternative separate da | :

  • V?I{,3}: Un opzionale Vseguito da un massimo di 3 Isecondi. Questa la stringa vuota I, II, III, V, VI,VII , VIII.
  • I[VX]: Un Iseguito da un Vo X. Questo corrispondeIV e IX.

Le stesse cose con l' X,L,Cabbinamento delle decine, conC,D,M corrispondenze delle centinaia e infine ^M{,3}consente fino a 3 M(migliaia) all'inizio.

Ho provato a generare il modello per ogni trio di personaggi anziché scriverlo 3 volte, ma è stato molto più lungo.


Non è necessario per l' ^ancoraggio all'inizio; matchimplica già che corrisponde all'inizio della stringa.
ShadowRanger

@ShadowRanger Grazie, ho rimosso il ^.
xnor

Anche se penso che tu abbia incasinato il conteggio nella modifica; dovrebbe essere 83, non 81.
ShadowRanger

@ShadowRanger Il conteggio è 81 perché f=non è incluso nel codice poiché sono consentite funzioni anonime. È solo per TIO.
xnor

1
Ah, ha senso. Non c'è modo fastidioso di organizzarlo per nasconderlo nell'intestazione o nel piè di pagina, ma sì, i messaggi non assegnati lambdasono legali, quindi anche i metodi associati non assegnati di regex compilati dovrebbero essere buoni.
ShadowRanger

1

Retina , 56 51 byte

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

La risposta Perl 5 di Port of @NahuelFouilleul , quindi assicurati di votarlo!

Provalo online o verifica tutti i casi di test .

Spiegazione:

(.)\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"

1

05AB1E , 61 9 8 byte

ŽF¯L.XIå

Enorme -52 bytegrazie a @Adnan , perché apparentemente il numero romano di 05AB1E incorporato non è stato documentato, haha ​​.. xD

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questo 05AB1E punta del mio (sezione Come comprimere grandi numeri interi? ) Per capire il motivo per cui ŽF¯è3999 .


Risposta originale a 61 byte:

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

Provalo online o verifica tutti i casi di test .

Spiegazione:

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)

Vedere questo suggerimento 05AB1E mio (sezioni Come stringhe comprimere non fa parte del dizionario? , Come comprimere grandi numeri interi? , E come liste di interi comprimere? ) Per capire perché:

  • •1∞Γ'иÛnuÞ\₂…• è 397940501547566186191992778
  • Ž8в è 2112
  • •1∞Γ'иÛnuÞ\₂…•Ž8вв è [1,11,111,12,2,21,211,2111,10]
  • .•6#&‘нδ• è "xivcxlmcd"

1
Non sono sicuro del perché .Xnon sia documentato, ma penso che dovrebbe funzionare:3999L.XQO
Adnan,

@Adnan Haha, -52 byte proprio lì. Dimenticato completamente che ci hai effettivamente detto di aggiungere un numero romano incorporato. Chiederà a @ Mr.Xcoder in chat di aggiungerlo ai documenti. Mancano altri comandi? ;) PS: salvato un altro byte mediante compressione 3999. :)
Kevin Cruijssen il

0

perl -MRegexp :: Common -pe, 34 byte

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

La &!/(.)\1{3}/parte è necessaria, perché Regexp::Commonconsente quattro (ma non cinque) degli stessi personaggi di fila. In questo modo, corrisponde ai numeri romani utilizzati sui quadranti dell'orologio, dove IIIIviene spesso utilizzato per 4.


0

Python 3 , 116 113 109 107 107 106 106 byte

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)

Provalo online!

-1 byte grazie a ShadowRanger


2
Come ho detto nella risposta Py2, il comando ^ non è necessario poiché matchcorrisponde solo all'inizio di una stringa.
ShadowRanger

@ShadowRanger ha aggiunto gli ancoraggi durante il debug e quindi non ha provato di nuovo senza di essi. Me lo ricorderò ora - grazie! :)
Noodle9

Bene, giusto per essere chiari, il trailing $è necessario ( fullmatchimplica solo ancore su entrambe le estremità, e ovviamente costerebbe più di un $).
ShadowRanger

@ShadowRanger Ah! Questo spiega perché avevo bisogno di ancore! Non avevo capito che avevo solo bisogno di ancorare la fine. Grazie ancora.
Noodle9,

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.