एक जुर्राब दराज अनुकरण

Question

पृष्ठभूमि

मेरे पास "कार्यदिवस के मोज़े" का एक संग्रह है, जो सप्ताह के दिनों तक लेबल किए गए सात जोड़े मोज़े हैं। जब मैं अपने मोजे धोता हूं, तो वे ढेर में समाप्त हो जाते हैं, और मुझे उन्हें अलमारी में रखने से पहले सही जोड़े में व्यवस्थित करना चाहिए। मेरी रणनीति एक समय में ढेर से एक यादृच्छिक जुर्राब खींचना और इसे एक दराज पर रखना है। जब भी ड्रॉअर पर मोजे की एक मिलान जोड़ी होती है, तो मैं उन्हें एक साथ बांधता हूं और उन्हें कोठरी में डाल देता हूं। आपका काम इस यादृच्छिक प्रक्रिया का अनुकरण करना है और पहली मिलान जोड़ी को खोजने के लिए आवश्यक ड्रॉ की संख्या वापस करना है।

इनपुट

आपका इनपुट एक पूर्णांक N। 1 है । यह "एक सप्ताह में दिनों की संख्या" का प्रतिनिधित्व करता है: ढेर में मोजे के एन जोड़े हैं , और प्रत्येक जोड़ी का एक अलग लेबल है। यदि आवश्यक हो, तो आप इनपुट के रूप में PRNG बीज भी ले सकते हैं।

उत्पादन

आपका आउटपुट मोज़े की संख्या है जो मुझे पहली मिलान जोड़ी मिलने से पहले खींचनी है। उदाहरण के लिए, यदि पहले दो मोज़े पहले से ही एक मिलान जोड़ी बनाते हैं, तो आउटपुट है 2।

बेशक, आउटपुट यादृच्छिक है, और ड्राइंग ऑर्डर पर निर्भर करता है। हम मानते हैं कि सभी ड्राइंग ऑर्डर समान रूप से संभव हैं , ताकि हर बार एक जुर्राब तैयार हो, पसंद सभी विकल्पों से समान और स्वतंत्र है।

उदाहरण

चलो एन = 3 , हम में कुल 6 मोजे, लेबल है ताकि AABBCC । "सॉक-ड्राइंग प्रोटोकॉल" का एक संभावित रन इस प्रकार है:

       | Pile   | Drawer | Pairs
Begin  | AABBCC | -      | -
Draw B | AABCC  | B      | -
Draw C | AABC   | BC     | -
Draw B | AAC    | C      | BB
Draw A | AC     | AC     | BB
Draw A | C      | C      | AA BB
Draw C | -      | -      | AA BB CC

दूसरी बी ड्राइंग के बाद पहली मिलान जोड़ी पाई गई थी , जिसे खींचा जाने वाला तीसरा शॉक था, इसलिए सही आउटपुट है 3।

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है। इनपुट और आउटपुट किसी भी उचित प्रारूप में हो सकते हैं, जिसमें यूनरी (स्ट्रिंग ऑफ 1एस) शामिल है।

आप मान सकते हैं कि आपकी भाषा बिल्ट-इन RNG एकदम सही है। आपको वास्तव में जुर्राब-ड्राइंग प्रोटोकॉल का अनुकरण करने की ज़रूरत नहीं है, जब तक कि आपके आउटपुट में सही संभावना वितरण नहीं होता है।

"परीक्षण के मामलों"

यहाँ इनपुट N = 7 के लिए सभी आउटपुट की अनुमानित संभावनाएँ हैं :

Output       2     3     4     5     6     7     8
Probability  0.077 0.154 0.210 0.224 0.186 0.112 0.037

अपने समाधान का परीक्षण करने के लिए, आप इसे 40 000 बार कह सकते हैं और देख सकते हैं कि आउटपुट वितरण यथोचित रूप से बंद है।

Comments

रियल लाइफ, 42 बाइट्स -Draw all socks. End up with an odd number.

— AdmBorkBork

देखें कि कुशलतापूर्वक ढेर से मोज़े कैसे जोड़े?

