ঠিক একটি সম্ভাবনা গণনা করুন

Question

এই টাস্কটি সম্ভবত কোনও সম্ভাবনার গণনা করার জন্য কোড লেখার বিষয়ে writing আউটপুটটি তার সর্বাধিক হ্রাসকৃত আকারে ভগ্নাংশ হিসাবে লিখিত একটি সুনির্দিষ্ট সম্ভাবনা হওয়া উচিত। এটি কখনও কখনও আউটপুট করা উচিত 4/8নয় 1/2।

কিছু ধনাত্মক পূর্ণসংখ্যা জন্য n, 1s একটি অবিশেষে র্যান্ডম স্ট্রিং বিবেচনা দৈর্ঘ্যের -1s nএবং এটি উ: এখন CONCATENATE কল Aতার প্রথম মান। যে A[1] = A[n+1]যদি 1. থেকে ইন্ডেক্স Aএখন দৈর্ঘ্য n+1। এখন দৈর্ঘ্যের দ্বিতীয় এলোমেলো স্ট্রিং বিবেচনা করুন nযার nসম্ভাব্যতা 1 / 4,1 / 2, 1/4 সহ প্রথম মান -1, 0, বা 1 হয় এবং এটিকে বি কল করুন call

উদাহরণস্বরূপ, বিবেচনা করুন 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।

— isaacg

আমি ন্যায্য বলে মনে করি এটি 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

এটি সমস্ত এন-টিপলস যুক্ত 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-1n = 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।

অবশেষে, যেহেতু আমরা এখন শুধু ভগ্নাংশ জানতে চাই 1এর একটি তালিকায় গুলি 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উৎস তালিকায় দুইবার প্রদর্শিত হবে এবং তারপর যে ভেতরের পণ্য শুন্যতে বেশী বড়, মোট ছাত্র। অভ্যন্তরীণ পণ্যটি Vইেক্টরাইজেশন সিনট্যাকটিক চিনি দ্বারা সহজ করা যায় । ভগ্নাংশটি সরল করা আমাকে প্রাথমিকভাবে ভয় দেখিয়েছিল, তবে Pরিম ফ্যাক্টরাইজেশন ফাংশন এবং উপলব্ধির সাথে এটি কেবল সহজ ছিল যে আমাদের কেবল 2 এর শক্তি দ্বারা হ্রাস করতে হবে।

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

Comments

আমি কীভাবে পরিবর্তন করব n?

@ ল্যাম্বিক পাইথ প্রোগ্রামটি একটি ব্যবহারকারী ইনপুটটির জন্য অনুরোধ করেছে, যা দ্বিতীয় পাঠ্যবক্সে নির্দিষ্ট করা হয়েছে (আপনি যদি অনলাইন সংকলক ব্যবহার করেন)।

— জাকুব

@ জাকুব ওহ ধন্যবাদ! এবং এটি আসলে খুব বেশি কাজ করছে বলে মনে হয় :)

Answer 4

সিজেম, 58 57 54 51 46 বাইট

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

এটি চালানোর জন্য WX]এবং এর মধ্যে পছন্দসই পূর্ণসংখ্যা প্রবেশ করান m*।

বিট ম্যাজিকের জন্য এবং 5 বাইট বন্ধ গল্ফ করার জন্য @ জিমি 23013 কে ধন্যবাদ!

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

ধারণা

এই উত্তরের বেশিরভাগ অংশ সোজা, তবে এটি দুটি ঝরঝরে কৌশল ব্যবহার করে:

• এর পরিবর্তে সব ভেক্টর যুক্ত করার এর {-1, 1} ^এন সব ভেক্টর দিয়ে {-1, 0, 1} ^এন আকাঙ্ক্ষিত সম্ভাব্যতার সঙ্গে, এটা গন্য ভেক্টর Triplets সংখ্যা বিবেচনা করে {-1, 1} ^এন যে সন্তুষ্ট একটি নির্দিষ্ট শর্ত

  আমরা যদি ট্রিপলেটের শেষ দুটি ভেক্টর যুক্ত করি তবে ফলাফলটি {-2, 0, 2} ^{n এর} ভেক্টর হবে ।

  যেহেতু (-1) + 1 = 0 = 1 + (-1) , 0 এস দ্বিগুণ হয় -2 এস এবং 2 এস হিসাবে দ্বিগুণ হবে ।

  প্রতিটি উপাদানকে 2 দ্বারা ^ভাগ করে নেওয়ার ফলে পছন্দসই সম্ভাব্যতা সহ {-1, 0, 1 ve ⁿ এর একটি ভেক্টর পাওয়া যাবে ।

  যেহেতু আমরা কেবল আগ্রহী যদি স্কেলার পণ্য 0 হয় বা না হয়, তাই আমরা বিভাগ 2 এড়িয়ে যেতে পারি ।

• প্রশ্নের শর্ত এবং মোট তিনটি সংখ্যা সন্তুষ্ট করে সমস্ত ট্রিপল্ট গণনা করার পরে, ফলস্বরূপ ভগ্নাংশটি হ্রাস করতে হবে।

  উভয় সংখ্যার জিসিডি গণনা করার পরিবর্তে, যেহেতু ডায়নামিটারটি সর্বদা 2 এর শক্তি হবে, তাই উভয় সংখ্যাকে 2 এর সর্বোচ্চ শক্তির দ্বারা বিভাজক করা যথেষ্ট যে সংখ্যাকে ভাগ করে দেয়।

  2 যে ভাগ সর্বোচ্চ ক্ষমতা প্রাপ্ত x , আমরা bitwise এবং গ্রহণ করতে পারেন এক্স এবং ~ X + 1 টি ।

  ~ X সব বিট reverses এক্স , তাই সব trailing 0 গুলি পরিণত 1 সে। যোগ করে 1 থেকে ~ X , ঐ 1 এর পিছনে পরিণত হবে 0 s এবং গত 1 মধ্যে ~ X + 1 টি গত ম্যাচ হবে 1 মধ্যে এক্স ।

  অন্যান্য সকল বিট পারেন উভয় 0 স্বতন্ত্র তাই, bitwise ও শেষ গঠিত পূর্ণসংখ্যা আসতে 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

@ জিমি 23013: এটি কিছু চিত্তাকর্ষক বিট যাদু। ধন্যবাদ!

— ডেনিস