ক্রমটি পুনরায় সাজানো

Question

ভূমিকা

আসুন নিম্নলিখিত ক্রমটি পর্যালোচনা করুন (অ-নেতিবাচক পূর্ণসংখ্যা):

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, ...

উদাহরণস্বরূপ, প্রথম তিনটি সংখ্যা নেওয়া যাক । এগুলি হল 0, 1, 2। এই ক্রমটিতে ব্যবহৃত নম্বরগুলি ছয়টি বিভিন্ন উপায়ে অর্ডার করা যেতে পারে :

012   120
021   201
102   210

সুতরাং, আসুন যে F (3) = 6 বলা যাক । আর একটি উদাহরণ এফ (12) । এটিতে সংখ্যাগুলি রয়েছে:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11

বা সংক্ষিপ্ত সংস্করণ:

01234567891011

এটি পুনরায় সাজানোর বিভিন্ন উপায়ের জন্য, আমাদের প্রথমে এই স্ট্রিংয়ের দৈর্ঘ্যটি দেখতে হবে। এই স্ট্রিংয়ের দৈর্ঘ্য 14। সুতরাং আমরা 14 গণনা ! । তবে উদাহরণস্বরূপ এগুলি চূড়ান্ত স্ট্রিংটি ব্যাহত না করে জায়গাগুলি বিনিময় করতে পারে। 2 টি শূন্য আছে, তাই 2 আছে! উপায়ে exhange করার শূণ্যসমূহ অর্ডার ব্যাহত ছাড়া। এছাড়াও 4 টি আছে, তাই 4 আছে! একগুলি স্যুইচ করার উপায়গুলি। আমরা এই দুটি সংখ্যা দ্বারা মোট ভাগ:

এটি 14 আছে! / (4! × 2!) = 1816214444 স্ট্রিংটি সাজানোর উপায় 01234567891011। সুতরাং আমরা এফ (12) = 1816214400 উপসংহারে পৌঁছে যেতে পারি ।

কাজটি

প্রদত্ত এন , আউটপুট এফ (এন) । যাদের পরিচিতির দরকার নেই তাদের জন্য। এফ (এন) গণনা করতে, আমরা প্রথমে প্রথম এন অ-নেতিবাচক পূর্ণসংখ্যার (যেমন এন = 12 এর জন্য, সংক্ষিপ্ত স্ট্রিংটি হবে 01234567891011) সংশ্লেষ করি এবং এই স্ট্রিংটি সাজানোর পদ্ধতিগুলির সংখ্যা গণনা করি।

পরীক্ষার মামলা

Input:   Output:
0        1
1        1
2        2
3        6
4        24
5        120
6        720
7        5040
8        40320
9        362880
10       3628800
11       119750400
12       1816214400
13       43589145600
14       1111523212800
15       30169915776000

বিঃদ্রঃ

উত্তর কম্পিউটিং একটি মধ্যে নির্ণিত করা আবশ্যক 10 সেকেন্ড সময় সীমা , নরপশু-অত্যাচার করা হয় অননুমোদিত ।

এটি কোড-গল্ফ , তাই সর্বনিম্ন পরিমাণ বাইটের সাথে জমাটি জয়!

Comments

আউটপুট কি 10সঠিক? এটি 10 ​​এর চেয়ে কম হওয়া উচিত বলে মনে হচ্ছে! যেহেতু পুনরাবৃত্তি সংখ্যাগুলি শুরু হয়।

— জিওবিটস

@ জিওবিটস প্রথম 10সংখ্যাগুলি হ'ল 0, 1, 2, 3, 4, 5, 6, 7, 8, 9। দশটি ভিন্ন অঙ্ক, সুতরাং ফলাফল 10 !.

— আদনান

আহ ঠিক. আমি মনে করি 0কেসটি আমার গণনা বন্ধ করে দিচ্ছে (বোকা ফাঁকা স্ট্রিং)।

— জিওবিটস

সে সম্পর্কে আর চিন্তা করার দরকার নেই। আমি মন্তব্যটি পোস্ট করার সময় লুফোল প্রস্তাবটি +4 এ ছিল । এটি এখন +9 এ ।

— ডেনিস

এই ধাঁধা সম্পর্কে এখানে একটি আকর্ষণীয় গণিত প্রশ্ন: এন (N) এর সাথে সম্পর্কিত F (N) এর মান কত? এন এর কয়েকটি মান রয়েছে যার জন্য এফ (এন) / এফ (এন -1) <এন, তবে এটি সাধারণত কিছুটা বড় হয়। আমি প্রায় নিশ্চিত যে আছি F(N)নয় O(N!)এবং যে log F(N)হয় O(log N!)কিন্তু যারা শুধু hunches ... হয়

— rici

Answer 1

জেলি, 17 15 বাইট

R’DFµ=€QS;@L!:/

এটি অনলাইন চেষ্টা করুন! বা একবারে সমস্ত পরীক্ষার কেস যাচাই করুন ।

কিভাবে এটা কাজ করে

R’DFµ=€QS;@L!:/    Main link. Input: n

R                  Yield [1, ..., n] for n > 0 or [0] for n = 0.
 ’                 Decrement. Yields [0, ..., n - 1] or [-1].
  D                Convert each integer into the list of its decimal digits.
   F               Flatten the resulting list of lists.
    µ              Begin a new, monadic chain. Argument: A (list of digits)
       Q           Obtain the unique elements of A.
     =€            Compare each element of A with the result of Q.
                   For example, 1,2,1 =€ Q -> 1,2,1 =€ 1,2
                                           -> [[1, 0], [0, 1], [1, 0]]
        S          Sum across columns.
                   This yields the occurrences of each unique digit.
         ;@L       Prepend the length of A.
            !      Apply factorial to each.
             :/    Reduce by divison.
                   This divides the first factorial by all remaining ones.

Comments

আসলেই কি এই জেলি? আমি অনেক ASCII অক্ষর দেখতে পাচ্ছি :

— লুইস মেন্ডো

