팩토리얼 이라고도 하는 팩토리얼 넘버 시스템 은 혼합 기수 시스템입니다. 계승은 숫자의 자리 값을 결정합니다.

이 시스템에서 가장 오른쪽에있는 숫자는 0 또는 1 일 수 있고, 두 번째 가장 오른쪽에있는 숫자는 0, 1 또는 2 등일 수 있습니다. 이것은 n숫자 팩토리얼 숫자가 최대 값을 가질 수 있음을 의미합니다 (n + 1)!.

예를 들어, 계승 수 24201를 10 진수 로 변환하려면 다음을 수행하십시오.

2 * 5! = 240
4 * 4! = 96
2 * 3! = 12
0 * 2! = 0
1 * 1! = 1
240 + 96 + 12 + 0 + 1 = 349

따라서 계승 수 24201는 349기본 10입니다.

10 진수 ( 349예를 들어)를 계승 수로 변환하려면 다음과 같이하십시오.

숫자보다 작은 계승을 취하십시오. 이 경우에는 120또는 5!입니다.

349 / 5! = 2 r 109
109 / 4! = 4 r 13
13 / 3! = 2 r 1
1 / 2! = 0 r 1
1 / 1! = 1 r 0

따라서 349기본 10은 계승 수 24201입니다.

문제는 입력 번호를 다른 기준으로 변환하는 가장 짧은 프로그램이나 기능을 만드는 것입니다.

입력은 음이 아닌 정수의 문자열 표현입니다. 계승 숫자 앞에는 !(예 :)가 표시되고 !2420110 진수 앞에는 아무것도 표시되지 않습니다. 당신은 최대 입력이 될 것이라고 가정 할 수있다 10! - 1- 3628799진수와 987654321factoradic에. 이것은 문자가 팩토리얼 입력 / 출력에 나타나지 않음을 의미합니다.

프로그램은 a !를 계승 출력 앞에 추가 할 필요가 없으며 문자열 또는 정수를 출력 할 수 있습니다. 입력은 적절한 형식 일 수 있습니다.

테스트 사례 :

Input: 1234
Output: 141120

Input: 746
Output: 101010

Input: !54321
Output: 719

Input: !30311
Output: 381

APL, 39 37 자

{A B←(9⍴10)(⌽1+⍳9)⌽⍨'!'∊⍵⋄A⊥B⊤⍎⍵~'!'}

예 :

      {A B←(9⍴10)(⌽1+⍳9)⌽⍨'!'∊⍵⋄A⊥B⊤⍎⍵~'!'}'1234'
141120
      {A B←(9⍴10)(⌽1+⍳9)⌽⍨'!'∊⍵⋄A⊥B⊤⍎⍵~'!'}'!54321'
719

2.7 파이썬 ( 163 (157) 152)

i=raw_input()
exec("b='';a=362880;j=int(i);x=9;"+'b+=`j//a`;j%=a;a/=x;x-=1;'*9,"a=x=1;b=0;"+'b+=a*int(i[-x]);x+=1;a*=x;'*~-len(i))['!'in i]
print int(b)

더 읽기 쉬운 버전 :

i=raw_input()
if'!'in i:a=x=1;b=0;c='b+=a*int(i[-x]);x+=1;a*=x;'*~-len(i)
else:b='';a=362880;j=int(i);x=9;c='b+=`j//a`;j%=a;a/=x;x-=1;'*9
exec c;print int(b)

고장:

Factoradic -> Decimal, when i is in the form !(number)
a=1   #Factorial value (multiplied every iteration)
x=1   #Index value
b=0   #Output
iterate ~-len(i) times:    #PSEUDOCODE! bitwisenot(a) = ~a = -a-1
    b+=a*int(i[-x])        #add the value of the xth last character in the factoradic #
    x+=1                   #Increment x
    a*=x                   #Set a to x!, (x-1)! * x = x!

Decimal -> Factoradic
b=''                       #Output
a=362880                   #Factorial value, set to 9! here
j=int(i)                   #Integer value of the input
x=9                        #Index value
iterate 9 times:           #PSEUDOCODE! This block is in an exec() loop
    b+=`j/a`               #Add floor(j/a) to b
    j%=a                   #Take out all multiples of a in j
    a/=x                   #Set a to (x-1)!, x! / x = (x-1)!
    x-=1                   #Decrement x

GolfScript ( 48 44 43 자)

.~\{1{):?\.?%\?/@}9*{*+}+9*}:^{:N,{^N=}?}if

