20

कार्ड का एक डेक Sसूट और Rरैंक का कार्टेशियन उत्पाद है । कई, हालांकि सभी नहीं, कार्ड गेम का उपयोग करते हैं S=4और R∊{6,8,13}। Hकार्ड के एक हाथ को डेक से निपटाया जाता है। इसका वितरण , उर्फ "हाथ पैटर्न", एक ऐसा सरणी है जो वर्णन करता है कि आपको प्रत्येक सूट से कितने कार्ड मिले, सूट ऑर्डर को अनदेखा करते हुए (इसलिए, यह एक बहु-सेट की तरह है)। एक वितरण को देखते हुए Dसंतोषजनक len(D)=S, 1≤sum(D)=H≤S×R, 0≤D[i]≤R, D[i]≥D[i+1], यह होने वाली की संभावना हैं।

इनपुट: एक पूर्णांक Rऔर एक सरणी D।

आउटपुट: दशमलव चिह्न के बाद कम से कम 5 अंकों की संभावना; अनुगामी शून्य को छोड़ दिया जा सकता है; वैज्ञानिक संकेतन ठीक है।

लूपोल्स मना। सबसे छोटी जीत।

टेस्ट:

R    D               probability
13   4 4 3 2     ->  0.2155117564516334148528314355068773
13   5 3 3 2     ->  0.1551684646451760586940386335649517
13   9 3 1 0     ->  0.0001004716813294328274372174524508
13   13 0 0 0    ->  0.0000000000062990780897964308603403
8    3 2 2 1     ->  0.4007096203759162602321667950144035
8    4 2 1 1     ->  0.1431105787056843786543452839337155
8    2 2 1 0     ->  0.3737486095661846496106785317018910
8    3 1 1 0     ->  0.2135706340378197997775305895439377
15   4 4 3 2 1   ->  0.1428926269185580521441708109954798
10   3 0 0       ->  0.0886699507389162561576354679802956
10   2 1 0       ->  0.6650246305418719211822660098522167
10   1 1 1       ->  0.2463054187192118226600985221674877

विकिपीडिया में ब्रिज हैंड पैटर्न भी देखें ।

EDIT: अनावश्यक प्रतिबंध हटा दिया गया H≤R

संपादित करें: जोड़ा बाधा H≥1

— NGN
स्रोत

क्या हम मान सकते हैं कि D को क्रमबद्ध किया गया है?

— orlp

1

@ योरिप हां, यही मेरा मतलब है कि D [i] iD [i + 1]

— ngn

मुझे पता है कि कार्ड 1 से शुरू होता है 0 से नहीं ...

— RosLuP

@RLLuP आपका क्या मतलब है?

— NGN

मुझे यकीन है कि मुझे कुछ समझ नहीं आया ... यदि कार्ड को 1,2 नंबर से दर्शाया गया है, ..., 13 सभी * 4; तो इसका क्या मतलब है "13 0 0 0" उदाहरण में? 0 का मतलब कार्ड 0 है?

— रोजल्यूप

9

एपीएल (डायलॉग यूनिकोड) , 30 वर्ण

×/!⍨,z,1÷((z←!∘≢⊢)⌸⊢),×∘≢!⍨1⊥⊢

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

@ Orlp के सूत्र का उपयोग करना ।

— FrownyFrog
स्रोत

बहुत बढ़िया, अच्छा किया! "+100" बटन कहता है कि बाउंटी को पुरस्कार देने से पहले मुझे 10 घंटे इंतजार करना होगा। उसके बाद मैं +200 के लिए एक और सेट करूँगा।

— ngn

याय मैं जीत! शुक्रिया @ संजयप्रकाश

— फ्रॉन्फ्रोग

@FrownyFrog J के साथ Dyalog APL को कैसे पसंद करते हैं?

— जोनाह

8

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

b=lambda n,k:k<1or n*b(n-1,k-1)/k
f=lambda R,D,i=1,s=1,t=0:D and b(R,D[0])*i/s*f(R,D[1:],i+1,(D[0]in D[1:])*s+1,t+D[0])or 1/b(~-i*R,t)

फॉर्मूला binom(R, d)प्रत्येक तत्व के लिए , समय dमें D, (जैसे समूह हैं ) के समूहों में प्रत्येक factorial(len(D))के factorial(len(S))लिए उत्पाद द्वारा विभाजित है , अंत में विभाजित है ।SD[4, 4, 3, 2][[4, 4], [3], [2]]binom(len(D) * R, sum(D))

