参差不齐的数组是其中每个元素都是未知数量的正整数的数组。

例如，以下是参差不齐的数组：

[[1,2,3],[4],[9,10]]               Shape:  3,1,2
[[1],[2],[3]]                      Shape:  1,1,1
[[1,2,3,4,5,6,8]]                  Shape:  7

以下不是破烂的数组：

[1]   Each element will be an array
[]    The array will contain at least 1 element
[[1,2,3],[]]  Each subarray will contain at least 1 integer

您需要输入一个衣衫array的数组，然后返回一个带有乱码整数的衣衫array的数组

• 输出数组必须与输入数组具有相同的形状。我们将数组的形状定义为每个子数组的长度。
• 每个整数必须有同样可能出现在每个可能的位置。
• 您可以假设语言的内置随机数是随机的。

例如，如果我通过了： [[4],[1,2,3],[4]]，那么[[1],[4,4,2],[3]]将是一个有效的输出，但[[4,1,3],[3],[4]]还是[[4],[4],[1,2,3]]不肯。

果冻，果冻代码页中的3个字节

FẊṁ

说明：

FẊṁ
F    flatten list
 Ẋ   shuffle the output from the previous line
  ṁ  unflatten the list, shaping it like…

因为程序不完整（ṁ没有声明第二个参数），所以默认设置是使用程序输入。因此ṁ导致输出具有与输入相同的子列表模式。

在线尝试！

PowerShell v2 +，86字节

param($n)$a=$n-split'[^\d]'-ne''|sort{random};-join($n-split'\d+'-ne''|%{$_+$a[$i++]})

通过字符串操作工作。输入将以代表该数组的字符串形式传入，并以适合您的语言的任何格式传递。;-)

-split根据非数字输入，将sort其基于random脚本块（它将为排序的每个输入分配不同的随机权重），然后将其存储到中$a。然后split，我们再次输入，这一次是数字输入，对于每个输出，当前值（通常是方括号和逗号）将字符串与对应的数字串联起来$a。这是-join编一起回到一个字符串，输出是隐含的。

例子

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "@(@(1,2,3),4)"
@(@(3,2,1),4)

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "@(@(1,2,3),4)"
@(@(1,2,4),3)

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[4],[1,2,3],[4]]"
[[4],[2,4,3],[1]]

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[10],[1,2,3],[5]]"
[[10],[5,2,1],[3]]

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[10],[1,2,3],[5]]"
[[5],[10,2,1],[3]]

Python 2，89个字节

from random import*
x=input();r=sum(x,[]);shuffle(r)
print[[r.pop()for _ in t]for t in x]

在线尝试！

JavaScript（ES6），78 75字节

x=>x.map(y=>y.map(z=>+s.splice(Math.random()*s.length,1)),s=eval(`[${x}]`))

这是我第一次记得.splice()在代码高尔夫球挑战赛中使用...

您可以通过预先对数组进行混洗来释放两个字节：

x=>x.map(y=>y.map(z=>s.pop()),s=eval(`[${x}]`).sort(_=>Math.random()-.5))

但是，这似乎将大多数时间都放在最后一个整数的前面，因此，我将假定这些整数不是均匀分布的。

Ruby，47个字节

->a{b=a.flatten.shuffle;a.map{|x|x.map{b.pop}}}

Brachylog，17个字节

c@~P,?:{l~l}a.cP,

在线尝试！

说明

我们基本上创建了一个带有变量元素的子列表列表，这些变量元素具有与Input相同的“形状”，然后声明如果将所有内容连接到一个列表中，则必须将输入的连接改组为一个列表。

c@~P,                 Concatenate the Input into a single list. Shuffle it and call that P.
     ?:{   }a.        The Output is the result of applying this to each element of the input:
        l~l               The Output is a list of same length as the Input.    
             .cP,     P is the concatenation of the sublists of the Output.

Perl，37个字节

36个字节的代码+ -p标志。

@n=/\d+/g;s/\d+/splice@n,rand@n,1/ge

要运行它：

perl -pE '@n=/\d+/g;s/\d+/splice@n,rand@n,1/ge' <<< "[[4],[1,2,3],[4]"

说明：

@ n = / d + / g＃将所有整数存储在@n中
s / \ d + /＃将每个整数替换为...
splice @ n，rand @ n，1 / ge＃一个位于@n随机位置的元素（从@n中删除）

05AB1E，17个字节

˜.r¹vDyg£DˆgF¦}}¯

˜                 Unflatten input
 .r               tmp = shuffle(flattened_input)
   ¹v             For each sub-array
     Dyg£         Take the first length(current_array) elements from tmp
         Dˆ       Append the result to a global array
           gF¦}   Remove the first elements from tmp
               }  End for
                ¯ Display the global array

在线尝试！

我正在等待05AB1E或2sable解决方案，这些解决方案使用一些尚不了解的内置未展平/模压:)。

APL，35个字节

我什至没有击败过Perl，肯定有我缺少的东西。

{Z[?⍨⍴Z]⊂⍨(⍳⍴Z←∊⍵)∊⊃¨{⍵+⊃⌽⍺}\⍳¨⍴¨⍵}

例如：

      {Z[?⍨⍴Z]⊂⍨(⍳⍴Z←∊⍵)∊⊃¨{⍵+⊃⌽⍺}\⍳¨⍴¨⍵}(1 2 3)(,4)(9 10)
┌──────┬─┬───┐
│10 3 2│1│9 4│
└──────┴─┴───┘

说明：