이것은 독립적 인 프로그램입니다. factoriadic => 십진 변환은 직접적인 기본 변환보다는 십진 => factoriadic 변환을 사용하여 검색하기 때문에 상당히 느립니다.

입력 형식은 매우 짧은 모드 전환을 허용 .~합니다. 입력 문자열을 복사하여 평가하므로 입력이 단지 숫자 인 "1234" 1234경우 스택과 같이 시작하고 시작하면 !(논리적이거나 비어 있지 않은) 우리는 예 0 30311를 들어 스택에서 끝납니다 . 그런 다음 스택 맨 아래의 값은 decimal => factoriadic의 경우 진실이고 factoriadic => decimal의 경우 거짓입니다.

PHP <7.1 178 171 170 168 164 155 147 144 138 126 123 바이트

for($b=$j=1,$i=strlen($x=$argn);+$x?$b<=$x:--$i;$b*=++$j)$r+=$x[$i]*$b;if(+$x)for(;$j>1;$x%=$b)$r.=$x/($b/=$j--)|0;echo+$r;

파이프로 실행 -r하거나 온라인으로 테스트하십시오 .

• 연장 불필요
• 하위 기능이 필요 하지 않습니다 : 계승 기반을 재사용하고 있습니다 (루프에서 증가 / 감소)
• 순수한 정수 및 문자열 산술은 PHP 3에서도 작동해야하며 여전히 PHP 7에서도 작동합니다.
• 10 진수 0은 대신 빈 문자열을 반환합니다 0. (다른 PHP 답변도 마찬가지입니다.) 이것이 허용되지 않는 경우, 여분의 경우 +5를 추가하십시오.

언 골프 :

// two loops in one: compute the decimal number from a factorial
// or find the first factorial larger than a decimal $x
// the latter inits $r with '0': $i=strlen -> $x[$i]=='' -> (int)$x[$i]==$x[$i]*$b==0
// $b is the current digit´s base; $j is the bases´ latest factor
for($b=$j=1,$i=strlen($x=$argn);+$x?$b<=$x:--$i;$b*=++$j)
    $r+=$x[$i]*$b;
// and now for dec->fact ...
if(+$x)
    for(;$j>1;$x%=$b)
        // both $b and $j are one step too far in the first iteration;
        // -> decrement must precede the actual loop body
        // -> can be merged into the digit calculation -> all braces golfed
        $r.=$x/($b/=$j--)|0;
        // now: go on with the remainder (see loop head)
echo+$r; // final type cast removes leading zeros (from the first loop)
    // and fixes the '0' result (no operations at all on that input!)

버려진 골프 아이디어 :

• $b<=$x-> $b<$x(-1)
  은 순수 십진 계승 (즉, 0이 아닌 하나의 숫자로 계승 된 숫자 ) 을 깰 것입니다. JMPC의 솔루션은 그 점에서 어려움을 겪습니다. HamZa´s는 그렇지 않습니다.
• floor($x/$b)-> (int)($x/$b)
  조금 더 빠를 수 있지만 타입 캐스팅은 나누기보다 우선하므로 괄호가 필요하고 바이트를 얻지 않습니다. $x/$b|0트릭을 수행
• 사실-> 루프는 사실상-팩토리얼 찾기와 유사합니다. 동일한 증분, 본문은 중요하지 않지만 불행히도 사전 설정과 사후 조건이 다릅니다. 댕; 거기에서 골프를 쳤을 수 있습니다.
  예, 해결책을 찾았습니다. 골프의 꽤했다,하지만 다른 떨어져 다진 -4 (번호 : -9) 및 모든 버그 / 허점을 마감했다.

더 이상 가능성이 있습니까? 아니면 골프를합니까?

자바 스크립트 (ES 6) 139 137 122 113 111

배열 마술을 사용하여 다른 접근법을 시도했습니다. 그러나 나는 174 172 바이트로 끝났습니다 .

f=x=>{if('!'==x[0]){a=x.split``.reverse();i=b=1;r=0;a.pop();a.map(d=>{r+=d*b;b*=++i})}else{t=[];for(i=b=1;b<=x;b*=++i){t.unshift(b)}r='';t.map(b=>{r+=x/b|0;x%=b})}return r}

방금 PHP 코드를 가져 와서 번역했습니다. 모든 $과를 제거 할 수 ;는 있지만 var를 초기화 해야하는 필요성은 그 이점 중 일부를 차지했습니다. 그래도 골프를 다룰 때 약간 더 해답을 얻습니다.

