중첩 목록을 "선택"하는 프로세스를 고려하십시오. 피킹은 다음과 같이 정의됩니다.

• 인수가 목록 인 경우 목록에서 임의로 (균일하게) 요소를 가져 와서 선택하십시오.
• 인수가리스트가 아닌 경우 간단히 리턴하십시오.

파이썬에서 구현 예 :

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

간단히하기 위해 중첩 목록에는 정수 또는 추가 중첩 목록 만 포함되어 있다고 가정합니다.

목록이 주어지면로 구별 할 수없는 평탄화 된 버전을 생성 할 수 있습니다 pick.

예를 들어, 목록을 "pick-flattening"

[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이됩니다. 각각 기회.

또한 싱글 톤 목록에서 선택하는 것은 요소에서 선택하는 것과 동일하며 빈 목록에서 선택하는 것은 의미가 없습니다.

도전

음이 아닌 정수의 중첩 된 목록이 주어지면, 음수 선택시 동일한 확률로 동일한 결과를 산출하는 음이 아닌 정수의 평탄화 된 목록을 리턴하십시오.

이것은 code-golf 이므로 가장 짧은 유효한 답변 (바이트 단위로 측정)이 이깁니다.

명세서

• 입력은 [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]

Wolfram Language (Mathematica) , 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}다음, 그들 모두에서 요소를 따기 유지하는 하나의 선택에 해당합니다.

우리 //@는 입력의 모든 수준에서 이것을 적용 하는 데 사용 합니다. 이 과정에서 Mathematica는 17로 바뀌는 원자를 로 바꾸고 있기 때문에 많은 불만을 제기합니다 Tuples[17]. 그러나 이것들 Tuples은 나중에 올바른 결과로 단순화합니다 ( Tuples[17]길이가 아닌 다른 머리를 가지고 있더라도 길이 1의 목록 으로 취급하는 것이 행복합니다 List).

파이썬 (2) , 105 (102) 99 바이트

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)),[])

온라인으로 사용해보십시오!

젤리 , 9 8 바이트

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

젤리 , 10 바이트

L€P⁸ṁ€ẎµÐL

온라인으로 사용해보십시오!

파이썬 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)

온라인으로 사용해보십시오!

내 젤리 포트 답변입니다.

Jonathan Frech 에게 -12 감사합니다 .

C (GCC) , 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);
}

파이썬 2 , 144 139 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 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)))))

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