Mélangez un tableau en lambeaux

23

Un tableau irrégulier est un tableau où chaque élément est un tableau d'un nombre inconnu d'entiers positifs.

Par exemple, les tableaux suivants sont des tableaux irréguliers:

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

Les tableaux suivants ne sont pas irréguliers:

[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

Vous devez entrer un tableau ragged et renvoyer un tableau ragged avec les entiers mélangés

  • Le tableau de sortie doit avoir la même forme que le tableau d'entrée. Nous définissons la forme du tableau comme la longueur de chaque sous-tableau.
  • Chaque entier doit avoir une chance également probable d'apparaître dans chaque emplacement possible.
  • Vous pouvez supposer que l'aléatoire intégré de votre langue est aléatoire.

Par exemple, si je transmettais:, [[4],[1,2,3],[4]]alors ce [[1],[4,4,2],[3]]serait une sortie valide, mais [[4,1,3],[3],[4]]ou [[4],[4],[1,2,3]]non.

Nathan Merrill
la source
En relation.
Martin Ender
1
L'entrée sera-t-elle toujours un tableau 2D?
Dennis

Réponses:

17

Jelly, 3 octets dans la page de codes de Jelly

FẊṁ

Explication:

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

Parce que le programme est incomplet ( n'a pas un deuxième argument indiqué), la valeur par défaut est d'utiliser l'entrée du programme; ainsi , la sortie a le même modèle de sous-liste que l'entrée.

Essayez-le en ligne!


la source
4
Wow, unflatten est une commande soignée et inattendue.
Magic Octopus Urn
3
Unflatten n'est peut-être pas le meilleur terme car l'argument de gauche n'a pas besoin d'être plat. Le mnémonique est la moisissure .
Dennis
@Dennis: Cela signifie-t-il que cela ne fonctionnerait pas correctement pour ce défi sur un tableau en entrée irrégulière qui contenait des listes en tant qu'éléments, plutôt que des entiers (car cela aplatirait d'abord les listes intérieures)? C'est un peu décevant, vous vous attendez à ce que cela fonctionne quel que soit le type de la matrice irrégulière. (Mise à jour: j'ai vérifié, il semble que les deux Fet le travail de plusieurs couches d'aplatissement, pas seulement un.)
Je veux dire que l'argument de gauche de peut être n'importe quoi, pas seulement une liste plate. Par exemple: tio.run/nexus/jelly#@/9wZ@P///@jow11FIxidRSijXUUTEC0qY6CWWzs…
Dennis
1
Oh, j'appellerais cela une opération non aplatie; l'argument de gauche est traité comme une liste plate (il se trouve qu'il contient des listes en tant qu'éléments, mais ces éléments sont interprétés comme opaques). En fait, je soupçonne que nous sommes d'accord sur ce qu'est un aplatissement mais en désaccord sur ce qu'est un aplatissement ...
7

PowerShell v2 +, 86 octets

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

Fonctionne via la manipulation de chaînes. L'entrée est transmise sous la forme d'une chaîne représentant le tableau, dans le format qui convient à votre langue. ;-)

-splits sortir l'entrée sur des non-chiffres, sorts les basée sur le randombloc de script (qui attribuera un poids aléatoire différent pour chaque entrée au tri), stocke cela dans $a. Nous entrons ensuite à splitnouveau, cette fois sur des chiffres, et pour chaque sortie, la valeur actuelle (généralement des crochets et des virgules) est concaténée en chaîne avec le nombre correspondant de $a. Ces informations sont -joinregroupées dans une chaîne et la sortie est implicite.

Exemples

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]]
AdmBorkBork
la source
5

Python 2 , 89 octets

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

Essayez-le en ligne!

Dennis
la source
Je ne connais pas très bien le python, mais ne pourriez-vous pas le faire shuffle(r=sum(x,[]))?
Conor O'Brien
1
Non, mélangez en place et retourne Aucun .
Dennis
3

JavaScript (ES6), 78 75 octets

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

C'est la première fois que je me souviens avoir utilisé .splice()dans un défi de code-golf ...

Vous pouvez jouer au golf sur deux octets en mélangeant au préalable le tableau:

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

Cependant, cela semble mettre le dernier entier en premier la majorité du temps, donc je vais supposer que les entiers ne sont pas uniformément distribués.

ETHproductions
la source
"Vous pouvez supposer que l'aléatoire intégré de votre langue est aléatoire."
Conor O'Brien
@ ConorO'Brien "Chaque entier doit avoir une chance égale d'apparaître dans chaque emplacement possible."
ETHproductions
sortne fonctionne pas correctement lorsque la clé de comparaison est incohérente. Même si l'aléatoire de la langue est aléatoire, son tri fonctionnera mal dans cette situation, et c'est ce qui crée le biais que vous voyez. En tant que tel, je pense que la deuxième solution est incorrecte.
2

