एक संभावना की गणना बिल्कुल

Question

यह कार्य एक प्रायिकता की गणना करने के लिए कोड लिखने के बारे में है। आउटपुट एक सटीक संभाव्यता होना चाहिए जो कि इसके सबसे कम रूप में एक अंश के रूप में लिखा गया हो। वह यह है कि उत्पादन कभी नहीं 4/8बल्कि होना चाहिए 1/2।

कुछ सकारात्मक पूर्णांक के लिए n, लंबाई के 1s और -1 के समान रूप से यादृच्छिक स्ट्रिंग पर विचार nकरें और इसे कॉल करें। ए। अब Aअपने पहले मूल्य के लिए संक्षिप्त करें । A[1] = A[n+1]यदि 1. से अनुक्रमण किया जाता है, तो Aअब लंबाई है n+1। अब लंबाई के दूसरे यादृच्छिक स्ट्रिंग पर भी विचार करें nजिनके पहले nमान -1, 0 या 1 हैं, प्रायिकता के साथ 1 / 4,1 / 2, 1/4 प्रत्येक और इसे बी कहते हैं।

उदाहरण के लिए, विचार करें n=3। के लिए संभव मान Aऔर Bहो सकता है A = [-1,1,1,-1]और B=[0,1,-1]। इस मामले में दो आंतरिक उत्पाद हैं 0और 2।

अब की आंतरिक उत्पाद पर विचार A[1,...,n]और Bऔर की आंतरिक उत्पाद A[2,...,n+1]और B।

आपके कोड को इस संभावना को आउटपुट करना होगा कि दोनों आंतरिक उत्पाद शून्य हैं।

इसके लिए n=1संभावना स्पष्ट है 1/2।

मुझे कोई आपत्ति नहीं है कि nकोड में कैसे निर्दिष्ट किया गया है, लेकिन यह बहुत सरल और स्पष्ट होना चाहिए कि इसे कैसे बदलना है।

भाषाएं और पुस्तकालय

आप अपनी पसंद की किसी भी भाषा और लाइब्रेरी का उपयोग कर सकते हैं। मैं आपका कोड चलाना चाहता हूं, इसलिए कृपया अपने कोड को लिनक्स में चलाने / संकलित करने के लिए एक पूर्ण विवरण शामिल करें यदि संभव हो तो।

Comments

पहले कुछ के लिए टेस्ट केस nमददगार होंगे। इसके अलावा शायद ए, बी और दो आंतरिक उत्पादों का एक स्पष्ट उदाहरण मदद कर सकता है।

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

यदि हम पूर्णांक को नुकसान पहुंचाने के लिए चुनते हैं, तो क्या n=4शून्य, दो या तीन बाइट्स के रूप में गिना जाता है? क्या आउटपुट बिल्कुल होना चाहिए a/bया [a b], उदाहरण के लिए, अनुमति दी जानी चाहिए?

— डेनिस

@ डेनिस इसे सटीक होना है। यदि आप पूर्णांक को हार्डकोड करते हैं तो क्या मुझे इसे बदलने के लिए केवल एक स्थान पर बदलना होगा n? अन्यथा, मुझे लगता है कि अनुमति नहीं है।

हां, मेरा कार्यक्रम केवल कार्टेसियन पावर की गणना करने के लिए एक बार पूर्णांक का उपयोग करता है। बाकी सब कुछ परिणामी सरणी से लिया गया है।

— डेनिस

Answer 1

पायथ, 48 47 46 44 बाइट्स

K,smlf!|Fms*Vd.>Tk2^,1_1Q^+0tM3Q^8Qj\//RiFKK

इसे ऑनलाइन आज़माएँ: प्रदर्शन

ऑनलाइन संस्करण शायद गणना नहीं करता है n=6। मेरे लैपटॉप (ऑफ़लाइन संस्करण) पर लगभग 45 सेकंड लगते हैं।

जानवर बल दृष्टिकोण।

स्पष्टीकरण:

smlf!|Fms*Vd.>Tk2^,1_1Q^+0tM3Q   implicit: Q = input number
                          tM3    the list [-1, 0, 1]
                        +0       add zero, results in [0, -1, 0, 1]
                       ^     Q   all possible lists of length Q using these elements
 m                               map each list d (B in Lembik's notation) to:
                  ,1_1              the list [1, -1]
                 ^    Q             all possible lists of length Q
   f                                filter for lists T (A in Lembik's notation),
                                    which satisfy:
       m        2                      map each k in [0, 1] to:
        s*Vd.>Tk                          scalar-product d*(shifted T by k)
    !|F                                not or (True if both scalar-products are 0)      
  l                                 determine the length                
s                                add all possibilities at the end

K,...^8QQj\//RiFKK   
 ,...^8Q             the list [result of above, 8^Q]
K                    store it in K
              iFK    determine the gcd of the numbers in K
            /R   K   divide the numbers in K by the gcd
         j\/         join the two numbers by "/" and print

Comments

— खतरा

+0r1_2से छोटा है /R2r2_2।

— इसहाक

मुझे लगता है कि यह 89/512 संस्करण होना चाहिए, जिसे आप गिनते हैं।

@ लेम्बिक ओके ने इसे बदल दिया।

— जक्यूब

मुझे स्वीकार करना होगा, मेरे साथ ऐसा कभी नहीं हुआ, यह 47 पात्रों में हो सकता है!

Answer 2

मैथमेटिका, 159 100 87 86 85 बाइट्स

n=3;1-Mean@Sign[##&@@Norm/@({1,0,0,-1}~t~n.Partition[#,2,1,1])&/@{1,-1}~(t=Tuples)~n]

बदलने के लिए nसिर्फ शुरुआत में चर परिभाषा बदल जाते हैं।

चूंकि यह जानवर बल है, यह काफी धीमा है, लेकिन यहां पहले आठ परिणाम हैं:

n   P(n)
1   1/2
2   3/8
3   7/32
4   89/512
5   269/2048
6   903/8192
7   3035/32768
8   169801/2097152

आखिरी वाला पहले से ही 231 सेकंड का समय ले चुका था और रनटाइम बुरी तरह से घातीय है।

व्याख्या

जैसा कि मैंने कहा कि यह क्रूर बल है। अनिवार्य रूप से, मैं बस सभी संभव गणना कर रहा हूं Aऔर B, हर संभव जोड़ी के लिए दो डॉट उत्पादों की गणना करता हूं और फिर जोड़े के अंश का पता लगाता हूं जो कि उपज है {0, 0}। मैथेमेटिका के कॉम्बिनेटरिक्स और लीनियर अलजेब्रा फ़ंक्शंस इस गोल्फिंग में काफी मददगार थे:

{1,-1}~(t=Tuples)~n

यह सभी n-tuples युक्त 1या -1सभी संभव बनाता है A। उसके लिए n = 3यह है:

{{1, 1, 1}, 
 {1, 1, -1}, 
 {1, -1, 1}, 
 {1, -1, -1}, 
 {-1, 1, 1}, 
 {-1, 1, -1}, 
 {-1, -1, 1}, 
 {-1, -1, -1}}

गणना करने के लिए Bहम लगभग वही करते हैं:

{1,0,0,-1}~t~n

दोहराने से 0, हम प्रत्येक के लिए प्रत्येक टपल को डुप्लिकेट करते 0हैं, जिसमें 0दो बार संभव होता है 1या जैसा कि संभव है -1। n = 3एक उदाहरण के रूप में फिर से उपयोग :

{{-1, -1, -1},
 {-1, -1, 0}, {-1, -1, 0},
 {-1, -1, 1},
 {-1, 0, -1}, {-1, 0, -1},
 {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 {-1, 0, 1}, {-1, 0, 1},
 {-1, 1, -1},
 {-1, 1, 0}, {-1, 1, 0},
 {-1, 1, 1},
 {0, -1, -1}, {0, -1, -1},
 {0, -1, 0}, {0, -1, 0}, {0, -1, 0}, {0, -1, 0},
 {0, -1, 1}, {0, -1, 1},
 {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1},
 {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
 {0, 0, 1}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1},
 {0, 1, -1}, {0, 1, -1},
 {0, 1, 0}, {0, 1, 0}, {0, 1, 0}, {0, 1, 0},
 {0, 1, 1}, {0, 1, 1},
 {1, -1, -1},
 {1, -1, 0}, {1, -1, 0},
 {1, -1, 1},
 {1, 0, -1}, {1, 0, -1},
 {1, 0, 0}, {1, 0, 0}, {1, 0, 0}, {1, 0, 0},
 {1, 0, 1}, {1, 0, 1},
 {1, 1, -1},
 {1, 1, 0}, {1, 1, 0},
 {1, 1, 1}}

अब, प्रत्येक संभव के लिए A, हम उन Bदोनों में से प्रत्येक का डॉट उत्पाद चाहते हैं , दोनों के साथ A[1 .. n]और A[2 .. n+1]। जैसे अगर हमारा करंट Aहै {1, 1, -1}, तो हम डॉट प्रोडक्ट को दोनों के {1, 1, -1}साथ और उसके साथ चाहते हैं {1, -1, 1}। चूँकि हमारे सभी Bपहले से ही एक मैट्रिक्स की पंक्तियों में सुविधाजनक हैं, हम चाहते हैं कि हम दो उप-कलाकारों Aको एक और मैट्रिक्स के कॉलम के रूप में दें, ताकि हम उनके बीच एक साधारण डॉट उत्पाद की गणना कर सकें। लेकिन ट्रांसपोसिंग {{1, 1, -1}, {1, -1, 1}}बस देता है, {{1, 1}, {1, -1}, {-1, 1}}जो सभी 2-तत्व चक्रीय सब्लिस्ट की एक सूची है A। यही वह करता है:

Partition[#,2,1,1]

तो हम गणना करते हैं और हमारी सूची के साथ डॉट उत्पाद लेते हैं B। चूँकि अब हम एक नेस्टेड सूची प्राप्त करते हैं (चूंकि प्रत्येक संभव Aएक अलग वेक्टर पैदा करता है), हम उन लोगों के साथ समतल करते हैं ##&@@।

यह जानने के लिए एक जोड़ी {x, y}है {0, 0}हम गणना Sign[Norm[{x,y}]] जहां Normदेता है √(x²+y²)। यह देता है 0या 1।

अंत में, चूँकि हम अब केवल 1s की सूची में 0s के अंशों को जानना चाहते हैं और 1हम सभी की आवश्यकता सूची का अंकगणितीय माध्य है। हालांकि, यह कम से कम एक डॉट उत्पाद के गैर-शून्य होने की संभावना पैदा करता है, इसलिए हम 1वांछित परिणाम प्राप्त करने के लिए इसे घटाते हैं ।

Answer 3

पायथ - 65 55 बाइट्स

एक बाइट की लागत में आंशिक कमी के साथ फिक्स्ड बग।

जानवर बल दृष्टिकोण का उपयोग करता है, और बेहद गले लगाया जा सकता है, लेकिन बस वहाँ से कुछ बाहर निकालना चाहता था। बहुत धीमी गति से

*F-KP/Jmms*Vked,thdPhd*makhk^,1_1Q^[1ZZ_1)Q,ZZ2/lJ^2/K2

यह दोनों को उत्पन्न करने के लिए कार्टेसियन उत्पादों का उपयोग करता है Aऔर स्रोत की सूची में दो बार दिखाई देने Bसे परिवर्तनीय संभावनाएं करता है 0और फिर उन आंतरिक उत्पादों को शून्य में गिना जाता है। आंतरिक उत्पाद Vectorization सिंटैक्टिक चीनी द्वारा आसान बनाते हैं । अंश को सरलीकृत करना मुझे शुरू में डरा रहा था, लेकिन यह बहुत ही आसान था Pरिम्स फैक्टराइजेशन फ़ंक्शन और यह अहसास कि हमें केवल 2 की शक्तियों से कम करना है।

इसे यहाँ ऑनलाइन आज़माएँ ।

Comments

मैं कैसे बदल सकता हूँ n?

@Lembik पायथ प्रोग्राम एक उपयोगकर्ता इनपुट का अनुरोध करता है, जो दूसरे टेक्स्टबॉक्स (यदि आप ऑनलाइन कंपाइलर का उपयोग करते हैं) में निर्दिष्ट है।

— जकुबे

@Jakube ओह धन्यवाद! और यह वास्तव में भी काम करने लगता है :)

Answer 4

CJam, 58 57 54 51 46 बाइट्स

WX]m*Zm*_{~.+2,@fm<\f.*::+0-!},,__~)&:T/'/@,T/

इसे चलाने के लिए, WX]और बीच में वांछित पूर्णांक डालें m*।

बिट मैजिक के लिए @ jimmy23013 और 5 बाइट्स से गोल्फ के लिए धन्यवाद!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

इन उत्तर के अधिकांश भाग सीधे हैं, लेकिन इसमें दो साफ-सुथरी तरकीबों का उपयोग किया गया है:

• इसके बजाय के सभी वैक्टर युग्मित होने की {-1, 1} ⁿ के सभी वैक्टर के साथ {-1, 0, 1} ⁿ वांछित संभावनाओं के साथ, यह मायने रखता है वैक्टर की तीन की संख्या में मानता है {-1, 1} ⁿ कि संतुष्ट एक निश्चित स्थिति।

  यदि हम एक ट्रिपलेट के अंतिम दो वैक्टर जोड़ते हैं, तो परिणाम {-2, 0, 2} ⁿ का वेक्टर होगा ।

  चूँकि (-1) + 1 = 0 = 1 + (-1) , 0 s -2 -2 s और 2 s के रूप में दो बार होगा ।

  प्रत्येक घटक को 2 से विभाजित करने पर वांछित संभावनाओं के साथ {-1, 0, 1} ⁿ का वेक्टर प्राप्त होगा ।

  चूँकि हम केवल दिलचस्पी रखते हैं कि स्केलर उत्पाद 0 है या नहीं, हम विभाजन को 2 से छोड़ सकते हैं ।

• सभी त्रिभुजों को गिनने के बाद प्रश्न की स्थिति और ट्रिपल की कुल संख्या को संतुष्ट करते हुए, हमें परिणामी अंश को कम करना होगा।

  दोनों संख्याओं के GCD की गणना करने के बजाय, चूंकि भाजक हमेशा 2 की शक्ति होगा, यह संख्या को विभाजित करने वाली 2 की उच्चतम शक्ति से दोनों संख्याओं को विभाजित करने का दम रखता है।

  X को विभाजित करने वाली 2 की उच्चतम शक्ति प्राप्त करने के लिए , हम बिटवाइंड AND ऑफ x और ~ x + 1 ले सकते हैं ।

  ~ एक्स के सभी बिट्स पराजयों एक्स , इसलिए सभी अनुगामी 0 रों बन 1 रों। जोड़ कर 1 करने के लिए ~ एक्स , उन 1 वापस में बदल जाएगा 0 एस और पिछले 1 में ~ x + 1 पिछले से मेल खाएगी 1 में एक्स ।

  अन्य सभी बिट्स या तो दोनों कर रहे हैं 0 , अलग की तो बिटवाइज़ और पिछले से मिलकर पूर्णांक लौट 1 के एक्स और सभी 0 रों कि यह पालन करें। यह 2 की उच्चतम शक्ति है जो x को विभाजित करती है ।

कोड

WX]    e# Push the array [-1 1].
       e# Insert N here.
