एक सूची को चुनें

20

एक नेस्टेड सूची "चुनने" की प्रक्रिया पर विचार करें। उठा के रूप में परिभाषित किया गया है:

  • यदि तर्क एक सूची है, तो यादृच्छिक (समान रूप से) सूची में से एक तत्व लें, और उसी से चुनें।
  • यदि तर्क एक सूची नहीं है, तो बस इसे वापस करें।

पायथन में एक उदाहरण कार्यान्वयन:

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

सादगी के लिए, हम मानते हैं कि नेस्टेड सूचियों में केवल पूर्णांक या आगे की नेस्टेड सूचियाँ हैं।

किसी भी सूची को देखते हुए, एक चपटा संस्करण बनाना संभव है, जो कि अप्रभेद्य है pick, अर्थात इससे चुनने पर समान परिणाम मिलते हैं।

उदाहरण के लिए, सूची को "पिक-सपाट करना"

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

सूची तैयार करता है

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

। बस चपटे होने का कारण अमान्य है, क्योंकि उप-सूचियों के तत्वों को चुने जाने की कम संभावना है, उदाहरण के लिए सूची [1, [2, 3]]में 1 में 2/4 = 1/2 मौका है, जबकि 3 और 4 दोनों में 1/4 है। प्रत्येक को मौका दें।

यह भी ध्यान दें कि एकल सूची से चुनना अपने तत्व से लेने के बराबर है, और खाली सूची से चुनने का कोई अर्थ नहीं है।

चुनौती

नॉनजेगेटिव पूर्णांकों की एक नेस्टेड सूची को देखते हुए, नॉनजेगेटिव पूर्णांकों की एक चपटी सूची लौटाएं, जिसमें से उठाकर समान संभाव्यता के साथ समान परिणाम मिलते हैं।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर (बाइट्स में मापा गया) जीतता है।

विशेष विवरण

  • इनपुट्स [2, 3, 4], [2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]और [2, [3, 3], [[4]]]समतुल्य हैं (यानी उन्हें समतुल्य परिणाम देना चाहिए)।
  • आउटपुट [2, 2, 2, 2, 3, 3, 3, 3]और [2, 3]समतुल्य हैं (यानी या तो आउटपुट हो सकता है)।
  • आप केवल अनुमान लगा सकते हैं कि समावेशी रेंज 1-100 की संख्या सूची में मौजूद होगी।
  • आप मान सकते हैं कि शीर्ष-स्तरीय इनपुट एक सूची होगी, अर्थात 2एक वैध इनपुट नहीं है।
  • आप उदाहरण के लिए, नेस्टेड सूचियों के किसी भी उचित प्रतिनिधित्व का उपयोग कर सकते हैं:
    [1, [2, 3]], 1 {2 3}, "[ 1 [ 2 3 ] ]", आदि
  • एक सूची के बजाय, आप एक मल्टीसेट या मैपिंग आउटपुट कर सकते हैं, या, चूंकि 1-100 की रेंज में संख्याओं की अनुमति है, मात्रा का प्रतिनिधित्व करने वाले पूर्णांकों की लंबाई -100 सूची।

परीक्षण के मामलों

ध्यान दें कि सूचीबद्ध आउटपुट केवल एक वैध संभावना है; मान्य इनपुट या आउटपुट के लिए विशिष्टताओं को देखें।

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]
code-golf  number  array-manipulation  combinatorics  probability-theory 
— फल तोड़ना
स्रोत
लंबाई एन्कोडिंग विकल्प और बंधी हुई सीमा को देखते हुए, क्या हम वैकल्पिक रूप से प्रत्येक पूर्णांक की घटनाओं को दर्शाते 100 तत्वों की सूची का उत्पादन कर सकते हैं? (जो दिए गए उदाहरणों के लिए कई शून्य के साथ परिणाम देगा)
— उरियेल
@ यूरिल श्योर; मैं इसे पुन: लिखूंगा।
— फल तोड़ना

जवाबों:

8

वोल्फ्राम भाषा (गणितज्ञ) , 41 20 बाइट्स

Flatten@*Tuples//@#&

इसे ऑनलाइन आज़माएं! कई चेतावनियों को नजरअंदाज करें, यह सब अंत में काम आता है।

यह काम किस प्रकार करता है

गहराई 2 की सूची के लिए इस तरह के रूप {{1,2},{3},{4,5,6}}, Tuplesसूची उत्पन्न होगी {{1,3,4},{1,3,5},{1,3,6},{2,3,4},{2,3,5},{2,3,6}}सभी तरीकों से एक तत्व लेने के लिए करने के लिए इसी {1,2} और से एक तत्व लेने {3} और से एक तत्व लेने {4,5,6}।

अगर हम Flattenइस, तो हम सही आवृत्तियों के साथ सभी तत्वों, क्योंकि से एक तत्व उठा पाने के एक से {1,2}, {3}या {4,5,6}उन सभी से एक तत्व उठा, तो जो एक रखने के लिए चुनने के बराबर है।

हम //@इसे इनपुट के सभी स्तरों पर लागू करने के लिए उपयोग करते हैं । इस प्रक्रिया में, गणितज्ञ बहुत शिकायत करता है, क्योंकि यह परमाणुओं को बदल 17रहा है Tuples[17], जो वास्तव में एक चीज नहीं है। लेकिन ये बाद में सही परिणाम के लिए सरल हो जाते हैं ( लंबाई 1 की सूची के रूप में Tuplesइलाज करने के लिए खुश हैं Tuples[17], भले ही इसके अलावा एक सिर हो List), इसलिए शिकायत अप्रासंगिक है।

— मिशा लावरोव
स्रोत
4

जेली , ९ by बाइट्स

߀Œp$¬¡F

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

यह काम किस प्रकार करता है

߀Œ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

अजगर 2 , 128 बाइट्स

def f(l,p=0):m=reduce(int.__mul__,[i*0<[]or len(i)for i in l]);return p*(p==l)or f(sum([(([i],i)[i*0>0]*m)[:m]for i in l],[]),l)

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

मेरे जैली जवाब का पोर्ट।

-12 जोनाथन फ्रेच को धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत
मुझे लगता है कि type(i)==intहो सकता है i*0<[]।
— जोनाथन फ्रेच
@ 0<[]type(i)==listi*0>0
— जोनाथनफ्रेच
1

सी (जीसीसी) , 234 223 बाइट्स

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

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

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

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

— darrylyeo
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.