整理列表


20

考虑“挑选”嵌套列表的过程。拣配定义如下:

  • 如果参数是列表,则从列表中随机(均匀地)选取一个元素,然后从中选择一个元素。
  • 如果参数不是列表,则只需将其返回即可。

Python中的示例实现:

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]

给定长度编码选项和有界范围,是否可以替代地输出100个元素的列表,描述每个整数的出现?(在给定的示例中,结果将带有多个零)
Uriel's

@Uriel当然;我会改写。
硕果累累

Answers:


8

Wolfram语言(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),因此抱怨是无关紧要的。



4

果冻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.



1

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



0

的JavaScript(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)))))

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.