Визначення проблеми

Роздрукуйте живлення даного набору. Наприклад:

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

Кожен елемент повинен бути надрукований на окремому рядку, тому приклад, що наведено вище, буде надрукований як:

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

Приклад коду (в D, приклад python тут ):

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

Вхідні дані

Елементи будуть передані як аргументи. Наприклад, наведений вище приклад буде переданий програмі під назвоюpowerset назвою:

powerset 1 2 3

Аргументи будуть буквено-цифровими.

Правила

1. Жодної бібліотеки, крім іо
2. Вихідні дані не потрібно замовляти
3. Powerset не потрібно зберігати, а лише друкувати
4. Елементи в наборі повинні бути обмежені (наприклад 1,2,3, [1,2,3]і ['1','2','3']є прийнятними, але123 ні
   • Трейлінг-роздільники прекрасні (наприклад 1,2,3, == 1,2,3)
5. Кращий визначається на основі кількості байтів

Найкраще рішення буде прийнято не менше ніж через 10 днів після першого подання.

Математика 16

Код

Subsets є рідним для Mathematica.

Column@Subsets@s

Код (без стовпця) можна перевірити на WolframAlpha . (Мені довелося використовувати дужки замість @; вони означають те саме.

Використання

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

Цей метод (55 символів) використовує підхід, запропонований @ w0lf.

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

Зламатися

Створіть кортежі, складені з довжини 0і 1'sLength[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}}

Помножте початковий список (вектор) на кожен кортеж:

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

Видаліть 0.%є скороченням для "попереднього виходу".

% /. {0:> Послідовність []}

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

Відображення в стовпці:

С, 118 115

Хоча ви можете заощадити приблизно 20 символів при більш простому форматуванні, але все одно не вигравати в кодовому вигляді гольфу в будь-якому випадку.

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

Тестування:

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

GolfScript, 22 18 символів

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

Ще одна спроба у GolfScript із зовсім іншим алгоритмом. Формат введення такий же, як і у відповіді w0lf. ( онлайн-тест )

GolfScript (43 символи)

Це може здатися досить довгим, але це перше рішення, яке слід виконати за специфікацією: введення - з аргументів командного рядка, а вихід - з обмеженим рядком.

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

Напр

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

awk (82)

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

припустимо збережений у файлі powerset.awk, використання

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

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

ps, якщо у вашого awk немає та () функції, замініть його, int(i/(2^j))%2але додайте два до рахунку.

JavaScript, 98

На жаль, хороший шматок витрачається на форматування вихідних даних.

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

Вхідні дані

Займає масив JavaScript. (наприклад, [1,2,3])

Вихідні дані

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

Пітон ( 74 70 символів)

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

для введення як 1,2,3або [1,2,3], вихід:

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

Python 70 67 байт

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

Введення приймається таким же чином, як і для розчину ugoren . Зразок вводу / виводу:

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

J, 19 символів

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

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

Бокс Ascii на виході називається boxingі забезпечує збір гетерогену (для різної довжини масивів тут).

Гольфскрипт 48

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

Ця програма використовує двійкові представлення чисел від 0 до довжини (вхідних даних) для генерування елементів живлення.

Вхідні дані

Формат введення - це формат масиву Golfscript (приклад: [1 2 3] )

Вихідні дані

Вихід - це сукупність масивів, розділених новими рядками, що представляють набір потужності. Приклад:

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

Інтернет-тест

Програму можна перевірити онлайн тут .

Хаскелл (96)

імпорт Control.Monad
Система імпорту. Навколишнє середовище
main = getArgs >> = mapM print.filterM (\ _-> [False ..])

Якщо імпорт Control.Monadзаборонено, це стає 100 символів:

Система імпорту. Навколишнє середовище
main = getArgs >> = mapM print.p
pz = випадок z {[] -> [[]]; x: y-> p y ++ карта (x:) (py)}

Математика 53

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

APL (26)

Читає дані з клавіатури, тому що немає argvеквівалента.

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

Використання:

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

Пояснення:

• T←⎕: читати вхід, зберігати в T
• M←⍴T: довжина магазину TвM
• (M/2)⊤⍳2*M: генерувати бітові шаблони для 1upto 2^Mза допомогою Mбітів.
• ↓⍉: розділіть матрицю так, щоб кожен бітовий шаблон був окремим
• (/∘T)¨: для кожного бітового шаблону виберіть ці підпункти з T.
• ↑⍕¨: для виводу отримайте рядкове подання кожного елемента (так що він заповнюватиметься пробілами, а не нулями) та відформатувати як матрицю (так, щоб кожен елемент знаходився у власному рядку).

Скала, 81

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

JavaScript ( ES6 ) 76

Частково скопійовано з цього: /codegolf//a/51502/21348

Використовуючи растрову карту, вона обмежується не більше 32 елементами.

Запустіть фрагмент у Firefox для тестування.

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

Людина це важко в 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 bytes

Використовуючи розділений комою вхід:

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

Pyth, 4 байти (використовуючи вбудований) або 14 байт (без)

Як зазначив @Jakube в коментарях, Pyth є занадто останнім для цього питання. Ще є рішення з використанням вбудованого оператора набору потужностей Pyth:

jbyQ

І ось один без цього:

jbu+Gm+d]HGQ]Y