m*     e# Cartesian product: Push the array of all vectors of {-1,1}^N.
Zm*    e# Cartesian product: Push the array of all triplets of these vectors.
_      e# Copy the array.
{      e# Filter; for each triplet of vectors U, V and W in {-1,1}^N:
  ~    e#   Dump U, V and W on the stack.
  .+   e#   Compute X := V + W, a vector of {-2,0,2}^N, where each component is
       e#   zero with probability 1/2.
  2,@  e#   Push [0 1]. Rotate U on top of it.
  fm<  e#   Push [U U'], where U' is U rotated one dimension to the left.
  \f.* e#   Push [U*X and U'*X], where * denotes the vectorized product.
  ::+  e#   Add the components of both products.
  0-   e#   Remove zeroes.
       e#   Push the logical NOT of the array.
},     e#   If the array was empty, keep the triplet.
,      e# Push X, the length of the filtered array.
__~)&  e# Push X & ~X + 1.
:T     e# Save the result in T and divide X by T.
'/     e# Push a slash.
@,T/   e# Dividet he length of the unfiltered array by T.

Comments

WX]m*Zm*_{~.+2,@fm<\f.*::+0-!},,__W*&:T/'/@,T/।

— jimmy23013

@ jimmy23013: यह कुछ प्रभावशाली सा जादू है। धन्यवाद!

— डेनिस