18

০.০ থেকে ১.০ এর মধ্যে সম্ভাব্যতার সাথে ইভেন্টগুলির ক্রম দেওয়া, প্রতিটি সংমিশ্রণের সম্ভাবনা উত্পন্ন এবং প্রাপ্ত করা ive আপনি অনুমান করতে পারেন যে আপনার নির্বাচিত ভাষা যা নির্মাণ করে তাতে সংখ্যার ক্রম সরবরাহ করা হয়।

এখানে একটি উদাহরণ; আপনি অনুমান করতে পারেন যে সিকোয়েন্সগুলির সংমিশ্রণের দৈর্ঘ্য মেমরির সাথে খাপ খায়:

{ 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 probability-theory

— মার্ক জনসন
সূত্র

3

প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ স্বাগতম, এবং চমৎকার প্রথম চ্যালেঞ্জ!

— ডুরকনব

চান [0.129195, 0.019305, 0.262305, ..., 0.047905]আউটপুট যথেষ্ট হতে পারে অথবা দ্বারা [0,0,0], [0,0,1], ...প্রয়োজনীয়?

— লাইকনি

@ লাইকনি যে আউটপুটটি ঠিক আছে। আউটপুট অংশ সমস্যার মাংস নয়।

— মার্ক জনসন

আউটপুট কি বিপরীত ক্রমে হতে পারে?

— লুইস মেন্ডো

@ লুইস মেন্ডো অবশ্যই, কেন নেই not

— মার্ক জনসন

8

হাস্কেল, 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

— nimi
সূত্র

এটি ঝরঝরে; আমি কৌতূহল ছিল যদি এটি করার একটি খুব সংক্ষিপ্তভাবে বিশুদ্ধভাবে কার্যকরী উপায় হতে চলেছে। আপনি কি সি # বা এফ # জানবেন? আমি কৌতূহলী যে those ভাষাগুলির একই অ্যালগরিদমটি দেখতে কেমন লাগবে কারণ আমি হাস্কেল সিনট্যাক্সের সাথে সম্পূর্ণ অপরিচিত।

— মার্ক জনসন

@ মার্ক জোনসন: না, দুঃখিত আমি সি # বা এফ # উভয়ই জানি না।

— নিমি

5

গণিত, 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সহ বিটের একটি তালিকা দেওয়া হয়েছে, গুণনের সম্ভাবনার তালিকাটি দেওয়া হয়েছে01

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 *)

— u54112
সূত্র

4

পার্ল, 42 40 বাইট

এর জন্য +1 অন্তর্ভুক্ত -a

এসটিডিনে নম্বর দিন:

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

আউটপুট

combi.pl:

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

— টন হসপেল
সূত্র

4

এমএটিএল , 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

— লুইস মেন্ডো
সূত্র

3

পার্ল, 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"
}

