ปัญหา

ลองกำหนดคันทอร์ทั่วไปที่ตั้งค่าโดยการลบเซกเมนต์ความยาวแบบมีเหตุผลบางส่วนออกจากช่วงกลางของช่วงเวลาทั้งหมดที่ยังไม่ถูกลบโดยเริ่มจากช่วงเวลาต่อเนื่องเดียว

กำหนดความยาวสัมพัทธ์ของเซกเมนต์ที่จะลบหรือไม่และจำนวนการวนซ้ำที่ต้องทำปัญหาคือการเขียนโปรแกรมหรือฟังก์ชันที่เอาต์พุตความยาวสัมพัทธ์ของเซกเมนต์ที่มีหรือไม่ถูกลบหลังจากnการวนซ้ำ

ตัวอย่าง: ลบซ้ำอันดับที่ 4 และ 6 อย่างซ้ำ ๆ

การป้อนข้อมูล:

n - จำนวนการวนซ้ำการทำดัชนีเริ่มต้นจาก 0 หรือ 1

l- รายการความยาวเซกเมนต์เป็นจำนวนเต็มบวกที่มีgcd(l)=1และความยาวคี่แทนความยาวสัมพัทธ์ของส่วนต่าง ๆ ที่คงอยู่หรือถูกลบเริ่มต้นจากเซกเมนต์ที่ไม่ถูกลบ เนื่องจากความยาวของรายการเป็นเลขคี่กลุ่มแรกและกลุ่มสุดท้ายจะไม่ถูกลบ ตัวอย่างเช่นสำหรับคันทอร์ปกติตั้งค่านี้จะเป็น [1,1,1] สำหรับหนึ่งในสามที่อยู่หนึ่งในสามที่จะถูกลบและอีกหนึ่งในสามที่ไม่

เอาท์พุท:

รายการจำนวนเต็มo, gcd(o)=1ของความยาวส่วนญาติในnการทำซ้ำ TH 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]

คุณสามารถสันนิษฐานว่าอินพุตนั้นถูกต้อง นี่คือโค้ดกอล์ฟดังนั้นโปรแกรมที่สั้นที่สุดที่วัดเป็นไบต์จะเป็นผู้ชนะ

เยลลี่ ,  15 13  12 ไบต์

-2 ต้องขอบคุณเดนนิส (การใช้ลิงค์แทนการใช้ลูกโซ่ทำให้สามารถใช้งานได้โดยปริยายโดย¡ไม่จำเป็นต้องห่อ1ในรายการเนื่องจากข้อเท็จจริงที่ว่าเยลลี่พิมพ์รายการหนึ่งรายการเหมือนกับรายการ)
-1 ขอบคุณ Erik the Outgolfer (ใช้Ɗเพื่อบันทึกบรรทัดใหม่จากการใช้Ç)

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

Python 2 , 120 107 104 103 100 99 89 ไบต์

f=lambda n,l:n and[x*y for i,x in enumerate(l)for y in[f(n-1,l),[sum(l)**~-n]][i%2]]or[1]

ลองออนไลน์!

ที่บันทึกไว้

• -10 ไบต์ขอบคุณ Neil

R , 94 ไบต์

f=function(n,a)"if"(n,unlist(Map(function(g,i)g(i),c(c,sum),split(m<-a%o%f(n-1,a),row(m)))),1)

ลองออนไลน์!

Haskell , 76 58 ไบต์

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

ลองออนไลน์!

ฟังก์ชัน(%)ใช้รายการความยาวบรรทัดlเป็นอาร์กิวเมนต์แรกและจำนวนการวนซ้ำnเป็นอินพุตที่สอง

ขอบคุณ Angs และØrjan Johansen สำหรับ -18 ไบต์!

JavaScript (Firefox 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]

ต้องการเวอร์ชันเฉพาะเหล่านั้นเนื่องจากใช้ทั้งความเข้าใจในอาร์เรย์และการยกกำลัง

JavaScript (Node.js) , 71 ไบต์

l=>f=(n,c=1,e)=>n--?''+l.map(_=>(e=!e)?f(n,c*_):eval(l.join`+`)**n*c):c

ลองออนไลน์!

Java 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`

เยลลี่ขนาด 13 ไบต์

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

ลองออนไลน์!

โปรแกรมเต็มรูปแบบ ขาออกแทน1 [1]น่ารำคาญḋไม่ชอบ×S¥ในบริบทนี้และƭทำงานได้ดีกับ nilads > _ <

APL (Dyalog Classic)ขนาด 20 ไบต์

{(∊⊢×⍵(+/⍵)⍴⍨≢)⍣⍺,1}

ลองออนไลน์!

K (ngn / k) , 27 ไบต์

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

ลองออนไลน์!

{ }เป็นฟังก์ชันที่มีอาร์กิวเมนต์xและy

(y;+/y)คู่yและผลรวมของมัน

{ }[(y;+/y)]เส้นโครง (หรือที่รู้จักกันในชื่อการปิดบังหรือการประยุกต์บางส่วน) ของฟังก์ชัน dyadic ด้วยอาร์กิวเมนต์หนึ่งตัว xจะเป็น(y;+/y)และyจะเป็นข้อโต้แย้งเมื่อนำไปใช้

,1 รายการเดี่ยวที่มี 1

x{ }[ ]/ใช้xเวลาฉาย

(#y)#x ก่อร่างใหม่ตามความยาวของผลลัพธ์ปัจจุบันเช่นสลับระหว่างด้านนอก yและผลรวม

y* คูณแต่ละองค์ประกอบของข้างบนด้วยองค์ประกอบที่สอดคล้องกันของผลลัพธ์ปัจจุบัน

,/ concatenate

Ruby , 73 ไบต์

->a,l{r=[1];a.times{s=p;r=r.flat_map{|x|(s=!s)?l.map{|y|x*y}:x*l.sum}};r}

ลองออนไลน์!

Pyth , 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