introduction

Observons la séquence suivante (entiers non négatifs):

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

Par exemple, prenons les trois premiers chiffres. Ce sont 0, 1, 2. Les numéros utilisés dans cette séquence peuvent être classés de six manières différentes:

012   120
021   201
102   210

Supposons donc que F (3) = 6 . Un autre exemple est F (12) . Il contient les chiffres:

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

Ou la version concaténée:

01234567891011

Pour trouver le nombre de façons de réorganiser cela, nous devons d'abord regarder la longueur de cette chaîne. La longueur de cette chaîne est 14. Nous calculons donc 14! . Cependant, par exemple, ceux-ci peuvent échanger des places sans interrompre la chaîne finale. Il y a 2 zéros, donc il y en a 2! façons d'échanger les zéros sans perturber la commande. Il y en a aussi 4, donc il y en a 4! façons de changer celles-là. Nous divisons le total par ces deux nombres:

Cela a 14! / (4! × 2!) = 1816214400 façons d'organiser la chaîne 01234567891011. On peut donc conclure que F (12) = 1816214400 .

La tâche

Étant donné N , sortie F (N) . Pour ceux qui n'ont pas besoin de l'introduction. Pour calculer F (N), nous concaténons d'abord les N premiers entiers non négatifs (par exemple pour N = 12, la chaîne concaténée serait 01234567891011) et calculons le nombre de façons d'organiser cette chaîne.

Cas de 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

Remarque

Le calcul de la réponse doit être calculé dans un délai de 10 secondes , le forçage brutal est interdit .

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Gelée, 17 15 octets

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

Essayez-le en ligne! ou vérifiez tous les cas de test à la fois .

Comment ça fonctionne

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 octets

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

Quelqu'un est obligé de me dire qu'il existe un moyen plus court de concaténer les nombres jusqu'à n.

Économisez 37 octets en prenant l'idée de @ edc65 et en l'exécutant sur des stéroïdes. (Enregistrez un octet supplémentaire en utilisant '|' au lieu de &&mais cela limite le résultat à 31 bits.)

Edit: encore 3 octets enregistrés grâce à @ edc65.

APL (Dyalog Extended) , 13 octets

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

Essayez-le en ligne!

Un programme complet. Les usages⎕IO←0 .

Comment ça fonctionne

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

Le calcul multinomial provient du fait suivant:

MATL , 21 octets

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

Essayez-le en ligne!

Explication

: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 octets

(Merci @adnan pour la suggestion input)

