Мы определяем карту как набор пар ключ-значение. Для этой задачи вам нужно взять каждое из значений и назначить их произвольно выбранному ключу.

• Вы должны случайным образом перемешать значения и вывести получившуюся карту. Это означает, что каждый раз, когда мы запускаем вашу программу, у нас есть шанс получить другой результат
• Каждая возможная перестановка значений должна иметь ненулевую вероятность появления.
• Все исходные ключи и исходные значения должны появиться в результирующем массиве. Повторяющиеся значения должны появляться в результирующем массиве одинаковое количество раз.

Например, если ваша карта была:

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

все следующее должно иметь шанс появиться:

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

Приемлемые входы / выходы:

• Родная карта ваших языков
• Вы можете ввести массив пар ключ-значение. Вы не можете вводить 2 массива, один с ключами, другой со значениями.
• Вы можете использовать строковое представление любого из вышеперечисленных
• Если вы введете массив или карту, вы можете изменить исходный объект вместо возврата
• Тип ввода должен соответствовать типу вывода
• Если вы вводите массив, порядок ключей должен быть сохранен.
• Вы можете предположить, что ключи являются уникальными, но вы не можете предположить, что значения являются уникальными.

Это Код-гольфтак ответь как можно короче

05AB1E , 5 байтов

Ввод - это список пар ключ-значение.

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

Попробуйте онлайн!

Брахилог , 13 12 байт

zt@~T,?zh:Tz

Попробуйте онлайн!

Ожидает список 2-элементных списков в качестве входных данных.

объяснение

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 байт

{z)mra+z}

Ввод - это список пар ключ-значение.

Проверьте это здесь.

объяснение

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.

Альтернативное решение с тем же количеством байтов:

{[z~mr]z}

Желе , 5 байт

Ṫ€Ẋṭ"

Попробуйте онлайн!

объяснение

Ṫ€Ẋṭ"  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 байт

Использует эту опцию: если вы вводите массив или карту, вы можете изменить исходный объект вместо возврата . Ввод словарный словарь {0: 10, 1: 10, 5: 5}.

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

Попробуйте онлайн

Вдохновение взято из этого SO ответа .

Python 3, 107 байт

Использует собственную структуру словаря Python.

Спасибо @ mbomb007 за сохранение байта.

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

Идео это!

Perl, 35 байт

Включает +2 для -0p

Задайте каждый ключ / значение через пробел в строке 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 байта

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

Ввод - это список пар ключ-значение. является оператором транспонирования Mathematica и RandomSampleможет использоваться для перемешивания списка.

php, 84 байта

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

Принимает ввод как сериализованный массив, выводит то же самое.

Clojure, 40 34 байта

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

Принимает ключи и значения из m (карта), перемешивает значения и упаковывает их в карту.

PowerShell v2 +, 52 байта

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

Принимает входные данные в виде массива кортежей, что значительно короче, чем использование хеша (что потребует .GetEnumerator()и вообще не сработает).

Мы зацикливаем входной массив |%{...}, каждая итерация вытягивает второй элемент $_[1]. Они передаются Sort-Objectс {Get-Random}помощью ключа сортировки. Это позволит назначить случайный вес от 0к [Int32]::MaxValueкаждому элементу для сортировки. Они передаются в другой цикл |%{...}, причем каждая итерация выводит кортеж соответствующего первого элемента кортежа и отсортированного числа.

Примеры

В приведенных здесь примерах есть дополнительный -join','вывод о кортеже, поэтому он лучше отображается на консоли, поскольку вывод по умолчанию для многомерных массивов трудно читать.

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

Это работает для нецелых значений, а также без изменений.

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 байт

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 байт

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

Ввод - это хеш
(технически любое значение с .keysметодом и .valuesметодом будет работать, но на выходе будет хеш )

Объяснение:

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

Вариант, который будет работать для других встроенных в Hash типов объектов:

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

.WHAT объект возвращает тип.

R, 47 (28) байтов

Немного опоздал на вечеринку, но я бы опубликовал решение в R с использованием встроенных функций.

Самое близкое, что R имеет к массиву с сопоставлением ключ / значение, это a list. Следующая функция принимает listобъект в качестве входных данных и выводит список с перемешанными значениями.

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

Разъяснения

Встроенный setNames()может назначать имена объектам путем ввода R-vectorимен. Следовательно, сначала перетасуйте, с listпомощью sample()которого перетасуйте пары, а затем присвойте имена в исходном порядке, используя names().

Пример:

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

Если xпредполагается, что он определен, нет необходимости в переносе функций, и программа сокращает до 28 байт.

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

Java 7, 156 байт

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

Тестовый код:

Попробуй это здесь.

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

Возможный вывод:

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