시퀀스 재정렬

23

소개

다음 순서 (음수가 아닌 정수)를 살펴 보겠습니다.

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

예를 들어 처음 세 숫자를 봅시다 . 이들은입니다 0, 1, 2. 이 순서에 사용 된 숫자는 6 가지 방법 으로 주문할 수 있습니다 .

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 개의 0이 있으므로 2가 있습니다! 순서를 방해하지 않고 0 을 바꾸는 방법 . 4 개도 있으므로 4 개가 있습니다 ! 그것들을 전환하는 방법. 총계를이 두 숫자로 나눕니다.

이것은 14입니다! / (4! × 2!) = 1816214400 문자열 정렬 방법 01234567891011. 따라서 F (12) = 1816214400 이라고 결론을 내릴 수 있습니다 .

작업

N이 주어지면 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 초의 시간 제한 , 짐승 - 강제가 되어 허용 .

이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!

code-golf  number  sequence  combinatorics  permutations 
— 아드 난
소스
출력이 10정확합니까? 반복 숫자가 시작되는 위치이므로 10보다 작아야합니다!
— Geobits
@Geobits 첫 번째 10숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9입니다. 다른 10 자리 숫자이므로 결과는 10!입니다.
— Adnan
아 맞아 나는 0사건이 내 카운트를 버리고 있다고 생각한다 (멍청한 빈 줄).
— Geobits
1
더 이상 걱정할 필요가 없습니다. 의견을 게시했을 때 허점 제안은 +4에 있었습니다 . 지금은 +9 입니다.
— Dennis
1
이 퍼즐에 대한 흥미로운 수학 질문이 있습니다 : N에 상대적인 F (N)의 가치는 무엇입니까? F (N) / F (N-1) <N 인 N의 값은 여러 개 있지만 일반적으로 약간 더 큽니다. 나는 확신이있어 F(N)되지 않습니다 O(N!)그것은 log F(N)이다 O(log N!)하지만 사람들은 그냥 직감입니다
— RICI

답변:

5

젤리, 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.
— 데니스
소스
정말 젤리인가요? 나는 많은 ASCII 문자 - P로 볼
— 루이스 Mendo
3
그들은 항상 어떻게 든 몰래 빠져
— Dennis
10

ES6, 118 81 78 바이트

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

누군가 숫자를 최대로 연결하는 더 짧은 방법이 있다고 말해 주어야합니다 n.

@ edc65의 아이디어를 가져 와서 스테로이드에서 실행하여 멋진 37 바이트를 절약했습니다. (대신 '|'를 사용하여 여분의 바이트를 저장 &&하지만 결과는 31 비트로 제한됩니다.)

편집 : @ edc65 덕분에 3 바이트를 더 절약했습니다.

— 닐
소스
숫자 연결을 줄이는 방법을 찾지 못했습니다. 그러나 나머지는 더 짧을 수 있습니다
— edc65
다음을 사용하여 2 바이트 저장 reduce:n=>[...[...Array(n).keys()].join``].reduce((r,c,i)=>r*++i/(o[c]=-~o[c]),1,o=[])
— user81655
1
와! 하지만 78이 더 낫습니다 :n=>[...[...Array(n).keys()].join``].map(c=>r/=(o[c]=-~o[c])/i++,o=[],i=r=1)&&r
— edc65
1
@ edc65가보다 r/=(...)/i++정확 r*=i++/(...)합니까? 그것은 내가 본 것 중 가장 성가신 골프입니다!
— Neil
2
나는 거기에 정규 표현식이 있다고 생각했기 때문에 잠시 멈춰야했습니다.
— Mama Fun Roll
7

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

다항식 계산은 다음 사실에서 비롯됩니다.

(a1+a2+⋯+an)!a1!a2!⋯an!=(a1+a2)!a1!a2!×(a1+a2+⋯+an)!(a1+a2)!a3!⋯an!

=(a1+a2)!a1!a2!×(a1+a2+a3)!(a1+a2)!a3!×(a1+a2+⋯+an)!(a1+a2+a3)!⋯an!

=⋯=(a1+a2a1)(a1+a2+a3a1+a2)⋯(a1+⋯+ana1+⋯+an−1)

— 버블 러
소스
1
그리고 이것이 프로그래머가 수학을 배워야하는 이유입니다.
— 익명 :
@Anonymous… 수학적으로 기울어 진 프로그래밍 언어를 사용하십시오.
— Adám
5

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
— 루이스 멘도
소스
@Adnan는 해결했다. 그리고 더 적은 바이트 :-)
— Luis Mendo 02:19에
아주 좋아 보인다! :)
— Adnan
@Adnan 감사합니다! 나는 설명을 추가했다
— Luis Mendo
5