(Appliqué le calcul incrémental de la version 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

Version originale utilisant factorielle

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

Vraiment, le seul golf dans ce qui précède appelle math.factorial Fet laisse de côté certains espaces, il y a donc probablement une solution de python plus courte.

Si une explication est nécessaire, vconserve un décompte de la fréquence de chaque chiffre; le décompte est mis à jour pour chaque chiffre de chaque numéro dans la plage indiquée.

Dans la version originale, nous calculons le nombre de permutations en utilisant la formule standard (Σf _i )! / Π (f _i !). Pour la version actuelle, ce calcul se fait de manière incrémentale en répartissant les multiplications et les divisions comme on voit les chiffres. Il n'est peut-être pas évident que la division entière sera toujours exacte, mais il est facile de prouver sur la base de l'observation que chaque division par kdoit suivrek multiplications d'entiers consécutifs, donc l'une de ces multiplications doit être divisible park . (C'est une intuition, pas une preuve.)

La version originale est plus rapide pour les gros arguments car elle ne divise que 10 bignums. Bien que la division d'un bignum par un petit entier soit plus rapide que la division d'un bignum par un bignum, lorsque vous avez des milliers de divisions de bignum, cela devient un peu lent.

Python 2, 197 octets (modification: enregistré 4 octets, merci 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

Non golfé:

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 octets

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

Testez-le ici.

Explication

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)

Tester

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 octets

/F.!M+lJ.njRTQ/LJT

Essayez-le en ligne: Démonstration

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

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

Exemple d'utilisation: h 12->1816214400 .

Comment ça fonctionne

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 121 octets

Beaucoup de crédit à rici, pour la réduction massive d'octets.

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

Non golfé

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

Essayez-le ici .

C / bc, 233 121 112 octets ( en supposant 3 pénalité d'octets pour |bc)

1. Inspiré par Cole Cameron, a supprimé la manipulation de caractère hacky et juste faire de l'arithmétique sur la valeur de l'argument.

2. Changé en scanf en utilisant le vecteur 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");}
   

Doit bcréellement faire le calcul de précision arbitraire.

Non golfé et sans avertissement:

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

Illustré (dont je fais confiance montre l'algorithme):

$ 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

Et, avec le tuyau passant par bc (et en ajoutant le calcul de 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

Cela a calculé F (5000) - un nombre de 18 592 chiffres - en moins de 10 secondes.

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

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

Perl 6, 117 octets

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

et dans un style plus lisible

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 octets

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

Un grand merci à dev-null pour m'avoir sauvé 17 octets, et à japhy pour l'idée factorielle.

05AB1E , 13 12 11 octets

ÝD¨SāPr¢!P÷

Essayez-le en ligne!

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

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

Essayez-le en ligne!

1. Convertissez le range de l'entrée en une seule chaîne
2. Vérifiez combien de fois chacun des nombres de 0 à 9 apparaît dans la chaîne et obtenez la factorielle pour chacun, puis multipliez-les
3. Divisez la factorielle de la longueur de la chaîne par le nombre calculé à l'étape 2

PowerShell, 125 octets

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

Prend l'entrée $args[0], soustrait 1, construit une plage d'entiers à partir de 0..ce nombre, -joins qui ensemble dans une chaîne, et l'enregistre sous $b. Nous prenons le .Lengthde cette chaîne, construisons une autre plage à partir de 1..cette longueur, -joinces entiers avec *, puis redirigeons cela versInvoke-Expression (similaire àeval ). En d'autres termes, nous avons construit la factorielle de la longueur de la séquence de nombres en fonction de l'entrée. Voilà notre numérateur.

Nous divisons cela / par ...

Notre dénominateur, qui est construit en prenant une plage 0..9et en l'envoyant via une boucle for |%{...}. À chaque itération, nous définissons une variable d'assistance $cégale au nombre de fois où le chiffre actuel $_apparaît à l'intérieur $bgrâce à l' appel .NET[regex]::matches couplé à l' .countattribut. Nous construisons ensuite une nouvelle plage allant 1..jusqu'à cette valeur, tant qu'elle n'est pas nulle. Oui, dans de nombreux cas, cela se traduira par une plage 1..1, qui est évaluée à juste 1. Nous prenons tous ces éléments et -joineux ensemble *, puis nous les redirigeons Invoke-Expression. En d'autres termes, nous avons construit le produit des factorielles du nombre d'occurrences de chaque chiffre.

NB

Gère l'entrée 90sans problème et en moins d'une seconde.

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

... au-delà, cela donne Infinitycomme sortie, car la longueur de la chaîne permutable résulte en 170!ce qui correspond au doubletype de données ( 7.25741561530799E+306), mais 171!ne le fait pas. PowerShell a une ... bizarrerie ... qui monte automatiquement de [int]à [double]en cas de débordement (à condition que vous n'ayez pas explicitement casté la variable pour commencer). Non, je ne sais pas pourquoi il ne va pas [long]pour les valeurs entières.

Si nous faisions un casting et une manipulation explicites (par exemple, en utilisant [uint64], pour des entiers 64 bits non signés), nous pourrions obtenir cela plus haut, mais cela alourdirait considérablement le code car nous aurions besoin d'une plage allant jusqu'à 170 avec des conditions, puis une refonte chaque multiplication à partir de là. Comme le défi ne spécifie pas de plage supérieure, je suppose que cela est adéquat.

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'

Plutôt non golfé pour le moment - besoin de dormir maintenant.

Groovy, 156 octets

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

Ma première solution humble Code Golf. Vous pouvez le tester ici.

Et voici une version plus lisible:

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

Assez simple, mais il y a eu quelques points saillants pour moi:

• Effectuer une injection / réduction d'un tableau de charsà un Map<Character, Integer>. C'était encore un peu compliqué par l'absence d'une valeur par défaut pour les valeurs de la carte. Ce doute que cela est possible, mais si la carte a par défaut toutes les valeurs à 0, je pourrais éviter le ternaire qui est nécessaire pour éviter un NPE.

• L'opérateur de propagation Groovy (par exemple }*.value) est toujours amusant à utiliser

Sur la caractéristique ennuyeuse, cependant, était la nécessité de déclarer la fonction factorielle avec le type de retour BigInteger. J'avais l'impression que Groovy enveloppait tous les chiffres dans BigIntegerou BigDecimal, mais cela pourrait ne pas être le cas lorsqu'il s'agit de renvoyer des types. Je vais devoir expérimenter davantage. Sans ce type de retour explicitement indiqué, nous obtenons très rapidement des valeurs factorielles incorrectes.

J, 33 octets

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

Convertit la plage en une chaîne de chiffres, compte chaque chiffre et applique le coefficient multinomial pour calculer le résultat.

Usage

   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 octets

Environ 8 mois de retard pour la fête, mais j'ai pensé que j'allais essayer car cela ressemblait à un défi intéressant.

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)

Essayez-le sur R-fiddle

Expliqué

1. Générez un vecteur 0 ... n-1et réduisez-le en une chaîne:paste(1:n-1,collapse="")
2. Fractionner la chaîne en ses chiffres et convertir en numérique (stocker sous x):x=as.numeric(el(strsplit(...,"")))
3. Pour calculer le numérateur, nous faisons simplement ce factorial(sum(1|x))qui est juste#digits!

4. Pour calculer le dénominateur, nous utilisons tablepour construire un tableau de contingence qui répertorie les fréquences. Dans le cas de F (12) la table générée est:

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

5. Ce qui signifie que nous pouvons prendre l'utilisation factorial()(qui est d'ailleurs vectorisée) sur le compte et simplement prendre le produit:prod(factorial(table(x)))

Remarque: les étapes 4 et 5 ne sont exécutées que dans le cas n>0contraire 1.

Mathematica, 65 octets

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

Pourrait probablement être joué au golf plus loin.

Ruby , 64 octets

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

Essayez-le en ligne!

Stax , 12 octets

éÄ\↑≈g→FP○░→

Exécutez-le et déboguez-le sur staxlang.xyz!

Déballé (14 octets) et explication:

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

Gelée , 11 octets

Réponse de Jelly Golfed 15 octets Jelly ...

ḶDFµW;ĠẈ!:/

Un lien monadique acceptant un entier non négatif qui donne un entier positif.

Essayez-le en ligne! Ou consultez la suite de tests .

Comment?

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

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

Essayez-le en ligne!

Python 2 , 134 octets

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

Essayez-le en ligne!

Une approche alternative ...