Câu trả lời cho câu hỏi này quá dài

Thử thách của bạn là viết một hàm phân vùng với số lượng ký tự nhỏ nhất.

Ví dụ đầu vào

['a', 'b', 'c']

Ví dụ đầu ra

[(('a'),('b'),('c')),
 (('a', 'b'), ('c')),
 (('a', 'c'), ('b')),
 (('b', 'c'), ('a')),
 (('a', 'b', 'c'))]

Đầu vào có thể là một danh sách / mảng / bộ / chuỗi, vv bất cứ điều gì dễ dàng nhất để chức năng của bạn xử lý

Bạn cũng có thể chọn định dạng đầu ra cho phù hợp với bản thân miễn là cấu trúc rõ ràng.

Chức năng của bạn phải hoạt động cho ít nhất 6 mục trong đầu vào

GolfScript (43 ký tự)

{[[]]:E\{:v;{:^E+1/{^1$-\[~[v]+]+}/}%}/}:P;

hoặc là

{[[]]:E\{:v;{:^E+1/{^1$-\{[v]+}%+}/}%}/}:P;

Định dạng đầu vào, định dạng đầu ra và tên hàm giống như giải pháp của Howard. Không có sự ép buộc nào: điều này có cách tiếp cận lặp đơn giản là thêm một phần tử từ danh sách đầu vào vào phân vùng mỗi lần vòng quanh vòng ngoài.

GolfScript, 51 ký tự

{[[]]\{[.;]`{1$[1$]+@@`1$`{[2$]-@@[+]+}++/}+%}/}:P;

Kịch bản lệnh xác định một biến Plấy một mảng từ đầu ngăn xếp và đẩy lùi danh sách tất cả các phân vùng, ví dụ:

[1 2] P            # => [[[1] [2]] [[1 2]]]
["a" "b" "c"] P    # => [[["a"] ["b"] ["c"]] [["b"] ["a" "c"]] [["a"] ["b" "c"]] [["a" "b"] ["c"]] [["a" "b" "c"]]]

Nó cũng hoạt động trên các danh sách lớn hơn:

6, P ,p            # prints 203, i.e. Bell number B6
8, P ,p            # 4140

Bạn có thể thực hiện các bài kiểm tra trực tuyến .

J, 51 ký tự

([:<a:-.~])"1~.((>:@i.#:i.@!)#l)<@;/."1[l=:;:1!:1[1

Lấy đầu vào từ bàn phím, các mục được phân tách bằng dấu cách:

   ([:<a:-.~])"1~.((>:@i.#:i.@!)#l)<@;/."1[l=:;:1!:1[1
a b c
+-----+------+------+------+-------+
|+---+|+--+-+|+--+-+|+-+--+|+-+-+-+|
||abc|||ab|c|||ac|b|||a|bc|||a|b|c||
|+---+|+--+-+|+--+-+|+-+--+|+-+-+-+|
+-----+------+------+------+-------+

Haskell, 90 87 71 66

Đã lưu 5 byte nhờ nimi .

x#[]=[[[x]]]
x#(y:s)=((x:y):s):map(y:)(x#s)
p=foldr((=<<).(#))[[]]

Thí dụ:

*Main> p "abc"
[["abc"],["bc","a"],["ac","b"],["c","ab"],["c","b","a"]]

Python 2, 131 byte

def P(L):
 if len(L)<2:yield[L];return
 for p in P(L[1:]):
	for n,s in enumerate(p):yield p[:n]+[[L[0]]+s]+p[n+1:]
	yield[[L[0]]]+p

Dùng thử trực tuyến

Sử dụng thuật toán này .