골프

f=x=>{for(r=0,b=j=1,i=x.length;x|0?b<=x:--i;b*=++j)r+=x[i]*b;if(x|0)for(r='';j>1;x%=b)r+=x/(b/=j--)|0;return r}

• 첫 번째 버전은 10 진수 0에 대해 ''을 반환합니다. 수정하려면 +2 추가
• 두 번째 버전에는 문자열 입력이 필요합니다
• Firefox, Edge 및 Opera에서 모두 테스트

언 골프

f=x=>
{
    for(r=0,b=j=1,i=x.length;x|0?b<=x:--i;b*=++j)
        r+=x[i]*b;
    if(x|0)
        for(r='';j>1;x%=b)
            r+=x/(b/=j--)|0;
    return r
}

테스트 스위트

<table id=out border=1><tr><th>dec</th><th>result<th>expected</th><th>ok?</th></tr></table>
<script>
    addR=(r,s)=>{var d=document.createElement('td');d.appendChild(document.createTextNode(s));r.appendChild(d)}
    test=(x,e)=>{var y=f(x),r=document.createElement('tr');addR(r,x);addR(r,y);addR(r,e);addR(r,e==y?'Y':'N');document.getElementById('out').appendChild(r)}
    samples={'349':'24201','1234':'141120','746':'101010','719':'54321','381':'30311','24':'1000','0':'0'};
    for(d in samples){test(d,samples[d]);test('!'+samples[d],d)}
</script>

펄 6 , 66 65 60 바이트

Jo King 덕분에 -1 바이트

{/\!/??:1[.flip.chop.comb Z*[\*] 1..*]!![R~] .polymod(2..*)}

온라인으로 사용해보십시오!

GolfScript, 69 자

10,1>{1$*}*](.0=33={1>01/-1%0\{~@(@*@+}/\}{~\-1%{1$<},{1$1$/@@%}/}if;

평소와 같이 STDIN에서 입력을 받아 결과를 인쇄합니다. 온라인 테스트 .

하스켈, 221 자

코드 골프

m v@(a:b)|a=='!'=(sum.zipWith(*)g.map(read.(:[])).reverse) b|True=(fst.until((<0).fst.snd)(\(s,(i,b))->(s*10+b`quot`f i,(i-1,b`rem`f i))).(\n->(0,((1+).last.takeWhile((n>=).f)$[1..], n))).read) v;g=scanl1(*)[1..];f=(g!!)

용법

$ ghci factorial.hs
ghci> m "1234"
 141120
ghci> m "!54321"
 719

Ungolfed 코드

parse v@(a:b) | a == '!' = to b
              | otherwise = from v

to = sum . zipWith (*) factorials . map (read . (:[])) . reverse

from = fst . until finished next . boostrap . read
    where finished = ((<0) . fst . snd)
          next (s,(i,r)) = (s * 10 + r `quot` factorial i, (i-1 ,r `rem` factorial i))
          bootstrap n = (0, (lastFact n, n))
          lastFact n = (1+) . last . takeWhile ((n>=) . factorial) $ [1..]

factorials = scanl1 (*) [1..]

factorial = (factorials!!)

매쓰 213 177 175

계승 수는 f[]입력이든 출력이든에 싸여 있습니다.

g@{n_,j_,r_}:=If[j==0,FromDigits@r,g@{q=QuotientRemainder[n,j!];q[[2]],j-1,Append[r,q[[1]]]}]
z@n_:=If[!IntegerQ@n, g[{n[[1]],9,{}}], f@Tr@(p=1;# (p++)!&/@Reverse@IntegerDigits@n)]

용법

z[24201]

f [349]

z[f[349]]

24201

계승을 10 진수로 변환 . QuotientRemainder[n,j!]왼쪽에서 오른쪽으로 계승 수의 자릿수에 재귀 적으로 작용하여 j각 단계에서 감소 합니다. QuotientRemainder[349, 5!]예를 들어, 등을 반환합니다 {2, 109}.

계승 수 소수의 변환 . 순수 함수 인 오른쪽에서 왼쪽으로 이동 # (p++)! &하면 각 자릿수에 #적절한 계승이 곱해 집니다.

파이썬, 128 자

실행하는 데 약 30 분이 걸리지 만 작습니다.

A=[`x`for x in xrange(10**9)if all(x/10**d%10<d+2 for d in range(9))]
i=raw_input()
print A.index(i[1:])if'!'in i else A[int(i)]

모든 <= 9 자리 팩토리 아 숫자 목록을 숫자 순서로 작성한 다음 조회 또는 색인을 수행하여 변환합니다.

테스트 할 경우 바로 교체 10**9와 10**66 자리의 가변 숫자에 자신을 제한합니다.

range(10**9)대신을 사용하여 기술적으로 문자를 저장할 수 xrange(10**9)있습니다. 집에서 시도하지 마십시오.

PHP 231 214 204

최신 답변

function g($x){return $x?$x*g($x-1):1;}function f($x,$e){if($x[0]=="!"){for($t=1;$t<$c=strlen($x);$t++){$e+=$x[$t]*g($c-$t);}}else{while(g(++$p)<=$x);while(--$p){$e.=floor($x/g($p));$x%=g($p);}}return$e;}

기존 답변

 function f($n){if($n[0]=="!"){$n=str_split($n);$c=count($n);$f=$y=1;while($c-->1){$e+=($f*$n[$c]);$f*=++$y;}return$e;}else{for($i=$c=1;$i<$n;$i*=$c){$r[$c++]=$i;}foreach(array_reverse($r)as$t){$e.=floor($n/$t);$n=$n%$t;}return$e;}}

예

echo f('349')."\n"
    .f('!24201')."\n"
    .f('1234')."\n"
    .f('746')."\n"
    .f('!54321')."\n"
    .f('!30311');

산출

24201
349
141120
101010
719
381

젤리, 5 바이트

Æ!ŒṘ€

설명

Æ!ŒṘ€
Æ!     -Convert to factoriadic (list form)
  ŒṘ€  -Construct string

* 젤리는 질문의 나이보다 어리므로 제 대답은 경쟁이 아닙니다.

젤리 , 15 바이트

ḊV€;0Æ¡µÆ!ṖḌƊ¬?

온라인으로 사용해보십시오!

작동 원리

ḊV€;0Æ¡µÆ!ṖḌƊ¬?     Main link (monad). Input: integer or string
             ¬?  *) If the given input is a string, run 1); otherwise run 2)

ḊV€;0Æ¡  1) Factorial base -> integer
ḊV€         Remove "!" and map each char to number
   ;0       Append zero (this is needed to run the built-in correctly)
     Æ¡     Built-in conversion