তারা সর্বদা কোনও না কোনওভাবে

— ডেনিস

Answer 2

ES6, 118 81 78 বাইট

n=>[...[...Array(n).keys()].join``].map(c=>r/=(o[c]=-~o[c])/i++,o=[],i=r=1)&&r

কারও কাছে আমাকে বলতে বাধ্য যে সংখ্যার অবধি সংক্ষিপ্তকরণের একটি ছোট উপায় n।

@ Edc65 এর ধারণাটি নিয়ে এবং স্টেরয়েডগুলিতে চালিয়ে একটি দুর্দান্ত 37 বাইট সংরক্ষণ করেছেন। (পরিবর্তে '|' ব্যবহার করে একটি অতিরিক্ত বাইট সংরক্ষণ করুন &&তবে ফলাফলটি 31 বিটের মধ্যে সীমাবদ্ধ)

সম্পাদনা করুন: আবার আরও 3 বাইট সংরক্ষিত হয়েছে @ এডক 65 এর জন্য ধন্যবাদ।

Comments

অঙ্কগুলি সংক্ষিপ্তকরণ সংক্ষিপ্ত করার কোনও উপায় খুঁজে পেল না। তবে বাকি

— সমস্তগুলি

এতে 2 বাইট সংরক্ষণ করুন reduce:n=>[...[...Array(n).keys()].join``].reduce((r,c,i)=>r*++i/(o[c]=-~o[c]),1,o=[])

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

কি দারুন! তবে 78 ভাল:n=>[...[...Array(n).keys()].join``].map(c=>r/=(o[c]=-~o[c])/i++,o=[],i=r=1)&&r

— edc65

@ এডসি 65 এর r/=(...)/i++চেয়ে বেশি সঠিক r*=i++/(...)? এটি আমি দেখেছি সবচেয়ে হাস্যকর গল্ফ!

— নীল

আমাকে এক মুহুর্তের জন্য থামতে হয়েছিল, কারণ আমি ভেবেছিলাম আপনার সেখানে একটি রেজিেক্স ছিল।

— মামা ফান রোল

Answer 3

এপিএল (ডায়ালগ প্রসারিত) , 13 বাইট

×/2!/+\⎕D⍧⍕⍳⎕

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

একটি সম্পূর্ণ প্রোগ্রাম। ব্যবহার ⎕IO←0।

কিভাবে এটা কাজ করে

×/2!/+\⎕D⍧⍕⍳⎕
            ⎕  ⍝ Take input from stdin (N)
           ⍳   ⍝ Generate range 0..N-1
          ⍕    ⍝ Stringify the entire array (S)
               ⍝ (The result has spaces between items)
       ⎕D      ⍝ The character array '0123456789'
         ⍧     ⍝ Count occurrences of each digit in S
×/2!/+\        ⍝ Calculate multinomial:
     +\        ⍝   Cumulative sum
  2!/          ⍝   Binomial of consecutive pairs
×/             ⍝   Product

বহুজাতিক গণনা নিম্নলিখিত সত্য থেকে আসে:

$$\frac{(a_1 + a_2 + \cdots + a_n)!}{a_1! a_2! \cdots a_n!} = \frac{(a_1 + a_2)!}{a_1! a_2!} \times \frac{(a_1 + a_2 + \cdots + a_n)!}{(a_1 + a_2)! a_3! \cdots a_n!}$$

$$= \frac{(a_1 + a_2)!}{a_1! a_2!} \times \frac{(a_1 + a_2 + a_3)!}{(a_1 + a_2)! a_3!} \times \frac{(a_1 + a_2 + \cdots + a_n)!}{(a_1 + a_2 + a_3)! \cdots a_n!}$$

$$= \cdots = \binom{a_1 + a_2}{a_1} \binom{a_1 + a_2 + a_3}{a_1 + a_2} \cdots \binom{a_1 + \cdots + a_n}{a_1 + \cdots + a_{n-1}}$$

Comments

এবং এই কারণেই প্রোগ্রামারদের গণিত শিখতে হবে।

— অজ্ঞাতনামা

@ নামবিহীন… এবং একটি গাণিতিকভাবে ঝুঁকির প্রোগ্রামিং ভাষা ব্যবহার করুন।

— অ্যাডম

Answer 4

এমএটিএল , 21 বাইট

:qV0h!4Y2=sts:pw"@:p/

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

ব্যাখ্যা

:q     % implicitly input N, and generate vector [0, 1, ..., N-1]
V      % convert to string representation of numbers. Contains spaces,
       % but no matter. Only characters '0', ..., '9' will be counted
0h     % append 0 character (not '0'), so that string is never empty
!      % convert string to column char array
4Y2    % string '0123456789' (row char array)
=      % test all pairs for equality
s      % sum each column. For N = 12 this gives [2, 4, 1, 1, ..., 1]
t      % duplicate
s      % compute sum. For N = 12 this gives 14
:p     % factorial
w      % swap. Now vector [2, 4, 1, 1, ..., 1] is on top
"      % for each number in that vector
  @:p  %   factorial
  /    %   divide
       % implicitly end loop
       % implicitly display

Comments

@ আদনান সলভ হয়েছে। এবং কম বাইট সহ :-)

— লুইস মেন্ডো

অনেক সুন্দর দেখতে! :)

— আদনান

@ আদনান ধন্যবাদ! আমি একটি ব্যাখ্যা যুক্ত করেছি

— লুইস মেন্ডো

Answer 5

পাইথন 2, 142 137 101 97 বাইট

(পরামর্শের জন্য @ আদনানকে ধন্যবাদ input)

( সি সংস্করণ থেকে বর্ধিত গণনা প্রয়োগ করা হয়েছে )

f=1;v=10*[0]
for i in range(input()):
 for h in str(i):k=int(h);v[k]+=1;f=f*sum(v)/v[k]
print f

ফ্যাকটোরিয়াল ব্যবহার করে আসল সংস্করণ

