도전

입력 문자열이 주어지면 1 (= I)에서 3999 (= MMMCMXCIX) 사이의 올바른 로마 숫자를 나타내면 true 값을, 그렇지 않으면 false 값을 반환하십시오.

세부

• 입력은 문자 만 포함하는 비어 있지 않은 문자열입니다 IVXLCDM.
• 로마 숫자 (이 문제에서 여기서 사용하는)는 다음과 같이 정의됩니다.

다음 기호 만 사용합니다.

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

실제로 유효한 로마 숫자 인 문자열을 정의하려면 아마도 대화 규칙을 제공하는 것이 가장 쉬운 방법 일 것입니다. 10 진수 a3 a2 a1 a0(각 ai숫자는 1 자리를 나타냅니다 . 예를 들어.를 나타내는 792경우 a3=0, a2=7, a1=9, a0=2)를 로마 숫자로 쓰려면 분해합니다. 수십의 힘으로. 10의 다른 힘은 다음과 같이 쓸 수 있습니다.

      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

왼쪽에서 가장 큰 숫자로 시작하여 각 숫자가 개별적으로 나타내는 숫자를 변환하여 연결할 수 있습니다. 따라서 위의 예에서는 다음과 같습니다.

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

따라서 로마 숫자는 792입니다 DCCXCII. 이 도전과 관련된 모든 로마 숫자의 전체 목록은 다음과 같습니다. OEIS a006968.txt

예

Truthy

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

팔시

MMIXVIII
IVX
IXV
MMMM
XXXVX
IVI
VIV

상세 , 1362 바이트

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

I범위 내의 유효한 로마 숫자를 출력 I-MMMCMXCIX하고 NULLA(0) 그렇지 않으면 사용자 입력이 유효한 로마 숫자가 아님을 알려줍니다.

C 번호 (카메라 C 번호 인터랙티브 컴파일러) , (79) 109 바이트

이것은 정규식 도전과 같은 것 같습니다. 더 짧은 솔루션을 찾을 수 있다고 확신합니다 ...

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

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) , 35 바이트

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

온라인으로 사용해보십시오!

@attinat 덕분에 5 바이트가 절약되었습니다.

[1,3999]불행히도 제한 은 7 바이트입니다 ...
여기 로마 숫자에 대한 코드가 있습니다

Wolfram Language (Mathematica) , 28 바이트

Check[FromRomanNumeral@#,F]&

온라인으로 사용해보십시오!

위의 코드는 [1,3999]뿐만 아니라 어떤 숫자에도 작동합니다.

CP-1610 어셈블리 ( Intellivision ),  52 ... 48  47 DECLEs ¹ = 59 바이트

펄보다 7 년 앞서는 시스템에서 이것을 시도해 보자. :-)

R4 에서 null로 끝나는 문자열에 대한 포인터를 가져 옵니다 . 입력이 유효한 로마 숫자이면 Zero 플래그를 설정 하거나 그렇지 않으면 지 웁니다.

                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

어떻게?

정규식 #은 입력 문자열에 존재하지 않는 유효하지 않은 문자 인 경우 동일한 구조를 가진 4 개의 그룹으로 다시 작성할 수 있습니다 .

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

$N$$N-1$$(\text{main_digit}, \text{second_suffix})$

우리의 루틴은 이러한 패턴에 따라 문자별로 입력 문자열을 구문 분석하고 결국 문자열 끝에 도달했는지 확인합니다.

산출

^{jzIntv의 스크린 샷}

_{1. CP-1610 opcode는 'DECLE'로 알려진 10 비트 값으로 인코딩됩니다. 이 루틴의 길이는 $ 4876에서 $ 48A4 (포함)로 끝나는 47 DECLE입니다.}

자바 8, 70 바이트

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

@ Innat3 의 C # 답변 포트 , 따라서 그를 찬성 해야합니다!

온라인으로 사용해보십시오.

설명:

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"

R , 74 71 56 바이트

R의 내장 기능으로 grep을 효과적으로 사용하는 방법에 대한 제안에 대해 @RobinRyder, @Giuseppe 및 @MickyT에게 감사드립니다 as.roman.

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

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) , 32 바이트

RomanNumeral@Range@3999~Count~#&

온라인으로 사용해보십시오!

젤리 ,  48 47 46  44 바이트

Nick Kennedy에게 -1 감사합니다

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

IVXLCDM1$1$$3999$0

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

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

펄 5 ( -p), 57 바이트

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

TIO

• {0,3}수량자가 다음을 변경 한 것을 제외하고는 거의 동일한 정규식을 사용합니다.*
• &!/(.)\1{3}/ 같은 문자가 한 번에 4 번 나타날 수 없도록합니다.
• 와 golfed 할 수없는 -/(.)\1{3}/줄 것이기 때문 -1에 대한 IIIIVI예를 들어,

파이썬 2 , 81 바이트

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

온라인으로 사용해보십시오!

로마 숫자를 최대 9까지 일치시키는 정규 표현식의 마지막 부분을 살펴 보겠습니다 (빈 문자열 포함).

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

여기에는 두 가지 대안이 있습니다 |.

• V?I{,3}: 선택 사항 V다음에 최대 3 개 I. 이 일치하는 빈 문자열 I, II, III, V, VI, VII,VIII .
• I[VX]일 :는 Ia로 하였다 V나 X. 이 일치 IV하고IX .

X,L,C수십을 C,D,M일치시키고 수백 을 일치 시키는 것과 똑같은 것들 , 마지막으로^M{,3} 최대 3 M(천) 까지 허용합니다 .

3 번 쓰지 않고 각 문자 트리오에 대한 템플릿을 생성하려고 시도했지만 훨씬 길었습니다.

망막 , 56 51 바이트

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

@NahuelFouilleul 의 포트 5 답변 포트 , 그래서 그를 해야합니다!

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

05AB1E , 61 9 8 바이트

ŽF¯L.XIå

엄청나게 $\color{green}{\textrm{-52 bytes}}$ 덕분에 @Adnan , 아마도 05AB1E의 Roman Number 내장이 문서화되지 않았기 때문에 haha ​​.. xD

온라인으로 사용해보십시오 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

내 (섹션이 05AB1E 팁을 참조하십시오 어떻게 큰 정수를 압축하는 방법을? ) 이유를 이해하기ŽF¯ 것입니다 3999.

원래 61 바이트 답변 :

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

온라인으로 사용해보십시오 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

다음과 같은 이유를 이해하려면이 05AB1E 팁 ( 사전의 일부가 아닌 문자열을 압축하는 방법? , 큰 정수 를 압축하는 방법 ? 및 정수 목록을 압축하는 방법? ) 을 참조하십시오.

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

perl -MRegexp :: Common -pe, 34 바이트

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

&!/(.)\1{3}/때문에 부분은 필요한 Regexp::Common행에서 같은 문자 사 (그러나 오) 할 수 있습니다. 그런 식으로 시계에 사용되는 로마 숫자와 일치하며 IIII종종 4에 사용됩니다.

파이썬 (3) , 116 (113) 109 107 105 106 바이트

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)

온라인으로 사용해보십시오!

ShadowRanger 덕분에 -1 바이트

루비 , ( -n) 56 바이트

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

온라인으로 사용해보십시오!

0 (truthy) 또는 nil (false)을 출력합니다.