Giới thiệu

Hãy quan sát chuỗi sau (số nguyên không âm):

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

Ví dụ: hãy lấy ba số đầu tiên . Đây là 0, 1, 2. Các số được sử dụng trong chuỗi này có thể được sắp xếp theo sáu cách khác nhau:

012   120
021   201
102   210

Vì vậy, hãy nói rằng F (3) = 6 . Một ví dụ khác là F (12) . Điều này chứa các số:

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

Hoặc phiên bản nối:

01234567891011

Để tìm số cách sắp xếp lại thứ này, trước tiên chúng ta cần xem xét độ dài của chuỗi này. Độ dài của chuỗi này là 14. Vì vậy, chúng tôi tính toán 14! . Tuy nhiên, ví dụ những người có thể trao đổi địa điểm mà không làm gián đoạn chuỗi cuối cùng. Có 2 số không, vì vậy có 2! cách để hô hào các số 0 mà không làm gián đoạn trật tự. Cũng có 4 cái, nên có 4 cái! cách để chuyển đổi những cái. Chúng tôi chia tổng số cho hai số này:

Cái này có 14! / (4! × 2!) = 1816214400 cách sắp xếp chuỗi 01234567891011. Vậy ta có thể kết luận rằng F (12) = 1816214400 .

Nhiệm vụ

Cho N , đầu ra F (N) . Đối với những người không cần giới thiệu. Để tính F (N), trước tiên chúng ta ghép nối các số nguyên không âm N đầu tiên (ví dụ: N = 12, chuỗi được nối sẽ là 01234567891011) và tính số cách sắp xếp chuỗi này.

Các trường hợp thử nghiệm

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

chú thích

Việc tính toán câu trả lời phải được tính toán trong thời gian giới hạn là 10 giây , vũ phu không được phép .

Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!

Thạch, 17 15 byte

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

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc .

Làm thế nào nó hoạt động

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.

ES6, 118 81 78 byte

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

Ai đó buộc phải nói với tôi rằng có một cách ngắn hơn để nối các số lên đến n.

Đã tiết kiệm được 37 byte bằng cách lấy ý tưởng của @ edc65 và chạy nó trên steroid. (Lưu thêm một byte bằng cách sử dụng '|' thay vì &&nhưng điều đó giới hạn kết quả ở mức 31 bit.)

Chỉnh sửa: Đã lưu thêm 3 byte nữa nhờ @ edc65.

APL (Dyalog Extended) , 13 byte

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

Hãy thử trực tuyến!

Một chương trình đầy đủ. Công dụng ⎕IO←0.

Làm thế nào nó hoạt động

×/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

Tính toán đa phương xuất phát từ thực tế sau:

MATL , 21 byte

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

Hãy thử trực tuyến!

Giải trình

: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

Python 2, 142 137 101 97 byte

(Cảm ơn @adnan đã gợi ý về input)

(Áp dụng tính toán tăng dần từ phiên bản C )

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

Phiên bản gốc sử dụng giai thừa

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

Thực sự, việc chơi golf duy nhất ở trên là gọi math.factorial Fvà để lại một số khoảng trống, vì vậy có lẽ có một giải pháp python ngắn hơn.

Nếu cần giải thích, vduy trì số lượng tần số của mỗi chữ số; số lượng được cập nhật cho mỗi chữ số trong mỗi số trong phạm vi được chỉ định.

Trong phiên bản gốc, chúng tôi tính toán số lượng hoán vị bằng cách sử dụng công thức tiêu chuẩn (Σf _i )! / Π (f _i !). Đối với phiên bản hiện tại, việc tính toán này được thực hiện tăng dần bằng cách phân phối các bội số và chia khi chúng ta thấy các chữ số. Có thể không rõ ràng rằng phép chia số nguyên sẽ luôn chính xác, nhưng có thể dễ dàng chứng minh dựa trên quan sát rằng mỗi phép chia kphải theo kbội số của các số nguyên liên tiếp, do đó, một trong các số nhân đó phải chia hết chok . (Đó là một trực giác, không phải là bằng chứng.)

Phiên bản gốc nhanh hơn cho các đối số lớn vì nó chỉ chia 10 bignum. Mặc dù việc chia một bignum cho một số nguyên nhỏ nhanh hơn so với việc chia một bignum cho một bignum, khi bạn có hàng ngàn bignum chia, nó có một chút chậm chạp.

