Faktoriyel Sayı Sistemi ayrıca factoradic denilen, karışık sayı tabanı rakamı sistemidir. Faktörler, bir sayının yer değerini belirler.

Bu sistemde, en sağdaki hane 0 veya 1 olabilir, en sağdaki ikinci hane 0, 1 veya 2 olabilir, vb. Bu, bir nrakam faktoradik sayısının maksimum değerine sahip olabileceği anlamına gelir (n + 1)!.

Örneğin, faktoradik sayıyı 24201ondalık sayıya dönüştürmek için şunu yapardınız :

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

Bu nedenle factoradic sayı 24201olduğu 349nokta 10.

Ondalık bir sayıyı ( 349örnek olarak) faktoradik bir sayıya dönüştürmek için şunu yaparsınız:

Sayıdan daha büyük olan en büyük faktörü alın. Bu durumda 120, ya da 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

Dolayısıyla 349taban 10faktoradik sayıdır 24201.

Buradaki zorluk, bir giriş numarasını diğerine dönüştüren en kısa programı veya işlevi oluşturmaktır.

Giriş, negatif olmayan bir tamsayının dizgi gösterimi olacaktır. Faktoradik bir sayının önünde bir !(örneğin !24201), ondalık sayısında hiçbir şey olmaz. Maksimum giriş olacağını varsayabiliriz 10! - 1- 3628799ondalık ve 987654321factoradic içinde. Bu, harflerin faktoradik bir girdi / çıktıda görünmeyeceği anlamına gelir.

Programın !faktoradik bir çıktıya hazırlanmasına gerek yoktur ve bir dize veya tamsayı üretebilir. Giriş herhangi bir makul formatta olabilir.

Test durumları:

Input: 1234
Output: 141120

Input: 746
Output: 101010

Input: !54321
Output: 719

Input: !30311
Output: 381

APL, 39 37 karakter

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

Örnekler:

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

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

Daha okunabilir sürüm:

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)

Yıkmak:

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

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

Bu kendi kendine yeten bir programdır. Factoriadic => ondalık dönüşüm oldukça yavaştır, çünkü doğrudan temel dönüşüm yerine ondalık => factoriadic dönüşüm kullanarak bir arama yapar.

Giriş formatı çok kısa bir mod anahtarına izin verir: .~giriş dizesini kopyalar ve değerlendirir, böylece giriş sadece "1234" 1234istif ile bittiğimiz bir sayıysa ve istif ile başlıyorsa !(mantıksal değil, boş olmayanlar varsa) string truthy) biz örneğin 0 30311yığında son buluruz . Daha sonra yığının altındaki değer ondalık => factoriadic için asal ve factoriadic => ondalık için yanlıştır.

PHP <7.1 178 171 170 168 164 155 147 144 138 138 123 bayt

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;

Boru olarak çalıştırın -rveya çevrimiçi olarak test edin .

• uzatma gerekmez
• bir alt fonksiyon gerekli: faktörlü bir baz (halkalarla / incresed azalma) yeniden kullanılması
• saf tamsayı ve string aritmetics, php 3'te bile çalışmalıdır (ve hala php 7'de çalışmaktadır):
• Ondalık 0 yerine boş bir dize döndürür 0. (diğer iki PHP cevabı da aynı şekilde yapılabilir.) Eğer bu kabul edilemez ise, ekstra durum için +5 ekleyin.

ungolfed:

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

terk edilmiş golf fikirleri:

• $b<=$x-> $b<$x(-1)
  yalnızca ondalık basamaklarla (yani yalnızca sıfır olmayan bir rakamla birlikte faktoring numarasıyla sonuçlananları ) kırar. JMPC’nin çözümü bundan sıkıntı çekiyor; HamZa değil.
• floor($x/$b)-> (int)($x/$b)
  biraz daha hızlı olabilirdi, ama tip döküm bölümden önce geliyor, bu yüzden parantez içinde olmalıyım ve bayt kazanmıyorum. $x/$b|0hile yapar
• Aslında-> dec'deki döngü, gerçekte faktör-bulmaya benzer. Aynı artış, vücut önemli değil, ama ne yazık ki farklı önceden belirlenmiş ve farklı post koşulu. Dang; orada -21 golf olabilirdi.
  YAY bir çözüm buldum. Biraz golf oynadı, fakat bir tane daha -4 kesildi (no: -9) ve tüm hataları / boşlukları kapattı.