— दादा

तो n = 8 1-> 7 और फिर 1 के बराबर नहीं है? यानी 4 मोज़े 1 लेबल

— विक्टर मेलग्रेन 9

@ViktorMellgren नहीं, आपके पास 8 अलग-अलग लेबल होंगे।

— जर्गर्ब

मेरे पास समरूप मोज़े से भरा एक दराज है, इसलिए उनके माध्यम से छाँटने की आवश्यकता नहीं है।

— JDługosz

Answer 1

जेली , 8 बाइट्स

ḤX€Ṛ<RTḢ

इसे ऑनलाइन आज़माएं! या N = 7 के वितरण को सत्यापित करें ।

पृष्ठभूमि

आज्ञा देना n जोड़े की संख्या; देखते हैं 2n व्यक्ति मोजे।

पहले ड्रा के लिए, 2n मोज़े हैं और उनमें से 0 का मिलान जोड़ी में होगा। इसलिए, सफलता की संभावना 0 / 2n = 0 है ।

चूंकि पहला ड्रॉ सफल नहीं था, इसलिए ढेर पर 2n - 1 मोज़े हैं और उनमें से 1 का मिलान जोड़ी में होगा। इसलिए, सफलता की संभावना 1 / (2n - 1) है ।

यदि दूसरा ड्रॉ सफल नहीं होता, तो ढेर पर 2n - 2 मोज़े होते हैं और उनमें से 2 का मिलान जोड़ी में होता है। इसलिए, सफलता की संभावना 2 / (2n - 2) है ।

सामान्य तौर पर, यदि पहले k ड्रॉ असफल थे, तो ढेर पर 2n - k मोज़े हैं और उनमें से 2 का मिलान जोड़ी में होगा। इसलिए, सफलता की संभावना k / (2n - k) है ।

अंत में, यदि पहले n ड्रॉ में से कोई भी सफल नहीं था, तो ढेर पर 2n - k मोज़े हैं और उन सभी का परिणाम एक मिलान जोड़ी में होगा। इसलिए, सफलता की संभावना n / (2n - n) = 1 है ।

यह काम किस प्रकार करता है

ḤX€Ṛ<RTḢ  Main link. Argument: n

