งานนี้เกี่ยวกับการเขียนโค้ดเพื่อคำนวณความน่าจะเป็น ผลลัพธ์ควรเป็นความน่าจะเป็นที่แม่นยำที่เขียนเป็นเศษส่วนในรูปแบบที่ลดลงมากที่สุด นั่นคือไม่ควรเอาท์พุท4/8แต่จะดี1/2กว่า

สำหรับจำนวนเต็มบวกnพิจารณาสตริงสุ่มอย่างสม่ำเสมอของ 1s และ -1s ของความยาวnและเรียกมันว่า A ตอนนี้เชื่อมต่อกับAค่าแรก นั่นคือA[1] = A[n+1]ถ้าการจัดทำดัชนีจาก 1. ในขณะนี้มีความยาวA n+1ทีนี้ลองพิจารณาความยาวสตริงที่สองแบบสุ่มnซึ่งnค่าแรกคือ -1, 0 หรือ 1 ที่มีความน่าจะเป็น 1/4, 1, 2, 1/4 แต่ละอันและเรียกมันว่า B

n=3ตัวอย่างเช่นพิจารณา ค่าที่เป็นไปได้AและBอาจจะเป็นและA = [-1,1,1,-1] B=[0,1,-1]ในกรณีนี้ผลิตภัณฑ์ทั้งสองด้านมีและ02

ตอนนี้พิจารณาผลิตภัณฑ์ภายในA[1,...,n]และBและสินค้าภายในของและA[2,...,n+1]B

รหัสของคุณจะต้องแสดงผลความน่าจะเป็นที่ผลิตภัณฑ์ทั้งสองนั้นมีค่าเป็นศูนย์

สำหรับความน่าจะเห็นผลชัดเจนn=11/2

ฉันไม่สนใจว่าnจะมีการระบุไว้อย่างไรในรหัส แต่ควรจะง่ายและชัดเจนในการเปลี่ยน

ภาษาและห้องสมุด

คุณสามารถใช้ภาษาและห้องสมุดที่คุณต้องการ ฉันต้องการเรียกใช้รหัสของคุณดังนั้นโปรดระบุคำอธิบายแบบเต็มสำหรับวิธีเรียกใช้ / รวบรวมรหัสของคุณใน linux หากเป็นไปได้

Pyth, 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

Mathematica, 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}คอมมิเนทีฟของ Mathematica และฟังก์ชันพีชคณิตเชิงเส้นค่อนข้างมีประโยชน์ในการตีกอล์ฟ:

{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เราซ้ำแต่ละ tuple สำหรับแต่ละ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เป็นคอลัมน์ของเมทริกซ์อื่นเพื่อให้เราสามารถคำนวณผลคูณแบบจุดแบบง่ายระหว่างพวกมันได้ แต่ transposing {{1, 1, -1}, {1, -1, 1}}เพียงแค่ให้{{1, 1}, {1, -1}, {-1, 1}}ซึ่งเป็นเพียงรายชื่อของทั้ง 2 องค์ประกอบ sublists Aวงจรของ นั่นคือสิ่งที่ทำ:

Partition[#,2,1,1]

ดังนั้นเราคำนวณและนำดอทโปรดัคกับรายการของBเรา เนื่องจากขณะนี้เราได้รับรายชื่อที่ซ้อนกัน (เพราะแต่ละที่เป็นไปได้Aที่อัตราผลตอบแทนเวกเตอร์ที่แยกต่างหาก) ##&@@เราแผ่ผู้ที่มี

หากต้องการค้นหาว่าคู่{x, y}คือ{0, 0}เราคำนวณSign[Norm[{x,y}]] ที่จะช่วยให้Norm √(x²+y²)นี้จะช่วยให้หรือ01

ในที่สุดเนื่องจากตอนนี้เราแค่อยากรู้เศษส่วนของ1s ในรายการ0s และ1s ทั้งหมดที่เราต้องการคือค่าเฉลี่ยเลขคณิตของรายการ อย่างไรก็ตามสิ่งนี้ให้ความน่าจะเป็นของทั้งสองจุดอย่างน้อยหนึ่งผลิตภัณฑ์ที่ไม่ใช่ศูนย์ดังนั้นเราจึงลบมันออก1เพื่อให้ได้ผลลัพธ์ที่ต้องการ

Pyth - 65 55 ไบต์

แก้ไขข้อบกพร่องด้วยการลดเศษส่วนที่ราคาหนึ่งไบต์

ใช้วิธีการดุร้ายและสามารถเล่นกอล์ฟได้อย่างมหาศาล แต่ต้องการออกไปที่นั่น ช้ามาก

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

จะใช้ผลิตภัณฑ์คาร์ทีเซียนเพื่อสร้างทั้งสองAและBทำความน่าจะเป็นตัวแปรโดยการ0ปรากฏขึ้นสองครั้งในรายการแหล่งที่มาและจากนั้นนับคนที่ผลิตภัณฑ์ภายในเป็นศูนย์ ผลิตภัณฑ์ด้านในทำให้ง่ายขึ้นโดยการVทำน้ำตาลซิสเทอไรเซชัน การทำให้เศษส่วนเล็กลงทำให้ฉันตกใจในตอนแรก แต่มันก็ค่อนข้างง่ายด้วยPฟังก์ชั่นการแยกตัวประกอบแบบไรม์และการรับรู้ที่เราต้องลดลงด้วยพลังของ 2

ลองมันออนไลน์ได้ที่นี่

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

  ตั้งแต่(-1) + 1 = 0 = 1 + (-1) , 0วินาทีจะเกิดขึ้นสองครั้งบ่อยครั้งเท่ากับ-2วินาทีและ2วินาที

  การหารแต่ละองค์ประกอบด้วย2จะให้เวกเตอร์ของ{-1, 0, 1} ⁿด้วยความน่าจะเป็นที่ต้องการ

  เนื่องจากเรามีความสนใจเฉพาะถ้าผลคูณเป็น0หรือไม่เราสามารถข้ามส่วนโดย2

• หลังจากการนับทริปเปิลทั้งหมดเป็นไปตามเงื่อนไขของคำถามและจำนวนทริปเปิลทั้งหมดแล้วเราต้องลดเศษส่วนที่เกิดขึ้น

  แทนที่จะคำนวณ GCD ของตัวเลขทั้งสองเนื่องจากตัวส่วนจะเป็นกำลัง 2 เสมอมันพอเพียงที่จะหารตัวเลขทั้งสองด้วยกำลังสูงสุด 2 ที่หารตัวเศษ

  ที่จะได้รับอำนาจสูงสุดของ 2 ที่แบ่งxเราสามารถนำค่าที่เหมาะสมและxและ~ x + 1

  ~ xย้อนกลับบิตทั้งหมดของxดังนั้นการติดตาม0 s ทั้งหมดกลายเป็น1วินาที โดยการเพิ่ม1ไป~ xผู้1 s จะหันกลับเข้ามาใน0และที่ผ่านมา1ใน~ x + 1จะตรงกับที่ผ่านมา1ในx

  บิตอื่น ๆ ทั้งหมดมีทั้ง0ของชัดเจนดังนั้นค่าบิตและส่งกลับจำนวนเต็มประกอบด้วย1ล่าสุดของxและ0 s ทั้งหมดที่ตามมา นี่คืออำนาจสูงสุดของ 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.