Ein unregelmäßiges Array ist ein Array, in dem jedes Element eine unbekannte Anzahl positiver Ganzzahlen enthält.

Beispielsweise handelt es sich bei den folgenden Elementen um unregelmäßige Arrays:

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

Die folgenden Arrays sind nicht unregelmäßig:

[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

Sie müssen ein unregelmäßiges Array eingeben und ein unregelmäßiges Array mit gemischten Ganzzahlen zurückgeben

• Das Ausgabearray muss dieselbe Form haben wie das Eingabearray. Wir definieren die Form des Arrays als die Länge jedes Subarrays.
• Jede Ganzzahl muss die gleiche Wahrscheinlichkeit haben, an jeder möglichen Position zu erscheinen.
• Sie können davon ausgehen, dass der Zufallsgenerator Ihrer Sprache zufällig ist.

Zum Beispiel, wenn ich in vergangen: [[4],[1,2,3],[4]], dann [[1],[4,4,2],[3]]wäre eine gültige Ausgabe, aber [[4,1,3],[3],[4]]oder [[4],[4],[1,2,3]]nicht würde.

Jelly, 3 Bytes in Jellys Codepage

FẊṁ

Erläuterung:

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

Da das Programm unvollständig ist ( ṁohne Angabe eines zweiten Arguments), wird standardmäßig die Programmeingabe verwendet. somit ṁbewirkt , dass die Ausgabe die gleichen sublist Muster wie der Eingang haben.

Probieren Sie es online!

PowerShell v2 +, 86 Byte

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

Funktioniert über String-Manipulation. Die Eingabe wird als Zeichenfolge übergeben, die das Array darstellt, unabhängig davon, welches Format für Ihre Sprache verwendet wird. ;-)

-splitWenn Sie die Eingabe auf Nicht-Ziffern ausgeben, speichern Sie sortdiese anhand des randomSkriptblocks (der der Sortierung für jede Eingabe eine andere zufällige Gewichtung zuweist) in $a. Wir geben dann splitdie Eingabe erneut ein, diesmal auf Ziffern, und geben für jede einzelne den aktuellen Wert (meist Klammern und Kommas) mit der entsprechenden Zahl verkettet aus $a. Das wird -joinwieder zu einer Zeichenfolge zusammengefasst, und die Ausgabe ist implizit.

Beispiele

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]

Probieren Sie es online!

JavaScript (ES6), 78 bis 75 Byte

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

Dies ist das erste Mal, dass ich mich .splice()an eine Code-Golf-Herausforderung erinnere ...

Sie können zwei Bytes entfernen, indem Sie das Array vorher mischen:

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

Dies scheint jedoch die meiste Zeit die letzte ganze Zahl an die erste zu setzen, daher gehe ich davon aus, dass die ganzen Zahlen nicht gleichmäßig verteilt sind.

Ruby, 47 Bytes

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

Brachylog , 17 Bytes

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

Probieren Sie es online!

Erläuterung

Wir erstellen im Grunde genommen eine Liste von Unterlisten mit variablen Elementen, die dieselbe "Form" wie die Eingabe haben, und geben dann an, dass, wenn wir alles zu einer einzigen Liste verketten, die Verkettung der Eingabe zu einer einzigen Liste gemischt werden muss .

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 Byte Code + -pFlag.

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

Um es auszuführen:

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

Erklärungen:

@ n = / d + / g # speichert alle ganzen Zahlen in @ n
s / \ d + / # Ersetzen Sie jede Ganzzahl durch ...
splice @ n, rand @ n, 1 / ge # ein Element an einer zufälligen Position von @n (das aus @n gelöscht wird)

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

Probieren Sie es online!

Ich warte auf die 05AB1E- oder 2sable-Lösung mit einer integrierten Funktion zum Glätten / Formen, die ich noch nicht kenne :).

APL, 35 Bytes

Ich habe Perl kaum geschlagen, es muss etwas geben, das mir fehlt.

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

Z.B:

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

Erläuterung:

• Suchen Sie die entsprechenden Indizes der Starts der Unterarrays in einem abgeflachten Array:
  • ⍳¨⍴¨⍵: Für jedes Sub-Array erhalten Sie eine Liste der Indizes
  • {⍵+⊃⌽⍺}\: Beginnen Sie mit dem ersten Unterarray und fügen Sie den letzten Wert im Array zu jedem Wert im nächsten Array hinzu.
  • ⊃¨: Holen Sie sich die ersten Elemente der Arrays, die die Startplätze sind
  • (⍳⍴Z←∊⍵)∊: Speichern Sie das abgeflachte Array in Z. Erzeugen Sie einen Bitvektor, in dem diejenigen die Stellen markieren, an denen die Sub-Arrays beginnen sollen.
• Mische das abgeflachte Array:
  • ?⍨⍴Z: erzeugen eine zufällige Permutation von Z.
  • Z[... ]: permutieren Z.
• ⊂⍨: Aufteilen der Permutation in Subarrays entsprechend dem Bitvektor.

Pyth, 15 Bytes

tPc.SsQ.u+NlYQ0

Ein Programm, das eine Liste eingibt und das Ergebnis druckt.

Testsuite

Wie es funktioniert

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

reduziert auf 105 Bytes dank user59178.

Ursprüngliche Antwort:

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

Bash, 6358 Bytes

EDITS:

• Optimierter sed Ausdruck ein bisschen, -5 Bytes

Hinweis:

Bash nicht wirklich multidimensionalen Arrays unterstützen (sie können nur simuliert werden, bis zu einem gewissen Grad), so stattdessen dieses Programm einer „serialisiert“ Textdarstellung eines robusten Array akzeptieren, wie es in der Aufgabenbeschreibung dargestellt, zum Beispiel: [[1,2,3],[4],[9,10]]und liefert Ausgang im gleichen Format.

Golf gespielt

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

Prüfung

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

Ein netter Bonus ist, dass Sie damit robuste Arrays beliebiger Tiefe füttern können:

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

und es wird immer noch richtig funktionieren.

Probieren Sie es online!

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

Die Methode static int[][] f( int[][] r ){...}löst die Herausforderung. beschlossen, meine eigene funktionale Schnittstelle zu rollen, um einen Import zu vermeiden und eine Standardmethode für die Benutzerfreundlichkeit hinzuzufügen

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

Erläuterung: Hiermit wird die Liste der Positionen aller Ganzzahlen im 2D-Array gemischt. Union@@Kurzform fürFlatten@

Hinweis: {}Anstelle von Klammern werden verzerrte Klammern verwendet [].