Định nghĩa vấn đề

In ra bộ quyền hạn của một bộ nhất định. Ví dụ:

[1, 2, 3] => [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]

Mỗi phần tử sẽ được in trên một dòng riêng biệt, vì vậy ví dụ trên sẽ được in dưới dạng:

[]
[1]
[2]
...
[1, 2, 3]

Mã ví dụ (trong D, ví dụ python ở đây ):

import std.stdio;

string[][] powerset(string[] set) {
    if (set.length == 1) {
        return [set, []];
    }

    string[][] ret;
    foreach (item; powerset(set[1 .. $])) {
        ret ~= set[0]~item;
        ret ~= item;
    }

    return ret;
}

void main(string[] argv) {
    foreach (set; powerset(argv[1 .. $]))
        writeln(set);
}

Đầu vào

Các yếu tố sẽ được thông qua dưới dạng đối số. Ví dụ: ví dụ được cung cấp ở trên sẽ được chuyển đến một chương trình có tên powersetlà:

powerset 1 2 3

Đối số sẽ là chữ và số.

Quy tắc

1. Không có thư viện ngoài io
2. Đầu ra không phải đặt hàng
3. Powerset không phải được lưu trữ, chỉ được in
4. Các yếu tố trong tập phải được phân định (ví dụ 1,2,3, [1,2,3]và ['1','2','3']được chấp nhận, nhưng 123không phải là
   • Dấu phân cách lưu trữ là tốt (ví dụ 1,2,3, == 1,2,3)
5. Tốt nhất được xác định dựa trên số byte

Giải pháp tốt nhất sẽ được quyết định không dưới 10 ngày sau lần gửi đầu tiên.

Toán 16

Mã

Subsets có nguồn gốc từ Mathicala.

Column@Subsets@s

Mã (không có cột) có thể được xác minh trên WolframAlpha . (Tôi đã phải sử dụng dấu ngoặc thay vì @; chúng có nghĩa tương tự.

Sử dụng

s={1,2,3}
Column@Subsets@s

Phương pháp này (55 ký tự) sử dụng phương pháp được đề xuất bởi @ w0lf.

s #&/@Tuples[{0,1},Length@s]/.{0:>Sequence[]}//Column

Phá vỡ

Tạo các bộ dữ liệu, bao gồm 0và 1chiều dàiLength[s]

Tuples[{0, 1}, Length@s]

{{0, 0, 0}, {0, 0, 1}, {0, 1, 0}, {0, 1, 1}, {1, 0, 0}, {1, 0, 1}, { 1, 1, 0}, {1, 1, 1}}

Nhân danh sách gốc (vectơ) cho mỗi bộ:

s # & /@ Tuples[{0, 1}, Length@s]

{{0, 0, 0}, {0, 0, 3}, {0, 2, 0}, {0, 2, 3}, {1, 0, 0}, {1, 0, 3}, { 1, 2, 0}, {1, 2, 3}}

Xóa các 0. %là viết tắt của "đầu ra trước".

% /. {0:> Trình tự []}

{{}, {3}, {2}, {2, 3}, {1}, {1, 3}, {1, 2}, {1, 2, 3}}

Hiển thị trong cột:

C, 118 115

Mặc dù có thể lưu khoảng 20 ký tự với định dạng đơn giản hơn, nhưng vẫn không thể giành chiến thắng trong các thuật ngữ golf mã.

x,i,f;
main(int a,char**s){
    for(;x<1<<a;x+=2,puts("[]"+f))
        for(i=f=0;++i<a;)x&1<<i?f=!!printf("%c%s","[,"[f],s[i]):0;
}

Kiểm tra:

/a.out 1 2 3
[]
[1]
[2]
[1,2]
[3]
[1,3]
[2,3]
[1,2,3]

GolfScript, 22 18 ký tự

~[[]]{{+}+1$%+}@/`

Một nỗ lực khác trong GolfScript với một thuật toán hoàn toàn khác. Định dạng đầu vào giống như với câu trả lời của w0lf. ( kiểm tra trực tuyến )

GolfScript (43 ký tự)

Điều này có vẻ khá dài, nhưng đó là giải pháp đầu tiên để theo thông số kỹ thuật: đầu vào là từ các đối số dòng lệnh và đầu ra được phân định bằng dòng mới.

"#{ARGV.join('
')}"n/[[]]\1/{`{1$+.p}+%}%p;

Ví dụ

$ golfscript.rb powset.gs 1 2 3
["1"]
["2"]
["2" "1"]
["3"]
["3" "2"]
["3" "1"]
["3" "2" "1"]
[]

ôi (82)

{for(;i<2^NF;i++){for(j=0;j<NF;j++)if(and(i,(2^j)))printf "%s ",$(j+1);print ""}}

giả sử được lưu trong tập tin powerset.awk, cách sử dụng

$ echo 1 2 3 | awk -f powerset.awk

1
2
1 2
3
1 3
2 3
1 2 3

ps nếu awk của bạn không có hàm và (), hãy thay thế nó bằng int(i/(2^j))%2nhưng thêm hai vào số đếm.

JavaScript, 98

Đáng buồn thay, một đoạn tốt được dành cho định dạng đầu ra.

for(n in a=eval(prompt(i=p=[[]])))
    for(j=i+1;j;)
        p[++i]=p[--j].concat(a[n]);
alert('[]'+p.join('\n'))

Đầu vào

Có một mảng JavaScript. (ví dụ: [1,2,3])

Đầu ra

[]
1
1,2
2
2,3
1,2,3
1,3
3

Con trăn ( 74 70 ký tự)

def p(a,v):
 if a:i,*a=a;p(a,v);p(a,v+[i])
 else:print v
p(input(),[])

cho đầu vào là 1,2,3hoặc [1,2,3], đầu ra là:

[]
[3]
[2]
[2, 3]
[1]
[1, 3]
[1, 2]
[1, 2, 3]

Python 70 67 byte

def p(a,*v):
 i=0;print v
 for n in a:i+=1;p(a[i:],n,*v)
p(input())

Đầu vào được thực hiện theo cách tương tự như đối với giải pháp của ugoren . Mẫu I / O:

$ echo [1,2,3] | powerset.py
()
(1,)
(2, 1)
(3, 2, 1)
(3, 1)
(2,)
(3, 2)
(3,)

J, 19 ký tự

   (<@#~#:@i.@(2&^)@#)

   (<@#~#:@i.@(2&^)@#) 1 2 3
┌┬─┬─┬───┬─┬───┬───┬─────┐
││3│2│2 3│1│1 3│1 2│1 2 3│
└┴─┴─┴───┴─┴───┴───┴─────┘

Quyền anh ascii trong đầu ra được gọi boxingvà cung cấp bộ sưu tập heterogen (cho các chiều dài khác nhau của mảng ở đây).

Golf 48

~:x,:§2\?,{[2base.,§\-[0]*\+x\]zip{~{}{;}if}%p}%

Chương trình này sử dụng các biểu diễn nhị phân của các số từ 0 đến chiều dài (đầu vào) để tạo các mục powerset.

Đầu vào

Định dạng đầu vào là định dạng mảng Golfscript (ví dụ: [1 2 3] :)

Đầu ra

Đầu ra là một tập hợp các mảng được phân tách bằng các dòng mới, đại diện cho tập hợp sức mạnh. Thí dụ:

[]
[3]
[2]
[2 3]
[1]
[1 3]
[1 2]
[1 2 3]

Bài kiểm tra trực tuyến

Chương trình có thể được kiểm tra trực tuyến tại đây .

Haskell (96)

kiểm soát nhập khẩu
Hệ thống nhập khẩu. Môi trường
main = getArss >> = mapM print.filterM (\ _-> [Sai ..])

Nếu nhập Control.Monadkhông được phép, điều này trở thành 100 ký tự:

Hệ thống nhập khẩu. Môi trường
main = getArss >> = mapM print.p
pz = trường hợp z của {[] -> [[]]; x: y-> p y ++ map (x :) (py)}

Toán học 53

Column@Fold[#~Join~Table[x~Join~{#2},{x,#}]&,{{}},#]&

APL (26)

Đọc đầu vào từ bàn phím vì không có argvtương đương.

↑⍕¨(/∘T)¨↓⍉(M/2)⊤⍳2*M←⍴T←⎕

Sử dụng:

      ↑⍕¨(/∘T)¨↓⍉(M/2)⊤⍳2*M←⍴T←⎕
⎕:
      1 2 3
3    
2    
2 3  
1    
1 3  
1 2  
1 2 3

Giải trình:

• T←⎕: đọc đầu vào, lưu trữ trong T
• M←⍴T: chiều dài cửa hàng TtrongM
• (M/2)⊤⍳2*M: tạo các mẫu bit cho 1tối đa 2^Mbằng cách sử dụng Mbit.
• ↓⍉: chia ma trận sao cho mỗi mẫu bit riêng biệt
• (/∘T)¨: cho mỗi mẫu bit, chọn các mục con từ đó T.
• ↑⍕¨: cho đầu ra, lấy biểu diễn chuỗi của từng phần tử (để nó sẽ điền vào bằng cách sử dụng khoảng trắng và không phải số 0) và định dạng dưới dạng ma trận (sao cho mỗi phần tử nằm trên một dòng riêng).

Scala, 81

def p[A](x:Seq[A]){x.foldLeft(Seq(Seq[A]()))((a,b)=>a++a.map(b+:_)).map(println)}

JavaScript ( ES6 ) 76

Một phần được sao chép từ cái này: /codegolf//a/51502/21348

Sử dụng một bitmap, do đó, nó bị giới hạn không quá 32 phần tử.

Chạy đoạn trích trong Firefox để kiểm tra.

f=l=>{ 
  for(i=0;i<1<<l.length;i++)
    console.log(l.filter(v=>[i&m,m+=m][0],m=1))
}  

// TEST

// Redefine console to have output inside the page
console = { log: (...p) => O.innerHTML += p.join(' ') + '\n' }

test=()=>{
  var set = I.value.match(/[^ ,]+/g)
  O.innerHTML='';
  f(set);
}

test()

#I,#O { border: 1px solid #aaa; width: 400px; padding:2px}

Insert values, space or comma separated:<br>
<input id=I value='1 2 3'> <button onclick="test()">-></button>
<pre id=O></pre>

C # 164

Người đàn ông này thật khó trong C #!

void P<T>(T[]c){foreach(var d in c.Aggregate<T,IEnumerable<IEnumerable<T>>>(new[]{new T[0]},(a,b)=>a.Concat(a.Select(x=>x.Concat(new[]{b})))))Console.WriteLine(d);}

Python 2, 64 byte

Sử dụng đầu vào được phân tách bằng dấu phẩy:

P=[[]]
for i in input():P+=[s+[i]for s in P]
for s in P:print s

Pyth, 4 byte (sử dụng dựng sẵn) hoặc 14 byte (không có)

Theo ghi nhận của @Jakube trong các bình luận, Pyth quá gần đây cho câu hỏi này. Vẫn đây là một giải pháp sử dụng toán tử lũy thừa dựng sẵn của Pyth:

jbyQ

Và đây là một cái không có nó:

jbu+Gm+d]HGQ]Y

Bạn có thể thử cả hai giải pháp ở đây và ở đây . Đây là một lời giải thích về giải pháp thứ hai:

jb       # "\n".join(
 u       #  reduce(
  +G     #   lambda G,H: G+
   m     #    map(
    +d]H #     lambda d: d+[H],
    G    #     G),
  Q      #   input()
  ]Y     #   [[]]))

