लुक-एंड-सीक्वेंस: रोमन अंक संस्करण

Question

चुनौती का वर्णन

हमने लुक-एंड-सीक्वेंस को शामिल करते हुए कुछ चुनौतियों का सामना किया है । त्वरित अनुस्मारक:

• अनुक्रम के साथ शुरू होता है 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)

Comments

प्रत्येक पूर्णांक के लिए एक अद्वितीय रोमन अंक नहीं है। यह व्यक्त करने के लिए कौन सी संख्याएँ आवश्यक हो सकती हैं, और उन संख्याओं में से कौन से भाव मान्य हैं?

— पीटर टेलर

"प्रत्येक पूर्णांक के लिए एक अद्वितीय रोमन अंक अभिव्यक्ति नहीं है" से आपका क्या मतलब है? जैसे 4/ IV/ IIII? या 95/ XCV/ VC? हमेशा एक पूर्णांक व्यक्त करने का एक अनूठा तरीका नहीं हो सकता है, लेकिन मुझे पूरा यकीन है कि हमेशा एक पसंदीदा (मानक) एक है - मुझे गलत होने पर सही करें।

— shooqie

हमें अपने रोमन नंबरों के साथ कितनी दूर जाना है?

— माल्टीसेन

हाँ, उन दोनों मामलों में। दूसरे मामले में, मुझे लगता है कि यह बहुत अधिक राय का विषय है जो बेहतर है।

— पीटर टेलर

@shooqie यदि इन विवरणों को स्पष्ट नहीं किया जाता है, तो आप उत्तरों की तुलना कैसे करेंगे? यदि वास्तविक स्कोर की व्याख्या करने के लिए कुछ किनारे मामले बचे हैं, तो वे निरर्थक हो जाते हैं क्योंकि वे आपके साथ आने वाले किसी भी गोल्फिंग ट्रिक्स की तुलना में एक बड़ा अंतर बना सकते हैं।

— मार्टिन एंडर

Answer 1

पर्ल, 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$'लूप कंट्रोल को एक बाइट को छोटा बनाने के लिए इस्तेमाल करता हूं , लेकिन इस साइट पर स्कोर करने से 2 का हैंडीकैप होता है, इसलिए यह 1 बाइट तक खत्म हो जाता है। पुराने पर्ल्स पर आप पहले स्पेस गिरा सकते हैं for। पर्ल के कुछ संस्करण आपको ;लिप्यंतरण बंद करने के लिए एक अंतिम जोड़ने के लिए मजबूर करते हैं । लेकिन ऊपर जो दिया गया है वह कोड है जो मेरे सिस्टम पर काम करता है।

व्याख्या

समाधान से कोड तक पीछे की ओर काम करना:

स्ट्रिंग परिवर्तनों की हमें आवश्यकता है:

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

V     -> IV
VV    -> IIV

प्रत्येक प्रतिस्थापन दोहराया चरित्र के साथ समाप्त होता है। मुझे regex का उपयोग करके समान वर्णों का अनुक्रम मिलेगा /(.)\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एकमात्र पैरामीटर संयोजन है जिसके लिए यह सरल सूत्र काम करता है।

Comments

यह प्रतिभा है! :)

— लिन

Answer 2

गणितज्ञ, 113 90 83 बाइट्स

25% से अधिक की लंबाई कम करने वाले सुझावों के लिए मार्टिन एंडर का धन्यवाद!

Mathematica में उच्च-स्तरीय कमांड दिखा रहा है।

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

एक शुद्ध फ़ंक्शन, एक तर्क एन ले रहा है और इस (0-अनुक्रमित) अनुक्रम के एनटीटी तत्व को वर्णों की सूची के रूप में आउटपुट करता है। थोड़ा बाहर फैलाएं:

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

बाहरी Nest, मध्य चार-पंक्ति फ़ंक्शन को पुन: प्रसारित करता है, जो {"I"}N समय पर शुरू होता है । लाइन 4 इनपुट रोमन अंक की वर्ण सूची को वर्णों के रनों में विभाजित करता है, प्रत्येक रन को गिनता है Tally, और उन वर्णों को गिनता है जिन्हें वे गिन रहे हैं। लाइन 3 रोमन अंकों के रूप में मायने रखता है, फिर उन रोमन अंकों को वर्णों की सूची में विभाजित करता है। Flattenआदेश एक आयामी सूची पूरी सूची के- सूचियों कम कर देता है।

यहाँ प्रारंभिक संस्करण है:

