introduzione

Osserviamo la seguente sequenza (numeri interi non negativi):

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

Ad esempio, prendiamo i primi tre numeri. Questi sono 0, 1, 2. I numeri utilizzati in questa sequenza possono essere ordinati in sei modi diversi:

012   120
021   201
102   210

Quindi, supponiamo che F (3) = 6 . Un altro esempio è F (12) . Questo contiene i numeri:

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

O la versione concatenata:

01234567891011

Per trovare il numero di modi per riorganizzarlo, dobbiamo prima guardare alla lunghezza di questa stringa. La lunghezza di questa stringa è 14. Quindi calcoliamo 14! . Tuttavia, ad esempio, quelli possono scambiare posti senza interrompere la stringa finale. Ci sono 2 zero, quindi ce ne sono 2! modi per scambiare gli zeri senza interrompere l'ordine. Ce ne sono anche 4, quindi ce ne sono 4! modi per cambiare quelli. Dividiamo il totale per questi due numeri:

Questo ha 14! / (4! × 2!) = 1816214400 modi per disporre la stringa 01234567891011. Quindi possiamo concludere che F (12) = 1816214400 .

L'obiettivo

Dato N , uscita F (N) . Per quelli che non hanno bisogno dell'introduzione. Per calcolare F (N), prima concateniamo i primi N numeri interi non negativi (ad es. Per N = 12, la stringa concatenata sarebbe 01234567891011) e calcoliamo il numero di modi per disporre questa stringa.

Casi test

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

Nota

Il calcolo della risposta deve essere calcolato entro un termine di 10 secondi , la forza bruta non è consentita .

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Gelatina, 17 15 byte

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

Provalo online! oppure verifica tutti i casi di test contemporaneamente .

Come funziona

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

Qualcuno è tenuto a dirmi che c'è un modo più breve di concatenare i numeri fino a n .

Hai risparmiato ben 37 byte prendendo l'idea di @ edc65 ed eseguendolo su steroidi. (Salvare un byte extra usando '|' invece di&& ma che limita il risultato a 31 bit.)

Modifica: di nuovo salvato altri 3 byte grazie a @ edc65.

APL (Dyalog Extended) , 13 byte

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

Provalo online!

Un programma completo. Usi ⎕IO←0.

Come funziona

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

Il calcolo multinomiale deriva dal fatto seguente:

MATL , 21 byte

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

Provalo online!

Spiegazione

: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

(Grazie @adnan per il suggerimento in merito input)

(Applicato il calcolo incrementale dalla versione 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

Versione originale usando fattoriale

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

Davvero, il solo golf di cui sopra sta chiamando math.factorial Fe tralasciando alcuni spazi, quindi probabilmente c'è una soluzione in pitone più corta.

Se è necessaria vuna spiegazione, mantiene un conteggio della frequenza di ciascuna cifra; il conteggio viene aggiornato per ogni cifra in ciascun numero nell'intervallo indicato.

Nella versione originale, calcoliamo il numero di permutazioni usando la formula standard (Σf _i )! / Π (f _i !). Per la versione corrente, questo calcolo viene eseguito in modo incrementale distribuendo i moltiplicatori e le divisioni quando vediamo le cifre. Potrebbe non essere ovvio che il divario intero sarà sempre esatto, ma è facile dimostrarlo in base all'osservazione che ogni divisione kdeve seguirek moltiplicatori di numeri interi consecutivi, quindi uno di quei moltiplicatori deve essere divisibile per k. (Questa è un'intuizione, non una prova.)

La versione originale è più veloce per argomenti di grandi dimensioni perché fa solo 10 divisioni bignum. Sebbene dividere un bignum per un piccolo numero intero sia più veloce della divisione di un bignum per un bignum, quando hai migliaia di bignum si divide, diventa un po 'lento.

Python 2, 197 byte (modifica: salvato 4 byte, grazie 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 byte

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

Provalo qui.

Spiegazione

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)

Test

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 byte

/F.!M+lJ.njRTQ/LJT

Provalo online: dimostrazione

/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

Esempio di utilizzo: h 12->1816214400 .

Come funziona

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

Molto credito a rici, per una massiccia riduzione di 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);}

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

Provalo qui .

C / bc, 233 121 112 byte (assumendo una penalità di 3 byte per |bc)

1. Ispirato da Cole Cameron, ha rimosso la manipolazione del personaggio confuso e ha semplicemente fatto l'aritmetica sul valore dell'argomento.

2. Modificato in scanf dall'uso di arg vector.

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

Deve bceffettivamente eseguire il calcolo di precisione arbitrario.

Ungolfed e senza preavviso:

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