Ви можете спробувати обидва рішення тут і тут . Ось пояснення другого рішення:

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

мозковий ебать, 94 байти

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

Відформатовано:

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

Очікує введення форми 9,10,11 без закінчення нового рядка та виводить підмножини у тому самому форматі, іноді із комою. Перший рядок, надрукований завжди буде порожнім, означає порожній набір.

Спробуйте в Інтернеті.

Основна ідея полягає в тому, щоб розмістити трохи поруч з кожним елементом, а потім повторно збільшувати двійкове число під час друку відповідного підмножини перед кожним збільшенням. (Біт вказує, чи є елемент у підмножині.) Біт дозорного зліва від масиву використовується для завершення програми. Ця версія фактично створює експоненціальну кількість дозорних, щоб зберегти деякі байти; в історії версій можна знайти більш ефективне 99-байтове рішення, яке використовує лише один дозорний.

Each bit is encoded as one plus its value; i.e., it can be either 1 or 2. The tape is laid out with the bit before each element and a single zero cell between adjacent elements. The comma is included on the tape for non-final elements, so we can conveniently just print elements without doing any extra work to handle delimiters.

APL (Dyalog Classic), 13 bytes

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

Try it online!

Output:

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

There's a blank line at the end to represent the empty set.

Explanation:

⎕ evaluated input

⎕,¨⊂⊂⍬ append an empty numeric list after each element

∘., Cartesian product

/ reduction (foldr)

⊃ disclose (necessary after reduction in APL)

At this point the result is an n-dimensional 2-by-...-by-2 array, where n is the length of the input.

, flatten into a vector

⍪ turn the vector into an upright 2ⁿ-by-1 matrix, so each subset is on a separate line

Haskell, 80 78 bytes

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

Try it online!

Jelly, 6 bytes

ŒPŒṘ€Y

Try it online!

ŒṘ€Y are string formatting.

Python, 93 87 chars

Python makes formatting simple, because the required input/output matches its native format.
Only supports items which are Python literals (e.g. 1,2,'hello', not 1,2,hello).
Reads standard input, not parameters.

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 chars

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

Getting parameters is long :/

R, 63

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

Here, v represents a vector.

Usage:

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 bytes

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

Generate all 0/1 vectors as long as the input, gather the indices of 1s and use those to select elements from the input vector. In practice:

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

This is a bit liberal with the output requirements, but I think it's legal. The most questionable part is that the empty set will be represented in a type dependent form; !0 is how K denotes an empty numeric vector:

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

Explanation

The (#x)#2 builds a vector of 2 as long as the input:

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

When monadic ! is applied to a vector, it is "odometer":

  !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)

Then we use "where" (&) on each (') vector to gather its indices. The colon is necessary to disambiguate between the monadic and dyadic form of &:

  &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)

If we just wanted combination vectors, we'd be done, but we need to use these as indices into the original set. Fortunately, K's indexing operator @ can accept a complex structure of indices and will produce a result with the same shape:

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

Elegant, no?

Mathematica, 51

More cheating:

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

Use with @{1,2,3}.

JavaScript (ES6), 68 bytes

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

Demo

let f =

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

f([1,2,3])

Brachylog, 4 bytes

⊇ᵘẉᵐ

Try it online!

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

Ruby Array method combination (from 1.9 ) [50 chars]

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