กำหนดลำดับของเหตุการณ์ที่มีความน่าจะเป็นระหว่าง 0.0 ถึง 1.0 ให้สร้างและรับความน่าจะเป็นของชุดค่าผสมแต่ละชุดที่เกิดขึ้น คุณสามารถสันนิษฐานได้ว่ามีการจัดลำดับของตัวเลขในภาษาที่คุณเลือก

นี่คือตัวอย่าง; คุณอาจเข้าใจว่าความยาวของการรวมกันของลำดับนั้นเหมาะสมกับหน่วยความจำ:

{ 0.55, 0.67, 0.13 }

โปรแกรมจะพิมพ์แต่ละชุดค่าผสมและความน่าจะเป็นที่เกี่ยวข้องของลำดับที่เกิดขึ้น 1 จะแสดงว่าเหตุการณ์ในดัชนีนั้นของลำดับการป้อนข้อมูลที่เกิดขึ้นและ 0 จะแสดงว่าเหตุการณ์นั้นไม่ได้เกิดขึ้น ผลลัพธ์ที่ต้องการอยู่ด้านล่าง (ฉันไม่สนใจเกี่ยวกับการพิมพ์งานนั่นเป็นเพียงข้อมูลวัตถุประสงค์ของอัลกอริทึม):

[0,0,0] = (1 - 0.55) * (1-0.67) * (1-0.13) = 0.129195
[0,0,1] = (1 - 0.55) * (1-0.67) * (0.13)   = 0.019305
[0,1,0] = (1 - 0.55) * (0.67)   * (1-0.13) = 0.262305
[0,1,1] = (1 - 0.55) * (0.67)   * (0.13)   = 0.039195
[1,0,0] = (0.55)     * (1-0.67) * (1-0.13) = 0.157905
[1,0,1] = (0.55)     * (1-0.67) * (0.13)   = 0.023595
[1,1,0] = (0.55)     * (0.67)   * (1-0.13) = 0.320595
[1,1,1] = (0.55)     * (0.67)   * (0.13)   = 0.047905

ปัญหานี้มีความเกี่ยวข้องกับการคำนวณ "ผลิตภัณฑ์คาร์ทีเซียน" ตามลำดับ

จำไว้ว่านี่คือ code-golf ดังนั้นโค้ดที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

Haskell, 86 ไบต์

unlines.map(\p->show(fst<$>p)++" = "++show(product$snd<$>p)).mapM(\x->[(0,1-x),(1,x)])

ตัวอย่างการใช้งาน:

Prelude> putStrLn $ unlines.map(\p->show(fst<$>p)++" = "++show(product$snd<$>p)).mapM(\x->[(0,1-x),(1,x)]) $ [0.55, 0.67, 0.13]
[0,0,0] = 0.12919499999999998
[0,0,1] = 1.9304999999999996e-2
[0,1,0] = 0.262305
[0,1,1] = 3.9195e-2
[1,0,0] = 0.157905
[1,0,1] = 2.3595e-2
[1,1,0] = 0.320595
[1,1,1] = 4.790500000000001e-2

ไบต์ส่วนใหญ่ใช้สำหรับการจัดรูปแบบผลลัพธ์ หากคุณสนใจเฉพาะเวกเตอร์ความน่าจะเป็นเพียง 29 ไบต์:

map product.mapM(\x->[1-x,x])

มันทำงานอย่างไร:

                    mapM(\x->[(0,1-x),(1,x)])   -- for each number x in the input
                                                -- list make either the pair (0,1-x)
                                                -- or (1,x). Build a list with
                                                -- all combinations

    map(\p->                    )               -- for each such combination p
          show(fst<$>p)                         -- print the first elements
          ++" = "++                             -- then the string " = "
          show(product$snd<$>p)                 -- then the product of the second
                                                -- elements

unlines                                         -- joins with newlines

Mathematica, 46 45 ไบต์

