บทนำ

ลองสังเกตลำดับต่อไปนี้ (จำนวนเต็มไม่เป็นลบ):

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 อีกตัวอย่างหนึ่งคือF (12) สิ่งนี้มีตัวเลข:

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

หรือรุ่นที่ต่อกัน:

01234567891011

ในการค้นหาจำนวนวิธีที่จะจัดเรียงสิ่งนี้ใหม่อันดับแรกเราต้องดูความยาวของสตริงนี้ 14ความยาวของสายนี้คือ ดังนั้นเราคำนวณ14! . อย่างไรก็ตามตัวอย่างเช่นสถานที่สามารถแลกเปลี่ยนสถานที่ได้โดยไม่กระทบกับสตริงสุดท้าย มี 2 ​​ศูนย์ดังนั้นมี2! วิธีในการเปลี่ยนเลขศูนย์โดยไม่รบกวนการสั่งซื้อ นอกจากนี้ยังมี 4 รายการดังนั้นจึงมี4! วิธีในการสลับสับเปลี่ยน เราหารผลรวมด้วยตัวเลขสองตัวนี้:

มี14! / (4! × 2!) = 1816214400 01234567891011วิธีในการจัดสตริง ดังนั้นเราจึงสามารถสรุปได้ว่าF (12) = 1816214400

งาน

ป.ร. ให้ไว้ไม่มีเอาท์พุทF (N) สำหรับคนที่ไม่ต้องการคำแนะนำ ในการคำนวณ F (N) อันดับแรกเราทำการเชื่อมต่อจำนวนเต็ม N ที่ไม่ใช่ลบแรก (เช่นสำหรับ N = 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 วินาที , เดรัจฉานบังคับให้เป็นไม่ได้รับอนุญาต

นี่คือโค้ดกอล์ฟดังนั้นการส่งที่มีจำนวนไบต์น้อยที่สุดจะชนะ!

เยลลี่, 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.

ES6, 118 81 78 ไบต์

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

มีคนผูกพันที่จะบอกฉันว่ามันมีวิธีที่สั้นกว่าในการต่อตัวเลขให้nมากที่สุด

บันทึกขนาด 37 ไบต์โดยใช้ความคิดของ @ edc65 และเรียกใช้บนเตียรอยด์ (บันทึกไบต์พิเศษโดยใช้ '|' แทน&&แต่ที่ จำกัด ผลลัพธ์ไว้ที่ 31 บิต)

แก้ไข: บันทึกอีก 3 ไบต์อีกครั้งขอบคุณ @ edc65

APL (Dyalog Extended)ขนาด 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

การคำนวณแบบหลายส่วนมาจากข้อเท็จจริงต่อไปนี้

MATL , 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

Python 2, 142 137 101 97 ไบต์

(ขอบคุณ @adnan สำหรับคำแนะนำเกี่ยวกับinput)

(ใช้การคำนวณแบบเพิ่มหน่วยจากเวอร์ชั่น 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

เวอร์ชันดั้งเดิมโดยใช้แฟกทอเรียล

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ให้นับความถี่ของแต่ละหลัก จำนวนที่ได้รับการปรับปรุงสำหรับแต่ละหลักในแต่ละหมายเลขในช่วงที่ระบุ

ในเวอร์ชั่นดั้งเดิมเราคำนวณจำนวนพีชคณิตโดยใช้สูตรมาตรฐาน (Σf _i )! / π (f _i !) สำหรับเวอร์ชั่นปัจจุบันการคำนวณนี้เพิ่มขึ้นทีละน้อยโดยการกระจายการคูณและหารตามที่เราเห็นตัวเลข มันอาจจะไม่เห็นได้ชัดว่าการหารจำนวนเต็มจะเป็นที่แน่นอน แต่มันเป็นเรื่องง่ายที่จะพิสูจน์ว่าขึ้นอยู่กับการสังเกตว่าแต่ละฝ่ายโดยkจะต้องปฏิบัติตามคูณของจำนวนเต็มติดต่อกันดังนั้นหนึ่งของคูณผู้ที่ต้องหารด้วยk k(นั่นเป็นสัญชาตญาณไม่ใช่ข้อพิสูจน์)

เวอร์ชันดั้งเดิมนั้นเร็วกว่าสำหรับอาร์กิวเมนต์ที่มีขนาดใหญ่เนื่องจากมันจะแบ่งได้เพียง 10 bignum แม้ว่าการหาร bignum ด้วยจำนวนเต็มขนาดเล็กจะเร็วกว่าการหาร bignum ด้วย bignum เมื่อคุณมีการหาร bignum นับพัน แต่ก็จะได้รับความเชื่องช้าเล็กน้อย

Python 2, 197 ไบต์ (แก้ไข: บันทึกแล้ว 4 ไบต์, ขอบคุณ 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

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

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

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)

ทดสอบ

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>

Pyth, 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

Haskell, 92 ไบต์

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

ตัวอย่างการใช้งาน: ->h 121816214400

มันทำงานอย่างไร

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 ไบต์

เครดิตมากมายสำหรับการลดจำนวนมหาศาลของไบต์

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

ลองมันนี่

C / bc, 233 121 112 ไบต์ (สมมติว่าโทษ 3 ไบต์สำหรับ|bc)

1. แรงบันดาลใจจาก Cole Cameron ลบการจัดการตัวละครแฮ็คและทำเลขคณิตกับค่าอาร์กิวเมนต์

2. เปลี่ยนเป็น scanf จากการใช้เวกเตอร์หาเรื่อง

   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ต้องทำการคำนวณความแม่นยำตามอำเภอใจ

Ungolfed และคำเตือนฟรี:

#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

และด้วย pipe ผ่าน bc (และเพิ่มการคำนวณ F (1,000):

$ 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

Perl 6, 117 ไบต์

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

และในแฟชั่นที่อ่านง่ายขึ้น

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 ไบต์

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

ขอบคุณมากสำหรับdev-null ที่ช่วยฉัน 17 ไบต์และขอบคุณ japhyสำหรับแนวคิดแฟคทอเรียล

05AB1E , 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

Python 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

PowerShell ขนาด 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..จำนวนที่-joins $bร่วมกันที่เป็นสตริงและบันทึกเป็น เราใช้.Lengthสตริงนั้นสร้างช่วงอื่นจาก1..ความยาว-joinนั้นจำนวนเต็มเหล่านั้นพร้อมกับ*ไพพ์นั้นไปที่Invoke-Expression(คล้ายกับeval ) เราได้สร้างแฟคทอเรียลของความยาวของลำดับหมายเลขตามอินพุต นั่นคือตัวเศษของเรา

เราหาร/ด้วย ...

หารของเราซึ่งถูกสร้างโดยการใช้ช่วงและการส่งผ่านสำหรับวง0..9 |%{...}การวนซ้ำแต่ละครั้งเราตั้งค่าตัวแปรตัวช่วย$cเท่ากับจำนวนครั้งที่ตัวเลขปัจจุบัน$_ปรากฏภายใน$bด้วยการเรียก. NET[regex]::matchesควบคู่กับ.countแอตทริบิวต์ จากนั้นเราสร้างช่วงใหม่จาก1..สูงถึงค่านั้นตราบใดที่มันไม่ใช่ศูนย์ ใช่ในหลาย ๆ กรณีนี้จะมีผลในช่วงซึ่งประเมินเพียง1..1 1เรานำสิ่งเหล่านั้นและ-joinพวกมันมารวมกัน*จากนั้นก็เป่าInvoke-Expressionอีกครั้ง เราได้สร้างผลิตภัณฑ์ของแฟคทอเรียลของจำนวนการเกิดขึ้นของแต่ละหลัก

NB

จัดการอินพุตได้สูงสุด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 ด้วยเงื่อนไข การคูณแต่ละครั้งจากที่นั่นเป็นต้นไป เนื่องจากความท้าทายไม่ได้ระบุช่วงที่สูงกว่าฉันจึงสันนิษฐานว่านี่เพียงพอแล้ว

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 ในขณะนี้ - ต้องนอนหลับตอนนี้

Groovy ขนาด 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)}

โซลูชั่น Golf Code ที่ต่ำต้อยของฉัน คุณสามารถทดสอบได้ที่นี่

และนี่คือรุ่นที่อ่านได้มากขึ้น:

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

ค่อนข้างตรงไปตรงมา แต่มีไฮไลท์สองสามอย่างสำหรับฉัน:

• การดำเนินการฉีด / ลดจาก array ของไปchars Map<Character, Integer>สิ่งนี้ยังมีความซับซ้อนเล็กน้อยเนื่องจากไม่มีค่าเริ่มต้นสำหรับค่าแผนที่ ข้อสงสัยนี้เป็นไปได้ แต่ถ้าแผนที่เริ่มต้นค่าทั้งหมดเป็น 0 ฉันสามารถหลีกเลี่ยง ternary ซึ่งจำเป็นเพื่อหลีกเลี่ยง NPE

• ตัวดำเนินการแพร่กระจาย Groovy (เช่น}*.value) ใช้งานได้สนุกเสมอ

