Definiamo una mappa come un insieme di coppie chiave-valore. Per questa sfida, devi prendere ciascuno dei valori e assegnarli a una chiave scelta casualmente.

• È necessario mescolare casualmente i valori e produrre la mappa risultante. Ciò significa che ogni volta che eseguiamo il tuo programma, abbiamo la possibilità di ottenere un output diverso
• Ogni possibile permutazione dei valori deve avere una probabilità diversa da zero di apparire.
• Tutte le chiavi originali e i valori originali devono apparire nella matrice risultante. I valori ripetuti devono apparire lo stesso numero di volte nella matrice risultante.

Ad esempio, se la tua mappa era:

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

tutte le seguenti devono avere la possibilità di apparire:

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

Ingressi / uscite accettabili:

• Mappa nativa delle tue lingue
• Puoi inserire un array di coppie chiave-valore. Si può non ingresso 2 campi, uno con i tasti, l'altra con i valori.
• È possibile utilizzare una rappresentazione in formato stringa di quanto sopra
• Se si inserisce un array o una mappa, è possibile modificare l'oggetto originale invece di restituirlo
• Il tipo di input deve corrispondere al tipo di output
• Se si inserisce un array, è necessario mantenere l'ordine delle chiavi.
• Puoi presumere che le chiavi siano univoche, ma non puoi assumere che i valori siano univoci.

Questo è un codice-golf , quindi rispondi il più breve possibile

05AB1E , 5 byte

L'input è un elenco di coppie chiave-valore.

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

Provalo online!

Brachylog , 13 12 byte

zt@~T,?zh:Tz

Provalo online!

Si aspetta un elenco di elenchi a 2 elementi come input.

Spiegazione

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 byte

{z)mra+z}

L'input è un elenco di coppie chiave-valore.

Provalo qui.

Spiegazione

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.

Soluzione alternativa, stesso conteggio byte:

{[z~mr]z}

Gelatina , 5 byte

Ṫ€Ẋṭ"

Provalo online!

Spiegazione

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

Utilizza questa opzione: se si inserisce un array o una mappa, è possibile modificare l'oggetto originale invece di restituirlo . L'input è un dizionario letterale come {0: 10, 1: 10, 5: 5}.

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

Provalo online

Ispirazione tratta da questa risposta SO .

Python 3, 107 byte

Utilizza la struttura del dizionario nativo di Python.

Grazie a @ mbomb007 per aver salvato 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 esso!

Perl, 35 byte

Include +2 per -0p

Fornisci ogni chiave / valore separato da spazio su una riga 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 byte

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

L'input è un elenco di coppie chiave-valore. è l'operatore di trasposizione di Mathematica e RandomSamplepuò essere utilizzato per mescolare un elenco.

php, 84 byte

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

Prende l'input come un array serializzato, produce lo stesso.

Clojure, 40 34 byte

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

Prende le chiavi e i valori da m (una mappa), mescola i valori e li comprime in una mappa.

PowerShell v2 +, 52 byte

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

Accetta input come una matrice di tuple, che è significativamente più breve rispetto all'utilizzo di un hash (che richiederebbe .GetEnumerator()e cosa non funzionerebbe).

Effettuiamo il loop dell'array di input |%{...}, ogni iterazione estrae il secondo elemento $_[1]. Questi vengono convogliati Sort-Objectcon la {Get-Random}chiave di ordinamento. Questo assegnerà un peso caso da 0a [Int32]::MaxValuead ogni elemento per l'ordinamento. Questi vengono convogliati in un altro ciclo |%{...}, con ogni iterazione che genera una tupla del primo elemento corrispondente della tupla e il numero ordinato.

Esempi

Gli esempi qui hanno un -join','output aggiuntivo sulla tupla, quindi viene mostrato meglio sulla console, poiché l'output predefinito per gli array multidimensionali è difficile da leggere.

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

Funziona anche con valori non interi senza modifiche.

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 byte

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 byte

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

L'input è un hash
(tecnicamente qualsiasi valore con un .keysmetodo e un .valuesmetodo funzionerebbe, ma l'output è un hash )

Spiegazione:

# 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 che funzionerebbe per l'altro tipo di oggetto incorporato in Hash è:

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

.WHAT su un oggetto restituisce il tipo.

R, 47 (28) byte

Un po 'in ritardo alla festa, ma anche se pubblicerei una soluzione in R usando i builtin.

La cosa più vicina che R ha a un array con mappatura chiave / valore è a list . La seguente funzione accetta un listoggetto come input e genera un elenco con i suoi valori mescolati.

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

spiegato

L'integrato setNames()può assegnare nomi agli oggetti immettendo uno R-vectordi nomi. Quindi, prima mescola illist in sample()cui mescola le coppie, quindi assegna i nomi nell'ordine originale usando names().

Esempio:

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

Se xsi presume che sia definito, non è necessario il wrapping delle funzioni e il programma si riduce a 28 byte.

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

Java 7, 156 byte

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

Ungolfed:

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

Codice di prova:

Provalo qui.

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

Uscita possibile:

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