(s=#;1##&@@Abs[#-s]&/@{1,0}~Tuples~Length@s)&

ใช้รายการ แม้ผลงานสำหรับรายการที่ว่างเปล่าซึ่งผลลัพธ์คือ{}{1}

กรณีทดสอบ:

%[{0.55, 0.67, 0.13}]
{0.129195, 0.019305, 0.262305, 0.039195, 0.157905, 0.023595, 0.320595, 0.047905}

คำอธิบาย

รับรายการของความน่าจะsเป็นและรายการของบิตที่bมีการ0บอกทางว่า "ไม่ได้เกิดขึ้น" และการ1บอกถึงความเป็นไปได้ที่ "เกิดขึ้น" รายการของความน่าจะเป็นที่จะถูกคูณด้วย

1 - b - s

สมัครใช้งาน หากแทน0หมายถึง "เกิดขึ้น" และ1"ไม่เกิดขึ้น" นี่จะทำให้ง่ายขึ้น

b - s

ดังนั้นเรา:

                      {1,0}~Tuples~Length@s   (* Generate all possible bit combinations *)
              (#-s)&/@{1,0}~Tuples~Length@s   (* Generate probabilities to be multiplied
                                                  up to sign *)
     1##&@@Abs[#-s]&/@{1,0}~Tuples~Length@s   (* Correct sign and multiply;
                                                 1##& is short for Times *)
(s=#;1##&@@Abs[#-s]&/@{1,0}~Tuples~Length@s)& (* Assign s to first argument of function,
                                                 done separately to avoid clash
                                                 with inner function *)

Perl, 42 40 ไบต์

รวม +1 สำหรับ -a

ให้ตัวเลขกับ STDIN:

perl -M5.010 combi.pl <<< "0.55 0.67 0.13"

เอาท์พุท

0.129195
0.019305
0.262305
0.039195
0.157905
0.023595
0.320595
0.047905

combi.pl:

#!/usr/bin/perl -a
$"=")\\*({1-,}";say eval for<({1-,}@F)>

MATL , 12 11 ไบต์

TF-|Z}&Z*!p

อินพุตเป็นเวกเตอร์คอลัมน์พร้อมรูปแบบ [0.55; 0.67; 0.13]

ลองออนไลน์!

TF    % Push [1, 0]
-     % Subtract from implicit input (column array), with broadcast. Gives a 2-col
      % matrix where the first column is the input minus 1 and the second is the input
|     % Absolute value
Z}    % Split the matrix into its rows
&Z*   % Cartesian product of all resulting. This gives a matrix as result, with each
      % "combination" on a different row
!p    % Product of each row. Implicitly display

Perl, 116 ไบต์