import math
F=math.factorial
v=10*[0]
for i in range(input()):
 for h in str(i):v[int(h)]+=1
print reduce(lambda a,x:a/F(x),v,F(sum(v)))

সত্যিই, উপরের একমাত্র গল্ফিং হ'ল কল math.factorial Fকরে কিছু জায়গা ছেড়ে চলেছে , সুতরাং সম্ভবত একটি সংক্ষিপ্ত অজগর সমাধান রয়েছে।

যদি ব্যাখ্যা প্রয়োজন হয়, vপ্রতিটি সংখ্যার ফ্রিকোয়েন্সি একটি গণনা বজায় রাখে; নির্দেশিত ব্যাপ্তিতে প্রতিটি সংখ্যার প্রতিটি অঙ্কের জন্য গণনা আপডেট করা হয়।

মূল সংস্করণে, আমরা মানক সূত্র (if _i )! / Π (f _i !) ব্যবহার করে ক্রমান্বয়ের সংখ্যা গণনা _করি । বর্তমান সংস্করণের জন্য, এই অঙ্কটি গুণমান বিতরণ করে ক্রমান্বয়ে সম্পন্ন করা হয় এবং আমরা অঙ্কগুলি দেখতে পাই ভাগ করে। এটি সুস্পষ্ট নাও হতে পারে যে পূর্ণসংখ্যার বিভাজন সর্বদা যথার্থই থাকবে তবে পর্যবেক্ষণের ভিত্তিতে প্রমাণ করা সহজ যে প্রতিটি বিভাগকে একের পর এক পূর্ণসংখ্যার kঅবশ্যই অনুসরণ করতে হবে k, সুতরাং সেই গুণগুলির মধ্যে একটির দ্বারা বিভাজক হতে হবে k। (এটি একটি স্বজ্ঞাত, একটি প্রমাণ নয়।)

মূল সংস্করণটি বড় আর্গুমেন্টগুলির জন্য দ্রুত কারণ এটি কেবল 10 বিগনাম বিভাজন করে। যদিও একটি ছোট ইন্টিজার দিয়ে একটি বিগনাম ভাগ করা একটি বিগনাম দ্বারা একটি বিগনামকে ভাগ করার চেয়ে দ্রুততর হয়, যখন আপনার কয়েক হাজার বিগনাম বিভাজক হয়, তখন এটি কিছুটা আলগা হয়ে যায়।

Comments

f = f * যোগ (v) / v [কে] -> চ * = যোগফল (ভি) / ভি [কে] একটি বাইট সংরক্ষণ করে

— মিক্কো ভাইরকিলি

@ সুফারফ্লাক্স: তবে এটি একই অর্থ নয়।

— ধনী

Answer 6

পাইথন 2, 197 বাইট (সম্পাদনা করুন: 4 বাইট সংরক্ষিত, থমাস কোওয়া ধন্যবাদ!)

import math
l,g,f,p,r,s=[],[],math.factorial,1,range,str
for x in r(int(input())):l.append(s(x))
l="".join(l)
for y in r(10):b=s(l).count(s(y));g.append(f(b));
for c in g:p*=y
print f(int(len(l)))/p

Ungolfed:

import math

l=[] #list of the numbers from 0 to n
exchange_list=[] #numbers that can be exchanged with each other, ie      repeats

multiplied = 1 #for multiplying the digits by each other
n = int(input())

for x in range(n): #put all the numbers from 0-n into the list
    l.append(str(x))

l = "".join(l) #put all the digits in a string to remove repeats

for x in range(10): #look at all the digits and check how many are in the     list/string
    count = str(l).count(str(x))
    if count > 1: #if there is more than 1 of the digit, put the factorial of the amount of - 
        exchange_list.append(math.factorial(count)) # - appearances into the exchange list.

for x in exchange_list: #multiply all the values in the list by each other
    multiplied*=x

print math.factorial(int(len(l)))/multiplied #print the factorial of the  length of the string 
#divided by the exchanges multiplied

Comments

প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ স্বাগতম! এই উত্তরটি ভিএলকিউ হিসাবে চিহ্নিত করা হয়েছিল (খুব নিম্নমানের), আমি সন্দেহ করি কারণ এতে কোনও ব্যাখ্যা বা অদম্য সংস্করণ নেই, যা এখানে আদর্শ। ধরে নিলাম আপনার উত্তরটি কাজ করে, এবং আপনি এটি "কেবল কোড" হতে উন্নতি করেছেন, এটি বেশ ভাল বলে মনে হচ্ছে!

— বিড়াল

range(0,10)হতে পারে range(10)।

— lirtosiast

Answer 7

সিজেম, 21 19 বাইট

ri,s_,A,s@fe=+:m!:/

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

ব্যাখ্যা

ri   e# Read input and convert to integer N.
,    e# Get a range [0 1 ... N-1].
s    e# Convert to string, flattening the range.
_,   e# Duplicate and get its length.
A,s  e# Push "012345789".
@fe= e# Pull up the other copy of the string and count the occurrences of each digit.
+    e# Prepend the string length.
:m!  e# Compute the factorial of each of them.
:/   e# Fold division over the list, dividing the factorial of the length by all the other
     e# factorials.

Answer 8

জাভাস্ক্রিপ্ট (ES6), 100

n=>(f=[...[...Array(n).keys()].join``].map(c=>(k[c]=~-k[c],p*=i++),i=p=1,k=[]),k.map(v=>p/=f[~v]),p)

পরীক্ষা

F=n=>(f=[...[...Array(n).keys()].join``].map(c=>(k[c]=~-k[c],p*=i++),i=p=1,k=[]),k.map((v,i)=>p/=f[~v]),p)

// Less golfed
U=n=>( // STEP 1, count digits, compute factorials
      f= // will contain the value of factorials 1 to len of digits string
      [...[...Array(n).keys()].join``] // array of cancatenated digits
      .map(c=> // execute the following for each digit
           (
            k[c]=~-k[c], // put in k[c] the repeat count for digit c, negated 
            p*=i++       // evaluate factorial, will be stored in f
           ),i=p=1,k=[]),// initialisations
       // at the end of step 1 we have all factorials if f and max factorial in p
       // STEP 2, divide the result taking into account the repeated digits
      k.map(v=>p/=f[~v]), // for each digit, divide p by the right factorial (~v === -v-1)
  p // return result in p
) 