या गणित अंकन में, यह मानते हुए मीटर की multiplicities शामिल n में अद्वितीय तत्व डी :

\frac{| डी |!}{म_{1}! \cdot म_{2}! \dots म_{n}!} {(\binom{| डी | \cdot आर}{Σ डी})}^{- 1} \underset{घ \in डी}{Π} (\binom{आर}{घ})

$\frac{|D|!}{m_1!\cdot m_2!\cdots m_n!} \binom{|D|\cdot R}{\sum D}^{-1} \prod_{d\in D}\binom{R}{d}$

— orlp
स्रोत

2

एक संक्षिप्त क्षण के लिए आपने मुझे विश्वास दिलाया कि PPCG अब LaTeX का समर्थन करता है :)

— ngn

दो कार्यों में शामिल होने से मुझे 136 मिल गए, लेकिन हो सकता है कि इसे और अधिक गोल्फ किया जा सके ( i=0मतलब के लिए b()उपयोग करता R,Dहै n,k)।

— जोनाथन एलन

7

आर , 90 85 83 बाइट्स

function(R,D,l=sum(D|1),K=choose)prod(K(R,D),1:l,1/gamma(1+table(D)))/K(R*l,sum(D))

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

मैंने उसी चीज़ को ओर्लप के रूप में देखा , लेकिन मैंने एक अच्छी भाषा चुनी जिसमें कॉम्बिनेटरिक्स बिल्डिंस हैं।

स्पष्टीकरण:

function(R,D,             # next are optional arguments
 l=sum(D|1),              # alias for length of D, aka S
 K=choose)                # alias for choose
  prod(                   # take the product of:
    K(R,D),               # "choose" is vectorized over R and D
    1:l,                  # S!
    1/gamma(1+            # gamma(n+1) = n! for integer n
     table(D))            # multiplicities of unique elements of D
  ) /                     # divide by
  K(R*l, sum(D))          # R*S choose H
                          # return last computation (which is all the computation)

— ग्यूसेप
स्रोत

आप इस के साथ कुछ और बचा सकते हैं: "<"=choose(फ़ंक्शन के बाहर) और संभावित रूप से seq का उपयोग ngn के टिप्पणी के जवाब के आधार पर करते हैं जो मैंने आज सुबह पोस्ट किया था।

— JayCe

6

जेली , 22 20 बाइट्स

-2 बाइट्स एक नए त्वरित ʋ, और एक नए मोनोडिक परमाणु का उपयोग करẈ

ĠẈ!;L×c⁸S¤ʋ
L!;c@÷çP

एक डाइएडिक लिंक, डील-डिस्ट्रीब्यूशन को ले रहा है, डी, बाईं ओर और नंबर-ऑफ-रैंक, आर, दाईं ओर, जो घटना की संभावना को लौटाता है।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें

कैसे?

ĠẈ!;L×c⁸S¤ʋ - Link 1, denomParts: list, distribution (D); number, ranks (R)
                                                                 e.g. [3,3,3,2,2]; 8
Ġ           - group indices of D by their values                      [[4,5],[1,2,3]]
 Ẉ          - length of each group                                    [2,3]
  !         - factorial (vectorises)                                  [2,6]
          ʋ - last four links as a dyad
            - ... i.e. totalWaysToDeal = f(list, distribution (D); number, ranks (R)):
    L       - length of D                                             5
     ×      - multiply by R = total number of cards                   40
         ¤  - nilad followed by link(s) as a nilad:
       ⁸    -   chain's left argument, D                              [3,3,3,2,2]
        S   -   sum = total cards dealt                               13
      c     - binomial                                        40C13 = 12033222880
   ;        - concatenate                                             [2,6,12033222880]                                                  

L!;c@÷çP - Main link: list, distribution (D); number, ranks (R)
         -                                                  e.g. [3,3,3,2,2]; 8
L        - length of D = number of suits                         5
 !       - factorial                                             120
   c@    - R binomial (vectorised across) D     (8C3=56;8C2=28)  [56,56,56,28,28]
  ;      - concatenate                                           [120,56,56,56,28,28]
      ç  - call the last link (1) as a dyad = denomParts(D,R)    [2,6,12033222880]
     ÷   - divide (vectorises)                                   [120/2,56/6,56/12033222880,56,28,28]
       P - product                                               0.11441900924883391

