룩앤 세이 시퀀스 : 로마 숫자판

20

도전 설명

Look-and-say 시퀀스와 관련된 몇 가지 문제가있었습니다 . 빠른 알림 :

  • 순서는로 시작합니다 1.
  • 이 시퀀스의 후속 항은 이전 항에서 각 반복 자릿수 그룹을 열거하여 생성됩니다.

따라서 처음 몇 용어는 다음과 같습니다.

1        "one"
11       "one one" (we look at the previous term)
21       "two ones"
1211     "one two, one one"
111221   "one one, one two, two ones"
312211   "three ones, two twos, one one"

이제 똑같은 일을했지만 대신 로마 숫자를 사용하십시오. 우리는 시작 I(우리가 읽을 수 있도록 우리가 대신 문자 숫자 카운팅 규칙을 적용하고 동일한 규칙을 따라야 IVX로 one one, one five, one ten대신 one four, one ten또는 다른 방법) :

I           "one"
II          "one one"
III         "two ones" = "II" + "I"
IIII        "three ones" = "III" + "I"
IVI         "four ones" = "IV" + "I"
IIIVII      "one one, one five, one one"
IIIIIVIII   "three ones, one five, two ones" = ("III" + "I") + ("I" + "V") + ("II" + "I")

양의 정수 감안할 때 N중 하나를 :

  • N이 시퀀스의 첫 번째 숫자를 출력 하십시오 (합리적인 구분 기호는 물론 괜찮습니다)["I", "II", "III", ...]
  • N이 시퀀스의 출력 항 (0- 인덱싱 될 수 있음).

코드 골프 문제 이므로 가능한 한 짧게 코드를 작성하십시오 !

편집 : 정수를 로마 숫자로 표현하는 표준 / 선호 방법이 항상 하나 있다고 생각합니다 (예 : 95-> XCV대신 VC). 온라인에서 찾은 로마 숫자 변환기 몇 개가 제 의견을 확증합니다. 의심스러운 경우 온라인 변환기 를 사용하십시오. 가능한 모든 대소 문자와 로마 숫자를 작성하는 특정 규칙을 나열하는 것은이 과제의 핵심이 아닙니다.

EDIT2 : @PeterTaylor 및 @GregMartin 지적 그 숫자 만 작거나 같음 5당신이 로마 숫자의 모호함에 대해 걱정할 필요가 없습니다 있도록 순서대로 표시 (숫자 1- 8이다 I, II, III, IV, V, VI, VII,과 VIII)

code-golf  sequence  roman-numerals 
— shooqie
소스
각 정수마다 고유 한 로마 숫자 표현이 없습니다. 어떤 숫자를 표현해야하며, 어떤 숫자가 유효한가?
— 피터 테일러
"각 정수마다 고유 한 로마 숫자 표현이 없습니다"는 무슨 뜻입니까? 처럼 4/ IV/ IIII? 또는 95/ XCV/ VC? 정수를 표현하는 독특한 방법이 항상있는 것은 아니지만 항상 선호하는 표준 표준이 있다고 확신합니다. 잘못되면 나를 수정하십시오.
— shooqie
1
로마 숫자와 얼마나 멀리 가야합니까?
— Maltysen
예, 두 경우 모두 두 번째 경우에는 그것이 매우 바람직한 의견이라고 생각합니다.
— 피터 테일러
9
@shooqie 자세한 내용이 명확하지 않은 경우 답변을 어떻게 비교 하시겠습니까? 해석해야 할 특별한 사례가 남아 있다면 실제 점수는 의미가 없어집니다. 왜냐하면 골프 점수는 당신이 생각해 낼 수있는 골프 트릭보다 더 큰 차이를 만들 수 있기 때문입니다.
— Martin Ender

답변:

17

펄, 49 바이트

에 +1 포함 -p

STDIN에서 0 기반 인덱스로 실행

ecce.pl <<< 14

ecce.pl:

#!/usr/bin/perl -p
s,(.)\1*,$&/$1%182 .$1,eg for($_=/$/)x$`;y;19;IV

마법의 공식은 너무 마법입니다.

일반적으로 ($_=//)x$'루프 제어를 1 바이트 더 짧게 만드는 데 사용 하지만이 사이트에서 점수를 매기면 핸디캡이 2이므로 1 바이트가 길어집니다. 오래된 perls에서는 전에 공간을 삭제할 수 있습니다 for. 일부 버전의 펄 ;에서는 음역을 닫기 위해 결승전 을 추가해야합니다 . 그러나 위에 주어진 것은 내 시스템에서 작동하는 코드입니다.

설명

솔루션에서 코드로 거꾸로 작업 :

필요한 문자열 변환 :

I     -> II
II    -> III
III   -> IIII
IIII  -> IVI
IIIII -> VI

V     -> IV
VV    -> IIV

각 교체는 반복되는 문자로 끝납니다. 정규식을 사용하여 동일한 문자 시퀀스를 얻을 /(.)\1*/수 있으므로이를 추가하면 $1됩니다. 앞에있는 부분 ->은입니다 $&. 그래도 여전히 필요합니다.

I     -> I
II    -> II
III   -> III
IIII  -> IV
IIIII -> V

V     -> I
VV    -> II

쓰기 I로 1하고 V9로 :

1     -> 1
11    -> 11
111   -> 111
1111  -> 19
11111 -> 9

9     -> 1
99    -> 11

->반복되는 숫자로 부품을 나누면 다음과 같이됩니다.

1     -> 1
11    -> 11
111   -> 111
1111  -> 19
11111 -> 9

1     -> 1
11    -> 11

따라서 이제 반복 된 원본 V은 더 이상 예외가 아닙니다. 그래서 나는 이것을 가능하게하는 표현을 원합니다.

1     -> 1
11    -> 11
111   -> 111
1111  -> 19
11111 -> 9

그리고 이것은 간단한 모듈로 (182)에 의해 수행 될 수 있습니다 :

1     % 182 = 1
11    % 182 = 11
111   % 182 = 111
1111  % 182 = 19
11111 % 182 = 9

(이 경우에도 취득 IIIIII에 VI이 여기에 필요하지 않습니다하지만 오른쪽)

좌측하다 모두로 작동 변수를 초기화하는 1인덱스 0, 루프에서 이러한 변화를 반복하고 마지막에 교체 1하여 I과 9에 의해V

1, 9그리고 182유일한 파라미터 조합이 단순한 수식 작품이다.

— 톤호 스펠
소스
2
이것은 천재입니다! :)
— Lynn
10

Mathematica, 113 90 83 바이트

길이를 25 % 이상 단축 한 제안에 대해 Martin Ender에게 감사드립니다!

Mathematica의 고급 명령을 보여줍니다.

Nest[Flatten[Characters@{RomanNumeral@#,#2}&@@@Reverse@@@Tally/@Split@#]&,{"I"},#]&

인수 N을 취하여이 (0- 인덱싱 된) 시퀀스의 N 번째 요소를 문자 목록으로 출력하는 순수한 함수입니다. 조금 퍼짐 :

Nest[
  Flatten[
    Characters @ {RomanNumeral@#,#2}& @@@
      Reverse @@@ Tally /@ Split@ #
    ]& ,
  {"I"}, #]&

바깥 쪽 Nest은 {"I"}N 번 부터 시작하여 가운데 4 줄 기능을 반복합니다 . 4 행은 입력 된 로마 숫자의 문자 목록을 유사한 문자의 런으로 분할하고을 사용하여 각 런을 Tally카운트하고 카운트하는 문자 앞에 카운트를 넣습니다. 3 행은 카운트를 로마 숫자로 렌더링 한 다음 로마 숫자를 문자 목록으로 나눕니다. 이 Flatten명령은 전체 목록 목록을 1 차원 목록으로 줄입니다.

초기 버전은 다음과 같습니다.

Nest[
  "" <> Flatten[{RomanNumeral@#[[1]], #[[2]]} & /@
    (Reverse@#[[1]] & /@ 
      Tally /@
        Split@Characters@#)] &,
  "I", #] &
— 그렉 마틴
소스
3
Grrr Mathematica;)
— Beta Decay
당신이 사용하는 경우 @@@대신 /@당신이 사용할 수있는 #및 #2대신 #[[1]]하고 #[[2]]. 또한 문자 목록은 허용되는 문자열 유형이므로이를 사용하여 작업을 피할 수 있습니다 Characters@.
— Martin Ender
@ MartinEnder Aha, 나는 @@@비슷한 지름길 이 있어야한다는 것을 알고있었습니다 ! 허용 가능한 문자열 유형 인 문자 목록에 관해서는 (코드를 줄이겠다 고 동의합니다.)이 사이트에 커뮤니티 표준을 설명하는 게시물이 있습니까?
— Greg Martin
2
— Martin Ender
1
약간의 추가 절약 : Characters쓰레드가 자동으로 사용되므로 @, Reverse@#&물론 일반과 동일합니다 Reverse.이 경우 괄호가 필요하지 않습니다. 접두사 표기법 (의 경우 Flatten)은 괄호를 추가해야 작동하면 아무것도 저장하지 않습니다. 이들 모두를 결합 :Nest[Flatten[Characters@{RomanNumeral@#,#2}&@@@Reverse@@@Tally/@Split@#]&,{"I"},#]&
— 마틴 엔더
8

CJam ( 33 30 바이트)

"I"{e`{(4md1$^'I*\'V*@}%e_}ri*

온라인 데모

구현의 정확성에 대한 열쇠는 다음 정리입니다.

1 세대가 I이면 런 길이가 5보다 길지 않습니다.

렘마 : 1 세대가 I이면 문자열이 포함되지 않습니다 VVV. 증거는 모순입니다. 세대에 포함 n된 첫 번째 색인이 있다고 가정합니다 . 그로 인해 이전 세대의 변환이 잘못 되면 고장 났어 야합니다 . 따라서 이전 세대 는 선택과 모순 되어 있어야한다 .nVVVVVV(a)V VV(a+5)VVV V(d)VVVVVn

이제 세대에 포함 m된 첫 번째 색인이 있다고 가정 합니다. 이전 세대에 9 초 또는 9 초의 런이 없었기 때문에 문자열 과 이외의 숫자는있을 수 없습니다 . s 중 최대 4 개는 이전 문자열 의 s에서 나옵니다 . 따라서 이전 문자열의 해당 섹션이 제공 해야합니다 . 이후 세대가 에서 오지 않는다 (보조 정리 참조), 두 번째 자리의 실행 길이 있어야합니다 그래서 세대, 우리가 . 우리가 원하기 때문에 초기 의 줄에 하지 나m...IIIIII...IVIVII...IIIVV...... IIII IIV ...VVm-1VVVVVVIm-1...IIIVVI...IIIIIIVIVI, 앞에 문자열의 시작 또는가옵니다 V.

우리가 (...V)?IIIVVI...세대에 있다면 m-1, 세대 에 무엇이 m-2있습니까? 우리는 이미 VVgen의 세대를 관찰했습니다 . m-1로 구문 분석해야합니다 (a)V V(I).

우리가 가지고 가정 a=2: (...V)?I IIV VI...사실 그것은해야합니다 ...VI IIV VI..., 즉 최고의 있지만 V의 일부가 될 수있다 IV; 그래서 이전 세대에서 우리는 하나가 (...V)? IIII VV IIIII...나 (...V)? IIIII VV IIIII. 두 가지 방법으로 문제가 발생합니다 VVIIIII. 두 번째 V는 실행 길이 여야하지만 ...VI IIII...동일한 숫자의 다음 (실행 길이, 숫자) 쌍이 필요합니다.

그래서해야합니다 a=1: (...V)?II IV VI.... 세대 이후 m여섯 개의 실행과 함께 처음 I의 그이어야합니다 (...V)? II IV VI...세대가 그래서, m-2입니다 (...V)? I V IIIII.... ...VIVIIIII...불가능하다 : 그러나 우리는 두 번째를 해석하기로 결정했다 V.

따라서 생성 m-2은 또는로 ^IVIIIII...구문 분석 해야합니다 . 이들은 각각 세대 를 또는로 제공 합니다.^IV IIII I(V)...^IV III II(V)...m-3^V III V ...^V II VV...

그러나로 시작하는 첫 번째 문자열로 시작하는 문자열의 시작을 보면 V주기가 나타납니다.

    VI IV I...
    IV III IV ...
    II IV IVI ...
    IIII IV II IV ...

따라서 어느 세대도 VIIIV또는로 시작하지 않습니다 VIIVV. 우리는 그런 것이 없다고 결론을 내야한다 m.

해부

"I"          e# Initial generation
{            e# Loop...
  e`         e#   Run-length encode
  {          e#   Foreach [run-length char] pair...
    (        e#     Extract the run-length r
    4md1$^   e#     Get the number of Vs and the number of Is
             e#     The number of Vs is r/4 ; the number of Is is (r%4)^(r/4)
    'I*\'V*@ e#     Repeat strings the appropriate number of times and reorder
  }%
  e_         e#  Flatten to a simple string
}ri*         e# ... n times, where n is taken from stdin
— 피터 테일러
소스
6

파이썬 3, 195 바이트

로마 숫자에는 많은 바이트가 낭비되므로 골프를 치기도합니다.

@ El'endiaStarman, @ Sherlock9 및 @Shooqie 덕분에

import re
def f(x,r=""):
 for v,i in(5,"V"),(4,"IV"),(1,"I"):a,x=divmod(x,v);r+=i*a
 return r
s="I"
for i in[0]*int(input()):print(s);s=re.sub(r'(.)\1*',lambda m:f(len(m.group()))+m.group()[0],s)

무시 했어!

— 베타 붕괴
소스
대괄호는 생략 할 수 있습니다.for v,i in(5,"V"),(4,"IV"),(1,"I")
— shooqie
@shooqie 난 당신이 할 수있는 것을 몰랐다가 : D
— 베타 붕괴
for v,i in(5,"V"),(4,"IV"),(1,"I"):a,x=divmod(x,v);r+=i*a바이트를 저장합니다.
— Sherlock9
@ βετѧΛєҫαγ : 또한 i(에서와 같이 for i in range(...)) 사용하지 않는 것 같습니다 . 나는 dabbling을 시도했지만 'sub'메서드에서 exec이스케이프 처리 1된 것은 코드를 엉망으로하는 것 같습니다. 해결 방법을 찾을 수 없었습니다.
— shooqie
@shooqie 나는 제거하여 조금 단축했습니다range
— Beta Decay
4

R, 110 107 바이트

as.roman와 결합 rle하면이 작업이 쉬워집니다. 남용을 방지하고 내장 된 고양이 동작으로 <<-몇 바이트 를 절약 할 수 있습니다.

x="I"
replicate(scan(),{r=rle(strsplit(x,"")[[1]])
x<<-paste(rbind(paste(as.roman(r$l)),r$v),collapse="")})

콘솔에서 N을받습니다. 시퀀스의 처음 2에서 N까지의 조건을 출력합니다.

 [1] "II"                                                                                                                                                                                                                                     
 [2] "III"                                                                                                                                                                                                                                    
 [3] "IIII"                                                                                                                                                                                                                                   
 [4] "IVI"                                                                                                                                                                                                                                    
 [5] "IIIVII"                                                                                                                                                                                                                                 
 [6] "IIIIIVIII"                                                                                                                                                                                                                              
 [7] "VIIVIIII"                                                                                                                                                                                                                               
 [8] "IVIIIIVIVI"                                                                                                                                                                                                                             
 [9] "IIIVIVIIVIIIVII"                                                                                                                                                                                                                        
[10] "IIIIIVIIIVIIIIVIIIIIVIII"                                                                                                                                                                                                               
[11] "VIIVIIIIIVIVIIVVIIVIIII"                                                                                                                                                                                                                
[12] "IVIIIIVVIIVIIIVIIIIIVIIIIVIVI"                                                                                                                                                                                                          
[13] "IIIVIVIIIVIIIIVIIIIIVVIIVIVIIVIIIVII"                                                                                                                                                                                                   
[14] "IIIIIVIIIVIIIIIVIVIIVVIIIVIIIIVIIIVIIIIVIIIIIVIII"                                                                                                                                                                                      
[15] "VIIVIIIIIVVIIVIIIVIIIIIVIIIIIVIVIIVIIIIIVIVIIVVIIVIIII"                                                                                                                                                                                 
[16] "IVIIIIVVIIIVIIIIVIIIIIVVIIVVIIVIIIVIIIIVVIIVIIIVIIIIIVIIIIVIVI"                                                                                                                                                                         
[17] "IIIVIVIIIVIIIIIVIVIIVVIIIVIIIIIVIIIIVIIIIIVIVIIIVIIIIVIIIIIVVIIVIVIIVIIIVII"                                                                                                                                                            
[18] "IIIIIVIIIVIIIIIVVIIVIIIVIIIIIVIIIIIVVIIVIVIIVVIIVIIIVIIIIIVIVIIVVIIIVIIIIVIIIVIIIIVIIIIIVIII"                                                                                                                                           
[19] "VIIVIIIIIVVIIIVIIIIVIIIIIVVIIVVIIIVIIIIVIIIVIIIIIVIIIIVIIIIIVVIIVIIIVIIIIIVIIIIIVIVIIVIIIIIVIVIIVVIIVIIII"                                                                                                                              
[20] "IVIIIIVVIIIVIIIIIVIVIIVVIIIVIIIIIVIIIIIVIVIIVIIIIIVVIIVIVIIVVIIIVIIIIVIIIIIVVIIVVIIVIIIVIIIIVVIIVIIIVIIIIIVIIIIVIVI"                                                                                                                    
[21] "IIIVIVIIIVIIIIIVVIIVIIIVIIIIIVIIIIIVVIIVVIIVIIIVIIIIVVIIIVIIIIVIIIVIIIIIVIIIIIVIVIIVVIIIVIIIIIVIIIIVIIIIIVIVIIIVIIIIVIIIIIVVIIVIVIIVIIIVII"                                                                                             
[22] "IIIIIVIIIVIIIIIVVIIIVIIIIVIIIIIVVIIVVIIIVIIIIIVIIIIVIIIIIVIVIIIVIIIIIVIVIIVIIIIIVVIIVVIIVIIIVIIIIIVIIIIIVVIIVIVIIVVIIVIIIVIIIIIVIVIIVVIIIVIIIIVIIIVIIIIVIIIIIVIII"                                                                      
[23] "VIIVIIIIIVVIIIVIIIIIVIVIIVVIIIVIIIIIVIIIIIVVIIVIVIIVVIIVIIIVIIIIIVVIIVIIIVIIIIVVIIIVIIIIIVIIIIVIIIIIVVIIVVIIIVIIIIVIIIVIIIIIVIIIIVIIIIIVVIIVIIIVIIIIIVIIIIIVIVIIVIIIIIVIVIIVVIIVIIII"                                                   
[24] "IVIIIIVVIIIVIIIIIVVIIVIIIVIIIIIVIIIIIVVIIVVIIIVIIIIVIIIVIIIIIVIIIIVIIIIIVVIIIVIIIIVIIIIIVIVIIIVIIIIIVVIIVIVIIVVIIIVIIIIIVIIIIIVIVIIVIIIIIVVIIVIVIIVVIIIVIIIIVIIIIIVVIIVVIIVIIIVIIIIVVIIVIIIVIIIIIVIIIIVIVI"                             
[25] "IIIVIVIIIVIIIIIVVIIIVIIIIVIIIIIVVIIVVIIIVIIIIIVIIIIIVIVIIVIIIIIVVIIVIVIIVVIIIVIIIIIVIVIIVVIIVIIIVIIIIIVVIIIVIIIIVIIIVIIIIIVIIIIIVVIIVVIIVIIIVIIIIVVIIIVIIIIVIIIVIIIIIVIIIIIVIVIIVVIIIVIIIIIVIIIIVIIIIIVIVIIIVIIIIVIIIIIVVIIVIVIIVIIIVII"
— 블로
소스
1

자바 스크립트 (ES6), 107

N 번째 항을 기반으로하는 재귀 함수

f=(n,r='I')=>n?f(n-1,r.match(/I+|V+/g).map(x=>((n=x.length)-4?'VIII'.slice(n<5,1+n%5):'IV')+x[0]).join``):r

테스트

f=(n,r='I')=>n?f(n-1,r.match(/I+|V+/g).map(x=>((n=x.length)-4?'VIII'.slice(n<5,1+n%5):'IV')+x[0]).join``):r

function update() {
  O.textContent=f(I.value)
}

update()
<input id=I value=25 type=number oninput='update()'><pre id=O></pre>
스 니펫 확장

— edc65
소스
1

펄 6 , 62 바이트

{("I",{S:g/(.)$0*/{<I II III IV V>[$/.chars-1]~$0}/}...*)[$_]}

0부터 시작하는 인덱스를 허용하는 익명 함수

발생할 수있는 반복 자릿수 그룹은 다음과 같기 때문에 5보다 큰 로마 숫자는 필요하지 않습니다.

I     -> II
II    -> III
III   -> IIII
IIII  -> IVI
IIIII -> VI

V     -> IV
VV    -> IIV

( 온라인 시도 )

— smls
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.