Brainfuck, 94 byte

+[[<+>>+<-]++[>-<------]>-[>]<<[>>+>]>,]++++++++++[[[<]<]+[-[>[.>]]<[<]>+[>]>]<<
.[<<[<]>-]++>]

Định dạng:

+
[
  [<+> >+<-]
  ++[>-<------]>-[>]
  <<[>>+>]
  >,
]
++++++++++
[
  [[<]<]
  +
  print
  [
    -[>[.>]]
    <[<]
    >+[>]
    >
  ]
  <<.
  increment
  [
    <<[<]
    >-
  ]
  ++>
]

Mong đợi đầu vào của mẫu 9,10,11 mà không có dòng mới, và xuất ra các tập hợp con có cùng định dạng, đôi khi có dấu phẩy. Dòng đầu tiên được in sẽ luôn trống, biểu thị bộ trống.

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

Ý tưởng cơ bản là đặt một bit bên cạnh mỗi phần tử, sau đó liên tục tăng số nhị phân trong khi in tập hợp con tương ứng trước mỗi lần tăng. (Một bit cho biết liệu một phần tử có nằm trong tập hợp con hay không.) Một bit sentinel ở bên trái của mảng được sử dụng để kết thúc chương trình. Phiên bản này thực sự tạo ra một số lượng trọng điểm theo cấp số nhân để lưu một số byte; một giải pháp 99 byte hiệu quả hơn chỉ sử dụng một sentinel có thể được tìm thấy trong lịch sử sửa đổi.

