Definimos un mapa como un conjunto de pares clave-valor. Para este desafío, debe tomar cada uno de los valores y asignarlos a una clave elegida al azar.

• Debe barajar aleatoriamente los valores y generar el mapa resultante. Esto significa que cada vez que ejecutamos su programa, tenemos la posibilidad de obtener un resultado diferente
• Cada posible permutación de los valores debe tener una probabilidad distinta de cero de aparecer.
• Todas las claves y valores originales deben aparecer en la matriz resultante. Los valores repetidos deben aparecer la misma cantidad de veces en la matriz resultante.

Por ejemplo, si su mapa era:

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

todo lo siguiente debe tener la posibilidad de aparecer:

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

Entradas / salidas aceptables:

• El mapa nativo de tus idiomas
• Puede ingresar una matriz de pares clave-valor. Es posible que no de entrada 2 arrays, uno con teclas, el otro con valores.
• Puede usar una representación de cadena de cualquiera de los anteriores
• Si ingresa una matriz o un mapa, puede modificar el objeto original en lugar de devolver
• El tipo de entrada debe coincidir con el tipo de salida.
• Si ingresa una matriz, se debe mantener el orden de las teclas.
• Puede suponer que las claves son únicas, pero no puede suponer que los valores son únicos.

Este es un código de golf , así que responda lo más breve posible

05AB1E , 5 bytes

La entrada es una lista de pares clave-valor.

ø       # 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.

Pruébalo en línea!

Brachylog , 13 12 bytes

zt@~T,?zh:Tz

Pruébalo en línea!

Espera una lista de listas de 2 elementos como entrada.

Explicación

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 bytes

{z)mra+z}

La entrada es una lista de pares clave-valor.

Pruébalo aquí.

Explicación

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.

Solución alternativa, mismo recuento de bytes:

{[z~mr]z}

Jalea , 5 bytes

Ṫ€Ẋṭ"

Pruébalo en línea!

Explicación

Ṫ€Ẋṭ"  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 bytes

Utiliza esta opción: si ingresa una matriz o un mapa, puede modificar el objeto original en lugar de devolverlo . La entrada es un diccionario literal como {0: 10, 1: 10, 5: 5}.

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

Pruébalo en línea

Inspiración tomada de esta respuesta SO .

Python 3, 107 bytes

Utiliza la estructura del diccionario nativo de Python.

Gracias a @ mbomb007 por guardar un byte.

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 bytes

Incluye +2 para -0p

Dé a cada clave / valor separados por espacio en una línea 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 bytes

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

La entrada es una lista de pares clave-valor. es el operador de transposición de Mathematica y RandomSamplepuede usarse para barajar una lista.

php, 84 bytes

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

Toma la entrada como una matriz serializada, emite la misma.

Clojure, 40 34 bytes

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

Toma las claves y los valores de m (un mapa), baraja los valores y los comprime en un mapa.

PowerShell v2 +, 52 bytes

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

Toma datos como una matriz de tuplas, que es significativamente más corta que usar un hash (lo que requeriría .GetEnumerator()y qué no funcionaría).

Hacemos un bucle en la matriz de entrada |%{...}, cada iteración saca el segundo elemento $_[1]. Esos se canalizan Sort-Objectcon la {Get-Random}clave de clasificación. Esto asignará un peso azar 0a [Int32]::MaxValuecada elemento para la clasificación. Estos se canalizan a otro bucle |%{...}, y cada iteración genera una tupla del primer elemento correspondiente de la tupla y el número ordenado.

Ejemplos

Los ejemplos aquí tienen un adicional -join','en la salida de tupla, por lo que se muestra mejor en la consola, ya que la salida predeterminada para las matrices multidimensionales es difícil de leer.

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

Esto también funciona para valores no enteros sin modificaciones.

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 bytes

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 bytes

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

La entrada es un hash
(técnicamente cualquier valor con un .keysmétodo y un .valuesmétodo funcionaría, pero la salida es un hash )

Explicación:

# 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
  )
}

Una variante que funcionaría para los otros tipos de objetos construidos en Hash es:

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

.WHAT en un objeto devuelve el tipo.

R, 47 (28) bytes

Un poco tarde para la fiesta, pero publicaría una solución en R usando builtins.

Lo más cercano que R tiene a una matriz con asignación de clave / valor es a list. La siguiente función toma un listobjeto como entrada y genera una lista con sus valores mezclados.

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

Explicado

El incorporado setNames()puede asignar nombres a los objetos ingresando uno R-vectorde los nombres. Por lo tanto, primero baraje el listpor el sample()cual baraja los pares, y luego asigne los nombres en el orden original usando names().

Ejemplo:

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 xse supone que está definido, no es necesario ajustar la función y el programa se reduce a 28 bytes.

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

Java 7, 156 bytes

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

Sin 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());
  }
}

Código de prueba:

Pruébalo aquí.

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

Salida posible:

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