Array acak adalah array di mana setiap elemen adalah array dengan bilangan bulat positif yang tidak diketahui jumlahnya.

Misalnya, berikut ini adalah array yang tidak rata:

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

Berikut ini bukan array yang tidak rata :

[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

Anda perlu memasukkan array yang tidak rata, dan mengembalikan array yang tidak rata dengan bilangan bulat yang dikocok

• Array output harus memiliki bentuk yang sama dengan array input. Kami mendefinisikan bentuk array sebagai panjang setiap subarray.
• Setiap bilangan bulat harus memiliki peluang yang sama untuk muncul di setiap lokasi yang memungkinkan.
• Anda dapat mengasumsikan bahwa bawaan bawaan bahasa Anda adalah acak.

Misalnya, jika saya meneruskan:, [[4],[1,2,3],[4]]maka [[1],[4,4,2],[3]]akan menjadi output yang valid, tetapi [[4,1,3],[3],[4]]atau [[4],[4],[1,2,3]]tidak.

Jelly, 3 byte dalam codepage Jelly

FẊṁ

Penjelasan:

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

Karena program tidak lengkap ( ṁtidak memiliki argumen kedua yang dinyatakan), standarnya adalah menggunakan input program; dengan demikian ṁmenyebabkan output memiliki pola sublist yang sama dengan input.

Cobalah online!

PowerShell v2 +, 86 byte

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

Bekerja melalui manipulasi string. Input dilewatkan sebagai string yang mewakili array, dalam format apa pun yang berfungsi untuk bahasa Anda . ;-)

-splits input pada non-digit, sorts mereka berdasarkan pada randomblok skrip (yang akan menetapkan bobot acak yang berbeda untuk setiap input ke sortir), menyimpannya ke dalam $a. Kami kemudian splitinput lagi, kali ini pada digit, dan untuk masing-masing output nilai saat ini (biasanya tanda kurung dan koma) -gabungkan dengan angka yang sesuai dari $a. Itu -joindisatukan kembali menjadi string, dan output tersirat.

Contohnya

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]

Cobalah online!

JavaScript (ES6), 78 75 byte

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

Ini adalah pertama kalinya saya bisa ingat menggunakan .splice()dalam tantangan kode-golf ...

Anda bisa bermain golf dua byte dengan mengocok array sebelumnya:

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

Namun, ini tampaknya menempatkan integer terakhir sebagai prioritas utama, jadi saya akan berasumsi bahwa integer tidak terdistribusi secara merata.

Ruby, 47 byte

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

Brachylog , 17 byte

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

Cobalah online!

Penjelasan

Kami pada dasarnya membuat daftar sublists dengan elemen variabel yang memiliki "bentuk" yang sama dengan Input, dan kemudian menyatakan bahwa jika kami menggabungkan semuanya menjadi satu daftar, itu harus menghasilkan pengocokan gabungan dari input menjadi satu daftar. .

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 kode + -pbendera.

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

Untuk menjalankannya:

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

Penjelasan:

@ n = / d + / g # menyimpan semua bilangan bulat di @n
s / \ d + / # ganti setiap bilangan bulat dengan ...
splice @ n, rand @ n, 1 / ge # a elemen pada posisi acak @n (yang dihapus dari @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

Cobalah online!

Saya sedang menunggu solusi 05AB1E atau 2sable menggunakan beberapa built-in unflattening / moulding Saya belum tahu :).

APL, 35 byte

Aku bahkan tidak bisa mengalahkan Perl, pasti ada sesuatu yang aku lewatkan.

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

Misalnya:

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

Penjelasan:

• Temukan indeks yang sesuai dari awal sub-array dalam array yang diratakan:
  • ⍳¨⍴¨⍵: Untuk setiap sub-larik, dapatkan daftar indeks
  • {⍵+⊃⌽⍺}\: Dimulai dengan sub-array pertama, tambahkan nilai terakhir dalam array ke setiap nilai dalam array berikutnya.
  • ⊃¨: dapatkan item pertama dari array, yang merupakan tempat awal
  • (⍳⍴Z←∊⍵)∊: simpan array yang rata di Z. Hasilkan bit-vektor di mana yang menandai tempat di mana sub-array harus dimulai.
• Kocok array yang rata:
  • ?⍨⍴Z: menghasilkan permutasi acak dari Z.
  • Z[... ]: permutasi Z.
• ⊂⍨: Membagi permutasi dalam sub-array sesuai dengan bit-vector.

Pyth, 15 byte

tPc.SsQ.u+NlYQ0

Program yang mengambil input daftar dan mencetak hasilnya.

Suite uji

Bagaimana itu bekerja

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

dikurangi menjadi 105 byte berkat user59178.

Jawaban asli:

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

Pesta, 63, 58 byte

EDIT:

• Dioptimalkan sed ekspresi sedikit, -5 byte

catatan:

Bash tidak benar-benar mendukung array multidimensi (mereka hanya dapat disimulasikan, sampai batas tertentu), jadi sebagai gantinya, program ini akan menerima representasi teks "serial" dari array kasar, seperti yang digambarkan dalam deskripsi tugas, misalnya:, [[1,2,3],[4],[9,10]]dan memberikan output dalam format yang sama.

Golf

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

Uji

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

Bonus yang bagus adalah Anda bisa memberinya array kasar dengan kedalaman yang sewenang-wenang:

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

dan masih akan beroperasi dengan benar.

Cobalah online!

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

metode static int[][] f( int[][] r ){...}memecahkan tantangan. memutuskan untuk memutar antarmuka fungsional saya sendiri untuk menghindari impor dan menambahkan metode default untuk kemudahan penggunaan

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 Bytes

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

Penjelasan: Ini mengocok daftar posisi semua bilangan bulat dalam array bergerigi 2D. Union@@kependekan dariFlatten@

Catatan: Kurung berlekuk {}digunakan sebagai pengganti kurung [].