Nous définissons une carte comme un ensemble de paires clé-valeur. Pour ce défi, vous devez prendre chacune des valeurs et les affecter à une clé choisie au hasard.

• Vous devez mélanger aléatoirement les valeurs et sortir la carte résultante. Cela signifie que chaque fois que nous exécutons votre programme, nous avons une chance d'obtenir une sortie différente
• Chaque permutation possible des valeurs doit avoir une chance non nulle d'apparaître.
• Toutes les clés et valeurs d'origine doivent apparaître dans le tableau résultant. Les valeurs répétées doivent apparaître le même nombre de fois dans le tableau résultant.

Par exemple, si votre carte était:

[0:10, 1:10, 5:5]

tous les éléments suivants doivent avoir une chance d'apparaître:

[0:10, 1:10, 5:5]  (original map)
[0:10, 1:5,  5:10]
[0:10, 1:10, 5:5]  (technically the same map, but I swapped the two tens)
[0:10, 1:5,  5:10]
[0:5,  1:10, 5:10]
[0:5,  1:10, 5:10]

Entrées / sorties acceptables:

• Carte native de vos langues
• Vous pouvez entrer un tableau de paires clé-valeur. Vous ne pouvez pas entrer 2 tableaux, l'un avec des clés, l'autre avec des valeurs.
• Vous pouvez utiliser une représentation sous forme de chaîne de tout ce qui précède
• Si vous entrez un tableau ou une carte, vous pouvez modifier l'objet d'origine au lieu de retourner
• Le type d'entrée doit correspondre au type de sortie
• Si vous entrez un tableau, l'ordre des clés doit être conservé.
• Vous pouvez supposer que les clés sont uniques, mais vous ne pouvez pas supposer que les valeurs sont uniques.

Ceci est un code-golf , alors répondez le plus brièvement possible

05AB1E , 5 octets

L'entrée est une liste de paires clé-valeur.

