অদ্বিতীয় আইটেমের সাথে অনুক্রম

Question

পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে, একবার পৃথক পৃথক সংখ্যাসূচক সংখ্যার সাথে পূর্ণসংখ্যার ক্রমের সংখ্যা আউটপুট করুন। যদি সেখানে nপূর্ণসংখ্যা থাকে এবং অবিসংবাদিত সংখ্যার প্রতিটি গ্রুপের দৈর্ঘ্য হয় n_i, এটিn! / (n_1! * n_2! * ...)

বিধি

• ইনপুট কোনও ফাংশন বা প্রোগ্রামটি 1 থেকে 12 অ-নেতিবাচক পূর্ণসংখ্যার সাথে যুক্তির হিসাবে তালিকার কিছু ফর্ম হবে।

• উপরের বর্ণনা অনুসারে আউটপুট প্রমোটেশনগুলির সংখ্যা মুদ্রণ বা ফিরিয়ে আনবে।

• কোনও স্ট্যান্ডার্ড লুফোলস বা অন্তর্নির্মিত ফাংশন নেই (ক্রমজাতকরণ, সংমিশ্রণ ইত্যাদি)। কারখানাগুলি অনুমোদিত।

পরীক্ষার কেস

ইনপুট:

1, 3000, 2, 2, 8
1, 1, 1
2, 4, 3, 2, 3, 4, 4, 4, 4, 4, 1, 1

আউটপুট:

60
1
83160

Comments

আপনি কোনও বিল্টিন না বললে, আমি যখন সমস্ত আদেশ তৈরি করার জন্য একটি বিল্টিন ব্যবহার করি তখন এর মধ্যে কী ঘটে থাকে?

— মাল্টেসেন

এটি বহুল পরিমাণে গুণফল হিসাবে গণনা করা হিসাবে বেশিরভাগ একই দেখাচ্ছে । ইনপুটটির জন্য অভিন্ন এন্ট্রি গণনা কি এটিকে ডুপ না করে যথেষ্ট আলাদা করে তোলে?

— xnor

@ এক্সনোর ভাল এখানে আপনি ডুপ্লিকেট গণনা করতে হবে, তাই এটি আমি মনে করি হিসাবে সহজ না । অন্যটি মানগুলিতে বেশ সরল প্লাগিং।

— Qwr

@ মালটিসেন দুঃখজনকভাবে হ্যাঁ, আমাকে প্রশ্নটি আপডেট করতে হবে

— qwr

@ লুইস মেন্ডো হ্যাঁ এটি হ'ল, যদিও আমি যতটা কল্পনা করতে পারি তাতে কোনও পার্থক্য করা উচিত নয়

— qwr

Answer 1

পাইথন, 48 বাইট

f=lambda l:l==[]or len(l)*f(l[1:])/l.count(l[0])

একটি পুনরাবৃত্তিমূলক বাস্তবায়ন।

সূত্রে, n! / (n_1! * n_2! * ...)আমরা যদি প্রথম উপাদানটি মুছে ফেলি (এটি বলুন 1), অবশিষ্ট n-1উপাদানগুলির জন্য ক্রমান্বনের সংখ্যা