Æ!ṖḌ  2) Integer -> factorial base
Æ!       Built-in conversion
  ṖḌ     Remove a zero at the end, and convert to decimal

왜 *)작동

¬요소 별 논리 NOT입니다. 단일 정수를 지정하면 단일 0이되고 이는 거짓입니다. 그러나 문자열이 주어지면 각 요소 (문자)가 0으로 바뀌고 전체 결과는 0으로 구성된 배열입니다.

정수로 0은 특별한 경우입니다. "factorial-> integer"경로를 통과하지만 여전히 0을 제공합니다.

팩토리얼베이스가 내장되어 있지 않고 25 바이트

⁵R!µ³%Ḋ:ṖUḌ
⁵R!ḋḊUV€ƊµÇ¬?

온라인으로 사용해보십시오!

작동 원리

⁵R!µ³%Ḋ:ṖUḌ  Aux. link (monad). Integer -> factorial base
⁵R!µ         Set (1..10)! as left argument
    ³%Ḋ:Ṗ    Compute each digit: (input % (2..10)!) // (1..9)!
         UḌ  Reverse and convert the digit array to decimal

⁵R!ḋḊUV€ƊµÇ¬?  Main link (monad).
         怪?  If the input is a string, apply the left chain;
               otherwise, apply the aux. link above
⁵R!            (1..10)!
   ḋ           Dot product with...
    ḊUV€Ɗ      Remove "!", reverse, map each character to digit

K, 102

"I"$,/$*:'|:'{{(x-y*g),g:_(x:*x)%y:*/1+!y}\[x,0n;|1+!{$[(x>(*/1+!y))&x<*/1+!y+1;y;.z.s[x;1+y]]}[x;0]]}

확실히 향상 될 수 있습니다.

k)"I"$,/$*:'|:'{{,[;g]x-y*g:_(x:*x)%y:*/1+!y}\[(x;0n);|1+!{{$[(x>(*/1+!y))&x<*/1+!y+1;y;.z.s[x;1+y]]}[x;0]}x]} 349
24201
k)"I"$,/$*:'|:'{{,[;g]x-y*g:_(x:*x)%y:*/1+!y}\[(x;0n);|1+!{{$[(x>(*/1+!y))&x<*/1+!y+1;y;.z.s[x;1+y]]}[x;0]}x]} 746
101010
k)"I"$,/$*:'|:'{{,[;g]x-y*g:_(x:*x)%y:*/1+!y}\[(x;0n);|1+!{{$[(x>(*/1+!y))&x<*/1+!y+1;y;.z.s[x;1+y]]}[x;0]}x]} 1234
141120

