सामान्यीकृत कैंटर सेट खंड लंबाई

17

मुसीबत

चलो एक सामान्यीकृत कैंटर को निर्धारित करते हैं जो पुनरावृत्त रूप से सभी अंतरालों के बीच से कुछ तर्कसंगत लंबाई खंडों को हटा रहा है जो अभी तक हटाए नहीं गए हैं, एक निरंतर अंतराल से शुरू हो रहे हैं।

हटाने या नहीं करने के लिए खंडों की सापेक्ष लंबाई को देखते हुए, और पुनरावृत्तियों की संख्या को देखते हुए, समस्या एक प्रोग्राम या फ़ंक्शन लिखने की है जो nपुनरावृत्तियों के बाद हटाए गए या नहीं हटाए गए खंडों की सापेक्ष लंबाई को आउटपुट करती है ।

उदाहरण 3,1,1,1,2

उदाहरण: चतुर्थ और छठवें आठवें को समान रूप से हटा दें

इनपुट:

n - पुनरावृत्तियों की संख्या, 0 या 1 से अनुक्रमित

l- खंड की सूची के साथ सकारात्मक पूर्णांक के रूप में लंबाई gcd(l)=1और विषम लंबाई, भागों की सापेक्ष लंबाई का प्रतिनिधित्व करते हैं जो या तो बने रहते हैं या हटाए जाते हैं, एक खंड से शुरू होता है जो नष्ट नहीं होता है। चूंकि सूची की लंबाई विषम है, इसलिए पहले और अंतिम खंड कभी नहीं हटते हैं। उदाहरण के लिए, नियमित कैंटर सेट के लिए यह एक तिहाई के लिए [1,1,1] होगा, जो कि एक तिहाई है जो हटा दिया जाता है और फिर से एक तिहाई नहीं होता है।

आउटपुट:

जब वे खंड जो पिछली पुनरावृत्ति में हटाए नहीं गए थे o, तो एग्‍जामर सूची , वें पुनरावृत्‍ति gcd(o)=1में लंबाई nकी होती है, जो सूची की कॉपी की गई स्केल से बदल दी जाती है l। पहला पुनरावृति ही है [1]। आप किसी भी अस्पष्ट आउटपुट विधि का उपयोग कर सकते हैं , यहां तक ​​कि एकात्मक भी।

उदाहरण

n=0, l=[3,1,1,1,2] →                 [1]
n=1, l=[3,1,1,1,2] →     [3,    1,    1,    1,    2]
n=2, l=[3,1,1,1,2] → [9,3,3,3,6,8,3,1,1,1,2,8,6,2,2,2,4]

n=3, l=[5,2,3]     → [125,50,75,100,75,30,45,200,75,30,45,60,45,18,27]
n=3, l=[1,1,1]     → [1,1,1,3,1,1,1,9,1,1,1,3,1,1,1]

आप मान सकते हैं कि इनपुट वैध है। यह कोड-गोल्फ है , इसलिए बाइट्स जीत में मापा जाने वाला सबसे छोटा कार्यक्रम है।

code-golf  sequence  fractal  recursion 
— Angs
स्रोत
क्या यह लंबाई के बजाय गैर-हटाए गए खंडों के इनपुट और आउटपुट के लिए स्वीकार्य होगा? उदाहरण के लिए, के [0, 1, 2, 4, 6, 7]बजाय [3, 1, 1, 1, 2]?
@ मेमोनिक यह एकात्मकता से बहुत दूर नहीं है, इसलिए मैं कहूंगा कि यह ठीक है।
— Angs
क्या आप समान-आकार की इनपुट-सूचियों के लिए एक (या एकाधिक) परीक्षण मामला जोड़ सकते हैं?
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन की इनपुट सूचियों के विषम आकार के होने की गारंटी दी गई है
— Angs

जवाबों:

6

जेली ,  15 13  12 बाइट्स

-2 डेनिस के लिए धन्यवाद (एक श्रृंखला के बजाय एक लिंक का उपयोग करके सही तरीके से अंतर्निहित रूप से उपयोग करने की अनुमति देता है ¡; 1इस तथ्य के कारण किसी सूची में लपेटने की आवश्यकता नहीं है कि जेली एक आइटम की सूची को आइटम के समान प्रिंट करती है)
-1 धन्यवाद आउटग्रॉफ़र का उपयोग करें (उपयोग Ɗकरने से नई रेखा को बचाने के लिए उपयोग करें Ç)

1×€³§JḤ$¦ẎƊ¡

एक पूरा कार्यक्रम जेली प्रारूप में एक सूची मुद्रण (इसलिए के [1]रूप में मुद्रित किया जाता है 1)

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

कैसे?

1×€³§JḤ$¦ẎƊ¡ - Main link: segmentLengths; iterations
1            - literal 1 (start with a single segment of length 1)
           ¡ - repeat...
             - ...times: implicitly use chain's right argument, iterations
          Ɗ  - ...do: last 3 links as a monad (with 1 then the previous output):
   ³         - (1) program's 3rd argument = segmentLengths
 ×€          -  1  multiply €ach (e.g. [1,2,3] ×€ [1,2,1] = [[1,4,3],[2,4,2],[3,6,3]])
        ¦    -  2  sparse application... 
       $     - (2) ...to: indices: last two links as a monad:
     J       - (2)          range of length = [1,2,3,...,numberOfLists]
      Ḥ      - (2)          double            [2,4,6,...] (note: out-of bounds are ignored by ¦)
    §        - (2) ...of: sum each (i.e. total the now split empty spaces)
         Ẏ   -  3  tighten (e.g. [[1,2,3],4,[5,6,7]] -> [1,2,3,4,5,6,7])
             - implicit print