Mỗi bit được mã hóa thành một cộng với giá trị của nó; ví dụ, nó có thể là một trong hai 1hoặc 2. Băng được đặt với bit trước mỗi phần tử và một ô 0 duy nhất giữa các phần tử liền kề. Dấu phẩy được bao gồm trên băng cho các phần tử không phải là cuối cùng, vì vậy chúng ta có thể thuận tiện chỉ in các phần tử mà không cần thực hiện thêm bất kỳ công việc nào để xử lý các dấu phân cách.

APL (Dyalog Classic) , 13 byte

⍪,⊃∘.,/⎕,¨⊂⊂⍬

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

Đầu ra:

 1 2 3 
 1 2   
 1 3   
 1     
 2 3   
 2     
 3     

Có một dòng trống ở cuối để thể hiện tập hợp trống.

Giải trình:

⎕ đánh giá đầu vào

⎕,¨⊂⊂⍬ nối một danh sách số trống sau mỗi phần tử

∘., Sản phẩm của Cartesian

/ giảm (gấp)

⊃ tiết lộ (cần thiết sau khi giảm APL)

Tại thời điểm này, kết quả là một mảng 2 chiều 2 chiều, trong đó n là chiều dài của đầu vào.

, san phẳng thành một vector

⍪biến vectơ thành ma trận 2 ⁿ -by-1 thẳng đứng , vì vậy mỗi tập hợp con nằm trên một dòng riêng biệt