ইনপুট প্যারামিটারগুলির সংখ্যার সমান 0 এর 1 এবং 1 এর দৈর্ঘ্যের সমস্ত সম্ভাব্য সংমিশ্রনের একটি তালিকা তৈরি করে (উদাহরণস্বরূপ, উপরের উদাহরণ হিসাবে, এটি দৈর্ঘ্যের 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

— গ্যাব্রিয়েল বেনামি
সূত্র

1

-aপরিবর্তে (@a=split/ /,<>)...

— দাদা

3

আর, 72 69 বাইট

স্টিডিন থেকে ইনপুট নেয় এবং সম্ভাবনার একটি আর-ভেক্টর প্রদান করে returns

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

প্রথম সম্ভাব্যতা উপরের ম্যাট্রিক্সের প্রথম সারির বিপরীত ফলাফলের সাথে এবং দ্বিতীয়টি উল্টো দ্বিতীয় সারির সাথে সম্পর্কিত। এটিকে আরও সুস্পষ্টভাবে দেখার জন্য আউটপুট ফর্ম্যাট করা প্রোগ্রামটিকে দীর্ঘতর করে তোলে (১ 16৪ বাইট):

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

— Billywob
সূত্র

আমি এটির জন্য আমার নিজের উত্তর নিয়ে কাজ করছি তবে আমি একটি পরিষ্কার সমাধান নিয়ে আসতে পারিনি। দুর্দান্ত ব্যবহার expand.grid! আমি মনে করি যে applyডেটা ফ্রেমের পাশাপাশি ম্যাট্রিকগুলিও পরিচালনা করতে পারে তাই আপনার কোডটি ছাড়াই কাজ করা উচিত t(t(...))যা আপনাকে 6 বাইট সংরক্ষণ করবে।

— rturnbull

@ আর্টারনবুল নোট যে tকোনও ডেটা ফ্রেমের সাথে সম্পর্কিত নয় তবে সম্ভাব্যতা ভেক্টরের বিয়োগটি মেট্রিক্স (বিভিন্ন মাত্রা সহ) থেকে বিয়োগের অনুমতি দেওয়ার জন্য। আর এই ভেক্টরাইজড ক্রিয়াকলাপগুলি যেভাবে পরিচালনা করে সেগুলির মধ্যে কমপক্ষে একটির প্রয়োজন হলেও আমি সম্ভবত বাহ্যিক ট্রান্সপোজ সরিয়ে ফেলতে এবং তার পরিবর্তে কলামগুলিতে পণ্যটি প্রয়োগ করতে পারি। আগামীকাল আপডেট হবে

— বিলিওব

2

জেলি , 9 বাইট

ż@C×þF¥@/

এটি অনলাইন চেষ্টা করুন!

— মাইল
সূত্র

2

জে, 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

— মাইল
সূত্র

আপনি কি |*//0.55 0.67 0.13-/0 1ট্রেন বানাতে পারবেন?

— অ্যাডম

2

পাইথ, 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

— Jakube
সূত্র

1

সি, 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 টি আইটেম পর্যন্ত কাজ করে, 64 আইটেমের জন্য + 5 + 1 বাইট (ঘোষণা long k;করুন Lএবং প্রথম লুপটিতে এটি যুক্ত করুন k<1L<<N)।

— কার্ল ন্যাপ
সূত্র

1

> 32 টি আইটেমের জন্য, সি এর জন্য কি "এল" আক্ষরিক প্রয়োজন হয় *1*<<nবা এটি কেবল একটি সি ++ জিনিস?

— মার্ক জনসন

@ মার্ক জোনসন হ্যাঁ আমার ধারণা এটির প্রয়োজন হবে।

— কার্ল ন্যাপ্ফ

1

05 এ বি 1 ই , 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]

— ম্যাজিক অক্টোপাস উরন
সূত্র

1