파이썬 (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 개의 큰 나누기 만 수행하므로 큰 인수에 대해 더 빠릅니다. 큰 숫자를 작은 정수로 나누는 것이 큰 숫자를 큰 숫자로 나누는 것보다 빠르지 만 수천 개의 큰 숫자 나누기가 있으면 조금 느려집니다.

— 리치
소스
f = f * sum (v) / v [k]-> f * = sum (v) / v [k]는 바이트를 절약합니다.
— Mikko Virkkilä
@superflux : 같은 의미가 아닙니다.
— rici
5

파이썬 2, 197 바이트 (편집 : Thomas Kwa 덕분에 4 바이트 절약!)

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

언 골프 드 :

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
— 데이브 린
소스
1
프로그래밍 퍼즐과 코드 골프에 오신 것을 환영합니다! 이 답변은 VLQ (매우 낮은 품질)로 표시되었습니다. 표준이나 설명이없는 버전이 없기 때문에 의심됩니다. 귀하의 답변이 효과가 있다고 가정하고 "코드 전용"으로 개선하면 상당히 좋습니다!
— 고양이
range(0,10)일 수 있습니다 range(10).
— lirtosiast
4

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.
— 마틴 엔더
소스
3

자바 스크립트 (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>
스 니펫 확장

— edc65
소스
하지인가 k[c]=~-k[c]와 동의어 --k[c]?
— usandfriends
1
@usandfriends no, k [c]가 정의되지 않은 경우 --k [c]가 NaN
— edc65
아, 계승의 멋진 배열.
— Neil
... 필요하지는 않지만. 최신 업데이트를 참조하십시오.
— Neil
3

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
— 자쿠 베
소스
3

하스켈, 92 바이트

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

사용 예 : h 12-> 1816214400.

작동 원리

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

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

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

C, 236 174 138 121 바이트

바이트를 크게 줄이면 rici에 많은 기여를합니다.

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

언 골프

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

여기에서 시도 하십시오 .

— 콜 카메론
소스
1
-lm을 사용하지 않고 43자를 저장할 수 있습니다. 찾은 숫자 만 세어보십시오.#define L long long L d;i,j,k,m,n,s=1,b[10]={1};L f(n){return n?n*f(n-1):1;}main(d){for(scanf("%d",&n);i<n;)for(j=i++;j;j/=10)++b[j%10],++s;for(;m<10;)d*=f(b[m++]);printf("%Ld",f(s)/d);}
— rici
d를 계산하는 루프에서 계산할 수도 있습니다. for(;m<10;)s+=b[m],d*=f(b[m++])하지만 몇 바이트 더 있다고 생각합니다.
— rici
훌륭합니다. 나는 현재의 골프 활동과 결합하여 편집 할 것입니다.
— Cole Cameron
좋은 점 : 인자 계산을 원래 루프에 통합하는 방법을 보려면 광산을 살펴보십시오. 임의의 정밀 산술이없는 경우 약간 더 큰 범위에서 작업 할 수 있다는 이점이 있습니다. 나는 그것이 면도해야 할 또 다른 20 바이트라고 생각합니다.
— rici
3

C / BC, 233 (121) 112 바이트 (3 바이트 패널티 가정 |bc)

  1. 콜 카메론 (Cole Cameron)에서 영감을 얻어 해키 (Hacky) 문자 조작을 제거하고 인수 값을 산술했습니다.

  2. arg 벡터 사용에서 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 실제로 임의 정밀도 계산을 할 수 있습니다.

언 골프 및 경고 무료 :

#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

그리고 파이프를 bc를 통해 (그리고 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

이것은 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
— 리치
소스
3

펄 6, 117 바이트

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

더 읽기 쉬운 fasion에서

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;
}
— 여호수아
소스
3

펄 5, 108 바이트

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

17 바이트를 절약 해 준 dev-null 과 팩토리얼 아이디어를위한 japhy 에 감사드립니다 .

— msh210
소스
3

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
— 그리미
소스
3

파이썬 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 단계에서 계산 된 숫자로 나눕니다.
— 엘 페드로
소스
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)

input $args[0]을 빼고 1, 0..그 숫자 에서 정수 범위를 만들고 , -join그 문자열을 문자열로 모아서로 저장합니다 $b. 우리 .Length는 그 문자열을 가져 와서 1..그 길이 에서 다른 범위를 만들고 -join그 정수를와 함께 *파이프 한 다음Invoke-Expression (와 유사하게 eval) . 즉, 입력을 기반으로 숫자 시퀀스 길이의 계승을 구성했습니다. 그것은 우리의 분자입니다.

우리는 그것을 나누어 / ...

우리의 분모는 범위를 취하고 0..9for-loop를 통해 전송 하여 구성됩니다 |%{...}. 각 반복마다 속성 과 결합 된 .NET 호출로 인해 $c현재 숫자 $_가 나타나는 횟수와 같은 도우미 변수를 설정했습니다 . 그런 다음 0이 아닌 한 해당 값까지 새로운 범위를 구성합니다. 예, 많은 경우에 이로 인해 range가 발생 하여 just로 평가됩니다 . 우리는 이것들과 그것들 을 모두 가지고 와서 다시 파이프로 연결 합니다. 다시 말해, 우리는 각 숫자의 발생 횟수에 대한 계승의 곱을 구성했습니다.$b[regex]::matches.count1..1..11-join*Invoke-Expression

NB

90문제없이 입력을 1 초 미만으로 처리합니다.

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 길이의 범위를 설정 한 다음 다시 캐스팅해야하므로 코드가 크게 팽창합니다 거기에서 각각의 곱셈. 도전 과제가 상위 범위를 지정하지 않기 때문에 이것이 적절하다고 가정합니다.

— AdmBorkBork
소스
2

펄 6

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'

지금 당장 골퍼가 아닌 지금 수면이 필요합니다.

— 사용자
소스
2

그루비, 156 바이트

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

나의 겸손한 첫 번째 코드 골프 솔루션. 여기서 테스트 할 수 있습니다.

그리고 더 읽기 쉬운 버전이 있습니다 :

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

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

매우 간단하지만 몇 가지 주요 사항이 있습니다.

  • 분사 수행 / 배열로부터 감소 chars(A)에 Map<Character, Integer>. 맵 값에 대한 기본값이 없기 때문에 여전히 약간 복잡했습니다. 이것은 의심의 여지가 있지만 맵이 모든 값을 0으로 기본 설정하면 NPE를 피하는 데 필요한 삼항을 피할 수 있습니다.

  • Groovy 스프레드 연산자 (예 :) }*.value는 항상 재미 있습니다

