Un array irregolare è un array in cui ogni elemento è un array di un numero sconosciuto di numeri interi positivi.

Ad esempio, i seguenti sono array irregolari:

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

I seguenti non sono array irregolari:

[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

È necessario immettere un array sfilacciato e restituire un array sfilacciato con gli interi mescolati

• L'array di output deve avere la stessa forma dell'array di input. Definiamo la forma dell'array come la lunghezza di ciascun subarray.
• Ogni numero intero deve avere una probabilità altrettanto probabile di apparire in ogni posizione possibile.
• Puoi presumere che il casuale incorporato nella tua lingua sia casuale.

Ad esempio, se avessi passato:, [[4],[1,2,3],[4]]allora [[1],[4,4,2],[3]]sarebbe un output valido, [[4,1,3],[3],[4]]o [[4],[4],[1,2,3]]no.

Jelly, 3 byte nella tabella codici di Jelly

FẊṁ

Spiegazione:

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

Poiché il programma è incompleto ( ṁnon è indicato un secondo argomento), l'impostazione predefinita è utilizzare l'input del programma; quindi ṁprovoca l'uscita di avere lo stesso modello sottolista come ingresso.

Provalo online!

PowerShell v2 +, 86 byte

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

Funziona tramite manipolazione di stringhe. L'input viene passato come una stringa che rappresenta l'array, in qualunque formato sia adatto alla tua lingua. ;-)

-splitinvia l'input su non cifre, sortli basa sul randomblocco di script (che assegnerà un peso casuale diverso per ciascun input all'ordinamento), lo memorizza in $a. Quindi di splitnuovo l'input, questa volta su cifre, e per ciascuno di essi viene emesso il valore corrente (solitamente parentesi e virgole) concatenato con il numero corrispondente da $a. Ecco -joinEd insieme in una stringa, e l'uscita è implicita.

Esempi

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]

Provalo online!

JavaScript (ES6), 78 75 byte

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

Questa è la prima volta che ricordo di aver usato .splice()in una sfida di code-golf ...

Puoi giocare a golf di due byte mescolando in anticipo l'array:

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

Tuttavia, questo sembra mettere l'ultimo intero al primo posto la maggior parte delle volte, quindi suppongo che gli interi non siano distribuiti uniformemente.

Rubino, 47 byte

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

Brachylog , 17 byte

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

Provalo online!

Spiegazione

Fondamentalmente creiamo un elenco di elenchi secondari con elementi variabili che hanno la stessa "forma" dell'input e quindi dichiariamo che se concateniamo tutto in un unico elenco, deve risultare un shuffle della concatenazione dell'input in un unico elenco .

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 di codice + -pflag.

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

Per eseguirlo:

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

spiegazioni:

@ n = / d + / g # archivia tutti gli interi in @n
s / \ d + / # sostituisce ogni numero intero con ...
splice @ n, rand @ n, 1 / ge # un elemento in una posizione casuale di @n (che viene eliminato da @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

Provalo online!

Sto aspettando la soluzione 05AB1E o 2sable usando un po 'di appiattimento / stampaggio incorporato che non conosco ancora :).

APL, 35 byte

Sto a malapena battendo il Perl, ci deve essere qualcosa che mi manca.

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

Per esempio:

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

Spiegazione:

• Trova gli indici corrispondenti degli inizi dei sotto-array in un array appiattito:
  • ⍳¨⍴¨⍵: Per ciascun array secondario, ottenere un elenco degli indici
  • {⍵+⊃⌽⍺}\: A partire dal primo array secondario, aggiungi l'ultimo valore dell'array a ciascun valore dell'array successivo.
  • ⊃¨: ottieni i primi elementi degli array, che sono i punti di partenza
  • (⍳⍴Z←∊⍵)∊: archivia l'array appiattito in Z. Genera un vettore di bit in cui quelli segnano i punti in cui dovrebbero iniziare i sotto-array.
• Mescola l'array appiattito:
  • ?⍨⍴Z: genera una permutazione casuale di Z.
  • Z[... ]: permuta Z.
• ⊂⍨: Suddivide la permutazione in sotto-matrici secondo il vettore di bit.

Pyth, 15 byte

tPc.SsQ.u+NlYQ0

Un programma che accetta l'inserimento di un elenco e stampa il risultato.

Suite di test

Come funziona

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

ridotto a 105 byte grazie a user59178.

Risposta originale:

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

Modifiche:

• Espressione sed ottimizzata un po ', -5 byte

Nota:

Bash in realtà non supporta array multidimensionali (possono solo essere simulati, in una certa misura), quindi invece questo programma accetterà una rappresentazione di testo "serializzata" di un array robusto, come illustrato nella descrizione dell'attività, ad esempio:, [[1,2,3],[4],[9,10]]e fornisce output nello stesso formato.

golfed

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

Test

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

Un bel bonus è che puoi alimentare array robusti di profondità arbitraria:

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

e continuerà a funzionare correttamente.

Provalo online!

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

il metodo static int[][] f( int[][] r ){...}risolve la sfida. ho deciso di implementare la mia interfaccia funzionale per evitare un'importazione e aggiungere un metodo predefinito per facilità d'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 byte

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

Spiegazione: Questo mescola l'elenco delle posizioni di tutti i numeri interi nella matrice irregolare 2D. Union@@è l'abbreviazione diFlatten@

Nota: al {}posto delle parentesi vengono utilizzate parentesi quadre [].