জেনারালাইজড ক্যান্টর সেগমেন্টের দৈর্ঘ্য সেট করে

17

সমস্যা

আসুন জেনারালাইজড ক্যান্টর সেটটি সংজ্ঞায়িত করি পুনরাবৃত্তভাবে সমস্ত অন্তরগুলির মধ্য থেকে কিছু যৌক্তিক দৈর্ঘ্যের অংশগুলি মুছে ফেলা হয়েছে যা এখনও মুছে ফেলা হয়নি, একক ধারাবাহিক বিরতি থেকে শুরু করে।

মুছে ফেলার জন্য সেগমেন্টের আপেক্ষিক দৈর্ঘ্য দেওয়া এবং না করা পুনরাবৃত্তির সংখ্যা, কোনও প্রোগ্রাম বা ফাংশন লিখতে সমস্যা হ'ল যা nপুনরাবৃত্তির পরে মুছে ফেলা বা না মুছে ফেলা সেগুলির তুলনামূলক দৈর্ঘ্যকে ছাড়িয়ে যায়।

উদাহরণ 3,1,1,1,2

উদাহরণ: Iteratively চতুর্থ এবং ষষ্ঠ অষ্টম মুছুন

ইনপুট:

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]?
@ স্মৃতিচারণ এটি আনারি থেকে খুব বেশি দূরে নয়, তাই আমি বলব যে এটি ঠিক আছে।
— অ্যাঙ্গস 22:25 '15
আপনি কি সম-আকারের ইনপুট-তালিকার জন্য একটি (বা একাধিক) পরীক্ষার কেস (গুলি) যুক্ত করতে পারবেন?
— কেভিন ক্রুইজসেন
1
@ কেভিন ক্রুজসন ইনপুট তালিকাটি বিজোড় আকারের গ্যারান্টিযুক্ত
— অ্যাংস

উত্তর:

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

এটি অনলাইন চেষ্টা করুন!

ফাংশনটি প্রথম আর্গুমেন্ট এবং পুনরাবৃত্তির সংখ্যা হিসাবে (%)লাইন দৈর্ঘ্যের তালিকা গ্রহণ করেln দ্বিতীয় ইনপুট হিসাবে ।

অ্যাংস এবং forrjan জোহানসেন -18 বাইট জন্য ধন্যবাদ!

— Laikoni
সূত্র
পুনরাবৃত্তিটি স্যুইচ করে nএবং #পুরোপুরি নেমে আপনি কমপক্ষে 7 বাইট সংরক্ষণ করতে সক্ষম হবেন
— অ্যাঙ্গস
@ অংজের পরামর্শ অনুযায়ী স্বতন্ত্রভাবে %সংক্ষিপ্ত করা যেতে পারে l%a=do(x,m)<-zip a$a>>[l,[sum l]];(*x)<$>m ।
— janর্জন জোহানসেন
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]। বিরক্তিকরভাবে, এই প্রসঙ্গে ḋমত কাজ করে না ×S¥, এবং ƭনীলাদের সাথে ভাল কাজ করে না। >: _ <

— এরিক দ্য আউটগল্ফার
সূত্র
2

কে (এনএনজি / কে) , 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* উপরের প্রতিটি উপাদানকে বর্তমান ফলাফলের সাথে সম্পর্কিত উপাদান দিয়ে গুন করুন

,/ শ্রেণীবদ্ধভাবে সংযুক্ত করা

— 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
— সোক
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.