Ḥ         Unhalve; yield 2n.
 X€       Map `random draw' over [1, ..., 2n], pseudo-randomly choosing an integer
          from [1, ..., k] for each k in [1, ..., 2n].
   Ṛ      Reverse the resulting array.
     R    Range; yield [1, ..., n].
    <     Perform vectorized comparison.
          Comparing k with the integer chosen from [1, ..., 2n - (k - 1)] yields 1
          with probability (k - 1) / (2n - (k - 1)), as desired.
          The latter half of elements of the left argument do not have a counter-
          part in the right argument, so they are left untouched and thus truthy.
      T   Truth; yield all indices of non-zero integers.
       Ḣ  Head; extract the first one.

Answer 2

जेली, 8 बाइट्स

Rx2ẊĠṪ€Ṃ

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

R    generate [1, 2, ..., n]
x2   duplicate every element (two socks of each pair)
Ẋ    shuffle the list, to represent the order in which socks are drawn
Ġ    group indices by value. this will produce a list of pairs of indices;
       each pair represents the point in time at which each of the corresponding
       socks were drawn
Ṫ€   take the last element of each pair. this returns an array of n integers
       which represent the points in time at which a matching sock was drawn
Ṃ    minimum, find the first point at which a matching sock was drawn

सत्यापित करने के लिए, यहां एक संस्करण है जो वांछित आउटपुट और "शफल सूची" ऑपरेशन के परिणाम को प्रदर्शित करता है (यह देखने के लिए कि मोज़े किस क्रम में खींचे गए थे)।

Answer 3

पायथन, 66 बाइट्स

from random import*
f=lambda n,k=1:k>randint(1,n*2)or-~f(n-.5,k+1)

डेनिस ने चीजों को फिर से व्यवस्थित करने के लिए एक चतुर तरीका सोचा, जिससे 5 बाइट्स की बचत हुई।

Answer 4

MATL , 16 15 बाइट्स

Q:"r@qGEy-/<?@.

इसे ऑनलाइन आज़माएं! या एन = 7 मामले में 1000 नमूनों के लिए अनुभवजन्य वितरण का निरीक्षण करें (इसमें थोड़ी देर लगती है)।

यह सीधे परिणाम का प्रतिनिधित्व करने वाले यादृच्छिक चर को उत्पन्न करता है , इसकी संभावना वितरण के आधार पर। बता दें कि N जुर्राब जोड़ियों की संख्या है, और p ( k ) इस संभावना को निरूपित करता है कि k -th ड्रा सफल है, इस तथ्य पर वातानुकूलित है कि k -th ड्रॉ सक्सेसफुल नहीं था। तब ( यहां भी देखें ):

• p (1) स्पष्ट रूप से 0. आप एक जुर्राब के साथ एक जोड़ी नहीं हो सकता।
• p (2) 1 / (2 * N .1) है। दूसरे ड्रॉ में एक जीतने वाली जुर्राब है जिसे 2 * N में से चुना जा सकता है socks1 शेष मोजे में से ।
• p (3) 2 / (2 * N .2 ) है। तीसरे ड्रॉ पर 2 * N .2 में से 2 विजेता सॉक्स हैं । जीतने वाले मोज़े की संख्या 2 है क्योंकि दूसरे ड्रा के बाद आपको जो दो मोज़े मिले, वे अलग थे।
• सामान्य तौर पर, एक ही तर्क से, p ( k ) है ( k )1) / (2 * N - k +1)
• उपरोक्त सूत्र द्वारा, p ( N +1) 1. है। यदि आप N + 1-वें ड्रॉ में आते हैं तो आपको सफल होने की गारंटी है।

तो कोड अधिकतम N +1 ड्रॉ के लिए पुनरावृत्त होता है। पर कश्मीर आकर्षित मई के एक यादृच्छिक चर उत्पन्न होता है कि संभावना के साथ 1 के बराबर होती है ( कश्मीर -1) / (2 * एन - कश्मीर अन्यथा), या 0। जब भी यादृच्छिक चर 1 के बराबर होती है (ड्रा सफल रहा है) प्रक्रिया बंद हो जाता है और वर्तमान कश्मीर उत्पादन होता है।

Q:      % Input N implicitly. Generate [1 2 ... N+1] (values of draw index, k)
"       % For each
  r     %   Random variable uniformly distributed on the interval (0,1)
  @q    %   Push iteration index, k-1
  GE    %   Push 2*N
  y     %   Duplicate: push k-1 again
  -     %   Subtract: gives 2*N-k+1
  /     %   Divide: gives (k-1)/(2*N-k+1)
  <     %   Push 1 if random value is less than (k-1)/(2*N-k+1), 0 otherwise
  ?     %   If we got a 1
    @   %     Push k
    .   %     Break loop
        %   End if implicitly
        % End loop implicitly
        % Display implicitly

Comments

आपको और मुझे एक ही विचार था, लेकिन आप MATL :)

— प्रोग्राम मैन

Answer 5

MATL , 14 13 बाइट्स

EZ@G\&=XRafX<

इसे ऑनलाइन आज़माएं! या एन = 7 मामले में 4000 नमूनों के लिए अनुभवजन्य वितरण का निरीक्षण करें (इसमें थोड़ी देर लगती है)।

E      % Input N implicitly. Multiply by 2
Z@     % Random permutation of [1 2 ... 2*N]
G\     % Modulo N: random permutation of [0 0 1 1 ... N-1 N-1]
&=     % Compare all pairs for equality. Gives an N×N matrix
XR     % Upper triangular part excluding the diagonal
a      % True for each column if it contains at least one true entry
f      % Get indices of true values
X<     % Take minimum. Implicitly display

Answer 6

जावास्क्रिप्ट, 77 73 बाइट्स

n=>{p={};for(i=n;i--;p[i]=2);while(--p[n*Math.random()|0])i++;return i+2}

व्याख्या

var f = (n) => {
    var index;      // used first to initialize pile, then as counter
    var pile = {};  // sock pile

    // start with index = n
    // check that index > 0, then decrement
    // put 2 socks in pile at index
    for(index = n; index--; pile[index] = 2);
    // index is now -1, reuse for counter

    // pick random sock out of pile and decrement its count
    // continue loop if removed sock was not the last
    while(--pile[n * Math.random() | 0]) {
        index++;    // increment counter
    }
    // loop finishes before incrementing counter when first matching pair is removed
    // add 1 to counter to account for initial value of -1
    // add 1 to counter to account for drawing of first matching pair
    return index + 2;
};

Comments

आप (या दो के f=(n)=>साथ चार वर्णों को सहेज सकते हैं n=>, यदि आप असाइनमेंट रखना चाहते हैं, तो कुछ इसे रखते हैं , कुछ इसे हटाते हैं )।

— गुस्तावो रोड्रिग्स

अच्छी पकड़ है, मैंने इसे ठीक कर लिया है। हालांकि, जब मैंने नियमों में "आप एक पूर्ण कार्यक्रम या फ़ंक्शन लिख सकते हैं" पढ़ा, तो मैंने सोचा कि यह एक आवश्यकता थी।

— kamoroso94

मेटा पर सर्वसम्मति के अनुसार , एक नाम के लिए बाध्य नहीं होने वाले अनाम फ़ंक्शन डिफ़ॉल्ट रूप से स्वीकार्य हैं।

— जर्गर्ब

यह JavaSock नहीं होना चाहिए? (हाँ, लंगड़ा)

— gcampbell

Answer 7

CJam, 17 बाइट्स

ri,2*mr{L+:L(&}#)

इसका परीक्षण यहां करें।

Answer 8

अजगर 3, 142 105 104 बाइट्स

Eᴛʜᴇ to Gᴏʟғᴇʀ के लिए धन्यवादएक बाइट को बचाने के लिए ! !

मेरा पहला जवाब:

import random 
i=[x/2 for x in range(int(2*input()))]
d=[]
a=0
random.shuffle(i)
while 1:
 b=i.pop()
 if b in d:
  print(a)
  s
 d=d+[b]
 a+=1

मेरा नया उत्तर:

from random import*
i=range(int(input()))*2
shuffle(i)
j=0
for x in i:
 if x in i[:j]:print(1+j)+s
 j+=1

एक साथ दोनों बाहर निकलने NameErrorपर s।

Answer 9

आर, ४ ९

N=scan();which(duplicated(sample(rep(1:N,2))))[1]

मुझे यकीन है कि आर में ऐसा करने का एक बेहतर तरीका होना चाहिए! मैंने कुछ चतुर करने की कोशिश की, लेकिन यह काम नहीं किया।

संपादित करें: @bouncyball द्वारा सुधार किया गया क्योंकि इसमें कोई फ़ंक्शन नहीं है।

Comments

क्या आपको उपयोग करना है function(N)? उपयोग करने से N=scan();2 बाइट्स

— बचती हैं

Answer 10

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

from random import*
d=[]
p=range(input())*2
shuffle(p)
while list(set(d))==d:d+=p.pop(),
print len(d)

Answer 11

वीबीए, 61 बाइट्स

Function K(D):While 2*D-K>K/Rnd:K=K+1:Wend:K=K+1:End Function

- जुर्राब मैच के स्थानांतरण की संभावना को मॉडल देता है जिसने मैच में पिछली विफलता दी। मूल्यांकन के बिंदु पर, K "हाथ में मोज़े" है, इसलिए ड्रा संख्या एक अधिक है।

Answer 12

अजगर, 14 बाइट्स

lhfnT{T._.S*2S

स्पष्टीकरण:

       ._        #Start with a list of all prefixes of
         .S      #a randomly shuffled
           *2S   #range from 1 to input (implicit), times 2.
  f              #filter this to only include elements where
   nT{T          #element is not equal to deduplicated self (i.e. it has duplicates)
lh               #print the length of the first element of that filtered list