Daha fazla potansiyel var mı yoksa golf oynamayı mı bitirdim?

JavaScript (ES 6) 139 137 122 113 111

Bazı dizi sihir kullanarak farklı bir yaklaşım denedi; ama bununla 174 172 byte bitirdim:

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}

Ben de sadece PHP kodumu aldım ve tercüme ettim. Tüm $s ve birkaçı kaldırabilir ;, ancak başlangıç ​​durumuna getirme zorunluluğu, bu faydadan bazılarını yedi. Yine de golf oynamaya başlandı, ancak biraz daha cevaplar.

golfed

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}

• ilk sürüm ondalık 0 için '' döndürür; düzeltmek için +2 ekle
• İkinci versiyon string girişi gerektiriyor
• her ikisi de Firefox, Edge ve Opera’da test edildi

ungolfed

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
}

test odası

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

Perl 6 , 66 65 60 bayt

Jo King sayesinde -1 bayt

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

Çevrimiçi deneyin!

GolfScript, 69 karakter

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

Her zamanki gibi STDIN'den girdi alır ve sonucu yazdırır. Çevrimiçi testi .

Haskell, 221 karakter

Code Golf

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

kullanım

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

Ungolfed kod

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

Mathematica 213 177 175

f[]Girdi veya çıktı olsun , bir faktöriyel sayı sarılır .

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

kullanım

z[24201]

f [349]

z[f[349]]

24201

Faktoringin ondalık sayıya dönüşümü . QuotientRemainder[n,j!]Faktoring sayısının basamağını j, her adımda azaltarak soldan sağa tekrarlayarak hareket eder . QuotientRemainder[349, 5!], örneğin, döner {2, 109}ve benzeri.

Ondalık değerin faktör sayısına çevrilmesi . Sağa ve sola hareket etme, saf işlev, # (p++)! &her basamağı, #uygun faktörle çarpar .

Python, 128 karakter

Bu çalıştırmak için yaklaşık yarım saat sürer, ancak küçük:

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

Sayısal sırayla tüm <= 9 basamaklı faktoradik numaraların bir listesini oluşturur, daha sonra dönüştürmek için bir arama veya dizin yapar.

Eğer teste istiyorsanız, sadece yerini 10**9ile 10**6ve 6 basamaklı variadic sayılara kendinizi kısıtlamak.

Teknik olarak range(10**9)yerine karakter kullanarak kaydedebilirim xrange(10**9). Bunu evde denemeyin.

PHP 231 214 204

En yeni cevap

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

Eski cevap

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

Örnek

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

Çıktı

24201
349
141120
101010
719
381

JELLY, 5 bayt

Æ!ŒṘ€

açıklama

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

* Jöle soru yaşından daha küçüktür, bu yüzden cevabım rekabetçi değildir.

Jöle , 15 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Ḋ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

Neden *)çalışıyor

¬eleman şeklinde mantıksal DEĞİLDİR. Tek bir tamsayı verildiğinde, yanlış olan, tek bir sıfır olur. Bununla birlikte, bir dize verildiğinde, her öğe (karakter) sıfıra çevrilir ve sonuç, doğru olan sıfır dizisidir.

Bir tamsayı olarak sıfır özel bir durumdur. "Faktöriyel -> tamsayı" yolundan geçiyor ancak yine de doğru olan sıfırı veriyor.

Faktoring temeli olmadan, 25 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

⁵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]]}

Kesinlikle geliştirilebilir.

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

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

Ungolfed ve program giriş noktası ile

Tüm komut satırı argümanları olarak yazdırılır <original> -> <converted>. Sadece faktoradic için ondalık, aslında içinde uygulanmaktadır x. Diğer taraftan x, sonuç girişe eşit olana kadar sadece tüm ondalık sayılarla (0 .. *) çağrılır. Bu en büyük giriş için ~ 3 saniye sürer (! 987654321).

Yürütülebilir çevrimiçi sürüm: 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

Yardım için Titus'a teşekkürler! Hala biraz daha golf oynamak istiyorum.

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 bayt

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;

Çevrimiçi deneyin!

Genişletilmiş

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

Perl 6 , 150 bayt

{/^\!/??([+] [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 karakter, 72 bayt

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

10⊥ (9..2) ⊤ özyinelemeli işlevden daha iyidir, bunu gösteren diğer APL çözümü için Howard sayesinde ... (% 100'ü anlamadım bile). '!' Olmayan numaraların girişi <10 !. Ölçek:

  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