समस्या की परिभाषा

किसी दिए गए सेट के अधिकार को प्रिंट करें। उदाहरण के लिए:

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

प्रत्येक तत्व को एक अलग लाइन पर मुद्रित किया जाना है, इसलिए उपरोक्त उदाहरण निम्नानुसार मुद्रित किया जाएगा:

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

उदाहरण कोड (डी में, अजगर उदाहरण यहाँ ):

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

तर्क अल्फ़ान्यूमेरिक होंगे।

नियम

Io के अलावा कोई लाइब्रेरी नहीं
आउटपुट का आदेश नहीं देना पड़ता है
पॉवर्स को संग्रहीत नहीं करना पड़ता है, केवल मुद्रित होता है
सेट में तत्वों को सीमांकित किया जाना चाहिए (जैसे 1,2,3, [1,2,3]और ['1','2','3']स्वीकार्य हैं, लेकिन 123ऐसा नहीं है
- ट्रेलिंग सीमांकक ठीक हैं (उदाहरण के लिए 1,2,3, == 1,2,3)
बेस्ट बाइट्स की संख्या के आधार पर निर्धारित किया जाता है

सबसे अच्छा समाधान पहले प्रस्तुत करने के बाद 10 दिनों से कम नहीं तय किया जाएगा।

code-golf array-manipulation combinatorics

— beatgammit
स्रोत

कोडगुल्फ.स्टैकएक्सचेंज.com

— पीटर टेलर

संबंधित: codegolf.stackexchange.com/q/51468/21348

— edc65

2

यदि केवल इस चुनौती को अद्यतन करने के लिए चूक और जैसे कार्यों की अनुमति देने के लिए अद्यतन किया गया था। पायथन 54 बाइट्स होगा lambda L:reduce(lambda r,x:r+[s+[x]for s in r],L,[[]]):।

— mbomb007

मैं केवल प्रिंट में सहमत नहीं हूँ ... डेटा, चर को भी अनुमति क्यों नहीं दी जाती ... थान क्यों कॉलम में प्रिंट करें और पंक्ति में नहीं?

— रोजलुप

15

गणितज्ञ १६

कोड

Subsets मैथमेटिका का मूल निवासी है।

Column@Subsets@s

कोड (स्तंभ के बिना) को वुल्फरामअल्फा पर सत्यापित किया जा सकता है । (मुझे इसके बजाय कोष्ठक का उपयोग करना पड़ा @, उनका मतलब वही है।

प्रयोग

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

उत्पादन

यह विधि (55 वर्ण) @ w0lf द्वारा सुझाए गए दृष्टिकोण का उपयोग करती है।

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

टूट - फूट

टुपल्स, लंबाई से बना 0और बना1Length[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}}

कॉलम में प्रदर्शित करें:

गणितज्ञ ग्राफिक्स

— DavidC
स्रोत

@tjameson मुझे इस बारे में गंभीर संदेह था कि क्या मुझे इसे पोस्ट करना चाहिए, लेकिन मुझे लगा कि कुछ लोगों को यह जानना दिलचस्प लग सकता है कि यह बिल्ट-इन है।

— 23

मुझे यह दिलचस्प लगता है :)

— डॉ। बिसरिज़री

क्या आप sलाइन से बाहर जाकर इनपुट छोड़ सकते हैं ?

— सोलोमन उको