เกี่ยวกับคุณลักษณะที่น่ารำคาญ BigIntegerแต่เป็นความจำเป็นในการประกาศฟังก์ชั่นปัจจัยที่มีประเภทผลตอบแทน ฉันอยู่ภายใต้การแสดงผลที่ Groovy หุ้มตัวเลขทั้งหมดไว้BigIntegerหรือBigDecimalแต่นี่อาจไม่ใช่กรณีที่มันกลับมาเป็นประเภท ฉันจะต้องทดลองเพิ่มเติม หากไม่ระบุประเภทการคืนนี้อย่างชัดเจนเราจะได้รับค่า factorial ที่ไม่ถูกต้องอย่างรวดเร็ว

J, 33 ไบต์

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

แปลงช่วงเป็นสตริงตัวเลขนับแต่ละหลักและใช้สัมประสิทธิ์ multinomial เพื่อคำนวณผลลัพธ์

การใช้

   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 ไบต์

สายไปงานเลี้ยงประมาณ 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)

ลองใช้กับ R-fiddle

อธิบาย

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()(ซึ่งเป็นวิธีการ vectorized) ในการนับและเพียงแค่นำผลิตภัณฑ์:prod(factorial(table(x)))

หมายเหตุ: ขั้นตอนที่ 4 และ 5 จะดำเนินการผ่านหากn>0ส่งคืนเป็นอย่างอื่น1เท่านั้น

Mathematica, 65 ไบต์

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

อาจจะเล่นกอล์ฟต่อไป

Ruby , 64 ไบต์

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

ลองออนไลน์!

Stax , 12 ไบต์

éÄ\↑≈g→FP○░→

เรียกใช้และแก้ไขปัญหาได้ที่ staxlang.xyz!

คลายการแพค (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

เยลลี่ 11 ไบต์

แข็งแรงเล่นกอล์ฟของเดนนิส 15 ไบต์ Jelly คำตอบ ...

ḶDFµW;ĠẈ!:/

Link monadic ยอมรับจำนวนเต็มแบบไม่ลบซึ่งให้ผลเป็นจำนวนเต็มบวก

ลองออนไลน์! หรือดูชุดทดสอบชุดทดสอบ

อย่างไร?

Ḷ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 ไบต์

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

ลองออนไลน์!

Python 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

ลองออนไลน์!

แนวทางอื่น ...