for(glob"{0,1}"x(@a=split/ /,<>)){@c=split//;$d=1;$d*=@c[$_]?$a[$_]:1-$a[$_]for 0..$#a;say"[".join(",",@c)."] = $d"}

อ่านได้:

for(glob"{0,1}"x(@a=split/ /,<>)){
    @c=split//;
    $d=1;$d*=@c[$_]?$a[$_]:1-$a[$_]for 0..$#a;
    say"[".join(",",@c)."] = $d"
}

สร้างรายการชุดค่าผสมที่เป็นไปได้ทั้งหมดของ 0s และ 1s ของความยาวเท่ากับจำนวนพารามิเตอร์ป้อนเข้า (เช่นตัวอย่างด้านบนมันจะมีความยาว 3) จากนั้นคำนวณแต่ละความน่าจะเป็น

ขอบคุณ @Dada ที่แสดงให้ฉันเห็นว่าglobฟังก์ชั่นสามารถทำอะไรได้แม้ว่าฉันจะไม่แน่ใจ 100% ฉันก็เข้าใจว่ามันทำยังไง

ตัวอย่างผลลัพธ์:

[0,0,0] = 0.129195
[0,0,1] = 0.019305
[0,1,0] = 0.262305
[0,1,1] = 0.039195
[1,0,0] = 0.157905
[1,0,1] = 0.023595
[1,1,0] = 0.320595
[1,1,1] = 0.047905

R, 72 69 ไบต์

รับอินพุตจาก stdin และส่งคืน R-vector ของความน่าจะเป็น

apply(abs(t(expand.grid(rep(list(1:0),length(x<-scan())))-x)),1,prod)

แก้ไข: นำทรานสโพสเทอเรชั่นที่ไม่จำเป็นออกแล้วเมทริกซ์การเปลี่ยนเป็นตอนนี้เป็นเวอร์ชันที่ถูกทรานสโพสของหนึ่งด้านล่างและความน่าจะเป็นถูกคำนวณเป็นผลิตภัณฑ์คอลัมน์ฉลาดมากกว่าแถวฉลาด ตัวอย่างผลลัพธ์:

[1] 0.129195 0.157905 0.262305 0.320595 0.019305 0.023595 0.039195 0.047905

โปรดทราบว่าความน่าจะเป็นอยู่ในลำดับที่แตกต่างกันเนื่องจากความจริงที่ว่าการเปลี่ยนแปลงเมทริกซ์ที่สร้างขึ้นโดยexpand.gridสร้างดังต่อไปนี้ (รุ่นของเมทริกซ์นี้อาจจะสามารถเล่นกอล์ฟโดยใช้แพคเกจภายนอก):

1    1    1    1
2    0    1    1
3    1    0    1
4    0    0    1
5    1    1    0
6    0    1    0
7    1    0    0
8    0    0    0

ความน่าจะเป็นแรกนั้นสอดคล้องกับผลลัพธ์ของแถวแรกในเมทริกซ์ด้านบนและแถวที่สองกับแถวที่สองที่กลับด้าน ฯลฯ การจัดรูปแบบผลลัพธ์เพื่อดูสิ่งนี้ชัดเจนยิ่งขึ้นทำให้โปรแกรมยาวขึ้น (164 ไบต์):

m=expand.grid(rep(list(1:0),length(x<-scan())))
cat(paste0("[",apply(abs(m-1),1,function(x)paste0(x,collapse=",")),"] = ",apply(abs(t(t(m)-x)),1,prod),"\n"),sep="")

ซึ่งผลิตแทน:

[0,0,0] = 0.129195
[1,0,0] = 0.157905
[0,1,0] = 0.262305
[1,1,0] = 0.320595
[0,0,1] = 0.019305
[1,0,1] = 0.023595
[0,1,1] = 0.039195
[1,1,1] = 0.047905

เยลลี่ขนาด 9 ไบต์

ż@C×þF¥@/

ลองออนไลน์!

J, 14 ไบต์

-.([:,*/)/@,.]

การใช้

   f =: -.([:,*/)/@,.]
   f 0.55 0.67 0.13
0.129195 0.019305 0.262305 0.039195 0.157905 0.023595 0.320595 0.047905

คำอธิบาย

-.([:,*/)/@,.]  Input: array P
-.              Complement (1-x) for each x in P
             ]  Identity, get P
           ,.   Interleave to make pairs [(1-x), x]
  (     )/@     Reduce from right-to-left by
      */          Forming the multiplication table
   [:,            Flattening the result

Pyth, 10 ไบต์

*MaVLQ^U2l

ลองใช้งานออนไลน์: การสาธิต

คำอธิบาย:

*MaVLQ^U2lQ   implicit Q at the end (Q = input list)
      ^U2lQ   repeated Cartesian product of [0, 1] with itself length(Q)-times
              this gives all combinations of 0s and 1s
  aVLQ        absolute difference between these 0-1-vectors with Q
*M            fold the vectors by multiplication

C, 110 ไบต์

i,k;f(float* a,int n){for(k=0;k<1<<n;++k){float p=1;for(i=0;i<n;++i)p*=k&(1<<i)?a[i]:1-a[i];printf("%f,",p);}}

Ungolfed:

i,k;f(float* a,int n){ 
 for(k=0; k<1<<n; ++k){
  float p=1;
  for (i=0; i<n; ++i)
   p*=k&(1<<i)?a[i]:1-a[i];
  printf("%f,",p);
 }
}

ทำงานได้สูงสุด 32 รายการ + 5 + 1 ไบต์สำหรับ 64 รายการ (ประกาศlong k;และเพิ่มLในลูปแรกดังนั้นk<1L<<N)

05AB1E , 8 ไบต์

<Äæ¹æR+P

ลองออนไลน์!

 <Äæ¹æR+P  # Main link (Input is [.1,.2])
 ###########
 <Ä        # Invert input, take the abs value.
           # Stack is [.9,.8]
   æ¹æ     # Powerset of both inverted and original arrays.
           # Stack is [[],[.1],[.2],[.1,.2]],[[],[.9],[.8],[.9,.8]]
      R+   # Reverse original array, add arrays together.
           # Stack is [.9,.8],[.1,.8],[.2,.9],[.1,.2]
        P  # For each sub array, push product.
           # Final Result: [0.02, 0.18, 0.08, 0.72]
           # E.G.          [  11,   10,   01,   00]

JavaScript (Firefox 30-57), 57 ไบต์

f=([p,...a])=>1/p?[for(q of[1-p,p])for(b of f(a))q*b]:[1]

ส่งคืนอาร์เรย์ของความน่าจะเป็นทั้งหมด หากคุณต้องการอาร์เรย์ของเหตุการณ์ด้วยเช่นกันสำหรับ 86 ไบต์:

f=([p,...a])=>1/p?[for(e of'01')for(b of f(a))[[+e,...b[0]],(+e?p:1-p)*b[1]]]:[[[],1]]

หากคุณอนุญาตให้เหตุการณ์เป็นสตริงแสดงว่ามีเพียง 80 ไบต์:

f=([p,...a])=>1/p?[for(e of'01')for(b of f(a))[e+b[0],(+e?p:1-p)*b[1]]]:[['',1]]

ลบสองไบต์สำหรับ1/แต่ละวิธีถ้าความน่าจะเป็นไม่เคยเป็นศูนย์

Perl 6, 24 19 ไบต์ของละติน -1

{[*] 1 «-»@_ «|»@_}

รหัสเก่า:

{[*] map {1-$^a|$^a},@_}

นี่คือฟังก์ชั่น ใช้แบบนี้:

{[*] 1 «-»@_ «|»@_}(0.55, 0.67, 0.13)

ที่จะได้รับ:

any(any(any(0.129195, 0.019305), any(0.262305, 0.039195)), any(any(0.157905, 0.023595), any(0.320595, 0.047905)))

คำอธิบายของรหัสเก่า:

[*]          multiply together all array elements
map          but first transform each element via
{1-$^a|$^a}  considering both 1 minus the value and the value
,@_          of the function input

โค้ดที่ใหม่กว่านั้นเหมือนกันเพียงแค่ใช้ไวยากรณ์ terser:

[*]          multiply together all array elements
1 «-»@_      of the array formed by subtracting the argument from 1
«|»@_        pointwise considering both that and the original array

แผนที่สร้างอาเรย์ที่เต็มไปด้วยanyโครงสร้างซึ่งทวีคูณเป็นanyโครงสร้างขนาดใหญ่แก้ปัญหาได้อย่างเป็นระเบียบโดยไม่ต้องวนซ้ำ

ไม่ใช่ภาษาที่สั้นที่สุดสำหรับโปรแกรม แต่เป็นการแปลปัญหาโดยตรง

Dyalog APL ขนาด 10 ไบต์

โซลูชั่นใหม่

ดัชนีกำเนิดอิสระ ฟังก์ชั่นไม่ระบุชื่อ รับรายการความน่าจะเป็นเป็นอาร์กิวเมนต์

∘.×/⊢,¨1-⊢

∘.×/ การลดสินค้าคาร์ทีเซียนมากกว่า

⊢ ค่าของอาร์กิวเมนต์

,¨ แต่ละคู่ขึ้นกับ

1-⊢ ค่าอาร์กิวเมนต์เสริม (สว่างหนึ่งค่าลบด้วยอาร์กิวเมนต์)

ลองใช้ออนไลน์!

โซลูชั่นเก่า

ต้องใช้⎕IO←0ซึ่งเป็นค่าเริ่มต้นในหลาย ๆ ระบบ แสดงรายการของความน่าจะเป็น

|⎕∘.×.-⊂⍳2

คำอธิบาย

| ค่าสัมบูรณ์ของ

⎕ใส่ɑ = [ ɑ ₁  ɑ ₂  ɑ ₃]

∘.×.-เมตริกซ์ด้านการแก้ไขคูณ ( ɑ ₁ - ข ₁) ⊗ ( ɑ ₂ - ข ₂) ⊗ ( ɑ ₃ - ข ₃) กับ

⊂⍳2รายการที่ล้อมรอบb = [[0 1]]

ความหมายทางคณิตศาสตร์

ในฐานะที่เป็นขถูกปิดล้อมมันเป็นสเกลาร์และดังนั้นจึงขยายความยาวของɑคือ 3 ดังนั้นการแสดงออกทั้ง= │ ( ɑ ₁ - ข ) ⊗ ( ɑ ₂ - ข ) ⊗ ( ɑ ₃ - ข ) │ =  │ ( ɑ ₁ - [0,1]) ⊗ ( ɑ ₂ - [0,1]) ⊗ ( ɑ ₃ - [0,1]) = │  │ [ ɑ ₁, ɑ ₁ - 1] ⊗ [ ɑ ₂ , ɑ ₂ - 1] ⊗ [ ɑ ₃, ɑ ₃ - 1] │ =  ⎢⎡⎡   ɑ ₁ ɑ ₂ ɑ

 





₃⎤⎡  ɑ ₁ ɑ ₂ ( ɑ ₃-1) ⎤⎤⎥
 ⎢⎢⎣  ɑ ₁ ( ɑ ₂-1) ɑ ₃⎦⎣  ɑ ₁ ( ɑ ₂-1) ( ɑ ₃-1) ⎦⎥⎥
 ⎢⎢⎡ ( ɑ ₁-1) ɑ ₂ ɑ ₃⎤⎡ ( ɑ ₁-1) ɑ ₂ ( ɑ ₃-1) ⎥⎥⎤
 ⎢⎣⎣ ( ɑ ₁-1) ( ɑ ₂-1) ɑ ₃⎦⎣ ( ɑ ₁- 1) ( ɑ ₂-1) ( ɑ ₃-1) ⎦⎦⎥

ลองใช้ออนไลน์!

หมายเหตุ (ใช้กับทั้งโซลูชันเก่าและใหม่)

โปรแกรมและสูตรใช้งานได้กับตัวแปรจำนวนใด ๆ ( n ) และส่งกลับอาร์เรย์n -dimensional ของความยาว 2 ในทุกมิติ ด้วยตัวแปรสามตัวความน่าจะเป็นของผลลัพธ์เฉพาะ
 P ( p , q , r ) = A _{p , q , r}
ซึ่งสามารถเลือกได้อย่างสะดวกจากอาเรย์ด้วย(⊃A)[p;q;r]แยกด้วยp q r⌷⊃A

เช่น1 1 0⌷⊃|0.55 0.67 0.13∘.×.-⊂⍳2ให้P (55%, 67%, ¬13%) = 1.9305%

PHP, 105 97 94 93 87 ไบต์

for(;$i<2**$c=count($a=$argv)-$p=1;$i+=print-abs($p))for(;$c;)$p*=$a[$c--]-!($i>>$c&1);

ทำงานแบบนี้:

php -r 'for(;$i<2**$c=count($a=$argv)-$p=1;$i+=print-abs($p))for(;$c;)$p*=$a[$c--]-!($i>>$c&1);' -- .55 .67 .13 2>/dev/null;echo
> -0.129195-0.157905-0.262305-0.320595-0.019305-0.023595-0.039195-0.047905

โปรดทราบว่าการส่งออกเป็น endian น้อย:

[0,0,0]
[1,0,0]
[0,1,0]
[1,1,0]
[0,0,1]
[1,0,1]
[0,1,1]
[1,1,1]

คำอธิบาย

for(
  ;
  $i<2**$c=                 # Iterate over possible combinations: 2^c,
    count($a=$argv)-$p=1;   #   where c is input length -p (set p to 1)
  $i+=print-abs($p)         # Increment i and print product after each
)                           #   iteration, dash separated
  for(
     ;
     $c;                    # Iterate over input ($c..0)
  )
    $p*=                    # Multiply the product by difference between:
      $a[$c--]-             # - The $c-th item of the input.
      !($i>>$c&1);          # - The $c-th bit of `$i`, negated (1 or 0)

การปรับแต่ง

• บันทึกแล้ว 8 ไบต์โดยใช้เลขฐานสองเพื่อรับบิตแทนที่จะแปลงเป็นสตริง
• บันทึกไบต์ด้วยการรวมการรีเซ็ต$pเป็น 1 กับการคำนวณ$c
• บันทึกเป็นไบต์ด้วยการเพิ่มผลลัพธ์ของการพิมพ์ (1) ไปที่$iแทนที่จะเพิ่มขึ้น
• บันทึกไบต์โดยใช้ขีดเส้นใต้เป็นตัวคั่นเอาต์พุต
• บันทึกไบต์โดยใช้เครื่องหมายลบเป็นตัวคั่น (ไม่มีโอกาสติดลบ)
• บันทึก 6 ไบต์โดยใช้$cแทน$$i

C ++ 17, 137 131 129 ไบต์

การบันทึก 6 ไบต์โดยการประกาศ#define A autoครั้งแรกที่แมโครแบบสั้นเช่นนี้จะบันทึกทุกอย่าง -2 ไบต์สำหรับการใช้#importและการลบพื้นที่ก่อน<

#import<iostream>
#define A auto
A g(A r){std::cout<<r<<",";}A g(A r,A x,A...p){g(x*r,p...);g(r-x*r,p...);}A f(A...p){g(1,p...);}

วางไข่รวมกันเป็นไปได้ทั้งหมด

Ungolfed:

//base case to print the result
int g(auto r){std::cout << r << ",";}

//extract item from parameter pack
int g(auto r, auto x, auto... p) {
 g(x*r,p...);    //multiply with temp result and call with tail
 g(r-x*r,p...);  //same as above for (1-x)
}

//start of recursion, setting temp result to 1
int f(auto...p){g(1,p...);}

การใช้งาน:

f(0.55, 0.67, 0.13);