Yuvalanmış bir listeyi "seçme" işlemini düşünün. Toplama aşağıdaki gibi tanımlanır:

• Argüman bir listeyse, listeden rastgele (tekdüze) bir öğe alın ve bu öğeyi seçin.
• Argüman bir liste değilse, geri döndürün.

Python'da örnek bir uygulama:

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

Basit olması açısından, iç içe listelerin yalnızca tamsayılar veya başka iç içe listeler içerdiğini varsayıyoruz.

Herhangi bir liste göz önüne alındığında, ayırt edilemeyen düzleştirilmiş bir versiyon oluşturmak mümkündür pick, yani ondan seçim yapmak aynı olasılıkla aynı sonuçları verir.

Örneğin, listeyi "düzleştirme"

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

listeyi verir

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

. Basitçe düzleştirmenin geçersiz olmasının nedeni, alt listelerin öğelerinin seçilme olasılığının daha düşük olmasıdır, örneğin listede [1, [2, 3]]1'in 2/4 = 1/2 seçilme şansı varken 3 ve 4'ün her ikisinin de 1/4 olması her biri şans.

Ayrıca, tek bir listeden seçim yapmanın öğesinden seçim yapmaya eşdeğer olduğunu ve boş bir listeden seçim yapmanın bir anlamı olmadığını da unutmayın.

Meydan okuma

İç içe negatif olmayan tamsayılar listesi verildiğinde, toplama aynı olasılıkla aynı sonuçları veren negatif olmayan tamsayıların düzleştirilmiş bir listesini döndürün.

Bu kod golf , bu nedenle (bayt cinsinden ölçülen) en kısa geçerli cevap kazanır.

Özellikler

• Girdiler [2, 3, 4], [2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]ve [2, [3, 3], [[4]]]eşdeğerdir (yani eşdeğer sonuçlar vermelidirler).
• Çıkışlar [2, 2, 2, 2, 3, 3, 3, 3]ve [2, 3]eşdeğerdir (yani her ikisi de çıktı olabilir).
• Listelerde yalnızca 1-100 dahil aralığındaki sayıların bulunacağını varsayabilirsiniz.
• Üst düzey girdinin bir liste olacağını varsayabilirsiniz, yani 2geçerli bir girdi değildir.
• Örneğin, iç içe listelerin herhangi makul temsilini kullanabilirsiniz:
  [1, [2, 3]], 1 {2 3}, "[ 1 [ 2 3 ] ]"vb
• Bir liste yerine, bir çoklu küme veya bir eşleme çıktısı alabilirsiniz veya yalnızca 1-100 aralığındaki sayılara izin verildiğinden, miktarları temsil eden tam sayı 100 uzunluklu bir liste.

Test Durumları

Listelenen çıkışların yalnızca bir geçerli olasılık olduğunu unutmayın; geçerli bir girdi veya çıktıyı nelerin oluşturduğu ile ilgili özelliklere bakın.

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]

Wolfram Dili (Mathematica) , 41 20 bayt

Flatten@*Tuples//@#&

Çevrimiçi deneyin! Birçok uyarıyı görmezden gelin, hepsi sonunda işe yarıyor.

Nasıl çalışır

Derinlik 2 bir listesi için örneğin {{1,2},{3},{4,5,6}}, Tupleslistesini oluşturacaktır {{1,3,4},{1,3,5},{1,3,6},{2,3,4},{2,3,5},{2,3,6}}bir eleman almak için tüm yolları tekabül eden {1,2} ve bir eleman almak {3} ve bir eleman almak {4,5,6}.

Biz ise Flattenbu, o zaman bir eleman toplama, çünkü doğru frekansları ile tüm öğelerini almak birine ait {1,2}, {3}ya da {4,5,6}daha sonra, hepsi bir eleman toplama tutmak için hangisinin seçilmesi eşdeğerdir.

Bunu //@girdinin tüm seviyelerinde uygulamak için kullanıyoruz . Süreçte, Mathematica çok şikayet ediyor, çünkü atomları 17içine çeviriyor Tuples[17], ki bu gerçekten bir şey değil. Ancak bunlar daha sonra doğru sonuca sadeleştirir ( Tuplesbaşka Tuples[17]bir başı olsa bile 1 uzunluğunun bir listesi olarak işlem yapmaktan mutluluk duyar List), bu nedenle şikayet ilgisizdir.

Piton 2 , 105 102 99 bayt

g=lambda y=[],*z:[w+[n]for n in y for w in g(*z)]or[y]
f=lambda x:x<[]and[x]or sum(g(*map(f,x)),[])

Çevrimiçi deneyin!

Jöle , 9 8 bayt

߀Œp$¬¡F

Çevrimiçi deneyin!

Nasıl çalışır

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

Jöle , 10 bayt

L€P⁸ṁ€ẎµÐL

Çevrimiçi deneyin!

Python 2 , 128 bayt

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)

Çevrimiçi deneyin!

Jelly cevabımın limanı.

-12 Jonathan Frech sayesinde .

C (gcc) , 234223 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Python 2 , 144139 bayt

def f(A,p):[F.append((len(A)*p,a))if a*0<[]else f(a,len(A)*p)for a in A]
F=[];f(input(),1);R=[]
for v in F:R+=max(F)[0]/v[0]*[v[1]]
print R

Çevrimiçi deneyin!

JavaScript (ES6), 132 131 bayt

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

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,x=>Array(n/a.length).fill(x))))

console.log( f( [3] ) )
console.log( f( [1, [1, 1]] ) )
console.log( f( [1, [2, 3]] ) )
console.log( f( [2, 3, [4, [5, 5, 6], 6, 7]] ) )
console.log( f( [[1, 1, 2], [2, 3, 3]] ) )
console.log( f( [[1, 1, 2], [2, 3, 3, 3]] ) )
console.log( f( [1, 2, [3, 4, 5], [6, 7]] ) )