Nest[
  "" <> Flatten[{RomanNumeral@#[[1]], #[[2]]} & /@
    (Reverse@#[[1]] & /@ 
      Tally /@
        Split@Characters@#)] &,
  "I", #] &

Comments

Grrr Mathematica;)

— बीटा डेके

आप का उपयोग करते हैं @@@बजाय /@आप उपयोग कर सकते हैं #और #2के बजाय #[[1]]और #[[2]]। इसके अलावा, पात्रों की सूची स्वीकार्य स्ट्रिंग प्रकार हैं, इसलिए आप उन लोगों के साथ काम कर सकते हैं और उपयोग करने से बच सकते हैं Characters@।

— मार्टिन एंडर

@MartinEnder अहा, मुझे पता था कि एक समान @@@शॉर्टकट होना चाहिए था ! जैसा कि स्वीकार्य स्ट्रिंग प्रकार के पात्रों की सूची के लिए (जो मैं सहमत हूं कि कोड छोटा होगा): क्या इस साइट पर एक पोस्ट है जो आप मुझे इंगित कर सकते हैं जो समुदाय मानक (ओं) का वर्णन करता है?

— ग्रेग मार्टिन

meta.codegolf.stackexchange.com/a/2216/8478

— मार्टिन

कुछ और बचत: Charactersसूत्र स्वचालित रूप से तो आप उपयोग कर सकते हैं @, Reverse@#&सादे रूप में पाठ्यक्रम भी इतना ही Reverseऐसी स्थिति में आप भी उन कोष्ठकों की जरूरत नहीं है,। और उपसर्ग संकेतन ( Flattenअगर आप इसे काम करने के लिए कोष्ठक जोड़ने की आवश्यकता है) के मामले में कुछ भी नहीं बचाता है। उन सभी को मिलाकर:Nest[Flatten[Characters@{RomanNumeral@#,#2}&@@@Reverse@@@Tally/@Split@#]&,{"I"},#]&

— मार्टिन एंडर

Answer 3

CJam ( 33 30 बाइट्स)

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

ऑनलाइन डेमो

कार्यान्वयन की शुद्धता की कुंजी निम्नलिखित प्रमेय है:

यदि पहली पीढ़ी है I, तो कोई रन लंबाई कभी पांच से अधिक नहीं होती है

लेम्मा: यदि पहली पीढ़ी है I, तो कभी भी कोई तार नहीं होता है VVV। विरोधाभास का प्रमाण है। मान लीजिए कि एक पहला सूचकांक nहै जिसके लिए nवें पीढ़ी शामिल है VVV। यदि वह VVVटूट जाता है (a)V VVतो पिछली पीढ़ी से रूपांतरण बुरा है: यह होना चाहिए था (a+5)V। तो यह होना चाहिए VV V(d), और पिछली पीढ़ी निहित है VVVVV, की पसंद के विपरीत n।

अब, मान लीजिए कि पहली पीढ़ी है mजिसके लिए mवें पीढ़ी शामिल है ...IIIIII...। ध्यान दें कि स्ट्रिंग में इसके अलावा Iऔर कोई अंक नहीं हो सकता है V, क्योंकि किसी भी पिछली पीढ़ी में नौ Iएस या नौ Vएस का रन नहीं था । ज़्यादा से ज़्यादा के चार Iएस के एक रन से आते हैं Iपुराने स्ट्रिंग में है, इसलिए पिछले स्ट्रिंग के इसी खंड जाना चाहिए ...IIIVV...दे रही है ... IIII IIV ...। चूंकि VVपीढ़ी पीढ़ी m-1से नहीं आती है VVVVV(लेम्मा देखें), दूसरा Vहोना चाहिए एक रन-लंबाई अंक I, इसलिए पीढ़ी में m-1हमारे पास है ...IIIVVI...। और चूंकि हम चाहते प्रारंभिक Iदेने के लिए रों IIIIऔर नहीं IVIयाVI, यह या तो स्ट्रिंग की शुरुआत से या एक से पहले है V।

अगर हमारे पास (...V)?IIIVVI...पीढ़ी है m-1, तो हमारे पास पीढ़ी में क्या है m-2? हमने पहले ही देखा है कि VVजीन की। 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

Answer 4

पायथन 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)

Ideone यह!

Comments

आप वर्ग कोष्ठक को छोड़ सकते हैं: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एक बाइट बचाता है।

— शर्लक 9

@ βετѧΛєҫα using: इसके अलावा, आप उपयोग नहीं कर रहे हैं i(के रूप में for i in range(...))। मैंने इसके साथ डबलिंग की कोशिश की execलेकिन यह 1'सब' विधि में बच गया कोड गड़बड़ कर रहा है, मैं वर्कअराउंड नहीं ढूंढ सका हूं।

— शुकी

@shooqie मैंने इसे कुछ हद तक छोटा कर दियाrange

— बीटा

Answer 5

आर, 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="")})

कंसोल से एन में ले जाता है। अनुक्रम के पहले 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"

Answer 6

जावास्क्रिप्ट (ईएस 6), 107

पुनरावर्ती फ़ंक्शन 0 पर आधारित Nth शब्द लौटाता है

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>

Answer 7

पर्ल 6 , 62 बाइट्स

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

बेनामी फ़ंक्शन जो शून्य-आधारित सूचकांक को स्वीकार करता है।

इस तथ्य का उपयोग करता है कि रोमन संख्या 5 से अधिक की आवश्यकता नहीं है, क्योंकि दोहराए जाने वाले अंकों के केवल समूह हो सकते हैं:

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

V     -> IV
VV    -> IIV

( इसे ऑनलाइन आज़माएं )