Chọn một danh sách


20

Hãy xem xét quá trình "chọn" một danh sách lồng nhau. Chọn được định nghĩa như sau:

  • Nếu đối số là một danh sách, hãy lấy một phần tử từ danh sách một cách ngẫu nhiên (thống nhất) và chọn từ đó.
  • Nếu đối số không phải là một danh sách, chỉ cần trả lại nó.

Một ví dụ triển khai trong Python:

import random
def pick(obj):
    if isinstance(obj, list):
        return pick(random.choice(obj))
    else:
        return obj

Để đơn giản, chúng tôi giả định rằng danh sách lồng nhau chỉ chứa số nguyên hoặc danh sách lồng nhau.

Với bất kỳ danh sách nào, có thể tạo ra một phiên bản phẳng không thể phân biệt bằng cách pickchọn từ nó mang lại kết quả tương tự, với cùng một xác suất.

Ví dụ: "chọn làm phẳng" danh sách

[1, 2, [3, 4, 5]]

mang lại danh sách

[1, 1, 1, 2, 2, 2, 3, 4, 5]

. Lý do đơn giản làm phẳng là không hợp lệ là vì các yếu tố của danh sách phụ có xác suất được chọn thấp hơn, ví dụ: trong danh sách [1, [2, 3]]1 có 2/4 = 1/2 cơ hội được chọn trong khi cả 3 và 4 đều có 1/4 cơ hội từng.

Cũng lưu ý rằng chọn từ danh sách đơn tương đương với chọn từ phần tử của nó và việc chọn từ danh sách trống không có ý nghĩa.

Các thách thức

Đưa ra một danh sách các số nguyên không âm lồng nhau, trả về một danh sách các số nguyên không âm được làm phẳng từ đó chọn kết quả cho cùng kết quả với cùng một xác suất.

Đây là , vì vậy câu trả lời hợp lệ ngắn nhất (tính bằng byte) sẽ thắng.

Thông số kỹ thuật

  • Các đầu vào [2, 3, 4], [2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4][2, [3, 3], [[4]]]tương đương (nghĩa là chúng sẽ cho kết quả tương đương).
  • Các đầu ra [2, 2, 2, 2, 3, 3, 3, 3][2, 3]tương đương (nghĩa là một trong hai có thể là đầu ra).
  • Bạn chỉ có thể giả sử các số trong phạm vi bao gồm 1-100 sẽ có mặt trong danh sách.
  • Bạn có thể giả sử đầu vào cấp cao nhất sẽ là một danh sách, tức 2là không phải là đầu vào hợp lệ.
  • Bạn có thể sử dụng bất kỳ đại diện hợp lý các danh sách lồng nhau, ví dụ:
    [1, [2, 3]], 1 {2 3}, "[ 1 [ 2 3 ] ]"vv
  • Thay vì danh sách, bạn có thể xuất nhiều trang hoặc ánh xạ hoặc, vì chỉ cho phép các số trong phạm vi 1-100, danh sách số nguyên dài 100 đại diện cho số lượng.

Các trường hợp thử nghiệm

Lưu ý rằng các đầu ra được liệt kê chỉ là một khả năng hợp lệ; xem thông số kỹ thuật cho những gì cấu thành đầu vào hoặc đầu ra hợp lệ.

format:
input -> output
[3]                          -> [3]
[1, [1, 1]]                  -> [1]
[1, [2, 3]]                  -> [1, 1, 2, 3]
[2, 3, [4, [5, 5, 6], 6, 7]] -> [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7]
[[1, 1, 2], [2, 3, 3]]       -> [1, 2, 3]
[[1, 1, 2], [2, 3, 3, 3]]    -> [1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3]

Với tùy chọn mã hóa độ dài và phạm vi giới hạn, chúng ta có thể thay thế một danh sách 100 phần tử mô tả sự xuất hiện của mỗi số nguyên không? (sẽ dẫn đến nhiều số không cho các ví dụ đã cho)
Uriel

@Uriel Chắc chắn; Tôi sẽ điều chỉnh lại nó.
Esolanging Fruit