(n-1)! / ((n_1-1)! * n_2! * ...) ==
n! / n / (n_1! / n_1! * n_2! * ...) == 
n/n_1 * (n! / (n_1! * n_2! * ...)`)

সুতরাং, আমরা উত্তরগুলি n/n1তালিকার বাকী অংশগুলির জন্য পুনরাবৃত্তির ফলাফল দ্বারা প্রথমটির সমান উপাদানের পারস্পরিক-ভগ্নাংশ দ্বারা গুণিত করে উত্তর পাই । খালি তালিকাটি 1 এর বেস কেস দেয়।

Comments

কেন আপনি /l.count(l[0])শেষ করা হয় না? তারপরে আপনার সেই আইকি ভাসমান পয়েন্টের দরকার নেই।

— শুক্রবার

Answer 2

এমএটিএল , 14 13 12 বাইট

fpGu"@G=s:p/

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

ব্যাখ্যা

@ অ্যাডনানের উত্তরে এই পদ্ধতির সাথে খুব মিল রয়েছে ।

f       % Take input implicitly. Push array of indices of nonzero entries.
        % This gives [1 2 ... n] where n is input length.
p       % Product (compute factorial)
Gu      % Push input. Array of its unique elements
"       % For each of those unique values
  @     %   Push unique value of current iteration
  G=s   %   Number of times (s) it's present (=) in the input (G)
  :p    %   Range, product (compute factorial)
  /     %   Divide
        % End for each implicitly. Display implicitly

Answer 3

05 এ বি 1 ই , 15 14 13 বাইট

কোড:

D©g!rÙv®yQO!/

ব্যাখ্যা:

               # implicit input
D©             # duplicate and save a copy to register
  g!           # factorial of input length (total nr of permutations without duplicates)
    rÙv        # for each unique number in input
       ®yQO!   # factorial of number of occurances in input
            /  # divide total nr of permutations by this
               # implicit output

ব্যবহার সিপি-1252 এনকোডিং।

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

Answer 4

জাভাস্ক্রিপ্ট (ES6), 64 61 বাইট

a=>a.sort().map((x,i)=>r=r*++i/(x-y?(y=x,c=1):++c),y=r=-1)|-r

প্রতিটি ফ্যাক্টরিয়াল বর্ধিতভাবে গণনা ব্যতীত প্রদত্ত সূত্রটি ব্যবহার করে (সুতরাং উদাহরণস্বরূপ r=r*++iকার্যকরভাবে ক্যালক্লুয়েটস n!)।

সম্পাদনা: মূলত আমি কোনও সীমাবদ্ধ নম্বর গ্রহণ করেছি তবে @ ব্যবহারকারী 81655 যখন উল্লেখ করেছে যে আমার কেবল ইতিবাচক পূর্ণসংখ্যার সমর্থন করা দরকার (যদিও আমি প্রকৃতপক্ষে অ-নেতিবাচক পূর্ণসংখ্যাকে গ্রহণ করি) I

Comments

r*=++i/(x-y?(y=x,c=1):++c),y=r=-1)|-r?

— ব্যবহারকারী81655

@ ইউজার ৮১5৫৫ আহ, আমি প্রশ্নটি পুরোপুরি পুরোপুরি পড়িনি এবং উপেক্ষা করেছিলাম যে আমি মানগুলি ইতিবাচক পূর্ণসংখ্যার উপর নির্ভর করতে পারি। আমি *=যদিও এটি পছন্দ করি না কারণ এটি গোলাকার ত্রুটির পরিচয় দেয়।

— নীল

Answer 5

পাইথ, 11 বাইট

/.!lQ*F/V._

পরীক্ষা স্যুট

স্ট্যান্ডার্ড সূত্রটি ব্যবহার করে, n! / (count1! * count2! * ...)গৌণগুলির ফ্যাক্টরিয়ালগুলি ব্যতীত প্রতিটি উপকরণের প্রিফিক্সে কতবার ঘটে তা গণনা করে তারপরে এই জাতীয় সমস্ত সংখ্যার একসাথে গুণ করে সন্ধান করা হয়।

ব্যাখ্যা:

/.!lQ*F/V._
/.!lQ*F/V._QQ    Implicit variable introduction.
                 Q = eval(input())
         ._Q     Form all prefixes of the input.
       /V   Q    Count how many times each element occurs in the prefix
                 ending with that element.
     *F          Fold on multiplication - take the product.
 .!lQ            Take the factorial of the input length
/                Divide.

Answer 6

পাইথ - 14 12 বাইট

/F.!M+lQ/LQ{

টেস্ট স্যুট ।

Answer 7

রুবি, 75 74 বাইট

কিন্ডার ইচ্ছা ছিল যে রুবির Mathমডিউলটির একটি ফ্যাক্টরিয়াল ফাংশন ছিল তাই আমার নিজের তৈরি করতে হবে না।

->l{f=->x{x<2?1:x*f[x-1]};l.uniq.map{|e|f[l.count e]}.inject f[l.size],:/}

Answer 8

সিজেম, 17 বাইট

q~_,\$e`0f=+:m!:/

এটি এখানে পরীক্ষা করুন।

ব্যাখ্যা

q~   e# Read input and evaluate.
_,   e# Duplicate and get length.
\$   e# Swap with other copy and sort it.
e`   e# Run-length encode. Since the list is sorted, this tallies the numbers.
0f=  e# Select the tally of each number.
+    e# Prepend the length of the input.
:m!  e# Compute the factorial of each number in the list.
:/   e# Fold division over it, which divides each factorial of a tally into
     e# the factorial of the length.

Answer 9

জেলি, 8 বাইট

W;ĠL€!:/

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

W;ĠL€!:/ example input:             [1, 3000, 2, 2, 8]
W        wrap:                      [[1, 3000, 2, 2, 8]]
  Ġ      group index by appearance: [[1], [3, 4], [5], [2]]
 ;       concatenate:               [[1, 3000, 2, 2, 8], [1], [3, 4], [5], [2]]
   L€    map by length:             [5, 1, 2, 1, 1]
     !   [map by] factorial:        [120, 1, 2, 1, 1]
      :/ reduce by division:        120÷1÷2÷1÷1 = 60

Answer 10

জে, 13 বাইট

#(%*/)&:!#/.~

ব্যবহার

   f =: #(%*/)&:!#/.~
   f 1 3000 2 2 8
60
   f 1 1 1
1
   f 2 4 3 2 3 4 4 4 4 4 1 1
83160

ব্যাখ্যা

#(%*/)&:!#/.~  Input: A
         #/.~  Partition A by equal values and get the size of each, these are the tallies
#              Get the size of A
      &:!      Take the factorial of both the size and the tallies
   */          Reduce using multiplication the factorial of the tallies
  %            Divide the factorial of the size by that product and return