Una matriz irregular es una matriz en la que cada elemento es una matriz de un número desconocido de enteros positivos.

Por ejemplo, los siguientes son matrices irregulares:

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

Los siguientes no son arreglos irregulares:

[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

Debe ingresar una matriz irregular y devolver una matriz irregular con los enteros mezclados

• La matriz de salida debe tener la misma forma que la matriz de entrada. Definimos la forma de la matriz como la longitud de cada submatriz.
• Cada número entero debe tener la misma probabilidad de aparecer en cada ubicación posible.
• Puede suponer que el idioma incorporado al azar es aleatorio.

Por ejemplo, si pasara:, [[4],[1,2,3],[4]]entonces [[1],[4,4,2],[3]]sería una salida válida, pero [[4,1,3],[3],[4]]o [[4],[4],[1,2,3]]no.

Jelly, 3 bytes en la página de códigos de Jelly

FẊṁ

Explicación:

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

Debido a que el programa está incompleto ( ṁno tiene un segundo argumento establecido), el valor predeterminado es usar la entrada del programa; por lo tanto ṁ, la salida tiene el mismo patrón de sublista que la entrada.

Pruébalo en línea!

PowerShell v2 +, 86 bytes

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

Funciona a través de la manipulación de cadenas. La entrada se pasa como una cadena que representa la matriz, en cualquier formato que funcione para su idioma. ;-)

-splits la entrada en no dígitos, sorts basada en el randombloque de secuencia de comandos (que asignará un peso aleatorio diferente para cada entrada a la clasificación), almacena eso en $a. Luego, splitingresamos nuevamente, esta vez en dígitos, y para cada salida el valor actual (generalmente corchetes y comas) concatenado en cadena con el número correspondiente de $a. Eso se -joinvuelve a unir en una cadena y la salida es implícita.

Ejemplos

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 bytes

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

Pruébalo en línea!

JavaScript (ES6), 78 75 bytes

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

Esta es la primera vez que recuerdo haberlo usado .splice()en un desafío de código de golf ...

Puede jugar golf en dos bytes barajando la matriz de antemano:

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

Sin embargo, esto parece poner el último entero primero la mayoría de las veces, por lo que voy a suponer que los enteros no están distribuidos uniformemente.

Ruby, 47 bytes

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

Brachylog , 17 bytes

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

Pruébalo en línea!

Explicación

Básicamente, creamos una lista de sublistas con elementos variables que tienen la misma "forma" que la entrada, y luego declaramos que si concatenamos todo en una sola lista, debe resultar en una combinación aleatoria de la concatenación de la entrada en una sola lista .

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 bytes

36 bytes de código + -pbandera.

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

Para ejecutarlo:

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

Explicaciones:

@ n = / d + / g # almacena todos los enteros en @n
s / \ d + / # reemplaza cada número entero con ...
empalme @ n, rand @ n, 1 / ge # un elemento en una posición aleatoria de @n (que se elimina de @n)

05AB1E , 17 bytes

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

Pruébalo en línea!

Estoy esperando la solución 05AB1E o 2sable usando algunos elementos incorporados de desmoldeo / moldeado que aún no conozco :).

APL, 35 bytes

Apenas estoy golpeando a Perl, tiene que haber algo que me falta.

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

P.ej:

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

Explicación:

• Encuentre los índices correspondientes de los inicios de las submatrices en una matriz aplanada:
  • ⍳¨⍴¨⍵: Para cada submatriz, obtenga una lista de los índices
  • {⍵+⊃⌽⍺}\: Comenzando con el primer subconjunto, agregue el último valor en el conjunto a cada valor en el siguiente conjunto.
  • ⊃¨: obtener los primeros elementos de las matrices, que son los lugares de inicio
  • (⍳⍴Z←∊⍵)∊: almacena la matriz aplanada en Z. Genere un vector de bits donde los que marcan los lugares donde deberían comenzar las sub-matrices.
• Mezcle la matriz aplanada:
  • ?⍨⍴Z: genera una permutación aleatoria de Z.
  • Z[... ]: permutar Z.
• ⊂⍨: Divide la permutación en sub-matrices de acuerdo con el vector de bits.

Pyth, 15 bytes

tPc.SsQ.u+NlYQ0

Un programa que toma la entrada de una lista e imprime el resultado.

Banco de pruebas

Cómo funciona

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 bytes

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

reducido a 105 bytes gracias a user59178.

Respuesta original:

PHP , 132 bytes

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

Golpetazo, 6358 bytes

EDICIONES:

• Expresión sed optimizada un poco, -5 bytes

Nota:

Bash realmente no admite matrices multidimensionales (solo se pueden simular, hasta cierto punto), por lo que, en su lugar, este programa aceptará una representación de texto "serializado" de una matriz resistente, como se muestra en la descripción de la tarea, por ejemplo: [[1,2,3],[4],[9,10]]y proporcionará resultados en el mismo formato

Golfed

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

Prueba

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

Una buena ventaja es que puedes alimentarlo con matrices resistentes de una profundidad arbitraria:

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

y seguirá funcionando correctamente.

Pruébalo en línea!

Octava, 60 bytes

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

MATLAB , 84 bytes

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

Java, 368 bytes

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

El método static int[][] f( int[][] r ){...}resuelve el desafío. decidí rodar mi propia interfaz funcional para evitar una importación y agregar un método predeterminado para facilitar su uso

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@@#]]&

Explicación: Esto baraja la lista de posiciones de todos los enteros en la matriz desigual 2D. Union@@es la abreviatura deFlatten@

Nota: Los corchetes {}se usan en lugar de los corchetes [].