D (159 자)

int x(string n){import std.conv;int r,i=9,f=9*'鶀',d;if(n[0]<48){while(r.text.x<n[1..$].to!int)r++;}else{d=n.to!int;while(i){r=r*10+d/f;d%=f;f/=i--;}}return r;}

언 골프 및 프로그램 진입 점

모든 명령 행 인수는로 인쇄됩니다 <original> -> <converted>. 실제로는 십진수에서 인수로만 구현됩니다 x. 다른 방법으로 라운드 x는 결과가 입력과 같아 질 때까지 모든 10 진수 (0 .. *)로 호출 합니다. 가장 큰 입력 (! 987654321)의 경우 ~ 3 초가 걸립니다.

실행 가능한 온라인 버전 : http://dpaste.dzfl.pl/46e425f9

void main(string[] args) {
    import std.stdio;
    foreach (arg; args[1 .. $]) {
        writefln("%s -> %s", arg, x(arg));
    }
}

int x(string n) {
    import std.conv;
    int r, i=9, f=9*'鶀', d;  // 鶀's Unicode index equals 8*7*6*5*4*3*2*1

    // If the first character value is less than 48 ('0') it should be a '!'.
    if (n[0] < 48) {
        // Call x with different input (0..*) until it matches our n.
        // r.text.x is rewritten as x(text(r)).
        while (r.text.x < n[1..$].to!int) r++;
    } else {
        d = n.to!int;
        // Try d / 9!, d / 8!, etc. just as in the problem description.
        while (i) {
            r = r*10 + d/f;
            d %= f;
            f /= i--;
        }
    }
    return r;
}

VBA 225

도움을 주신 Titus에게 감사드립니다! 아직도 더 골프를 찾고 있습니다.

Sub a(b)
Set w=WorksheetFunction
e=Len(b)
If IsNumeric(b) Then
i=0
For d=0To 8
h=w.Fact(9-d)
g=b Mod h
If g<b+i Then
i=1
f=f &Int(b/h)
b=g
End If
Next
Else
For d=2To e
f=f+w.Fact(e-d-1)*Mid(b,d,1)
Next
End If
MsgBox f
End Sub

PHP , 124 바이트

for($f=1;("$">$a=$argn)&&~$c=strrev($a)[$n];)$r+=$c*$f*=++$n;for(;$a>=$f*=++$i;);for(;~-$i;$a%=$f)$r.=0|$a/$f/=$i--;echo+$r;

온라인으로 사용해보십시오!

펼친

for($f=1;("$">$a=$argn)&&~$c=strrev($a)[$n];) # runs in case of "!" at the beginning
  $r+=$c*$f*=++$n; #reverse string multiply with the next factorial "!"*$f=0
for(;$a>=$f*=++$i;); # runs not in case of "!" at the beginning string comparing. search the factorial that is higher as input value
for(;~-$i;$a%=$f) # runs only when the second loop had runs
  $r.=0|$a/$f/=$i--; # concat the value of the division with the highest factorial used
echo+$r; # Output result

펄 6 , 150 바이트

{/^\!/??([+] [Z*] .comb.skip.reverse,[\*] 1..*)!!(reduce
->\a,\b{a[0]~a[1] div b,a[1]%b},("",+$_),|(first
*[*-1]>$_,[\,] [\*] 1..*).reverse[1..*])[0]}

APL (NARS), 36 자, 72 바이트

{⍵⊆⎕D:10⊥(9..2)⊤⍎⍵⋄t+.×⌽!⍳≢t←⍎¨,1↓⍵}

하워드 덕분에 10 ⊥ (9..2) re가 재귀 함수보다 낫습니다 (100 %를 이해하지 못하더라도). '!'없이 숫자 입력 <10 !. 테스트:

  u←{⍵⊆⎕D:10⊥(9..2)⊤⍎⍵⋄t+.×⌽!⍳≢t←⍎¨,1↓⍵}    
  u¨'1234' '746' '!54321' '!30311' '!24201'    
141120 101010 719 381 349 
  u '0'
0
  u '!0'
0
  u '9'
111
  u '!111'
9
  u '!9'
9