— जोनाथन एलन
स्रोत

5

05AB1E , 21 बाइट्स

cP¹g!*¹γ€g!P¹gI*¹Oc*/

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

व्याख्या

 P                      # product of
c                       # bin(input1,input2)
     *                  # multiplied by
    !                   # fac of
  ¹g                    # length of input1
                    /   # divided by
           P            # product of
          !             # fac of each
        €g              # length of each
      ¹γ                # chunk of consecutive equal elements of input1
                   *    # multiplied by
                  c     # bin of
            ¹g          # length of input1
              I*        # times input2
                ¹O      # and sum of input1

— Emigna
स्रोत

3

पायथ , 32 बाइट्स

cc*.!lQ*F.cLvzQ*F.!hMr8Q.c*vzlQs

यहाँ कोशिश करो! या सभी परीक्षण मामलों को सत्यापित करें!

यह कैसे काम करता है?

cc *।! lQ * F.cLvzQ * F।! hMr8Q.c * vzlQs ~ पूरा कार्यक्रम। डी = सूची, आर = संख्या।

   ।! ~ की सच्चाई
     lQ ~ D की लंबाई।
  * * इससे गुणा ...
       * एफ ~ तत्वों के उत्पाद ...
         .c ~ के बीच nCr ...
           LQ ~ D के प्रत्येक तत्व, और ...
            vz ~ आर।
 सी ~ द्वारा विभाजित ...
               * एफ ~ तत्वों के उत्पाद ...
                 ।! ~ प्रत्येक के तथ्य ...
                   एचएम ~ प्रमुख। आसन्न तत्वों की गिनती में ...
                     r8Q ~ डी की रन लंबाई एन्कोडिंग।
सी ~ द्वारा विभाजित ...
                        .c ~ के बीच nCr ...
                          * ~ उत्पाद ...
                           vz ~ R, और ...
                             lQ ~ D की लंबाई।
                               s ~ और D का योग।
                                 ~ आउटपुट implicitly।

— श्री Xcoder
स्रोत

3

एपीएल (डायलॉग) , 42 बाइट्स

{×/(!≢⍵),(⍵!⍺),÷((+/⍵)!⍺×≢⍵),!≢¨⍵⊂⍨1,2≠/⍵}

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

फिर भी गोल्फ।

— Uriel
स्रोत

चुनौती: 30 बाइट्स

— ngn

@ngn चुनौती स्वीकार कर ली

— ऊरीएल

क्षमा करें, यह वास्तव में 30 वर्ण है । जानकारी देने के जोखिम के साथ: मेरा एक वर्ण क्लासिक वर्णमाला में नहीं है, मुझे पहले ऐसा महसूस नहीं हुआ था।

— NGN

@ng क्या आप केवल 30 बाइट्स बनाने के लिए अदम के चरित्र का उपयोग नहीं कर सकते हैं ?

— प्रोबी

@Probie हाँ, यह है कि मैं "SBCS" द्वारा बाउंटी विवरण में कहा गया है

— ngn

2

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

#(apply +(for[_(range 1e06):when(=(remove #{0}%)(reverse(sort(vals(frequencies(take(apply + %)(shuffle(for[i(range %2)j(range(count %))]j))))))))]1e-06))

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

— NikoNyrh
स्रोत

2