// Test
console.log=x=>O.textContent+=x+'\n'

for(j=0;j<=15;j++) console.log(j+' '+F(j))

<pre id=O></pre>

Comments

k[c]=~-k[c]প্রতিশব্দ নয় --k[c]?

— usandfriends

@ ইউসুফ বন্ধুরা না, যখন কে [সি] অপরিবর্তিত রয়েছে - কে [সি] হয় এনএন

— এডি 6565

ওহ, ফ্যাকটোরিয়ালগুলির দুর্দান্ত অ্যারে।

— নীল

... যদিও আপনার এটির দরকার নেই। আমার সর্বশেষ আপডেট দেখুন।

— নীল

Answer 9

পাইথ, 18 বাইট

/F.!M+lJ.njRTQ/LJT

অনলাইনে চেষ্টা করুন: বিক্ষোভ

/F.!M+lJ.njRTQ/LJT   implicit: Q = input number
          jRTQ       convert each number in [0, ..., Q-1] to their digits
        .n           flatten to a single list
       J             store this list in J
              /LJT   for each digit count the number of appearances in J
     +lJ             prepend the length of J
  .!M                compute the factorial for each number
/F                   fold by division

Answer 10

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

import Data.List
h n|l<-sort$show=<<[0..n-1]=foldl1 div$product.map fst.zip[1..]<$>l:group l

ব্যবহারের উদাহরণ: h 12-> 1816214400।

কিভাবে এটা কাজ করে

l<-sort$show=<<[0..n-1]       -- bind l to the sorted concatenated string
                              -- representations of the numbers from 0 to n-1
                              -- e.g. n=12 -> "00111123456789"

               l: group l     -- group the chars in l and put l itself in front
                              -- e.g. ["00111123456789","00","1111","2",..."9"]
            <$>               -- map over this list
    product.map fst.zip[1..]  -- the faculty the length of the sublist (see below)  
                              -- e.g. [87178291200,2,24,1,1,1,..,1]
foldl1 div                    -- fold integer division from the left into this list
                              -- e.g. 87178291200 / 2 / 24 / 1

                              -- Faculty of the length of a list:
                  zip[1..]    -- make pairs with the natural numbers
                              -- e.g. "1111" -> [(1,'1'),(2,'1'),(3,'1'),(4,'1')]
          map fst             -- drop 2nd element form the pairs
                              -- e.g. [1,2,3,4]
  product                     -- calculate product of the list

Answer 11

সি, 236 174 138 121 বাইট

বাইটগুলি হ্রাস করার জন্য ধনীদের কাছে অনেক ক্রেডিট।

long long d,f=1;j,s=1,n,b[10]={1};main(d){for(scanf("%d",&n);n--;)for(j=n;j;j/=10,f*=++s)d*=++b[j%10];printf("%Ld",f/d);}

Ungolfed

long long d,f=1;
j,s=1,n,b[10]={1};

main(d)
{
    scanf("%d",&n); /* get input */
    for(;n--;) /* iterate through numbers... */
        for(j=n;j;j/=10,f*=++s) /* iterate through digits, sum up and factorial */
            d*=++b[j%10]; /* count and factorial duplicates */
    printf("%Ld",f/d); /* print out result */
}

এখানে চেষ্টা করুন ।

Comments

আপনি -lm এর সাথে ঘৃণা না করে 43 অক্ষর সংরক্ষণ করতে পারেন। অঙ্কগুলি যেমন আপনি খুঁজে পান কেবল তা গণনা করুন:#define L long long L d;i,j,k,m,n,s=1,b[10]={1};L f(n){return n?n*f(n-1):1;}main(d){for(scanf("%d",&n);i<n;)for(j=i++;j;j/=10)++b[j%10],++s;for(;m<10;)d*=f(b[m++]);printf("%Ld",f(s)/d);}

— ধনী

আপনি সেগুলি লুপে গণনা করতে পারেন যেখানে আপনি গণনা করেন: for(;m<10;)s+=b[m],d*=f(b[m++])তবে আমি মনে করি এটি আরও কয়েকটি বাইট।

— ধনী

উজ্জ্বল। আমি আমার বর্তমান গল্ফ প্রচেষ্টা এবং সম্পাদনার সাথে একত্রিত করব।

— কোল ক্যামেরন

সুন্দর: খাঁটি গণনাটিকে মূল লুপে কীভাবে সংহত করতে হয় তা দেখতে আমার একবার নজর দিন, যা আপনার যদি স্বেচ্ছাচারিতা-নির্ভুলতা পাটিগণিত না থাকে তবে কিছুটা বড় পরিসরে কাজ করার সুবিধা রয়েছে। আমার মনে হয় শেভ করার জন্য এটি আরও 20 বাইট।

— রিচি

Answer 12

সি / বিসি, 233 121 112 বাইট (এর জন্য 3 বাইট জরিমানা ধরে |bc)

1. কোল ক্যামেরনের দ্বারা অনুপ্রাণিত হয়ে হ্যাকি চরিত্রের ম্যানিপুলেশন সরানো হয়েছে এবং আর্গুমেন্টের মানটিতে পাটিগণিত করুন।

2. আরগ ভেক্টর ব্যবহার থেকে স্ক্যানফে পরিবর্তন করা হয়েছে।

   C[10]={1},n=1,k,t;main(){for(scanf("%d",&k);k--;)for(t=k;t;t/=10)printf("%d/%d*",++n,++C[t%10]);puts("1");}
   

চাহিদা bcআসলে অবাধ স্পষ্টতা গণনার না।

নিরবচ্ছিন্ন এবং সতর্কতা বিনামূল্যে:

#include <stdio.h>
int main() {
  int C[10]={1},n=1,k,t;    /* 0 is special-cased */
  for(scanf("%d",&k);k--;)  /* For each integer less than k */
    for(int t=k;t;t/=10)    /* For each digit in t */
      printf("%d/%d*",++n,++C[t%10]);  /* Incremental choice computation */
  puts("1");                /* Finish the expression */
}

সচিত্র (যা আমি বিশ্বাস করি অ্যালগরিদম দেখায়):

$ for i in {0..15} 100 ; do printf %4d\  $i;./cg70892g<<<$i;done
   0 1
   1 1
   2 2/1*1
   3 2/1*3/1*1
   4 2/1*3/1*4/1*1
   5 2/1*3/1*4/1*5/1*1
   6 2/1*3/1*4/1*5/1*6/1*1
   7 2/1*3/1*4/1*5/1*6/1*7/1*1
   8 2/1*3/1*4/1*5/1*6/1*7/1*8/1*1
   9 2/1*3/1*4/1*5/1*6/1*7/1*8/1*9/1*1
  10 2/1*3/1*4/1*5/1*6/1*7/1*8/1*9/1*10/1*1
  11 2/1*3/2*4/1*5/1*6/1*7/1*8/1*9/1*10/1*11/1*12/2*1
  12 2/1*3/2*4/3*5/2*6/1*7/1*8/1*9/1*10/1*11/1*12/1*13/1*14/4*1
  13 2/1*3/1*4/2*5/3*6/4*7/2*8/1*9/1*10/1*11/1*12/1*13/1*14/1*15/2*16/5*1
  14 2/1*3/1*4/2*5/1*6/3*7/4*8/5*9/2*10/1*11/1*12/1*13/1*14/1*15/1*16/2*17/2*18/6*1
  15 2/1*3/1*4/2*5/1*6/3*7/1*8/4*9/5*10/6*11/2*12/1*13/1*14/1*15/1*16/1*17/2*18/2*19/2*20/7*1
 100 2/1*3/2*4/3*5/1*6/4*7/1*8/5*9/1*10/6*11/1*12/7*13/1*14/8*15/1*16/9*17/1*18/10*19/1*20/11*21/2*22/2*23/12*24/3*25/4*26/5*27/2*28/6*29/2*30/7*31/2*32/8*33/2*34/9*35/2*36/10*37/2*38/11*39/2*40/12*41/3*42/3*43/13*44/4*45/13*46/5*47/6*48/7*49/3*50/8*51/3*52/9*53/3*54/10*55/3*56/11*57/3*58/12*59/3*60/13*61/4*62/4*63/14*64/5*65/14*66/6*67/14*68/7*69/8*70/9*71/4*72/10*73/4*74/11*75/4*76/12*77/4*78/13*79/4*80/14*81/5*82/5*83/15*84/6*85/15*86/7*87/15*88/8*89/15*90/9*91/10*92/11*93/5*94/12*95/5*96/13*97/5*98/14*99/5*100/15*101/6*102/6*103/16*104/7*105/16*106/8*107/16*108/9*109/16*110/10*111/16*112/11*113/12*114/13*115/6*116/14*117/6*118/15*119/6*120/16*121/7*122/7*123/17*124/8*125/17*126/9*127/17*128/10*129/17*130/11*131/17*132/12*133/17*134/13*135/14*136/15*137/7*138/16*139/7*140/17*141/8*142/8*143/18*144/9*145/18*146/10*147/18*148/11*149/18*150/12*151/18*152/13*153/18*154/14*155/18*156/15*157/16*158/17*159/8*160/18*161/9*162/9*163/19*164/10*165/19*166/11*167/19*168/12*169/19*170/13*171/19*172/14*173/19*174/15*175/19*176/16*177/19*178/17*179/18*180/19*181/10*182/20*183/20*184/20*185/20*186/20*187/20*188/20*189/20*190/20*1