그러나 성가신 기능에서는 반환 유형으로 계승 함수를 선언해야했습니다 BigInteger. Groovy가 모든 숫자를 BigInteger또는 안에 넣었다는 인상을 BigDecimal받았지만 반환 유형에 대해서는 그렇지 않을 수도 있습니다. 나는 더 많은 실험을해야 할 것이다. 이 반환 유형을 명시 적으로 지정하지 않으면 잘못된 계승 값을 매우 빠르게 얻을 수 있습니다.

— 리그
소스
2

J, 33 바이트

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

범위를 자릿수 문자열로 변환하고 각 자릿수를 센 다음 다항 계수를 적용하여 결과를 계산합니다.

용법

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

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 바이올린에서 사용해보십시오

설명

  1. 벡터를 생성 0 ... n-1하고 문자열로 축소 :paste(1:n-1,collapse="")
  2. 문자열을 숫자로 나누고 numeric (store as x) 으로 변환하십시오 .x=as.numeric(el(strsplit(...,"")))
  3. 분자를 계산하기 위해 우리 factorial(sum(1|x))는 단순히#digits!

  4. 분모를 계산하기 table위해 빈도를 나열하는 우발 사태 테이블을 구성하는 데 사용 합니다. F (12)의 경우 생성 된 테이블은 다음과 같습니다.

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

  5. 즉 factorial(), 카운트 에서 사용 (벡터화 됨)을 취하고 간단히 제품을 사용할 수 있음을 의미 합니다.prod(factorial(table(x)))

참고 : 4 단계와 5 단계는 n>0그렇지 않은 경우에만 전달됩니다 1.

— 빌리 wo
소스
1

Mathematica, 65 바이트

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

아마도 더 골프를 칠 수있을 것입니다.

— 군단 포유류 978
소스
1

젤리 , 11 바이트

골프 데니스의 15 바이트 젤리 답변 ...

ḶDFµW;ĠẈ!:/

음이 아닌 정수를 허용하는 양수 링크는 양의 정수를 생성합니다.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

ḶDFµW;ĠẈ!:/ - Link: non-negative integer, N   e.g. 12
Ḷ           - lowered range            [0,1,2,3,4,5,6,7,8,9,10,11]
 D          - to decimal (vectorises)  [[0],[1],[2],[3],[4],[5],[6],[7],[8],[9],[1,0],[1,1]]
  F         - flatten                  [0,1,2,3,4,5,6,7,8,9,1,0,1,1]
   µ        - start a new monadic chain - i.e. f(that)
    W       - wrap in a list           [[0,1,2,3,4,5,6,7,8,9,1,0,1,1]]
      Ġ     - group indices by values  [[1,12],[2,11,13,14],3,4,5,6,7,8,9,10]
     ;      - concatenate              [[0,1,2,3,4,5,6,7,8,9,1,0,1,1],[1,12],[2,11,13,14],3,4,5,6,7,8,9,10]
       Ẉ    - length of each           [14,2,4,1,1,1,1,1,1,1,1]
        !   - factorial (vectorises)   [87178291200,2,24,1,1,1,1,1,1,1,1]
          / - reduce by:
         :  -   integer division       1816214400
— 조나단 앨런
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.