Illustrato (di cui mi fido mostra l'algoritmo):

$ 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

E, con il pipe through bc (e aggiungendo il calcolo di 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

Questo calcolato F (5000) - un numero di 18.592 cifre - in meno di 10 secondi.

$ 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

e in una leggenda più leggibile

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

Mille grazie a dev-null per avermi salvato 17 byte e japhy per l'idea fattoriale.

05AB1E , 13 12 11 byte

ÝD¨SāPr¢!P÷

Provalo online!

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

Provalo online!

1. Converti l' rangeinput in una singola stringa
2. Controlla quante volte ciascuno dei numeri da 0 a 9 appare nella stringa e ottieni il fattoriale per ciascuno, quindi moltiplicali insieme
3. Dividi il fattoriale della lunghezza della stringa per il numero calcolato nel passaggio 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)

Prende input $args[0], sottrae 1, costruisce un intervallo di numeri interi da 0..quel numero, lo -joinunisce in una stringa e lo salva come $b. Prendiamo la .Lengthstringa di quella, costruiamo un altro intervallo da 1..quella lunghezza, -joininsieme a quelli interi* , quindi reindirizziamo a Invoke-Expression(simile aeval ). In altre parole, abbiamo costruito il fattoriale della lunghezza della sequenza numerica in base all'input. Questo è il nostro numeratore.

Lo dividiamo / per ...

Il nostro denominatore, che è costruito prendendo un intervallo 0..9e inviandolo attraverso un for-loop |%{...}. Ad ogni iterazione, impostiamo una variabile helper $cpari al numero di volte in cui $_appare la cifra corrente $bgrazie alla chiamata .NET[regex]::matches accoppiata con l' .countattributo. Costruiamo quindi un nuovo intervallo 1..fino a quel valore, purché sia ​​diverso da zero. Sì, in molti casi, questo si tradurrà in un intervallo 1..1, che viene valutato solo 1. Prendiamo tutti questi e -joinloro insieme *, quindi li convogliamo di Invoke-Expressionnuovo. In altre parole, abbiamo costruito il prodotto dei fattoriali del numero di occorrenze di ciascuna cifra.

NB

Gestisce l'input fino a 90senza problemi e in modo significativamente inferiore a un secondo.

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

... oltre a ciò si traduce in Infinityoutput, poiché la lunghezza della stringa permutabile risulta nella 170!quale si adatta al doubletipo di dati ( 7.25741561530799E+306), ma 171!non lo fa. PowerShell ha un ... eccentrico ... che esegue l'upgrade automatico da [int]a [double]in caso di overflow (a condizione che tu non abbia espressamente lanciato la variabile per iniziare). No, non so perché non valga [long]per i valori interi.

Se avessimo eseguito un cast e una manipolazione espliciti (ad esempio, utilizzando [uint64], per numeri interi a 64 bit senza segno), potremmo ottenere un valore superiore, ma aumenterebbe in modo significativo il codice in quanto avremmo bisogno di andare fino a 170 di lunghezza con i condizionali e quindi rifondere ogni moltiplicazione da lì in poi. Poiché la sfida non specifica una gamma superiore, presumo che ciò sia adeguato.

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'

Piuttosto ungolf al momento - ora ho bisogno di dormire.

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

La mia umile prima soluzione Code Golf. Puoi provarlo qui.

Ed ecco una versione più leggibile:

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

Abbastanza semplice, ma ci sono stati un paio di punti salienti per me:

• Esecuzione di un'iniezione / riduzione da un array di charsa Map<Character, Integer>. Ciò era ancora un po 'complicato dalla mancanza di un valore predefinito per i valori della mappa. Questo dubbio è possibile, ma se la mappa ha impostato tutti i valori su 0, potrei evitare il ternario necessario per evitare un NPE.

• L'operatore di diffusione Groovy (ad es. }*.value) È sempre divertente da usare

La caratteristica fastidiosa, tuttavia, era la necessità di dichiarare la funzione fattoriale con il tipo restituito BigInteger. Avevo l'impressione che Groovy avesse racchiuso tutti i numeri BigIntegero BigDecimal, ma questo potrebbe non essere il caso di restituire i tipi. Dovrò sperimentare di più. Senza questo tipo restituito indicato esplicitamente, otteniamo valori fattoriali errati molto rapidamente.

J, 33 byte

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

Converte l'intervallo in una stringa di cifre, conta ogni cifra e applica il coefficiente multinomiale per calcolare il risultato.

uso

   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

Circa 8 mesi di ritardo alla festa, ma ho pensato di provarlo perché sembrava una sfida interessante.

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)

Provalo su R-violino

spiegato

1. Genera vettore 0 ... n-1 e comprimilo in una stringa:paste(1:n-1,collapse="")
2. Dividi la stringa nelle sue cifre e convertila in un numero (memorizza come x ):x=as.numeric(el(strsplit(...,"")))
3. Per calcolare il numeratore facciamo semplicemente ciò factorial(sum(1|x))che è giusto#digits!

4. Per calcolare il denominatore che utilizziamo tableper costruire una tabella di contingenza che elenca le frequenze. Nel caso di F (12) la tabella generata è:

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

5. Ciò significa che possiamo prendere l'uso factorial()(che tra l'altro è vettorializzato) sul conteggio e semplicemente prendere il prodotto:prod(factorial(table(x)))

Nota: i passaggi 4 e 5 vengono eseguiti solo se n>0altrimenti ritornano 1.

Mathematica, 65 byte

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

Probabilmente potrebbe essere ulteriormente giocato a golf.

Rubino , 64 byte

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

Provalo online!

Stax , 12 byte

éÄ\↑≈g→FP○░→

Eseguilo e esegui il debug su staxlang.xyz!

Spacchettato (14 byte) e spiegazione:

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

Gelatina , 11 byte

Jelly Dennis '15 byte golfato risposta ...

ḶDFµW;ĠẈ!:/

Un collegamento monadico che accetta un numero intero non negativo che produce un numero intero positivo.

Provalo online! Oppure vedi la suite di test .

Come?

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

Provalo online!

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

Provalo online!

Un approccio alternativo ...