Chúng tôi xác định bản đồ là một tập hợp các cặp khóa-giá trị. Đối với thử thách này, bạn cần lấy từng giá trị và gán chúng cho một khóa được chọn ngẫu nhiên.

• Bạn phải trộn ngẫu nhiên các giá trị và xuất bản đồ kết quả. Điều này có nghĩa là mỗi lần chúng tôi chạy chương trình của bạn, chúng tôi có cơ hội nhận được một đầu ra khác nhau
• Mỗi hoán vị có thể có của các giá trị phải có cơ hội xuất hiện khác không.
• Tất cả các khóa gốc và giá trị gốc phải xuất hiện trong mảng kết quả. Các giá trị lặp lại phải xuất hiện cùng số lần trong mảng kết quả.

Ví dụ: nếu bản đồ của bạn là:

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

tất cả những điều sau đây phải có cơ hội xuất hiện:

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

Đầu vào / đầu ra chấp nhận được:

• Bản đồ ngôn ngữ của bạn
• Bạn có thể nhập một mảng các cặp khóa-giá trị. Bạn không thể nhập 2 mảng, một mảng có khóa, cái còn lại có giá trị.
• Bạn có thể sử dụng một đại diện chuỗi của bất kỳ ở trên
• Nếu bạn nhập một mảng hoặc bản đồ, bạn có thể sửa đổi đối tượng ban đầu thay vì quay lại
• Loại đầu vào phải phù hợp với loại đầu ra
• Nếu bạn nhập một mảng, thứ tự của các phím phải được duy trì.
• Bạn có thể cho rằng các khóa là duy nhất, nhưng bạn không thể cho rằng các giá trị là duy nhất.

Đây là một môn đánh gôn , vì vậy hãy trả lời càng ngắn càng tốt

05AB1E , 5 byte

Đầu vào là danh sách các cặp khóa-giá trị.

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

Hãy thử trực tuyến!

Brachylog , 13 12 byte

zt@~T,?zh:Tz

Hãy thử trực tuyến!

Yêu cầu một danh sách các danh sách 2 yếu tố làm đầu vào.

Giải trình

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}

Đầu vào là danh sách các cặp khóa-giá trị.

Kiểm tra nó ở đây.

Giải trình

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.

Giải pháp thay thế, cùng số byte:

{[z~mr]z}

Thạch , 5 byte

Ṫ€Ẋṭ"

Hãy thử trực tuyến!

Giải trình

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

Sử dụng tùy chọn này: Nếu bạn nhập một mảng hoặc bản đồ, bạn có thể sửa đổi đối tượng ban đầu thay vì quay lại . Đầu vào là một từ điển theo nghĩa đen {0: 10, 1: 10, 5: 5}.

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

Dùng thử trực tuyến

Cảm hứng lấy từ câu trả lời SO này .

Python 3, 107 byte

Sử dụng cấu trúc từ điển gốc của Python.

Cảm ơn @ mbomb007 vì đã lưu một 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

Nghĩa là nó!

Perl, 35 byte

Bao gồm +2 cho -0p

Cung cấp cho mỗi khóa / giá trị cách nhau bởi khoảng trắng trên dòng 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

Toán học, 32 byte

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

Đầu vào là danh sách các cặp khóa-giá trị. là toán tử chuyển vị của Mathicala và RandomSamplecó thể được sử dụng để xáo trộn danh sách.

php, 84 byte

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

Đưa đầu vào như một mảng nối tiếp, đầu ra giống nhau.

Clojure, 40 34 byte

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

Lấy các khóa và giá trị từ m (bản đồ), xáo trộn các giá trị và nén chúng vào bản đồ.

PowerShell v2 +, 52 byte

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

Đưa đầu vào dưới dạng một mảng các bộ dữ liệu, ngắn hơn đáng kể so với sử dụng hàm băm (sẽ yêu cầu .GetEnumerator()và không có gì để làm việc).

Chúng tôi lặp lại mảng đầu vào |%{...}, mỗi lần lặp kéo ra phần tử thứ hai $_[1]. Chúng được dẫn vào Sort-Objectcùng với {Get-Random}phím sắp xếp. Điều này sẽ gán một trọng lượng ngẫu nhiên từ 0để [Int32]::MaxValuecho mỗi yếu tố để phân loại. Chúng được dẫn vào một vòng lặp khác |%{...}, với mỗi lần lặp xuất ra một tuple của phần tử đầu tiên tương ứng của bộ dữ liệu và số được sắp xếp.

Ví dụ

Các ví dụ ở đây có bổ sung -join','về đầu ra tuple để nó hiển thị tốt hơn trên bảng điều khiển, vì đầu ra mặc định cho các mảng đa chiều rất khó đọc.

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

Điều này hoạt động cho các giá trị không nguyên cũng như không có sửa đổi.

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

Đầu vào là một Hash
(Về mặt kỹ thuật, mọi giá trị với một .keysphương thức và một .valuesphương thức sẽ hoạt động, nhưng đầu ra là một Hash )

Giải trình:

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

Một biến thể sẽ hoạt động cho các loại đối tượng được xây dựng trong Hash khác là:

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

.WHAT trên một đối tượng trả về kiểu.

R, 47 (28) byte

Một chút muộn cho bữa tiệc nhưng mặc dù tôi sẽ đăng một giải pháp trong R bằng cách sử dụng nội dung.

Điều gần nhất R có với một mảng với ánh xạ khóa / giá trị là a list. Hàm sau lấy một listđối tượng làm đầu vào và xuất ra một danh sách với các giá trị được xáo trộn.

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

Giải thích

Nội dung setNames()có thể gán tên cho các đối tượng bằng cách nhập một R-vectortên. Do đó, trước tiên, xáo trộn listtheo sample()đó xáo trộn các cặp, sau đó gán tên theo thứ tự ban đầu bằng cách sử dụng names().

Thí dụ:

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

Nếu xđược giả định là không cần gói chức năng và chương trình giảm xuống còn 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());}

Ung dung:

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

Mã kiểm tra:

Hãy thử nó ở đây.

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

Sản lượng có thể:

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