Vấn đề

Chúng ta hãy xác định một Cantor tổng quát được đặt bằng cách lặp đi lặp lại xóa một số phân đoạn có độ dài hợp lý từ giữa tất cả các khoảng chưa được xóa, bắt đầu từ một khoảng liên tục duy nhất.

Với độ dài tương đối của các phân đoạn có nên xóa hay không và số lần lặp để thực hiện, vấn đề là viết một chương trình hoặc hàm tạo ra độ dài tương đối của các phân đoạn đã hoặc chưa bị xóa sau các nlần lặp.

Ví dụ: Lặp lại xóa lần thứ 4 và thứ 6

Đầu vào:

n - số lần lặp, được lập chỉ mục bắt đầu từ 0 hoặc 1

l- danh sách các độ dài phân đoạn dưới dạng số nguyên dương gcd(l)=1và độ dài lẻ, biểu thị độ dài tương đối của các phần tồn tại khi chúng bị xóa hoặc bị xóa, bắt đầu từ một phân đoạn không bị xóa. Vì độ dài danh sách là số lẻ, các phân đoạn đầu tiên và cuối cùng không bao giờ bị xóa. Ví dụ, đối với Cantor thông thường, giá trị này sẽ là [1,1,1] cho một phần ba còn lại, một phần ba bị xóa và một phần ba thì không.

Đầu ra:

Danh sách số nguyên o,, có gcd(o)=1độ dài phân đoạn tương đối trong nlần lặp thứ năm khi các phân đoạn không bị xóa trong lần lặp trước được thay thế bằng bản sao thu nhỏ của danh sách l. Lặp lại đầu tiên chỉ là [1]. Bạn có thể sử dụng bất kỳ phương thức đầu ra rõ ràng nào , thậm chí là đơn nguyên.

Ví dụ

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]

Bạn có thể giả sử đầu vào là hợp lệ. Đây là môn đánh gôn , vì vậy chương trình ngắn nhất được tính bằng byte sẽ thắng.

Thạch ,  15 13  12 byte

-2 nhờ Dennis (sử dụng Liên kết chứ không phải chuỗi cho phép quyền được sử dụng hoàn toàn bằng cách ¡; Không cần phải bọc 1trong danh sách do thực tế là Jelly in danh sách một mặt hàng giống như mặt hàng)
-1 nhờ Erik the Outgolfer (sử dụng Ɗđể lưu dòng mới từ việc sử dụng Ç)

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

Một chương trình đầy đủ in một danh sách ở định dạng Jelly ( [1]được in dưới dạng 1)

Hãy thử trực tuyến!

Làm sao?

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 byte

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]

Hãy thử trực tuyến!

Đã lưu

• -10 byte, nhờ Neil

R , 94 byte

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)

Hãy thử trực tuyến!

Haskell , 76 58 byte

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

Hãy thử trực tuyến!

Hàm (%)lấy danh sách độ dài dòng llàm đối số thứ nhất và số lần lặp nlàm đầu vào thứ hai.

Cảm ơn Angs và Ørjan Johansen cho -18 byte!

JavaScript (Firefox 42-57), 80 byte

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]

Cần những phiên bản cụ thể bởi vì nó sử dụng cả mảng hiểu và lũy thừa.

JavaScript (Node.js) , 71 byte

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

Hãy thử trực tuyến!

Java 10, 261 byte

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);}}}}

Sửa đổi danh sách đầu vào thay vì trả về một cái mới để lưu byte.

Hãy thử trực tuyến.

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`

Thạch , 13 byte

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

Hãy thử trực tuyến!

Chương trình đầy đủ. Đầu ra 1thay vì [1]. Khó chịu, ḋkhông hoạt động như ×S¥trong bối cảnh này, và ƭkhông hoạt động tốt với nilad. > _ <

APL (Dyalog Classic) , 20 byte

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

Hãy thử trực tuyến!

K (ngn / k) , 27 byte

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

Hãy thử trực tuyến!

{ }là một hàm với các đối số xvày

(y;+/y)một cặp yvà tổng của nó

{ }[(y;+/y)]phép chiếu (còn gọi là currying hoặc ứng dụng một phần) của hàm dyadic với một đối số. xsẽ (y;+/y)và ysẽ là đối số khi áp dụng.

,1 danh sách đơn có chứa 1

x{ }[ ]/áp dụng xthời gian chiếu

(#y)#xđịnh hình lại theo chiều dài của kết quả hiện tại, tức là xen kẽ giữa bên ngoài yvà tổng của nó

y* nhân từng phần tử ở trên với phần tử tương ứng của kết quả hiện tại

,/ ghép

Ruby , 73 byte

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

Hãy thử trực tuyến!

Bình thường , 20 byte

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

Đầu vào là mảng phân đoạn l, sau đó lặp lại n. Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

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