Haskell , 80 78 byte

import System.Environment
main=getArgs>>=mapM(print.concat).mapM(\a->[[a],[]])

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

Thạch , 6 byte

ŒPŒṘ€Y

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

ŒṘ€Y là định dạng chuỗi.

Python, 93 87 ký tự

Python làm cho định dạng đơn giản, bởi vì đầu vào / đầu ra cần thiết khớp với định dạng gốc của nó.
Chỉ hỗ trợ các mục là chữ Python (ví dụ: 1,2,'hello'không 1,2,hello).
Đọc đầu vào tiêu chuẩn, không tham số.

f=lambda x:x and f(x[1:])+[x[:1]+a for a in f(x[1:])]or[()]
for l in f(input()):print l

Ruby, 39

$*.map{p *$*.combination($.)
$.+=1}
p$*

Haskell 89 ký tự

import System.Environment
main=getArgs>>=mapM print.p
p[]=[[]]
p(x:y)=(map(x:)$p y)++p y

Lấy tham số dài: /

R, 63

y=lapply(seq(v),function(x)cat(paste(combn(v,x,s=F)),sep="\n"))

Ở đây, vđại diện cho một vector.

Cách sử dụng :

v <- c(1, 2, 3)
y=lapply(seq(v),function(x)cat(paste(combn(v,x,s=F)),sep="\n"))
1
2
3
c(1, 2)
c(1, 3)
c(2, 3)
c(1, 2, 3)