Python 2, 197 Byte (chỉnh sửa: đã lưu 4 byte, cảm ơn Thomas Kwa!)

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

Ung dung:

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

CJam, 21 19 byte

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

Kiểm tra nó ở đây.

Giải trình

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.

JavaScript (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)

Kiểm tra

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>

Bình thường, 18 byte

/F.!M+lJ.njRTQ/LJT

Dùng thử trực tuyến: Trình diễn

/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

Haskell, 92 byte

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

Ví dụ sử dụng: h 12-> 1816214400.

Làm thế nào nó hoạt động

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

C, 236 174 138 121 byte

Nhiều tín dụng cho rici, để giảm rất nhiều byte.

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);}

Bị đánh cắp

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 */
}

Hãy thử nó ở đây .

C / bc, 233 121 112 byte (giả sử hình phạt 3 byte cho |bc)

1. Lấy cảm hứng từ Cole Cameron, loại bỏ các thao tác nhân vật hacky và chỉ làm số học về giá trị đối số.

2. Thay đổi để scanf từ sử dụng vector arg.

   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");}
   

Cần bcphải thực sự tính toán chính xác tùy ý.

Ungolfed và cảnh báo miễn phí:

#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 */
}

Minh họa (mà tôi tin tưởng cho thấy thuật toán):

$ 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

Và, với đường ống qua bc (và thêm tính toán của F (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

Điều này đã tính F (5000) - một số 18.592 chữ số - trong vòng dưới 10 giây.

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

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

Perl 6, 117 byte

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

và trong một fading dễ đọc hơn

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;
}

Perl 5, 108 byte

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

Rất cám ơn dev-null đã tiết kiệm cho tôi 17 byte và để japhy cho ý tưởng giai thừa.

05AB1E , 13 12 11 byte

ÝD¨SāPr¢!P÷

Hãy thử trực tuyến!

Ý             # 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

Python 2 , 123 byte

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

Hãy thử trực tuyến!

1. Chuyển đổi range đầu vào thành một chuỗi
2. Kiểm tra số lần mỗi số từ 0 đến 9 xuất hiện trong chuỗi và lấy giai thừa cho từng số sau đó nhân chúng với nhau
3. Chia giai thừa của độ dài của chuỗi cho số được tính trong bước 2

PowerShell, 125 byte

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

Lấy đầu vào $args[0], trừ 1, xây dựng một loạt các số nguyên từ0.. số đó, -joinkết hợp thành một chuỗi và lưu nó dưới dạng $b. Chúng tôi lấy .Lengthchuỗi đó, xây dựng một phạm vi khác từ 1..độ dài đó, -joincác số nguyên đó cùng với *, sau đó chuyển sang chuỗi đóInvoke-Expression (tương tự nhưeval ). Nói cách khác, chúng tôi đã xây dựng giai thừa của độ dài của dãy số dựa trên đầu vào. Đó là tử số của chúng tôi.

Chúng tôi chia / ...

Mẫu số của chúng tôi, được xây dựng bằng cách lấy một phạm vi 0..9và gửi nó qua một vòng lặp for |%{...}. Mỗi lần lặp, chúng ta đặt một biến của trình trợ giúp $cbằng số lần chữ số hiện tại $_xuất hiện bên trong $bnhờ vào lệnh gọi .NET được[regex]::matches kết hợp với .countthuộc tính. Sau đó chúng tôi xây dựng một phạm vi mới từ1.. tối đa giá trị đó, miễn là nó khác không. Có, trong nhiều trường hợp, điều này sẽ dẫn đến một phạm vi 1..1, đánh giá chỉ 1. Chúng tôi mang tất cả những thứ đó và -joinchúng cùng với nhau *, sau đó chuyển nó sang Invoke-Expressionmột lần nữa. Nói cách khác, chúng tôi đã xây dựng sản phẩm của các yếu tố về số lần xuất hiện của mỗi chữ số.

Lưu ý

Xử lý đầu vào lên đến 90mà không có vấn đề và trong ít hơn đáng kể một giây.

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

... vượt quá kết quả đó Infinitylà đầu ra, vì độ dài của chuỗi cho phép dẫn đến kết quả 170!phù hợp với doublekiểu dữ liệu ( 7.25741561530799E+306), nhưng 171!không. PowerShell có một ... trò chơi ... tự động khởi động từ[int] để [double]trong trường hợp tràn bộ nhớ (với điều kiện bạn không rõ ràng đúc biến để bắt đầu). Không, tôi không biết tại sao nó không đi đến[long] các giá trị nguyên.

Nếu chúng tôi thực hiện một số thao tác đúc và thao tác rõ ràng (ví dụ: bằng cách sử dụng [uint64]các số nguyên 64 bit không dấu), chúng tôi có thể tăng cao hơn, nhưng nó sẽ làm phồng mã đáng kể vì chúng tôi sẽ cần phải kéo dài đến 170 độ dài với các điều kiện và sau đó đúc lại mỗi phép nhân từ đó trở đi. Vì thách thức không chỉ định phạm vi trên, tôi cho rằng điều này là đủ.

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'

Hiện tại khá vô dụng - cần ngủ ngay bây giờ.

Groovy, 156 byte

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

Giải pháp Code Golf khiêm tốn đầu tiên của tôi. Bạn có thể kiểm tra nó ở đây.

Và đây là một phiên bản dễ đọc hơn:

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...

Khá đơn giản, nhưng có một vài điểm nổi bật đối với tôi:

• Thực hiện tiêm / giảm từ một mảng charsthànhMap<Character, Integer> . Điều này vẫn còn một chút phức tạp do thiếu giá trị mặc định cho các giá trị bản đồ. Điều này nghi ngờ điều này là có thể, nhưng nếu bản đồ mặc định tất cả các giá trị là 0, tôi có thể tránh được ternary cần thiết để tránh NPE.

• Toán tử lây lan Groovy (ví dụ }*.value) luôn thú vị khi sử dụng

