Bir haritayı bir dizi anahtar / değer çifti olarak tanımlıyoruz. Bu meydan okuma için, değerlerin her birini almanız ve bunları rastgele seçilen bir anahtara atamanız gerekir.

• Sen gerekir rastgele ortaya çıkan harita değerlerini karıştırmak ve çıkışı. Bu, programınızı her çalıştırdığımızda farklı bir çıktı alma şansımız olduğu anlamına gelir
• Değerlerin olası her permütasyonunun sıfırdan farklı görünme şansı olmalıdır.
• Tüm orijinal anahtarlar ve orijinal değerler sonuç dizisinde görünmelidir. Tekrarlanan değerler, elde edilen dizide aynı sayıda görünmelidir.

Örneğin, haritanız:

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

aşağıdakilerin tümü görünme şansına sahip olmalıdır:

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

Kabul edilebilir giriş / çıkışlar:

• Dillerinizin yerel haritası
• Bir dizi anahtar / değer çifti girebilirsiniz. Şunları değil girişi 2 diziler, anahtarlarla biri değerlerle diğer.
• Yukarıdakilerden herhangi birinin dize olarak temsilini kullanabilirsiniz
• Bir dizi veya harita girerseniz, geri dönmek yerine orijinal nesneyi değiştirebilirsiniz
• Giriş türü, çıkış türüyle eşleşmelidir
• Bir dizi girerseniz, tuşların sırası korunmalıdır.
• Anahtarların benzersiz olduğunu varsayabilirsiniz, ancak değerlerin benzersiz olduğunu varsayamazsınız.

Bu bir kod golf, bu yüzden mümkün olduğunca kısa cevap verin

05AB1E , 5 bayt

Girdi, anahtar / değer çiftlerinin bir listesidir.

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

Çevrimiçi deneyin!

Brachylog , 13 12 bayt

zt@~T,?zh:Tz

Çevrimiçi deneyin!

Giriş olarak 2 elemanlı listelerin bir listesini bekler.

açıklama

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 bayt

{z)mra+z}

Girdi, anahtar / değer çiftlerinin bir listesidir.

Burada test edin.

açıklama

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.

Alternatif çözüm, aynı bayt sayısı:

{[z~mr]z}

Jöle , 5 bayt

Ṫ€Ẋṭ"

Çevrimiçi deneyin!

açıklama

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

Bu seçeneği kullanır: Bir dizi veya harita girerseniz, dönmek yerine orijinal nesneyi değiştirebilirsiniz . Girdi, sözlük gibi bir kelimedir {0: 10, 1: 10, 5: 5}.

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

Çevrimiçi deneyin

Bu SO cevabından ilham alındı .

Python 3, 107 bayt

Python'un yerel sözlük yapısını kullanır.

Bir bayt tasarrufu için @ mbomb007 sayesinde.

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

Boşver!

Perl, 35 bayt

İçin +2 içerir -0p

Her anahtarı / değeri bir STDIN satırında boşlukla ayırarak verin

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 bayt

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

Girdi, anahtar / değer çiftlerinin bir listesidir. Mathematica'nın aktarma operatörüdür ve RandomSamplebir listeyi karıştırmak için kullanılabilir.

php, 84 bayt

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

Serileştirilmiş bir dizi olarak girdi alır, aynı çıktıyı verir.

Clojure, 40 34 bayt

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

Anahtarları ve değerleri m'den (bir harita) alır, değerleri karıştırır ve bir haritaya sıkıştırır.

PowerShell v2 +, 52 bayt

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

Girdiyi, bir karma (gerektirecek .GetEnumerator()ve işe yaramayacak) kullanmaktan önemli ölçüde daha kısa olan bir dizi tuples olarak alır .

Giriş dizisini döngüye alıyoruz |%{...}, her yineleme ikinci elemanı çekiyor $_[1]. Bunlar yöneltilen edilir Sort-Objectile {Get-Random}sıralama anahtarı olarak. Bu rastgele ağırlık atar 0için [Int32]::MaxValuesıralama için her bir eleman için. Bunlar, |%{...}her bir yinelemenin, grubun karşılık gelen birinci elemanının bir demetini ve sıralanan sayıyı çıkardığı başka bir döngüye pipetlenir.

Örnekler

Buradaki örneklerin -join','demet çıktısında ek bir özelliği vardır, bu nedenle çok boyutlu diziler için varsayılan çıktıyı okumak zor olduğundan konsolda daha iyi gösterilir.

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

Bu, tamsayı olmayan değerler için ve değişiklik yapmadan çalışır.

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 bayt

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 bayt

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

Girdi bir Hash
(Teknik olarak bir .keysyöntem ve bir .valuesyöntemle herhangi bir değer işe yarayacaktır, ancak çıktı bir Hash'tir )

Açıklama:

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

Nesne türleri gibi Hash'te yerleşik olan diğer için çalışacak bir varyant:

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

.WHAT bir nesnede türü döndürür.

R, 47 (28) bayt

Partiye biraz geç ama yerleşik R kullanarak R bir çözüm göndermek istiyorum.

R'nin anahtar / değer eşlemeli bir diziye sahip olduğu en yakın şey bir list. Aşağıdaki işlev bir listnesneyi girdi olarak alır ve değerleri karıştırılmış olarak bir liste çıkarır.

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

Açıklaması

Yerleşik setNames(), bir ad girerek nesnelere ad atayabilir R-vector. Bu yüzden, ilk karışık listgöre sample()olan çiftleri karıştırır ve sonra kullanarak orijinal sırayla isim verilmesi names().

Misal:

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

Eğer xis tanımlanabilir varsayılır orada fonksiyon sarma gerek var ve program 28 bayta azaltır.

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

Java 7, 156 bayt

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

Test kodu:

Burada deneyin.

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

Olası çıktı:

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