এবং, বিসি মাধ্যমে পাইপ সহ (এবং এফ (1000) এর গণনা যোগ করুন:

$ time for i in {0..15} 100 1000; do printf "%4d " $i;./cg70892g<<<$i|bc;done
   0 1
   1 1
   2 2
   3 6
   4 24
   5 120
   6 720
   7 5040
   8 40320
   9 362880
  10 3628800
  11 119750400
  12 1816214400
  13 43589145600
  14 1111523212800
  15 30169915776000
 100 89331628085599251432057142025907698637261121628839475101631496666431\
15835656928284205265561741805657733401084399630568002336920697364324\
98970890135552420133438596044287494400000000
1000 45200893173828954313462564749564394748293201305047605660842814405721\
30092686078003307269244907986874394907789568742409099103180981532605\
76231293886961761709984429587680151617686667512237878219659252822955\
55855915137324368886659115209005785474446635212359968384367827713791\
69355041534558858979596889046036904489098979549000982849236697235269\
84664448178907805505235469406005706911668121136625035542732996808166\
71752374116504390483133390439301402722573240794966940354106575288336\
39766175522867371509169655132556575711715087379432371430586196966835\
43089966265752333684689143889508566769950374797319794056104571082582\
53644590587856607528082987941397113655371589938050447115717559753757\
79446152023767716192400610266474748572681254153493484293955143895453\
81280908664541776100187003079567924365036116757255349569574010994259\
42252682660514007543791061446917037576087844330206560326832409035999\
90672829766080114799705907407587600120545365651997858351981479835689\
62520355320273524791310387643586826781881487448984068291616884371091\
27306575532308329716263827084514072165421099632713760304738427510918\
71188533274405854336233290053390700237606793599783757546507331350892\
88552594944038125624374807070741486495868374775574664206439929587630\
93667017165594552704187212379733964347029984154761167646334095514093\
41014074159155080290000223139198934433986437329522583470244030479680\
80866686589020270883335109556978058400711868633837851169536982150682\
22082858700246313728903459417761162785473029666917398283159071647546\
25844593629926674983035063831472139097788160483618679674924756797415\
01543820568689780263752397467403353950193326283322603869951030951143\
12095550653333416019778941123095611302340896001090093514839997456409\
66516109033654275890898159131736630979339211437991724524614375616264\
98121300206207564613016310794402755159986115141240217861695468584757\
07607748055900145922743960221362021598547253896628914921068009536934\
53398462709898222067305585598129104976359039062330308062337203828230\
98091897165418693363718603034176658552809115848560316073473467386230\
73804128409097707239681863089355678037027073808304307450440838875460\
15170489461680451649825579772944318869172793737462142676823872348291\
29912605105826175323042543434860948610529385778083808434502476018689\
05150440954486767102167489188484011917026321182516566110873814183716\
30563399848922002627453188732598763510259863554716922484424965400444\
85477201353937599094224594031100637903407963255597853004241634993708\
88946719656130076918366596377038503741692563720593324564994191848547\
42253991635763101712362557282161765775758580627861922528934708371322\
38741942406807912441719473787691540334781785897367428903185049347013\
44010772740694376407991152539070804262207515449370191345071234566501\
33117923283207435702471401696679650483057129117719401161591349048379\
16542686360084412816741479754504459158308795445295721744444794851033\
08800000000

real    0m0.246s
user    0m0.213s
sys     0m0.055s

এই গণনা করা F (5000) - একটি 18,592-সংখ্যা সংখ্যা - 10 সেকেন্ডের মধ্যে।

$ time ./cg70892g3<<<5000|BC_LINE_LENGTH=0 bc|wc -c
18593

real    0m9.274s
user    0m9.273s
sys     0m0.005s

Answer 13

পার্ল 6, 117 বাইট

say $_ <2??1!!permutations(+[(my@n=^$_ .join.comb)]).elems÷[*] ([*] 2..$_ for @n.classify(&unique).values)for lines

এবং আরও পঠনযোগ্য fars মধ্যে

for (lines) -> $number {
    say 1 and next if $number < 2;
    my @digits = (^$number).join.comb;
    my @duplicates = @digits.classify(&unique).values;
    my $unique_permutations = permutations(+@digits).elems ÷ [*] ([*] 2..$_ for @duplicates);
    say $unique_permutations;
}

Answer 14

পার্ল 5, 108 বাইট

sub f{eval join"*",@_,1}push@a,/./g for 0..<>-1;for$i(0..9){$b[$i]=grep/$i/,@a}say f(1..@a)/f map{f 1..$_}@b

আমাকে 17 বাইট বাঁচানোর জন্য দেব-নাল এবং ফ্যাক্টরিয়াল আইডিয়াটির জন্য জাপিকে অনেক ধন্যবাদ ।

Answer 15

05 এ বি 1 ই , 13 12 11 বাইট

ÝD¨SāPr¢!P÷

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

Ý             # range [0..input]
 D            # duplicate
  ¨           # drop the last element
   S          # split into digits
    ā         # length range: [1..number of digits]
     P        # product (effectively a factorial)
      r       # reverse the stack
       ¢      # count occurences of each number in the list of digits
        !     # factorial of each count
         P    # product of those
          ÷   # divide the initial factorial by this product

Answer 16

পাইথন 2 , 123 বাইট

import math
i,b,F="".join(map(str,range(input()))),1,math.factorial
for x in range(10):b*=F(i.count(`x`))
print F(len(i))/b

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

1. ইনপুটটির rangeএকক স্ট্রিংয়ে রূপান্তর করুন
2. 0 থেকে 9 পর্যন্ত প্রতিটি সংখ্যার কতবার স্ট্রিংয়ে উপস্থিত হয় তা পরীক্ষা করে দেখুন এবং প্রতিটিটির জন্য ফ্যাক্টরিয়াল পাবেন তারপরে তাদের একসাথে গুণ করুন
3. পদক্ষেপ 2 এ গণনা করা স্ট্রিংয়ের দৈর্ঘ্যের ফ্যাক্টরিয়ালটি ভাগ করুন Div

Answer 17

পাওয়ারশেল, 125 বাইট

(1..(($b=0..($args[0]-1)-join'').Length)-join'*'|iex)/((0..9|%{$c=[regex]::Matches($b,$_).count;1..($c,1)[!$c]})-join'*'|iex)

ইনপুট নেয় $args[0], বিয়োগ 1করে 0..that সংখ্যাটি থেকে বহুসংখ্যক পূর্ণসংখ্যা তৈরি করে , -joinযা একত্রে একটি স্ট্রিংয়ে রূপান্তর করে এবং এর হিসাবে সংরক্ষণ করে $b। আমরা .Lengthসেই স্ট্রিংটি নিয়ে থাকি 1.., -joinসেই দৈর্ঘ্য থেকে অন্য পরিসর তৈরি করি, সেই সংখ্যার সাথে একত্রে *, তারপরে পাইপটি Invoke-Expression(অনুরূপ eval)। অন্য কথায়, আমরা ইনপুটটির উপর ভিত্তি করে সংখ্যা ক্রমের দৈর্ঘ্যের ফ্যাক্টরিয়ালটি তৈরি করেছি। এটি আমাদের সংখ্যা

আমরা এটি /দ্বারা বিভক্ত ...

আমাদের হর, যা একটি সীমার গ্রহণ দ্বারা সংস্থাপিত হয় 0..9এবং একটি জন্য-লুপের মাধ্যমে এটি পাঠানোর |%{...}। প্রতিটি পুনরাবৃত্তি, আমরা গুণমানের সাথে মিলিত .NET কলকে ধন্যবাদ হিসাবে $cবর্তমান সংখ্যাটি যে পরিমাণ $_প্রদর্শিত হবে তার সমানভাবে একটি সহায়ক ভেরিয়েবল সেট করি । তারপরে আমরা সেই মান পর্যন্ত একটি নতুন পরিসর তৈরি করি, যতক্ষণ এটি শূন্য নয় non হ্যাঁ, অনেক ক্ষেত্রে, এর ফলে একটি পরিসীমা তৈরি হবে , যা কেবলমাত্রে মূল্যায়ন করে । আমরা সেগুলি এবং তাদের সকলকে সাথে এক সাথে রাখি, তারপরে আবার পাইপ করুন । অন্য কথায়, আমরা প্রতিটি সংখ্যার সংখ্যার সংখ্যার ফ্যাক্টরিয়ালগুলির পণ্যটি তৈরি করেছি।$b[regex]::matches.count1..1..11-join*Invoke-Expression

---

বিশেষ দ্রষ্টব্য

90কোনও ইস্যু ছাড়াই এবং এক সেকেন্ডের চেয়ে উল্লেখযোগ্যভাবে কম ইনপুট হ্যান্ডেল করে ।

PS C:\Tools\Scripts\golfing> .\rearranging-the-sequence.ps1 90
1.14947348910454E+159

PS C:\Tools\Scripts\golfing> Measure-Command {.\rearranging-the-sequence.ps1 90} | FL TotalMilliseconds
TotalMilliseconds : 282.587

... এর বাইরেও Infinityআউটপুট হিসাবে ফলাফল দেখা যায়, যেহেতু অনুমতিযোগ্য স্ট্রিংয়ের দৈর্ঘ্য 170!যার ফলে doubleডেটাটাইপ ( 7.25741561530799E+306) এ ফিট হয় তবে 171!তা হয় না। PowerShell রয়েছে ... ছল ... স্বয়ংক্রিয়ভাবে থেকে আপ-কাস্ট [int]করার [double]ওভারফ্লো ক্ষেত্রে (উপলব্ধ আপনি স্পষ্টভাবে পরিবর্তনশীল দিয়ে শুরু কাস্ট করা হয়নি)। না, আমি জানি না কেন এটি [long]পূর্ণসংখ্যার মানগুলিতে যায় না।

যদি আমরা কিছু স্পষ্টত কাস্টিং এবং হেরফের করি (যেমন, [uint64]স্বাক্ষরযুক্ত স্বাক্ষরিত 64৪-বিট পূর্ণসংখ্যার জন্য ব্যবহার করে ), আমরা এটি আরও উচ্চতর পেতে পারতাম, তবে এটি কোডটি উল্লেখযোগ্যভাবে ফুলে উঠবে কারণ আমাদের শর্তসাপেক্ষে ১ 170০-দৈর্ঘ্য বিস্তৃত করতে হবে এবং তারপরে পুনঃস্থাপন করতে হবে সেখান থেকে প্রতিটি গুণ চ্যালেঞ্জটি কোনও উচ্চতর পরিসীমা নির্দিষ্ট করে না বলে, আমি এটি পর্যাপ্ত বলে ধরে নিচ্ছি।

Answer 18

Perl6

perl6 -e 'sub p ($a) { my $x = $a.join.comb.classify(+*).values.map(*.elems).classify(+*).values.flatmap(*.list).flatmap((2..+*).list); my $y = 2..$a[*-1]; [/] $x.list * [*] $y.list }; p([1..11]).say'

বরং এই মুহূর্তে ungolfed - এখন ঘুম প্রয়োজন।

Answer 19

গ্রোভী, 156 বাইট

def f(n){def s=(0..n-1).join('')
0==n?1:g(s.size())/s.inject([:]){a,i->a[i]=a[i]?a[i]+1:1;a}*.value.inject(1){a,i->a*g(i)}}
BigInteger g(n){n<=1?1:n*g(n-1)}

আমার নম্র প্রথম কোড গল্ফ সমাধান। আপনি এটি এখানে পরীক্ষা করতে পারেন।

এবং এখানে আরও পাঠযোগ্য সংস্করণ:

def f(n) {
  def s = (0..n - 1).join('')                       // Store our concatented range, s
  0 == n ? 1 :                                      // Handle annoying case where n = 0
    fact(s.size()) / s.inject([:]) {                // Divide s.size()! by the product of the values we calculate by...
      a, i ->                                       // ...reducing into a map...
        a[i] = a[i] ? a[i] + 1 : 1                  // ...the frequency of each digit
        a                                           // Our Groovy return statement
    }*.value.inject(1) { a, i -> a * fact(i) }      // Finally, take the product of the factorial of each frequency value
}

BigInteger fact(n) { n <= 1 ? 1 : n * fact(n - 1) } // No built-in factorial function...

বেশ সোজা, তবে আমার জন্য বেশ কয়েকটি হাইলাইট ছিল:

• একটি উদ্বুদ্ধ পারফর্মিং / একটি অ্যারে থেকে কমাতে charsএকটি থেকে Map<Character, Integer>। মানচিত্রের মানগুলির জন্য একটি ডিফল্ট মান না থাকায় এটি এখনও কিছুটা জটিল ছিল। এই সন্দেহটি এটি সম্ভব, তবে মানচিত্রটি যদি সমস্ত মানকে 0 এ ডিফল্ট করে দেয় তবে আমি এনপিই এড়াতে প্রয়োজনীয় ত্রৈমাসিকটি এড়াতে পারি।

• গ্রোভি স্প্রেড অপারেটর (উদাঃ }*.value) ব্যবহার করা সর্বদা মজাদার