ø       # zip into a list of keys and one of values
 `      # flatten
  .r    # randomize the values
    ø   # zip back again into a list of key-value pairs.

Essayez-le en ligne!

Brachylog , 13 12 octets

zt@~T,?zh:Tz

Essayez-le en ligne!

Attend une liste de listes à 2 éléments en entrée.

Explication

z              Zip the input to get a list of keys and a list of values
 t@~T,         Take the list of values, and shuffle it ; call that T
      ?zh      Zip the input to get the list of keys
         :Tz   Zip the list of keys with the list of shuffled values

CJam, 9 octets

{z)mra+z}

L'entrée est une liste de paires clé-valeur.

Testez-le ici.

Explication

z  e# Zip, to separate keys from values.
)  e# Pull off values.
mr e# Shuffle them.
a+ e# Append them to the array again.
z  e# Zip, to restore key-value pairs.

Solution alternative, même nombre d'octets:

{[z~mr]z}

Gelée , 5 octets

Ṫ€Ẋṭ"

Essayez-le en ligne!

Explication

Ṫ€Ẋṭ"  Input: list of [k, v] pairs
Ṫ€     Pop and return the last element of each k-v pair (modifies each list)
  Ẋ    Shuffle the list of v's
   ṭ"  Append each v back to a k and return

Python 2, 77 octets

Utilise cette option: Si vous entrez un tableau ou une carte, vous pouvez modifier l'objet d'origine au lieu de revenir . L'entrée est un dictionnaire littéral comme {0: 10, 1: 10, 5: 5}.

from random import*
D=input()
k=D.keys()
shuffle(k)
D=dict(zip(k,D.values()))

Essayez-le en ligne

Inspiration tirée de cette réponse SO .

Python 3, 107 octets

Utilise la structure du dictionnaire natif de Python.

Merci à @ mbomb007 d'avoir enregistré un octet.

from random import*
def f(d,o={}):
 i=list(d.values());shuffle(i)
 for k in d.keys():o[k]=i.pop()
 return o

Ideone it!

Perl, 35 octets

Comprend +2 pour -0p

Donnez chaque clé / valeur séparée par un espace sur une ligne STDIN

shuffle.pl
1 5
3 8
9 2
^D

shuffle.pl:

#!/usr/bin/perl -p0
@F=/ .*/g;s//splice@F,rand@F,1/eg

Mathematica, 32 octets

{#,RandomSample@#2}&@@(#)&

L'entrée est une liste de paires clé-valeur. est l'opérateur de transposition de Mathematica et RandomSamplepeut être utilisé pour mélanger une liste.

php, 84 octets

<?= serialise(array_combine(array_keys($a=unserialize($argv[1])),shuffle($a)?$a:0));

Prend l'entrée comme un tableau sérialisé, sort le même.

Clojure, 40 34 octets

#(zipmap(keys %)(shuffle(vals %)))

Prend les clés et les valeurs de m (une carte), mélange les valeurs et les zippe dans une carte.

PowerShell v2 +, 52 octets

param($a)$a|%{$_[1]}|sort {random}|%{$a[$i++][0],$_}

Prend l'entrée sous la forme d'un tableau de tuples, ce qui est nettement plus court que l'utilisation d'un hachage (ce qui nécessiterait .GetEnumerator()et tout cela ne fonctionne pas).

Nous bouclons le tableau d'entrée |%{...}, chaque itération tirant le deuxième élément $_[1]. Ceux-ci sont acheminés Sort-Objectavec le {Get-Random}comme clé de tri. Cela attribuera un poids aléatoire de 0à [Int32]::MaxValueà chaque élément pour le tri. Ceux-ci sont dirigés vers une autre boucle |%{...}, chaque itération produisant un tuple du premier élément correspondant du tuple et le numéro trié.

Exemples

Les exemples ici ont un supplément -join','sur la sortie de tuple, donc il est mieux affiché sur la console, car la sortie par défaut pour les tableaux multidimensionnels est difficile à lire.

PS C:\Tools\Scripts\golfing> .\shuffle-a-mapping.ps1 ((0,10),(1,10),(5,5))
0,10
1,5
5,10

PS C:\Tools\Scripts\golfing> .\shuffle-a-mapping.ps1 ((0,10),(1,10),(5,5))
0,10
1,10
5,5

PS C:\Tools\Scripts\golfing> .\shuffle-a-mapping.ps1 ((1,1),(2,2),(3,3),(4,4),(5,5))
1,2
2,4
3,3
4,5
5,1

Cela fonctionne également pour les valeurs non entières sans aucune modification.

PS C:\Tools\Scripts\golfing> .\shuffle-a-mapping.ps1 (('one','one'),('two','two'),('three','three'),('four','four'))
one,four
two,three
three,two
four,one

JavaScript (ES6), 89 octets

a=>a.map((_,i)=>[i,Math.random()]).sort((a,b)=>a[1]-b[1]).map(([i],j)=>[a[j][0],a[i][1]])

Perl 6 , 28 octets

{%(.keys.pick(*)Z=>.values)}

L'entrée est un hachage
(techniquement, toute valeur avec une .keysméthode et une .valuesméthode fonctionnerait, mais la sortie est un hachage )

Explication:

# bare block lambda with implicit parameter ｢$_｣
{

  # turn the list of key => value Pairs into a Hash
  %(
      # get the keys from ｢$_｣ ( implicit method call on ｢$_｣ )
      .keys

      # get all of the keys in random order
      .pick(*)

    # zip using ｢&infix:« => »｣ the Pair constructor
    Z[=>]

      # the values from ｢$_｣ ( implicit method call on ｢$_｣ )
      .values
  )
}

Une variante qui fonctionnerait pour les autres types d'objets Hash similaires est:

{.WHAT.(.keys.pick(*)Z=>.values)}

.WHAT sur un objet renvoie le type.

R, 47 (28) octets

Un peu tard pour la fête, mais je publierais une solution en R à l'aide de builtins.

La chose la plus proche de R à un tableau avec mappage clé / valeur est a list. La fonction suivante prend un listobjet en entrée et génère une liste avec ses valeurs mélangées.

function(x)return(setNames(sample(x),names(x)))

Expliqué

La fonction intégrée setNames()peut attribuer des noms aux objets en saisissant un R-vectordes noms. Par conséquent, mélangez d'abord le listpar sample()lequel mélange les paires, puis attribuez les noms dans l'ordre d'origine à l'aide de names().

Exemple:

z  <- list(fish = 1, dog = 2, cat = 3, monkey = 4, harambe = 69)

f=function(x)return(setNames(sample(x),names(x)))
f(z)

$fish
[1] 3

$dog
[1] 1

$cat
[1] 2

$monkey
[1] 69

$harambe
[1] 4

Si xest supposé être défini, il n'est pas nécessaire d'envelopper la fonction et le programme se réduit à 28 octets.

setNames(sample(x),names(x))

Java 7, 156 octets

import java.util.*;void c(Map m){List t=new ArrayList(m.values());Collections.shuffle(t);Iterator i=t.iterator();for(Object k:m.keySet())m.put(k,i.next());}

Non golfé:

void c(Map m){
  List t = new ArrayList(m.values());
  Collections.shuffle(t);
  Iterator i = t.iterator();
  for(Object k : m.keySet()){
    m.put(k, i.next());
  }
}

Code de test:

Essayez-le ici.

import java.util.*;
class M{
  static void c(Map m){List t=new ArrayList(m.values());Collections.shuffle(t);Iterator i=t.iterator();for(Object k:m.keySet())m.put(k,i.next());}

  public static void main(String[]a){
    for(int i=0;i<10;i++){
      Map m=new HashMap();
      m.put(0, 10);
      m.put(1, 10);
      m.put(5, 5);
      c(m);
      System.out.println(m);
    }
  }
}

Sortie possible:

{0=5, 1=10, 5=10}
{0=10, 1=10, 5=5}
{0=10, 1=5, 5=10}
{0=10, 1=10, 5=5}
{0=10, 1=10, 5=5}
{0=10, 1=10, 5=5}
{0=10, 1=10, 5=5}
{0=10, 1=10, 5=5}
{0=10, 1=5, 5=10}
{0=5, 1=10, 5=10}