— जोनाथन एलन
स्रोत
4

हास्केल , 76 58 बाइट्स

l%0=[1]
l%n=do(x,m)<-l%(n-1)`zip`cycle[l,[sum l]];map(*x)m

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

फ़ंक्शन पहले तर्क के रूप (%)में लाइन की लंबाई lऔर nदूसरे इनपुट के रूप में पुनरावृत्तियों की संख्या लेता है ।

-18 बाइट्स के लिए एंगेज और अर्जन जोहान्सन को धन्यवाद!

— Laikoni
स्रोत
आपको कम से कम 7 बाइट को बचाने के लिए एक पुनरावर्ती पर स्विच करके nऔर #पूरी तरह से छोड़ने में सक्षम होना चाहिए
— एंग्स
स्वतंत्र रूप से @Angs के सुझाव पर मूल %को छोटा किया जा सकता है l%a=do(x,m)<-zip a$a>>[l,[sum l]];(*x)<$>m ।
— अर्जन जोहान्स
3

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 42-57), 80 बाइट्स

f=(n,l,i=0)=>n--?[for(x of l)for(y of(i^=1)?f(n,l):[eval(l.join`+`)**n])x*y]:[1]

उन विशिष्ट संस्करणों की आवश्यकता है क्योंकि यह सरणी समझ और घातांक दोनों का उपयोग करता है।

— नील
स्रोत
2

जावा 10, 261 बाइट्स

L->n->{if(n<1){L.clear();L.add(1);}else if(n>1){var C=new java.util.ArrayList<Integer>(L);for(int l=C.size(),i,x,t,s;n-->1;)for(i=x=0;i<L.size();){t=L.remove(i);if(i%2<1)for(;i%-~l<l;)L.add(i,C.get((i++-x)%l)*t);else{x++;s=0;for(int c:C)s+=c;L.add(i++,t*s);}}}}

बाइट्स को सहेजने के लिए नया वापस करने के बजाय इनपुट-सूची को संशोधित करता है।

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

L->n->{                       // Method with List and integer parameters and no return-type
  if(n<1){                    //  If `n` is 0:
    L.clear();                //   Remove everything from the List
    L.add(1);}                //   And only add a single 1
                              //  Else-if `n` is 1: Leave the List as is
  else if(n>1){               //  Else-if `n` is 2 or larger:
    var C=new java.util.ArrayList<Integer>(L);
                              //   Create a copy of the input-List
    for(int l=C.size(),       //   Set `l` to the size of the input-List
        i,x,t,s;              //   Index and temp integers
        n-->1;)               //   Loop `n-1` times:
      for(i=x=0;              //    Reset `x` to 0
          i<L.size();){       //    Inner loop `i` over the input-List
        t=L.remove(i);        //     Remove the current item, saving its value in `t`
        if(i%2<1)             //     If the current iteration is even:
          for(;i%-~l<l;)      //      Loop over the copy-List
            L.add(i,C.get((i++-x)%l)*t);
                              //       And add the values multiplied by `t`
                              //       at index `i` to the List `L`
        else{                 //     Else (the current iteration is odd):
          x++;                //      Increase `x` by 1
          s=0;for(int c:C)s+=c;
                              //      Calculate the sum of the copy-List
          L.add(i++,t*s);}}}} //      Add this sum multiplied by `t`
                              //      at index `i` to the List `L`
— केविन क्रूज़सेन
स्रोत
2

जेली , 13 बाइट्स

Ø1××S¥ƭ€³Ẏ$¡Ṗ

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

पूरा कार्यक्रम। के 1बजाय आउटपुट [1]। Annoyingly, ḋकी तरह काम नहीं करता है ×S¥इस संदर्भ में, और ƭnilads साथ अच्छी तरह से काम नहीं करता। > _ <

— आउटगोल्फ को एरिक करें
स्रोत
2

के (ngn / k) , 27 बाइट्स

{x{,/y*(#y)#x}[(y;+/y)]/,1}

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

{ }तर्क के साथ एक समारोह है xऔरy

(y;+/y)की जोड़ी yऔर इसका योग

{ }[(y;+/y)]एक वाद के साथ एक रंग समारोह के प्रक्षेपण (उर्फ करी या आंशिक अनुप्रयोग)। लागू किया xजाएगा (y;+/y)और yजब तर्क दिया जाएगा।

,1 1 से युक्त एकल सूची

x{ }[ ]/ प्रक्षेपण लागू करें x समय

(#y)#xवर्तमान परिणाम की लंबाई को फिर से आकार दें, यानी बाहरी yऔर इसकी राशि के बीच वैकल्पिक

y* वर्तमान परिणाम के संगत तत्व के साथ उपरोक्त के प्रत्येक तत्व को गुणा करें

,/ CONCATENATE

— NGN
स्रोत
1

अजगर , 20 बाइट्स

us.e?%k2*bsQ*LbQGE]1

इनपुट खंड सरणी है l, फिर पुनरावृत्तियों n। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

us.e?%k2*bsQ*LbQGE]1   Implicit, Q=1st arg (segment array), E=2nd arg (iterations)
u                E     Execute E times, with current value G...
                  ]1   ... and initial value [1]:
  .e            G        Map G, with element b and index k:
        *bsQ               Multiply b and the sum of Q {A}
            *LbQ           Multiply each value of Q by b {B}
    ?%k2                   If k is odd, yield {A}, otherwise yield {B}
 s                       Flatten the resulting nested array
— सोक
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.