Tuy nhiên, về tính năng gây khó chịu là sự cần thiết phải khai báo hàm giai thừa với kiểu trả về BigInteger. Tôi đã có ấn tượng rằng Groovy gói tất cả các số trong BigIntegerhoặc BigDecimal, nhưng điều này có thể không phải là trường hợp khi nói đến các kiểu trả về. Tôi sẽ phải thử nghiệm nhiều hơn. Nếu không có kiểu trả về này được nêu rõ ràng, chúng ta sẽ nhận được các giá trị giai thừa không chính xác rất nhanh.

J, 33 byte

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

Chuyển đổi phạm vi thành một chuỗi các chữ số, đếm từng chữ số và áp dụng hệ số đa thức để tính kết quả.

Sử dụng

   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

R, 118 byte

Đến bữa tiệc muộn khoảng 8 tháng nhưng tôi nghĩ tôi sẽ thử vì nó giống như một thử thách thú vị.

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)

Hãy thử nó trên R-fiddle

Giải thích

1. Tạo vector 0 ... n-1và thu gọn nó thành một chuỗi:paste(1:n-1,collapse="")
2. Chia chuỗi thành các chữ số của nó và chuyển đổi thành số (lưu trữ dưới dạng x):x=as.numeric(el(strsplit(...,"")))
3. Để tính toán tử số chúng ta chỉ cần làm factorial(sum(1|x))đó chỉ là#digits!

4. Để tính mẫu số, chúng tôi sử dụng tableđể xây dựng bảng dự phòng liệt kê các tần số. Trong trường hợp F (12), bảng được tạo là:

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

5. Điều đó có nghĩa là chúng ta có thể sử dụng factorial()(bằng cách này được vector hóa) trên số đếm và chỉ cần lấy sản phẩm:prod(factorial(table(x)))

Lưu ý: bước 4 và 5 chỉ được thực hiện nếu n>0không quay trở lại 1.

Toán học, 65 byte

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

Có lẽ có thể được chơi golf hơn nữa.

Ruby , 64 byte

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

Hãy thử trực tuyến!

Stax , 12 byte

éÄ\↑≈g→FP○░→

Chạy và gỡ lỗi nó tại staxlang.xyz!

Giải nén (14 byte) và giải thích:

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

Thạch , 11 byte

Golfed Dennis' 15 byte Jelly câu trả lời ...

ḶDFµW;ĠẈ!:/

Một liên kết đơn âm chấp nhận một số nguyên không âm mang lại một số nguyên dương.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

Ḷ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

Python 2 , 190 byte

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

Hãy thử trực tuyến!

Python 2 , 134 byte

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

Hãy thử trực tuyến!

Một cách tiếp cận khác ...