जे, 57 बाइट्स

](#@]%~[:+/[-:"1[:\:~@(#/.~)"1+/@[{."1])i.@!@(*+/)A.(##\)

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

यह O (गोल्फ) में चलता है और कई टेस्ट मामलों (हालांकि सैद्धांतिक रूप से काम करता है) पर चोक करेगा, जो कि गोल्फर के लिए ठीक रहेगा। लेकिन मैं इसे ट्रिमिंग पर अटका रहा हूं, विशेष रूप से बार-बार टालने के साथ "1। अगर कोई मदद करना चाहता है, तो यहाँ का संस्करण ...

मुख्य कांटे के दाईं ओर डेक के सभी संभावित सौदे हैं , और मुख्य कांटे के बाईं ओर सिर्फ मूल सही arg है, यानी, सूट मास्क जिसके खिलाफ हम मिलान कर रहे हैं।

अंदर, प्रत्येक "फेरबदल" डेक से, हम पहले हाथ तत्वों को लेते हैं, फिर उन्हें कुंजी का उपयोग करके समूह /.बनाते हैं और परिणाम को सॉर्ट करते हैं, और जांचते हैं कि क्या सूट का मुखौटा प्रश्न में मेल खाता है। हम कुल संख्या को जोड़ते हैं जो मैच करते हैं, और इसे सभी संभव डेक की लंबाई में विभाजित करते हैं।

┌─┬─────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────┐
│]│┌───────┬─────┬─────────────────────────────────────────────────────────────────────────────────┐│┌──────────────────────┬──┬─────────┐│
│ ││┌─┬─┬─┐│┌─┬─┐│┌──┬─────┬──────────────────────────────────────────────────────────────────────┐│││┌────────┬─┬─────────┐│A.│┌─┬─────┐││
│ │││#│@│]│││%│~│││[:│┌─┬─┐│┌─┬────────┬─────────────────────────────────────────────────────────┐│││││┌──┬─┬─┐│@│┌─┬─────┐││  ││#│┌─┬─┐│││
│ ││└─┴─┴─┘│└─┴─┘││  ││+│/│││[│┌──┬─┬─┐│┌──┬───────────────────────────┬────────────────────────┐│││││││i.│@│!││ ││*│┌─┬─┐│││  ││ ││#│\││││
│ ││       │     ││  │└─┴─┘││ ││-:│"│1│││[:│┌─────────────────────┬─┬─┐│┌───────────┬────────┬─┐│││││││└──┴─┴─┘│ ││ ││+│/││││  ││ │└─┴─┘│││
│ ││       │     ││  │     ││ │└──┴─┴─┘││  ││┌──────┬─┬──────────┐│"│1│││┌─────┬─┬─┐│┌──┬─┬─┐│]││││││││        │ ││ │└─┴─┘│││  │└─┴─────┘││
│ ││       │     ││  │     ││ │        ││  │││┌──┬─┐│@│┌──────┬─┐││ │ ││││┌─┬─┐│@│[│││{.│"│1││ ││││││││        │ │└─┴─────┘││  │         ││
│ ││       │     ││  │     ││ │        ││  ││││\:│~││ ││┌─┬──┐│~│││ │ │││││+│/││ │ ││└──┴─┴─┘│ │││││││└────────┴─┴─────────┘│  │         ││
│ ││       │     ││  │     ││ │        ││  │││└──┴─┘│ │││#│/.││ │││ │ ││││└─┴─┘│ │ ││        │ ││││││└──────────────────────┴──┴─────────┘│
│ ││       │     ││  │     ││ │        ││  │││      │ ││└─┴──┘│ │││ │ │││└─────┴─┴─┘│        │ ││││││                                     │
│ ││       │     ││  │     ││ │        ││  │││      │ │└──────┴─┘││ │ ││└───────────┴────────┴─┘│││││                                     │
│ ││       │     ││  │     ││ │        ││  ││└──────┴─┴──────────┘│ │ ││                        │││││                                     │
│ ││       │     ││  │     ││ │        ││  │└─────────────────────┴─┴─┘│                        │││││                                     │
│ ││       │     ││  │     ││ │        │└──┴───────────────────────────┴────────────────────────┘││││                                     │
│ ││       │     ││  │     │└─┴────────┴─────────────────────────────────────────────────────────┘│││                                     │
│ ││       │     │└──┴─────┴──────────────────────────────────────────────────────────────────────┘││                                     │
│ │└───────┴─────┴─────────────────────────────────────────────────────────────────────────────────┘│                                     │
└─┴─────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────┘

— जोनाह
स्रोत

1

एपीएल के लिए ओर्लप के फार्मूले ने 42 रन बनाए, हो सकता है कि यह जे पर 58 से कम स्कोर हो?

— ऊरीएल

1

मुझे 45 तक का रास्ता मिलता है जिस तरह से f=:(([:!#)%[:*/[:!#/.~)@]**/@(]![)%+/@]![*#@] TIO

— jayprich

एक कार्ड खेल में हाथ पैटर्न

एपीएल (डायलॉग यूनिकोड) , 30 वर्ण

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

आर , 90 85 83 बाइट्स

जेली , 22 20 बाइट्स

कैसे?

05AB1E , 21 बाइट्स

पायथ , 32 बाइट्स

यह कैसे काम करता है?

एपीएल (डायलॉग) , 42 बाइट्स

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

जे, 57 बाइट्स