Mảng ragged là một mảng trong đó mỗi phần tử là một mảng không biết số nguyên dương.

Ví dụ, sau đây là các mảng rách rưới:

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

Sau đây không phải là mảng rách rưới:

[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

Bạn cần nhập một mảng bị rách và trả về một mảng bị rách với các số nguyên được xáo trộn

• Mảng đầu ra phải có hình dạng giống như mảng đầu vào. Chúng tôi xác định hình dạng của mảng là chiều dài của mỗi phân đoạn.
• Mỗi số nguyên phải có cơ hội như nhau có thể xuất hiện ở mỗi vị trí có thể.
• Bạn có thể cho rằng ngẫu nhiên tích hợp ngôn ngữ của bạn là ngẫu nhiên.

Ví dụ: nếu tôi chuyển vào : [[4],[1,2,3],[4]], thì đó [[1],[4,4,2],[3]]sẽ là đầu ra hợp lệ, nhưng [[4,1,3],[3],[4]]hoặc [[4],[4],[1,2,3]]không.

Jelly, 3 byte trong bảng mã của Jelly

FẊṁ

Giải trình:

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

Bởi vì chương trình không đầy đủ ( ṁkhông có đối số thứ hai đã nêu), mặc định là sử dụng đầu vào chương trình; do đó ṁlàm cho đầu ra có cùng một mẫu danh sách con như đầu vào.

Hãy thử trực tuyến!

PowerShell v2 +, 86 byte

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

Hoạt động thông qua thao tác chuỗi. Đầu vào được truyền vào dưới dạng một chuỗi đại diện cho mảng, ở bất kỳ định dạng nào hoạt động cho ngôn ngữ của bạn . ;-)

-splits ra đầu vào trên các chữ số không, sorts dựa trên randomkhối tập lệnh (sẽ gán một trọng số ngẫu nhiên khác nhau cho mỗi đầu vào cho sắp xếp), lưu trữ nó vào $a. Chúng tôi sau đó splitnhập lại, lần này là các chữ số và với mỗi đầu ra, giá trị hiện tại (thường là dấu ngoặc và dấu phẩy) được nối với số tương ứng từ $a. Đó là -joined lại với nhau thành một chuỗi, và đầu ra là ẩn.

Ví dụ

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 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 78 75 byte

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

Đây là lần đầu tiên tôi có thể nhớ sử dụng .splice()trong một thử thách chơi gôn ...

Bạn có thể loại bỏ hai byte bằng cách xáo trộn mảng trước:

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

Tuy nhiên, điều này dường như đặt số nguyên cuối cùng chiếm phần lớn thời gian, vì vậy tôi sẽ giả định rằng các số nguyên không được phân phối đồng đều.

Ruby, 47 byte

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

Brachylog , 17 byte

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

Hãy thử trực tuyến!

Giải trình

Về cơ bản, chúng tôi tạo một danh sách các danh sách con với các thành phần biến có cùng "hình dạng" với Đầu vào, và sau đó tuyên bố rằng nếu chúng ta ghép tất cả mọi thứ vào một danh sách, thì nó phải dẫn đến việc ghép nối đầu vào thành một danh sách .

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 byte

36 byte mã + -pcờ.

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

Để chạy nó:

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

Giải thích:

@ n = / d + / g # lưu trữ tất cả các số nguyên trong @n
s / \ d + / # thay thế mỗi số nguyên bằng ...
splice @ n, rand @ n, 1 / ge # một phần tử tại một vị trí ngẫu nhiên của @n (được xóa khỏi @n)

05AB1E , 17 byte

˜.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

Hãy thử trực tuyến!

Tôi đang chờ giải pháp 05AB1E hoặc 2sable bằng cách sử dụng một số tính năng tạo khối / đúc không tích hợp mà tôi chưa biết :).

APL, 35 byte

Tôi hầu như không đánh bại Perl, phải có điều gì đó tôi đang thiếu.

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

Ví dụ:

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

Giải trình:

• Tìm các chỉ số tương ứng của điểm bắt đầu của các mảng con trong một mảng được làm phẳng:
  • ⍳¨⍴¨⍵: Đối với mỗi mảng con, hãy lấy danh sách các chỉ mục
  • {⍵+⊃⌽⍺}\: Bắt đầu với mảng con đầu tiên, thêm giá trị cuối cùng trong mảng vào từng giá trị trong mảng tiếp theo.
  • ⊃¨: lấy các mục đầu tiên của mảng, là nơi bắt đầu
  • (⍳⍴Z←∊⍵)∊: lưu trữ mảng dẹt trong Z. Tạo một vectơ bit trong đó các vectơ đánh dấu các vị trí nơi các mảng con sẽ bắt đầu.
• Xáo trộn mảng phẳng:
  • ?⍨⍴Z: tạo ra một hoán vị ngẫu nhiên của Z.
  • Z[... ]: hoán vị Z.
• ⊂⍨: Tách hoán vị trong các mảng con theo vectơ bit.

Bình thường, 15 byte

tPc.SsQ.u+NlYQ0

Một chương trình lấy đầu vào của một danh sách và in kết quả.

Bộ kiểm tra

Làm thế nào nó hoạt động

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 byte

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

giảm xuống 105 byte nhờ user59178.

Câu trả lời gốc:

PHP , 132 byte

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

Bash, 63, 58 byte

CHỈNH SỬA:

• Tối ưu hóa biểu thức sed một chút, -5 byte

Chú thích:

Bash không thực sự hỗ trợ các mảng đa chiều (chúng chỉ có thể được mô phỏng, ở một mức độ nào đó), vì vậy, chương trình này sẽ chấp nhận biểu diễn văn bản "nối tiếp" của một mảng gồ ghề, như được mô tả trong mô tả nhiệm vụ, ví dụ: [[1,2,3],[4],[9,10]]và cung cấp đầu ra trong cùng một định dạng.

Chơi gôn

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

Kiểm tra

>./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]]

Một phần thưởng tuyệt vời là bạn có thể cung cấp cho nó các mảng gồ ghề có độ sâu tùy ý:

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

và nó vẫn sẽ hoạt động chính xác.

Hãy thử trực tuyến!

Octave, 60 byte

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

MATLAB , 84 byte

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

Java, 368 byte

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

phương pháp static int[][] f( int[][] r ){...}giải quyết thách thức. quyết định cuộn giao diện chức năng của riêng tôi để tránh nhập và thêm vào một phương thức mặc định để dễ sử dụng

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

}

Toán học, 67 byte

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

Giải thích: Điều này xáo trộn danh sách các vị trí của tất cả các số nguyên trong mảng rách nát 2D. Union@@là viết tắt củaFlatten@

Lưu ý: Dấu ngoặc vuông {}được sử dụng thay vì dấu ngoặc [].