Wir definieren eine Karte als eine Reihe von Schlüssel-Wert-Paaren. Für diese Herausforderung müssen Sie jeden der Werte einem zufällig ausgewählten Schlüssel zuweisen.

• Sie müssen die Werte zufällig mischen und die resultierende Karte ausgeben. Dies bedeutet, dass wir jedes Mal, wenn wir Ihr Programm ausführen, die Möglichkeit haben, eine andere Ausgabe zu erhalten
• Jede mögliche Permutation der Werte muss eine Wahrscheinlichkeit ungleich Null aufweisen.
• Alle Originalschlüssel und Originalwerte müssen im resultierenden Array erscheinen. Wiederholte Werte müssen im resultierenden Array gleich oft vorkommen.

Zum Beispiel, wenn Ihre Karte war:

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

Alle folgenden müssen eine Chance haben zu erscheinen:

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

Akzeptable Ein- / Ausgänge:

• Die Mutterkarte Ihrer Sprachen
• Sie können ein Array von Schlüssel-Wert-Paaren eingeben. Sie dürfen nicht zwei Arrays eingeben, eines mit Schlüsseln, das andere mit Werten.
• Sie können eine Zeichenfolgendarstellung der oben genannten verwenden
• Wenn Sie ein Array oder eine Karte eingeben, können Sie das ursprüngliche Objekt ändern, anstatt es zurückzugeben
• Der Eingabetyp muss mit dem Ausgabetyp übereinstimmen
• Wenn Sie ein Array eingeben, muss die Reihenfolge der Schlüssel beibehalten werden.
• Sie können davon ausgehen, dass die Schlüssel eindeutig sind, aber Sie können nicht davon ausgehen, dass die Werte eindeutig sind.

Dies ist ein Code-Golf , also antworte so kurz wie möglich

05AB1E , 5 Bytes

Eingabe ist eine Liste von Schlüssel-Wert-Paaren.

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

Probieren Sie es online aus!

Brachylog , 13 12 Bytes

zt@~T,?zh:Tz

Probieren Sie es online aus!

Erwartet eine Liste mit 2-Element-Listen als Eingabe.

Erläuterung

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}

Eingabe ist eine Liste von Schlüssel-Wert-Paaren.

Testen Sie es hier.

Erläuterung

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.

Alternative Lösung, gleiche Byteanzahl:

{[z~mr]z}

Gelee , 5 Bytes

Ṫ€Ẋṭ"

Probieren Sie es online aus!

Erläuterung

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

Verwendet diese Option: Wenn Sie ein Array oder eine Karte eingeben, können Sie das ursprüngliche Objekt ändern, anstatt es zurückzugeben . Die Eingabe ist wie ein Wörterbuchliteral {0: 10, 1: 10, 5: 5}.

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

Probieren Sie es online aus

Inspiration aus dieser SO-Antwort .

Python 3, 107 Bytes

Verwendet die native Wörterbuchstruktur von Python.

Vielen Dank an @ mbomb007 für das Speichern eines Bytes.

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 es!

Perl, 35 Bytes

Beinhaltet +2 für -0p

Geben Sie jeden Schlüssel / Wert in einer STDIN-Zeile durch Leerzeichen getrennt an

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}&@@(#)&

Eingabe ist eine Liste von Schlüssel-Wert-Paaren. ist der Transpositionsoperator von Mathematica und RandomSamplekann zum Mischen einer Liste verwendet werden.

PHP, 84 Bytes

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

Nimmt die Eingabe als serialisiertes Array auf und gibt dieselbe aus.

Clojure, 40 34 Bytes

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

Nimmt die Schlüssel und Werte von m (einer Karte), mischt die Werte und komprimiert sie in eine Karte.

PowerShell v2 +, 52 Byte

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

Nimmt die Eingabe als Array von Tupeln auf, was erheblich kürzer ist als die Verwendung eines .GetEnumerator()Hashs (was erforderlich wäre und was nicht).

Wir schleifen das Eingabearray |%{...}, wobei jede Iteration das zweite Element herauszieht $_[1]. Diese werden Sort-Objectmit dem {Get-Random}als Sortierschlüssel versehen. Dadurch wird jedem Element eine zufällige Gewichtung von 0bis [Int32]::MaxValuezum Sortieren zugewiesen . Diese werden in eine andere Schleife geleitet |%{...}, wobei jede Iteration ein Tupel des entsprechenden ersten Elements des Tupels und die sortierte Zahl ausgibt.

Beispiele

Die Beispiele hier enthalten eine zusätzliche -join','Ausgabe für die Tupelausgabe, damit sie auf der Konsole besser angezeigt wird, da die Standardausgabe für mehrdimensionale Arrays schwer zu lesen ist.

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

Dies funktioniert auch für nicht ganzzahlige Werte ohne Änderungen.

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 Bytes

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

Eingabe ist ein Hash
(Technisch gesehen würde jeder Wert mit einer .keysMethode und einer .valuesMethode funktionieren, aber die Ausgabe ist ein Hash )

Erläuterung:

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

Eine Variante, die für die anderen in Hash eingebauten Objekttypen funktionieren würde, ist:

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

.WHAT für ein Objekt gibt den Typ zurück.

R, 47 (28) Bytes

Ein bisschen spät zur Party, aber obwohl ich eine Lösung in R mit eingebauten Funktionen veröffentlichen würde.

Das, was R einem Array mit Schlüssel / Wert-Zuordnung am nächsten kommt, ist a list. Die folgende Funktion nimmt ein listObjekt als Eingabe und gibt eine Liste mit gemischten Werten aus.

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

Erklärt

Das eingebaute Objekt setNames()kann Objekten Namen zuweisen, indem es einen R-vectorNamen eingibt . Mischen Sie daher zuerst die, listdurch sample()die die Paare gemischt werden, und weisen Sie dann die Namen in der ursprünglichen Reihenfolge mit zu names().

Beispiel:

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

Wenn xangenommen wird, dass es definiert ist, ist kein Funktionsumbruch erforderlich, und das Programm wird auf 28 Byte reduziert.

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

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

Testcode:

Probieren Sie es hier aus.

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

Mögliche Ausgabe:

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