Câu trả lời:


8

Ngôn ngữ Wolfram (Mathicala) , 41 20 byte

Flatten@*Tuples//@#&

Hãy thử trực tuyến! Bỏ qua nhiều cảnh báo, cuối cùng tất cả đều hoạt động.

Làm thế nào nó hoạt động

Đối với danh sách độ sâu 2 như {{1,2},{3},{4,5,6}}, Tuplessẽ tạo danh sách {{1,3,4},{1,3,5},{1,3,6},{2,3,4},{2,3,5},{2,3,6}}tương ứng với tất cả các cách để chọn một phần tử từ {1,2} chọn một phần tử từ {3} chọn một phần tử từ đó {4,5,6}.

Nếu chúng ta làm Flattenđiều này, thì chúng ta sẽ có được tất cả các phần tử với tần số chính xác, bởi vì chọn một phần tử từ một trong số đó {1,2}, {3}hoặc {4,5,6}tương đương với việc chọn một phần tử từ tất cả chúng, sau đó chọn phần tử nào để giữ.

Chúng tôi sử dụng //@để áp dụng điều này ở tất cả các cấp của đầu vào. Trong quá trình này, Mathicala phàn nàn rất nhiều, bởi vì nó biến các nguyên tử như 17thành Tuples[17], thứ thực sự không phải là một thứ. Nhưng những điều này đơn giản hóa để đạt được kết quả đúng sau này ( Tuplesrất vui khi được coi Tuples[17]là danh sách có độ dài 1, ngay cả khi nó có phần đầu khác List), vì vậy việc phàn nàn là không liên quan.



4

Thạch , 9 8 byte

߀Œp$¬¡F

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

Làm thế nào nó hoạt động

߀Œp$¬¡F  Main link. Argument: x (array or positive integer)

     ¬    Compute elementwise logical NOT of x: a non-empty array for a non-empty array, 0 for a positive integer.
      ¡   Apply the link to the left once if ¬ returned a non-empty
          array, zero timed if it returned 0.
    $     Monadic chain:
߀            Map the main link over x.
  Œp          Take the Cartesian product.
       F  Flatten the result.



1

C (gcc) , 234 223 byte

h[9][101];o[101];n[9];l;L;e;main(x){for(;(x=scanf("%d",&e))>=0;x?++h[l][e],++n[l]:(e=getchar())-'['?e-']'?0:--l:++l>L&&++L);for(e=1,l=L+1;l--;){for(x=101;--x;o[x]+=e*h[l][x]);e*=n[l];}while(o[x]--?printf("%d ",x):++x<101);}

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

Giải trình:

h[9][101];  // <- number occurences per nesting level
o[101];     // <- number occurences in "flattened" array
n[9];       // <- number of entries per nesting level
l;          // <- current nesting level
L;          // <- max nesting level
e;          // <- multi-purpose temporary
main(x){    // x: multi-purpose temporary
    for(;
            // while not EOF try reading number
            (x=scanf("%d",&e))>=0;

            // number was read?
            x

                // then increment occurence and # entries in level
                ?++h[l][e],++n[l]

                // else read any character ... if not [
                :(e=getchar())-'['

                    // if not ]
                    ?e-']'

                        // do nothing
                        ?0

                        // else decrement nesting level
                        :--l

                    // else increment nesting level and adjust max level
                    :++l>L&&++L);

    // init factor in e to 1, iterate over nesting level from innermost
    for(e=1,l=L+1;l--;){

        // iterate over all numbers
        for(x=101;
                --x;

                // add factor times occurence on current level to output
                o[x]+=e*h[l][x]);

        // multiply factor by number of entries on current level
        e*=n[l];
    }

    // iterate over all numbers and output count times
    while(o[x]--?printf("%d ",x):++x<101);
}



0

JavaScript (ES6), 132 131 byte

f=A=>(_=(a,m)=>[].concat(...a.map(m)),n=1,A=A.map(a=>a.map?f(a):[a]),_(A,a=>n*=a.length),_(A,a=>_(a.map(x=>Array(n/a.length).fill(x)))))

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.