জাভাস্ক্রিপ্ট (ফায়ারফক্স 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/সম্ভাবনাটি কখনই শূন্য হতে না পারলে প্রতিটি সমাধানের জন্য দুটি বাইট বিয়োগ করুন ।

— নিল
সূত্র

আপনি কিভাবে এটি একটি <script></script>ব্লক চালাতে হবে ? আমি প্রথম "জন্য" অপ্রত্যাশিত হয়ে সমস্যাগুলি পাচ্ছি?

— মার্ক জনসন

@ মার্ক জোনসন যতক্ষণ আপনি ফায়ারফক্স 30 বা তার পরে ব্যবহার করছেন, এটি ঠিক কাজ করা উচিত।

— নিল

0

পার্ল 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

নতুন কোডটি মূলত সারণী বাক্য গঠন ব্যবহার করে একই রকম:

[*]          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কনস্ট্রাক্টগুলিতে গুন করে , এমনকি একটি লুপের প্রয়োজন ছাড়াই ঝরঝরে সমস্যার সমাধান করে।

প্রোগ্রামটির জন্য স্বল্পতম ভাষা নয়, তবে এটি সমস্যার খুব সরাসরি অনুবাদ।

0

ডায়ালগ এপিএল , 10 বাইট

নতুন সমাধান

সূচকের উত্স স্বাধীন। বেনামে ফাংশন। সম্ভাব্যতার তালিকাটিকে যুক্তি হিসাবে গ্রহণ করে।

∘.×/⊢,¨1-⊢

∘.×/ কার্টেসিয়ান পণ্য হ্রাস

⊢ আর্গুমেন্ট মান

,¨ প্রত্যেকের সাথে জুটিবদ্ধ

1-⊢ পরিপূরক আর্গুমেন্টের মানগুলি (লিট। এক আর্গুমেন্টের মানগুলি)

অনলাইনে চেষ্টা করুন!

ওল্ড সলিউশন

দরকার ⎕IO←0যা অনেক সিস্টেমে পূর্বনির্ধারিত। সম্ভাব্যতার তালিকার জন্য অনুরোধ জানানো হয়।

|⎕∘.×.-⊂⍳2

ব্যাখ্যা

| এর পরম মান

⎕ইনপুট, ɑ = [ ɑ ₁ ɑ ₂ ɑ ₃]

∘.×.-পরিবর্তিত অভ্যন্তরীণ টেন্সরটি বহুগুণ, ( ɑ ₁ - বি ₁) ⊗ ( ɑ ₂ - বি ₂) ⊗ ( ɑ ₃ - বি ₃) সহ

⊂⍳2বদ্ধ তালিকা খ = [[0 1]]

গাণিতিক সংজ্ঞা

হিসাবে খ ঘিরা হয়, এটি স্কালে, সেইজন্য এবং দৈর্ঘ্য বাড়ানো হয় ɑ , যথা 3 তাই সমগ্র অভিব্যক্তি

একটি = │ ( ɑ ₁ - খ ) ⊗ ( ɑ ₂ - খ ) ⊗ ( ɑ ₃ - খ ) │ =

│ ( ɑ ₁ - [0,1]) ⊗ ( ɑ ₂ - [0,1]) ⊗ ( ɑ ₃ - [0,1]) │ =

│ [ ɑ ₁, ɑ ₁ - 1] ⊗ [ ɑ ₂ , ɑ ₂ - 1] ⊗ [ ɑ ₃, ɑ ₃ - 1] │ =

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

অনলাইনে চেষ্টা করুন!

নোটস (পুরানো এবং নতুন উভয় সমাধানের জন্য প্রযোজ্য)

প্রোগ্রাম এবং সূত্রটি ভেরিয়েবলের যে কোনও সংখ্যার ( এন ) জন্য কাজ করে এবং প্রতিটি মাত্রায় দৈর্ঘ্য 2 এর একটি n- মাত্রিক অ্যারে প্রদান করে। তিনটি ভেরিয়েবল সহ, একটি নির্দিষ্ট ফলাফলের সম্ভাবনা
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 দেয় (55%, 67%, ¬13%) = 1.9305%

— আদম
সূত্র

0

পিএইচপি, 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

দ্রষ্টব্য যে আউটপুটটি সামান্য এন্ডিয়ান:

[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বর্ধিতকরণের পরিবর্তে
আউটপুট ডিলিমিটার হিসাবে আন্ডারস্কোর ব্যবহার করে একটি বাইট সংরক্ষণ করা হয়েছে
বিয়োগ চিহ্নটি ডিলিমিটার হিসাবে ব্যবহার করে একটি বাইট সংরক্ষণ করেছেন (কোনও নেতিবাচক সম্ভাবনা নেই)।
$cপরিবর্তে ব্যবহার করে 6 বাইট সংরক্ষণ করা হয়েছে$$i

— aross
সূত্র

0

সি ++ 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);

— কার্ল ন্যাপ
সূত্র

প্রদত্ত ইভেন্টগুলির সমস্ত সংমিশ্রণের সম্ভাবনা

হাস্কেল, 86 বাইট

গণিত, 46 45 বাইট

পরীক্ষা ক্ষেত্রে:

ব্যাখ্যা

পার্ল, 42 40 বাইট

এমএটিএল , 12 11 বাইট

পার্ল, 116 বাইট

আর, 72 69 বাইট

জেলি , 9 বাইট

জে, 14 বাইট

ব্যবহার

ব্যাখ্যা

পাইথ, 10 বাইট

ব্যাখ্যা:

সি, 110 বাইট

05 এ বি 1 ই , 8 বাইট

জাভাস্ক্রিপ্ট (ফায়ারফক্স 30-57), 57 বাইট

পার্ল 6, 24 19 ল্যাটিন -1 এর বাইট

ডায়ালগ এপিএল , 10 বাইট

নতুন সমাধান

ওল্ড সলিউশন

ব্যাখ্যা

গাণিতিক সংজ্ঞা

নোটস (পুরানো এবং নতুন উভয় সমাধানের জন্য প্রযোজ্য)

পিএইচপি, 105 97 94 93 87 বাইট

ব্যাখ্যা

বদলান

সি ++ 17, 137 131 129 বাইট