एक मैपिंग को शफल करें

Question

हम मुख्य-मूल्य जोड़े के एक सेट के रूप में मानचित्र को परिभाषित करते हैं। इस चुनौती के लिए, आपको प्रत्येक मान लेने और उन्हें बेतरतीब ढंग से चुनी गई कुंजी को सौंपने की आवश्यकता है।

• आपको बेतरतीब ढंग से मूल्यों में फेरबदल करना होगा , और परिणामस्वरूप मानचित्र को आउटपुट करना होगा। इसका मतलब है कि हर बार जब हम आपका प्रोग्राम चलाते हैं, तो हमारे पास एक अलग आउटपुट प्राप्त करने का एक मौका होता है
• मूल्यों के प्रत्येक संभावित क्रमांकन में गैर-शून्य दिखने की संभावना होनी चाहिए।
• सभी मूल कुंजी और मूल मान परिणामी सरणी में दिखाई देने चाहिए। बार-बार मान परिणामी सरणी में समान संख्या में दिखाई देना चाहिए।

उदाहरण के लिए, यदि आपका नक्शा था:

[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 सरणियों को इनपुट नहीं कर सकते हैं , एक कुंजी के साथ, दूसरा मान के साथ।
• आप उपरोक्त में से किसी एक का प्रतिनिधित्व कर सकते हैं
• यदि आप किसी सरणी या मानचित्र को इनपुट करते हैं, तो आप लौटने के बजाय मूल ऑब्जेक्ट को संशोधित कर सकते हैं
• इनपुट प्रकार को आउटपुट प्रकार से मेल खाना चाहिए
• यदि आप एक सरणी इनपुट करते हैं, तो कुंजियों का क्रम बनाए रखा जाना चाहिए।
• आप मान सकते हैं कि कुंजियाँ अद्वितीय हैं, लेकिन आप यह नहीं मान सकते कि मान अद्वितीय हैं।

यह है एक कोड गोल्फ, इसलिए जितना संभव हो उतना छोटा जवाब दें

Comments

बहुत बारीकी से संबंधित। (अंतर यह है कि खदान में चाबियाँ बस सरणी के सूचकांक हैं, कि मुझे सभी क्रमपरिवर्तन पर एक समान संभावना की आवश्यकता है और यह कि मैं बिल-इन को अस्वीकार करता हूं।)

— मार्टिन एंडर

क्या केवी जोड़े को ऑर्डर में होना चाहिए [k, v]या [v, k]स्वीकार्य होगा ?

— डेनिस

वे में होना चाहिए[k, v]

— नाथन मेरिल

क्या हम एक मूल मानचित्र इनपुट कर सकते हैं और कुंजी-मूल्य जोड़े की एक सरणी आउटपुट कर सकते हैं?

— स्टीवन एच।

नहीं, मिलान करने के लिए प्रकारों की आवश्यकता होती है।

— नाथन मेरिल

Answer 1

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.

इसे ऑनलाइन आज़माएं!

Answer 2

ब्रेकीलॉग , 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

Answer 3

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}

Comments

बहुत यकीन है कि यह अधिकांश भाषाओं में सबसे छोटा एल्गोरिथ्म है जिसमें ज़िप है: पी

— घातक

Answer 4

जेली , 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

Comments

जैसा दिखता हैTEXt"

— ETHproductions

Answer 5

पायथन 2, 77 बाइट्स

इस विकल्प का उपयोग करता है: यदि आप किसी सरणी या मानचित्र को इनपुट करते हैं, तो आप लौटने के बजाय मूल ऑब्जेक्ट को संशोधित कर सकते हैं । इनपुट एक शाब्दिक शब्द है जैसे {0: 10, 1: 10, 5: 5}।

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

इसे ऑनलाइन आज़माएं

इस एसओ उत्तर से प्रेरणा ली गई ।

Answer 6

पायथन 3, 107 बाइट्स

पायथन की मूल शब्दकोश संरचना का उपयोग करता है।

एक बाइट को बचाने के लिए @ 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

Ideone यह!

Comments

फ़ंक्शन से पहले आयात करें, और उपयोग करें from random import*।

— mbomb007

निकालें .keys()। एक शब्दकोश को चाबियों में बदलना। return dict(zip(d, i))लूप के बजाय का उपयोग करें ।

— जोनास शफर

Answer 7

पर्ल, 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

Answer 8

गणितज्ञ, 32 बाइट्स

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

इनपुट कुंजी-मूल्य जोड़े की एक सूची है। Mathematica का ट्रांसपोज़र ऑपरेटर है, और RandomSampleइसका उपयोग किसी सूची में फेरबदल करने के लिए किया जा सकता है।

Answer 9

php, 84 बाइट्स

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

एक क्रमबद्ध सरणी के रूप में इनपुट लेता है, वही आउटपुट करता है।

Answer 10

क्लोजर, 40 34 बाइट्स

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

M (a) मैप से कुंजियों और मानों को लेता है, मानों को फेरबदल करता है और उन्हें मैप में जिप करता है।

Comments

फ़ंक्शन मैक्रो का उपयोग करें: # (zipmap (कुंजियाँ%) (फेरबदल (%%)))

— MattPutnam

Answer 11

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

Answer 12

जावास्क्रिप्ट (ईएस 6), 89 बाइट्स

a=>a.map((_,i)=>[i,Math.random()]).sort((a,b)=>a[1]-b[1]).map(([i],j)=>[a[j][0],a[i][1]])

Answer 13

पर्ल 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
  )
}

---

एक प्रकार जो वस्तु प्रकारों की तरह हैश में निर्मित अन्य के लिए काम करेगा:

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

.WHAT एक वस्तु पर प्रकार देता है।

Answer 14

आर, 47 (28) बाइट्स

पार्टी के लिए थोड़ी देर हो गई है, हालांकि मैं आर में एक समाधान पोस्ट करूंगा।

आर / कुंजी मैपिंग के साथ सरणी के लिए निकटतम चीज़ आर है 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))

Answer 15

जावा 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}