K, 14 byte

{x@&:'!(#x)#2}

Tạo tất cả các vectơ 0/1 miễn là đầu vào, thu thập các chỉ số của 1s và sử dụng các vectơ đó để chọn các phần tử từ vectơ đầu vào. Trong thực tế:

  {x@&:'!(#x)#2} 1 2 3
(!0
 ,3
 ,2
 2 3
 ,1
 1 3
 1 2
 1 2 3)

Điều này là một chút tự do với các yêu cầu đầu ra, nhưng tôi nghĩ đó là hợp pháp. Phần nghi vấn nhất là tập hợp trống sẽ được biểu diễn dưới dạng phụ thuộc kiểu; !0là cách K biểu thị một vectơ số rỗng:

  0#1 2 3      / integers
!0
  0#`a `b `c   / symbols
0#`
  0#"foobar"   / characters
""

Giải trình

Việc (#x)#2xây dựng một vectơ 2miễn là đầu vào:

  {(#x)#2}1 2 3
2 2 2
  {(#x)#2}`k `d `b `"+"
2 2 2 2

Khi monadic !được áp dụng cho một vectơ, đó là "đo đường":

  !2 2 2
(0 0 0
 0 0 1
 0 1 0
 0 1 1
 1 0 0
 1 0 1
 1 1 0
 1 1 1)

Sau đó, chúng tôi sử dụng "where" ( &) trên mỗi 'vector ( ) để thu thập các chỉ số của nó. Đại tràng là cần thiết để phân tán giữa các hình thức đơn nguyên và nhuộm &:

  &0 0 1 0 1 1
2 4 5

  {&:'!(#x)#2} 1 2 3
(!0
 ,2
 ,1
 1 2
 ,0
 0 2
 0 1
 0 1 2)

Nếu chúng ta chỉ muốn các vectơ kết hợp, chúng ta sẽ hoàn thành, nhưng chúng ta cần sử dụng các vectơ này làm chỉ mục vào tập gốc. May mắn thay, toán tử lập chỉ mục của K@ có thể chấp nhận một cấu trúc phức tạp của các chỉ mục và sẽ tạo ra kết quả có cùng hình dạng:

  {x@&:'!(#x)#2} `a `c `e
(0#`
 ,`e
 ,`c
 `c `e
 ,`a
 `a `e
 `a `c
 `a `c `e)

Thanh lịch, không?

Toán học, 51

Gian lận hơn:

Column@ReplaceList[Plus@@HoldForm/@#,x___+___->{x}]&

Sử dụng với @{1,2,3}.

JavaScript (ES6), 68 byte

a=>alert(a.reduce((a,x)=>[...a,...a.map(y=>[...y,x])],[[]]).join`
`)

Bản giới thiệu

let f =

a=>alert(a.reduce((a,x)=>[...a,...a.map(y=>[...y,x])],[[]]).join`
`)

f([1,2,3])

Brachylog , 4 byte

⊇ᵘẉᵐ

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

  ẉ     Write on its own line
 ᵘ ᵐ    every unique
⊇       subset of the input.

Kết hợp phương thức Ruby Array (từ 1.9) [50 ký tự]

0.upto(ARGV.size){|a|ARGV.combination(a){|v| p v}}