বিরক্তিকর বৈশিষ্ট্যটিতে, তবে রিটার্নের ধরণের সাথে ফ্যাক্টরিয়াল ফাংশনটি ঘোষণা করার প্রয়োজনীয়তা ছিল BigInteger। আমি এই ছাপে ছিলাম যে গ্রোভি সমস্ত সংখ্যার মধ্যে BigIntegerবা জড়ো করে রেখেছিলেন BigDecimal, তবে ফেরতের প্রকারের ক্ষেত্রে এটি এমনটি হতে পারে না। আমাকে আরও পরীক্ষা করতে হবে। এই রিটার্নের ধরণটি স্পষ্টভাবে বর্ণিত না করে আমরা খুব দ্রুত ভুল ফ্যাক্টরিয়াল মান পেতে পারি।

Answer 20

জে, 33 বাইট

(#(%*/)&:!&x:#/.~)@([:;<@":"0)@i.

পরিসীমাটিকে অঙ্কের একটি স্ট্রিংয়ে রূপান্তর করে, প্রতিটি অঙ্ককে গণনা করে এবং ফলাফলটি গণনার জন্য বহু-জাতীয় সহগ প্রয়োগ করে।

ব্যবহার

   f =: (#(%*/)&:!&x:#/.~)@([:;<@":"0)@i.
   (,.f"0) i. 16
 0              1
 1              1
 2              2
 3              6
 4             24
 5            120
 6            720
 7           5040
 8          40320
 9         362880
10        3628800
11      119750400
12     1816214400
13    43589145600
14  1111523212800
15 30169915776000

Answer 21

আর, 118 বাইট

পার্টিতে প্রায় 8 মাস দেরি হলেও ভেবেছিলাম আমি এটিকে এগিয়ে দেব কারণ এটি আকর্ষণীয় চ্যালেঞ্জের মতো দেখাচ্ছে।

function(n,x=as.numeric(el(strsplit(paste(1:n-1,collapse=""),""))),F=factorial)`if`(n,F(sum(1|x))/prod(F(table(x))),1)

এটি আর-ফিডেলে চেষ্টা করুন

ব্যাখ্যা

1. ভেক্টর জেনারেট করুন 0 ... n-1এবং এটিকে একটি স্ট্রিংয়ে সঙ্কুচিত করুন :paste(1:n-1,collapse="")
2. স্ট্রিংটিকে তার অঙ্কগুলিতে বিভক্ত করুন এবং সংখ্যায় রূপান্তর করুন (স্টোর হিসাবে x):x=as.numeric(el(strsplit(...,"")))
3. অঙ্কের গণনা করার জন্য আমরা কেবল factorial(sum(1|x))এটিই করি যা সঠিক#digits!

4. ডিনোমিনেটর গণনা করার জন্য আমরা tableফ্রিকোয়েন্সিগুলির তালিকা তৈরি করে এমন একটি কন্টিনজেন্সি টেবিল তৈরি করতে ব্যবহার করি । F (12) এর ক্ষেত্রে তৈরি করা সারণীটি হ'ল:

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

5. যার অর্থ আমরা factorial()গণনাতে (যা উপায় দ্বারা ভেক্টরাইজড) ব্যবহার করতে পারি এবং কেবল পণ্যটি নিতে পারি:prod(factorial(table(x)))

দ্রষ্টব্য: 4 এবং 5 ধাপ কেবল তখনই চালিত হয় যদি n>0অন্যথায় ফিরে আসে 1।

Answer 22

গণিত, 65 বাইট

(Tr@IntegerLength[a=Range@#-1]+1)!/Times@@(Total[DigitCount@a]!)&

সম্ভবত আরও গল্ফ করা যেতে পারে।

Answer 23

রুবি , 64 বাইট

->n,*w{a=1;[*0...n].join.chars{|d|a=a*(w<<d).size/w.count(d)};a}

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

Answer 24

স্ট্যাক্স , 12 বাইট

éÄ\↑≈g→FP○░→

এটি চালান এবং এটি স্ট্যাক্সএল.এক্সজে ডিবাগ করুন!

প্যাকযুক্ত (14 বাইট) এবং ব্যাখ্যা:

r$c%|Fso:GF|F/
r                 Range [0..input)
 $                Stringify each and concat
  c               Copy atop the stack
   %|F            Factorial of length
      s           Swap original back to top
       o          Sort
        :G        Run lengths
          F       For each:
           |F       Factorial
             /      Divide running quotient by this factorial
                  Implicit print

Answer 25

জেলি , 11 বাইট

গল্ফড ডেনিসের 15 বাইট জেলি উত্তর ...

ḶDFµW;ĠẈ!:/

একটি মোনাডিক লিঙ্ক একটি অ-নেতিবাচক পূর্ণসংখ্যাকে গ্রহণ করে যা ইতিবাচক পূর্ণসংখ্যার ফলন করে।

এটি অনলাইন চেষ্টা করুন! অথবা পরীক্ষা স্যুট দেখুন ।

কিভাবে?

ḶDFµW;ĠẈ!:/ - Link: non-negative integer, N   e.g. 12
Ḷ           - lowered range            [0,1,2,3,4,5,6,7,8,9,10,11]
 D          - to decimal (vectorises)  [[0],[1],[2],[3],[4],[5],[6],[7],[8],[9],[1,0],[1,1]]
  F         - flatten                  [0,1,2,3,4,5,6,7,8,9,1,0,1,1]
   µ        - start a new monadic chain - i.e. f(that)
    W       - wrap in a list           [[0,1,2,3,4,5,6,7,8,9,1,0,1,1]]
      Ġ     - group indices by values  [[1,12],[2,11,13,14],3,4,5,6,7,8,9,10]
     ;      - concatenate              [[0,1,2,3,4,5,6,7,8,9,1,0,1,1],[1,12],[2,11,13,14],3,4,5,6,7,8,9,10]
       Ẉ    - length of each           [14,2,4,1,1,1,1,1,1,1,1]
        !   - factorial (vectorises)   [87178291200,2,24,1,1,1,1,1,1,1,1]
          / - reduce by:
         :  -   integer division       1816214400

Answer 26

পাইথন 2 , 190 বাইট

from collections import*
g,n=range,int(input())
p=lambda r:reduce(lambda x,y:x*y,r,1)
f=lambda n:p(g(1,n+1))
s=''.join(str(i)for i in g(n))
c=Counter(s)
print(f(len(s))/p(f(c[i])for i in c))

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

Answer 27

পাইথন 2 , 134 বাইট

s="".join(map(str,range(input())))
n=d=1
for i in range(1,len(s)+1):n*=i;d*=i**len([c for c in range(10)if s.count(`c`)>=i])
print n/d

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

একটি বিকল্প পদ্ধতির ...