• 在展平的数组中找到子数组起点的相应索引：
  • ⍳¨⍴¨⍵：对于每个子数组，获取索引列表
  • {⍵+⊃⌽⍺}\：从第一个子数组开始，将数组中的最后一个值添加到下一个数组中的每个值。
  • ⊃¨：获取数组的第一项，它们是起始位置
  • (⍳⍴Z←∊⍵)∊：将展平的数组存储在中Z。生成一个位向量，其中一个标记子数组应开始的位置。
• 随机播放展平的数组：
  • ?⍨⍴Z：产生的随机排列Z。
  • Z[... ]：置换Z。
• ⊂⍨：根据位向量在子数组中分解排列。

Pyth，15个字节

tPc.SsQ.u+NlYQ0

接受列表输入并打印结果的程序。

测试套件

怎么运行的

tPc.SsQ.u+NlYQ0  Program. Input: Q
       .u    Q0  (1) Reduce Q with starting value 0, returning all results:
         +        Add
          N       the current value
           lY     to the length of the next element of Q
     sQ          Flatten Q
   .S            (2) Randomly shuffle
  c              Chop (1) at every location in (2)
tP               Discard the first and last elements
                 Implicitly print

PHP，105字节

$m=array_merge(...$i=$_GET[i]);shuffle($m);foreach($i as$v)$o[]=array_splice($m,0,count($v));print_r($o);

由于减少到105个字节user59178。

原始答案：

PHP，132字节

$i=$_GET['i'];$m=call_user_func_array('array_merge',$i);shuffle($m);foreach($i as$v){$o[]=array_splice($m,0,count($v));}print_r($o);

重击 63，58字节

编辑：

• 优化的sed表达式，-5字节

注意：

Bash并不真正支持多维数组（只能在某种程度上进行模拟），因此，该程序将接受坚固数组的“序列化”文本表示，如任务描述中所述，例如：[[1,2,3],[4],[9,10]]，并提供输出以相同的格式。

打高尔夫球

printf `sed 's/\w\+/%d/g'<<<$1` `grep -Po '\d+'<<<$1|shuf`

测试

>./shuffle []
[]

>./shuffle [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
[11,12,9,5,3,6,1,15,14,2,13,7,10,8,4]

>./shuffle [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
[9,15,11,10,7,6,1,14,2,3,12,5,4,13,8]

>./shuffle [[1,2,3],[4],[9,10]]
[[10,2,4],[9],[3,1]]

>./shuffle [[1,2,3],[4],[9,10]]
[[3,4,1],[10],[2,9]]

一个不错的好处是您可以向它提供任意深度的坚固阵列：

./shuffle [[1,[2,[3,[99,101]]],[4],[9,10]]
[[9,[4,[1,[101,2]]],[10],[3,99]]

并且仍然可以正常运行。

在线尝试！

八度，60字节

@(a)mat2cell([a{:}](randperm(sum(s=cellfun(@numel,a)))),1,s)

MATLAB，84字节

function b=g(c);a=[c{:}];a=a(randperm(numel(a)));b=mat2cell(a,1,cellfun('length',c))

Java，368个字节

interface Z{int w(int i);default Z m(int n,int s){return i->w(i)+i>=n?s:0;}static int[][]f(int[][]r){int L=0,o=0,x,d,e=0;Z u=i->0,v=i->i;for(int[]a:r){d=a.length;L+=d;u=u.m(L,1);v=v.m(L,-d);}int[]c=new int[L];for(;e<L;)c[e++]=(int)(L*Math.random());for(int[]a:r){for(x=0;x<a.length;){d=c[x+o];e=v.w(d);d=u.w(d);L=a[x];a[x++]=r[d][e];r[d][e]=L;}o+=a.length;}return r;}}

该方法static int[][] f( int[][] r ){...}解决了挑战。决定滚动自己的功能接口以避免导入，并添加默认方法以方便使用

interface Z{ //define my own functional interface instead of importing

  int w(int i);

  //return a new lambda
  //where w(int i) adds the value s
  //to the result when i is greater than n
  default Z m(int n,int s){
      return i->w(i)+i>=n?s:0;
  }

  static int[][]f(int[][]r){
      int L=0,o=0,x,d,e=0;
      Z u=i->0, //lambda to convert a flattened index to the input's first dimension index
        v=i->i; //lambda to convert a flattened index to the input's second dimension index
      for(int[]a:r){
          d=a.length;
          L+=d; //running total of the lengths
          u=u.m(L,1); //increment the 1st conversion by 1 at every array length
          v=v.m(L,-d); //decrement the 2nd conversion by the array length after that length
      }
      int[]c=new int[L]; //will contain flattened index swapping positions
      for(;e<L;) //randomize the swap positions
          c[e++]=(int)(L*Math.random());
      for(int[]a:r){ //swap the elements from the input
          for(x=0;x<a.length;){
              d=c[x+o]; //flattened swap index
              e=v.w(d); //convert swap index to 2nd dimension index
              d=u.w(d); //convert swap index to 1st dimension index
              L=a[x];
              a[x++]=r[d][e];
              r[d][e]=L;
          }
          o+=a.length; //increment offset for flattened index array
      }
      return r;
  }

}

Mathematica，67字节

ReplacePart[#,Thread[RandomSample@Position[#,_Integer]->Union@@#]]&

说明：这将对2D锯齿状数组中所有整数的位置列表进行混洗。Union@@的缩写Flatten@

注意：{}使用方括号代替方括号[]。