Rubis, 47 octets

->a{b=a.flatten.shuffle;a.map{|x|x.map{b.pop}}}
Lee W
la source
2

Brachylog , 17 octets

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

Essayez-le en ligne!

Explication

Nous créons essentiellement une liste de sous-listes avec des éléments variables qui a la même "forme" que l'entrée, puis déclarons que si nous concaténons tout dans une seule liste, cela doit entraîner un mélange de la concaténation de l'entrée en une seule liste .

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.
Fatalize
la source
1

Perl, 37 octets

36 octets de code + -pindicateur.

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

Pour l'exécuter:

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

Explications:

@ n = / d + / g # stocke tous les entiers dans @n
s / \ d + / # remplacer chaque entier par ...
splice @ n, rand @ n, 1 / ge # un élément à une position aléatoire de @n (qui est supprimé de @n)
Dada
la source
1

05AB1E , 17 octets

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

Essayez-le en ligne!

J'attends la solution 05AB1E ou 2sable utilisant un peu d'aplatissement / moulage intégré que je ne connais pas encore :).

Osable
la source
1

APL, 35 octets

Je bat à peine Perl, il doit y avoir quelque chose qui me manque.

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

Par exemple:

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

Explication:

  • Trouvez les indices correspondants des débuts des sous-tableaux dans un tableau aplati:
    • ⍳¨⍴¨⍵: Pour chaque sous-tableau, obtenez une liste des indices
    • {⍵+⊃⌽⍺}\: En commençant par le premier sous-tableau, ajoutez la dernière valeur du tableau à chaque valeur du tableau suivant.
    • ⊃¨: récupérez les premiers éléments des tableaux, qui sont les points de départ
    • (⍳⍴Z←∊⍵)∊: stocker le tableau aplati dans Z. Générez un bit-vecteur où ceux marquent les endroits où les sous-tableaux doivent commencer.
  • Mélangez le tableau aplati:
    • ?⍨⍴Z: générer une permutation aléatoire de Z.
    • Z[... ]: permuter Z.
  • ⊂⍨: Divise la permutation en sous-tableaux en fonction du vecteur binaire.
marinus
la source
1
Vous pouvez faire un remplacement sur place. L'affectation vous a permis d'aplatir la variable:A⊣(∊A)←(∊A)[?⍨≢∊A←⎕]
Adam
@ Adám: wow, je ne savais pas que tu pouvais faire ça. Existe-t-il une liste des fonctions qui peuvent le faire?
marinus
1
Oui . Et cela fonctionne également avec une affectation modifiée.
Adám
1

Pyth, 15 octets

tPc.SsQ.u+NlYQ0

Un programme qui prend l'entrée d'une liste et imprime le résultat.

Suite de tests

Comment ça marche

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
TheBikingViking
la source
1

PHP , 105 octets

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

réduit à 105 octets grâce à user59178.

Réponse originale:

PHP , 132 octets

$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);
Arthur Shveida
la source
$m=array_merge(...$i=$_GET[i]);est de 25 octets plus court que $i=$_GET['i'];$m=call_user_func_array('array_merge',$i);et fait la même chose. De plus, vous pouvez supprimer l' {}after foreachpour enregistrer 2 octets supplémentaires.
user59178
1

Frapper, 63, 58 octets

MODIFICATIONS:

  • Expression sed optimisée un peu, -5 octets

Remarque:

Bash ne prend pas vraiment en charge les tableaux multidimensionnels (ils ne peuvent être simulés que dans une certaine mesure), donc à la place, ce programme acceptera une représentation textuelle "sérialisée" d'un tableau robuste, comme décrit dans la description de la tâche, par exemple:, [[1,2,3],[4],[9,10]]et fournira une sortie dans le même format.

Golfé

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

Tester

>./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 bon bonus est que vous pouvez lui fournir des tableaux robustes d'une profondeur arbitraire:

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

et il fonctionnera toujours correctement.

Essayez-le en ligne!

Zeppelin
la source
0

Octave, 60 octets

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

MATLAB , 84 octets

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

Java, 368 octets

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

la méthode static int[][] f( int[][] r ){...}résout le défi. décidé de rouler ma propre interface fonctionnelle pour éviter une importation et ajouter une méthode par défaut pour une facilité d'utilisation

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

}
Jack Ammo
la source
0

Mathematica, 67 octets

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

Explication: Cela mélange la liste des positions de tous les entiers dans le tableau 2D irrégulier. Union@@est l'abréviation deFlatten@

Remarque: des crochets ondulés {}sont utilisés à la place des crochets [].

Kelly Lowder
la source