15 बाइट्स: Subsets/*Columnएक अनाम फ़ंक्शन बनाता है जो एक सूची लेता है और कॉलम में डिस्प्ले लौटाता है।

— रोमन

9

C, 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]

— बच्चे-खरगोश
स्रोत

अच्छा लगा। कुछ सुझाव: K & R शैली ( main(a,s)char**s;{...}), f|=x&1<<i&&printfसे छोटा है ?:।

— ugoren

बस पता लगा लिया कि पीछे क्या है x+=2(और कहां गया s[0])। वास्तव में अच्छी चाल।

— ugoren

अपने जवाब को गोल्फ के लिए मना कर देना क्योंकि यह "अभी भी कोड गोल्फ शब्दों में जीतने वाला नहीं है।" चुनौती के विजयी मापदंड के लिए जवाब को गंभीर दावेदार नहीं बनाता है।

— पिपरी

7

गोल्फस्क्रिप्ट, 22 18 अक्षर

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

पूरी तरह से अलग एल्गोरिथ्म के साथ गोल्फस्क्रिप्ट में एक और प्रयास। इनपुट प्रारूप w0lf के उत्तर के समान है। ( ऑनलाइन परीक्षा )

— हावर्ड
स्रोत

+1 महान समाधान! मेरा पठनीयता के लिए फिर से बनाया गया है :-P

— क्रिस्टियन लुपस्कु

5

गोल्फस्क्रिप्ट (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"]
[]

— पीटर टेलर
स्रोत

यदि आवश्यक हो, तो उद्धरण आवश्यक नहीं है।

— 22

@tjameson, उद्धरण प्रिंट करने के लिए सबसे कम संभव तरीके का उपयोग करने से आते हैं। तथ्य यह है कि उन मूल्यों को पूर्णांक के बजाय तार हैं जो सीधे कमांड-लाइन तर्कों तक पहुंचने के लिए गोल्फस्क्रिप्ट की अक्षमता से आता है: इसे रूबी में एक निष्कासन करने और परिणाम को एक स्ट्रिंग में डालने वाले दुभाषिया पर भरोसा करना होगा।

— पीटर टेलर

4

awk (82)

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

फ़ाइल poweret.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लेकिन गिनती में दो जोड़ देता है।

— karakfa
स्रोत

(2^j)-> 2^jआप 2 बाइट्स बचाता है; .awkफ़ाइल भी पीछे बिना काम करता है \n, इसलिए आपको कोई बाइट बंद दाढ़ी सकता है।

— mklement0

3

जावास्क्रिप्ट, 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'))

इनपुट

एक जावास्क्रिप्ट सरणी लेता है। (उदाहरण [1,2,3])

उत्पादन

[]
1
1,2
2
2,3
1,2,3
1,3
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]

— AMK
स्रोत

[a[0]]=a[:1]

— 17

इनपुट के साथ 1,2,3 a[:1]काम नहीं करता है। tuple + सूची की अनुमति नहीं है। मौजूदा बेहतर समाधान

— AMK

+1 के लिएi,*a=a

— प्राइमो

i,*a=aअजगर 3 नहीं है? यह मेरे 2.7.1 पर काम नहीं करता है।

— 15

न ही 2.7.2 पर। यह समझा सकता है कि मैंने पहले कभी ऐसा ट्रिक क्यों नहीं देखा ... अधिकांश कोड गोल्फ सर्वर 2.7.x चलाते हैं।

— प्राइमो

3

पायथन 70 67 बाइट्स

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

बदसूरत समाधान के लिए इनपुट उसी तरह से लिया जाता है । नमूना I / O:

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

— Primo
स्रोत

1

आप कुछ के साथ def p(a,*v)और फिर बचा सकते हैं p(a[i:],n,*v)। आउटपुट कुछ हद तक बदसूरत हो जाता है, लेकिन फिर भी ठीक है।

— 14

बहुत चालाक, टिप के लिए धन्यवाद।

— प्रिमो

3

जे, 19 चरस

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

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

Ascii मुक्केबाजी आउटपुट में कहा जाता है boxingऔर हेटेरोजेन संग्रह प्रदान करता है (यहां सरणियों की विभिन्न लंबाई के लिए)।

— randomra
स्रोत

2

गोल्फस्क्रिप्ट 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]

ऑनलाइन टेस्ट

कार्यक्रम का परीक्षण यहां ऑनलाइन किया जा सकता है ।

— क्रिस्टियन लुपस्कू
स्रोत

बहुत बढ़िया, लेकिन क्या आप नई कहानियों के साथ परिसीमन कर सकते हैं?

— बीटगैमिट

@tjameson मैं एक ही कैरेक्टर काउंट को बनाए रखते हुए नईलाइनों द्वारा सीमांकित आउटपुट में कामयाब रहा। कृपया मेरे उत्तर के लिए अद्यतन देखें।

— क्रिस्टियन लुपस्कू

2

हास्केल (96)

आयात नियंत्रण
आयात प्रणाली। पर्यावरण
मुख्य = getArgs >> = mapM Print.filterM (\ _-> [गलत ..])

यदि आयात Control.Monadकी अनुमति नहीं है, तो यह 100 वर्ण हो जाता है :

आयात प्रणाली। पर्यावरण
मुख्य = getArgs >> = mapM print.p
pz = केस z का {[] -> [[]]; x: y-> p y ++ नक्शा (x:) (py)}

— लंबोदर परी
स्रोत

2

गणितज्ञ 53

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

यहां छवि विवरण दर्ज करें

— chyanog
स्रोत

2

एपीएल (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: के लिए बिट प्रतिमान निर्मित 1तक 2^Mका उपयोग कर Mबिट्स।
↓⍉: मैट्रिक्स को विभाजित करें ताकि प्रत्येक बिट पैटर्न अलग हो
(/∘T)¨: प्रत्येक बिट पैटर्न के लिए, उन उप-मदों का चयन करें T।
↑⍕¨: आउटपुट के लिए, प्रत्येक तत्व का स्ट्रिंग प्रतिनिधित्व प्राप्त करें (ताकि यह खाली और शून्य का उपयोग न करें), और मैट्रिक्स के रूप में प्रारूपित करें (ताकि प्रत्येक तत्व अपनी लाइन पर हो)।

— मारीनस
स्रोत

2

स्काला, 81

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

— दान जी
स्रोत

2

जावास्क्रिप्ट ( ईएस 6 ) 76

आंशिक रूप से इस एक से कॉपी किया गया: /codegolf//a/51502/21348

बिटमैप का उपयोग करना, इसलिए यह 32 से अधिक तत्वों तक सीमित नहीं है।

परीक्षण करने के लिए फ़ायरफ़ॉक्स में स्निपेट चलाएँ।

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>

स्निपेट का विस्तार करें

— edc65
स्रोत

2

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

— बेन रीच
स्रोत

2

पायथन 2, 64 बाइट्स

अल्पविराम से अलग इनपुट का उपयोग करना:

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

पायथ, 4 बाइट्स (बिलिन का उपयोग करके) या 14 बाइट्स (बिना)

जैसा कि @Jakube द्वारा टिप्पणियों में उल्लेख किया गया है, 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     #   [[]]))

— उड़ी ग्रामटा
स्रोत

2

ब्रेनफक, 94 बाइट्स

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

प्रारूपित:

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

प्रपत्र के इनपुट की अपेक्षा करता है 9,10,11एक अनुगामी न्यूलाइन के बिना अपेक्षा करता है, और कभी-कभी एक अनुगामी अल्पविराम के साथ, एक ही प्रारूप में सबसेट आउटपुट देता है। मुद्रित पहली पंक्ति हमेशा खाली होगी, खाली सेट को दर्शाता है।

इसे ऑनलाइन आज़माएं।

मूल विचार प्रत्येक तत्व के बगल में थोड़ा सा स्थान देना है, फिर प्रत्येक वृद्धि से पहले संबंधित उपसेट को प्रिंट करते समय बार-बार द्विआधारी संख्या में वृद्धि करना है। (एक बिट इंगित करता है कि क्या कोई तत्व सबसेट में है।) सरणी के बाईं ओर एक प्रहरी बिट प्रोग्राम को समाप्त करने के लिए उपयोग किया जाता है। यह संस्करण वास्तव में कुछ बाइट्स को बचाने के लिए प्रहरी की एक घातीय संख्या बनाता है; एक अधिक कुशल 99-बाइट समाधान जो केवल एक प्रहरी का उपयोग करता है, संशोधन इतिहास में पाया जा सकता है।

प्रत्येक बिट को एक से अधिक मान के साथ एन्कोड किया गया है; यानी, यह 1या तो हो सकता है 2। प्रत्येक तत्व से पहले बिट के साथ टेप लगाया जाता है और आसन्न तत्वों के बीच एक एकल शून्य सेल होता है। अल्पविराम को गैर-अंतिम तत्वों के लिए टेप पर शामिल किया गया है, इसलिए हम आसानी से सीमांकित तत्वों को संभालने के लिए कोई अतिरिक्त काम किए बिना केवल तत्वों को प्रिंट कर सकते हैं।

— मिच श्वार्ट्ज
स्रोत

2

APL (Dyalog Classic) , 13 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आउटपुट:

खाली सेट का प्रतिनिधित्व करने के लिए अंत में एक खाली लाइन है।

स्पष्टीकरण:

⎕ मूल्यांकन किया गया इनपुट

⎕,¨⊂⊂⍬ प्रत्येक तत्व के बाद एक खाली संख्यात्मक सूची संलग्न करें

∘., कार्तीय गुणन

/ कमी (तह)

⊃ खुलासा (एपीएल में कमी के बाद आवश्यक)

इस बिंदु पर परिणाम एक n-आयामी 2-by -...-by-2 सरणी है, जहां n इनपुट की लंबाई है।

, एक सदिश में समतल

⍪वेक्टर को एक सीधा 2 ⁿ -by-1 मैट्रिक्स में बदल दें, ताकि प्रत्येक सबसेट एक अलग लाइन पर हो

— NGN
स्रोत

2

हास्केल , 80 78 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Angs
स्रोत

I / O आवश्यकताएं भयानक हैं, हालांकि लोग उन्हें काफी शिथिल कर रहे हैं। यदि आप स्टड के माध्यम से इनपुट लेने के लिए बदलते हैं तो आप 15 बाइट्स बचा सकते हैं , इसे देखें ।

— ।

2

जेली , 6 बाइट्स

ŒPŒṘ€Y

इसे ऑनलाइन आज़माएं!

ŒṘ€Y स्ट्रिंग स्वरूपण हैं।

— आउटगोल्फर को एरिक करें
स्रोत

1

पायथन, 93 87 वर्ण

पायथन प्रारूपण को सरल बनाता है, क्योंकि आवश्यक इनपुट / आउटपुट इसके मूल प्रारूप से मेल खाता है।
केवल उन वस्तुओं का समर्थन करता है जो पायथन शाब्दिक हैं (उदाहरण के लिए 1,2,'hello', नहीं 1,2,hello)।
मानक इनपुट पढ़ता है, पैरामीटर नहीं।

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

— ugoren
स्रोत

print f(input())छोटा

— AMK

@AMK, आवश्यकता प्रत्येक तत्व को एक पंक्ति में मुद्रित करने के लिए है। लेकिन listवास्तव में हटाया जा सकता है (यदि [[]]साथ में भी [()]

— प्रतिकृति

print'\n'.join(f(input()))दो पात्रों को बचाता है

— beary605

@ beary605, काम नहीं करता, f()जिसमें ट्यूल होते हैं, तार नहीं।

— 5

1

रूबी, ३ ९

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

— Lowjacker
स्रोत

1

हास्केल 89 वर्ण

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

पैरामीटर मिलना लंबा है: /

— kyticka
स्रोत

एक और चार के साथ मुंडा जा सकता है map(x:)(p y)++p yऔर फिर भी इसके साथ दो और चार्ट ऊपर दिए जा सकते हैं [(x:),id]<*>p y। जाहिर <*>है अब प्रस्तावना में है। ( filterMनहीं है)।

— विल नेस

1

आर, 63

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

यहाँ, vएक वेक्टर का प्रतिनिधित्व करता है।

उपयोग :

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)

— स्वेन होहेंस्टीन
स्रोत

1

के, 14 बाइट्स

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

जब तक इनपुट के रूप में सभी 0/1 वैक्टर उत्पन्न करें, 1s के सूचकांक को इकट्ठा करें और इनपुट वेक्टर से तत्वों का चयन करने के लिए उन का उपयोग करें। प्रयोग में:

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

यह आउटपुट आवश्यकताओं के साथ थोड़ा उदार है, लेकिन मुझे लगता है कि यह कानूनी है। सबसे संदिग्ध हिस्सा यह है कि खाली सेट को एक प्रकार पर निर्भर रूप में दर्शाया जाएगा; !0यह है कि K एक खाली संख्यात्मक वेक्टर को कैसे दर्शाता है:

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

व्याख्या

(#x)#2का एक वेक्टर बनाता है 2जब तक इनपुट के रूप में:

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

जब !एक सदिश वेक्टर पर लागू होता है, तो यह "ओडोमीटर" है:

फिर हम &प्रत्येक 'सूचकांक पर "कहां" ( ) (प्रत्येक ) वेक्टर का उपयोग करते हैं। बृहदान्त्र के विवादास्पद रूप से मानदण्ड और डाइएडिक रूप के बीच अंतर करना आवश्यक है &:

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

अगर हम सिर्फ संयोजन वैक्टर चाहते हैं, तो हम किया जाएगा, लेकिन हमें मूल सेट में इन सूचकांकों के रूप में उपयोग करने की आवश्यकता है। सौभाग्य से, K का अनुक्रमण ऑपरेटर @सूचकांकों की एक जटिल संरचना को स्वीकार कर सकता है और एक ही आकार के साथ एक परिणाम उत्पन्न करेगा:

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

सुरुचिपूर्ण, नहीं?

— JohnE
स्रोत

1

यह अब मान्य नहीं है, क्योंकि ओके में "ओडोमीटर" अब एक फ़्लिप्ड मैट्रिक्स उत्पन्न करता है। इसे एकल बाइट की कीमत पर सुधारा जा सकता है {x@&:'+!(#x)#2}:। असंबंधित: एक छोटा समतुल्य (#x)#2है 2|~x।

— nn

1

गणितज्ञ, ५१

अधिक धोखा:

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

के साथ प्रयोग करें @{1,2,3}।

— LogicBreaker
स्रोत

आपके कोड को सेट को इनपुट के रूप में लेना चाहिए, न कि केवल इसे हार्डकोड करना चाहिए। इसके अलावा, चूंकि यह कोड गोल्फ है, आपको कोड की बाइट गिनती (और संभवतः अनावश्यक रिक्त स्थान को हटा दें) को शामिल करना चाहिए।

— मार्टिन एंडर

चूंकि यह प्रतियोगिता लंबी है, इसलिए विचार के लिए पोस्ट अधिक थी, लेकिन मैंने इसे संपादित किया है।

— लॉजिकब्रीकर

1

जावास्क्रिप्ट (ईएस 6), 68 बाइट्स

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

डेमो

कोड स्निपेट दिखाएं

let f =

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

f([1,2,3])

स्निपेट का विस्तार करें

— Arnauld
स्रोत

क्यों alert?

— झबरा

@ शैगी चुनौती स्पष्ट रूप से प्रत्येक तत्व को एक अलग लाइन पर प्रिंट करने के लिए कहती है - जो शायद हमारे वर्तमान मानकों के साथ-साथ समाप्त हो जाएगी। अधिकांश उत्तर इस नियम से चिपके हुए प्रतीत होते हैं।

— अरनौल्ड

आह, पर्याप्त निष्पक्ष; मैंने "प्रिंट" की व्याख्या "आउटपुट" के रूप में की।

— झबरा

1

ब्रेकीलॉग , 4 बाइट्स

⊇ᵘẉᵐ

इसे ऑनलाइन आज़माएं!

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

— असंबंधित स्ट्रिंग
स्रोत

0

रूबी एरे विधि संयोजन (1.9 से) [50 वर्ण]

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

— beginnerProg
स्रोत

सबसे कम बिजली सेट कार्यान्वयन

समस्या की परिभाषा

उदाहरण कोड (डी में, अजगर उदाहरण यहाँ ):

इनपुट

नियम

गणितज्ञ १६

C, 118 115

गोल्फस्क्रिप्ट, 22 18 अक्षर

गोल्फस्क्रिप्ट (43 वर्ण)

awk (82)

जावास्क्रिप्ट, 98

इनपुट

उत्पादन

पायथन ( 74 70 वर्ण)

पायथन 70 67 बाइट्स

जे, 19 चरस

गोल्फस्क्रिप्ट 48

इनपुट

उत्पादन

ऑनलाइन टेस्ट

हास्केल (96)

एपीएल (26)

जावास्क्रिप्ट ( ईएस 6 ) 76

C # 164

पायथन 2, 64 बाइट्स

पायथ, 4 बाइट्स (बिलिन का उपयोग करके) या 14 बाइट्स (बिना)

ब्रेनफक, 94 बाइट्स

APL (Dyalog Classic) , 13 बाइट्स

हास्केल , 80 78 बाइट्स

जेली , 6 बाइट्स

पायथन, 93 87 वर्ण

रूबी, ३ ९

हास्केल 89 वर्ण

आर, 63

के, 14 बाइट्स

व्याख्या

गणितज्ञ, ५१

जावास्क्रिप्ट (ईएस 6), 68 बाइट्स

डेमो

ब्रेकीलॉग , 4 बाइट्स

रूबी एरे विधि संयोजन (1.9 से) [50 वर्ण]