27

भाज्य संख्या प्रणाली , भी factoradic कहा जाता है, एक मिश्रित मूलांक अंक प्रणाली है। भाज्य एक संख्या के स्थान मूल्य को निर्धारित करते हैं।

इस प्रणाली में, सबसे सही अंक 0 या 1 हो सकता है, दूसरा सबसे सही अंक 0, 1 या 2 हो सकता है, और इसी तरह। इसका मतलब यह है कि एक nअंक कारक संख्या का अधिकतम मूल्य हो सकता है (n + 1)!।

उदाहरण के लिए, फैक्टरैडिक संख्या 24201को दशमलव में बदलने के लिए आप यह करेंगे:

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

इसलिए factoradic संख्या 24201है 349आधार 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।

आपकी चुनौती सबसे छोटा प्रोग्राम या फ़ंक्शन बनाना है जो एक इनपुट नंबर को दूसरे आधार में परिवर्तित करता है।

इनपुट एक गैर-नकारात्मक पूर्णांक का एक स्ट्रिंग प्रतिनिधित्व होगा। एक फैक्टरैडिक संख्या एक !(जैसे !24201) से पहले होगी, जबकि एक दशमलव संख्या कुछ भी पहले नहीं होगी। आप मान सकते हैं कि अधिकतम इनपुट होगा 10! - 1- 3628799दशमलव में और 987654321factoradic में। इसका मतलब है कि कारक फैक्टरैडिक इनपुट / आउटपुट में नहीं दिखाई देंगे।

कार्यक्रम !को एक फैक्टरैडिक आउटपुट के लिए प्रस्तुत करने की आवश्यकता नहीं है , और एक स्ट्रिंग या पूर्णांक का उत्पादन कर सकता है। इनपुट किसी भी उचित प्रारूप में हो सकता है।

परीक्षण के मामलों:

Input: 1234
Output: 141120

Input: 746
Output: 101010

Input: !54321
Output: 719

Input: !30311
Output: 381

code-golf number base-conversion

— अस्थिरता
स्रोत

10

एपीएल, ३ ९ ३ characters अक्षर

{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

— हावर्ड
स्रोत

1

मुझे लगता है कि आप की जगह ले सकता ⍴⍵∩'!'के साथ '!'∊⍵एक चरित्र को बचाने के लिए।

— अस्थिरता

@Volatility हाँ आप कर सकते हैं। मुझे भी एक और मिला।

— हावर्ड

11

आपकी लिपि में "pwn" शब्द होने से IMO अतिरिक्त चरित्र के लायक है।

— '12:

1

मैं एज्रब से सहमत हूं। क्या आप कृपया इसे तोड़ देंगे?

— टाइटस

1

एक चरित्र को बचाने के लिए के ~'!'साथ बदलें ∩⎕D।

— एडम

9

पायथन 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

— beary605
स्रोत

1

अच्छा समाधान है। मुझे लगता है कि आप के '!'==i[0]साथ बदल '!'in iसकते हैं, और उपयोग कर सकते हैं a=x=1। इसके अलावा, आपको निष्पादन विवरण के आसपास कोष्ठक की आवश्यकता नहीं है।

— GRC

1

आप के (len(i)-1)साथ भी बदल सकता है ~-len(i)।

— उतार

@Volatility, grc: धन्यवाद! मुझे अपने

— बिटवाइज

1

अच्छा जवाब, मैंने इस कथन को बदलने की कोशिश की स्वतंत्रता ली (a,b)['!'in i]और 6 वर्णों को हटाने में कामयाब रहा। हालांकि यह उतना पठनीय नहीं है, जितना कि ...

— पास्टेबिन

@erjb: सुझाव के लिए धन्यवाद! मैं कोड के साथ एक 2-ट्यूपल का उपयोग करता था जिसमें एक स्ट्रिंग इन-लाइन फंक्शन के साथ होता था, जो दो और पात्रों को बचाता है :)

— beary605

8

गोल्फक्राफ्ट ( 48 44 43 वर्ण)

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

यह एक स्व-निहित कार्यक्रम है। फ़ैक्टियाडिक => दशमलव रूपांतरण काफी धीमा है, क्योंकि यह प्रत्यक्ष आधार रूपांतरण के बजाय दशमलव => कारक रूपांतरण का उपयोग करके खोज करता है।

इनपुट प्रारूप बहुत कम मोड स्विच के लिए अनुमति देता है: .~इनपुट स्ट्रिंग की प्रतिलिपि बनाता है और इसका मूल्यांकन करता है, इसलिए यदि इनपुट सिर्फ एक संख्या है जो हम "1234" 1234स्टैक पर उदाहरण के साथ समाप्त करते हैं, और अगर यह !किसी भी गैर-खाली के साथ शुरू होता है (तार्किक नहीं, तो स्ट्रिंग का सत्य होना) हम 0 30311स्टैक पर उदाहरण के साथ समाप्त होते हैं । तब स्टैक के निचले भाग में मान दशमलव => फ़ैक्टियाडिक और फ़ैसीसिक => दशमलव के लिए गलत है।

— पीटर टेलर
स्रोत

4

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 में काम करता है):
~~दशमलव 0 के बजाय खाली स्ट्रिंग देता है 0।~~ (दोनों अन्य PHP उत्तर भी करते हैं।) ~~यदि यह अस्वीकार्य है, तो अतिरिक्त मामले के लिए +5 जोड़ें।~~

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

परित्यक्त गोल्फ विचार:

$b<=$x-> $b<$x(-1)
शुद्ध दशमलव भाज्य को तोड़ देगा (अर्थात जो केवल एक शून्य-शून्य अंक के साथ एक भाज्य संख्या का परिणाम होगा)। JMPC के समाधान से ग्रस्त है; HamZa doess नहीं करता है।
floor($x/$b)-> (int)($x/$b)
थोड़ा तेज हो सकता है, लेकिन टाइपिंग कास्टिंग पूर्व विभाजन है, इसलिए मुझे कोष्ठक की जरूरत है और एक बाइट हासिल नहीं करना चाहिए। $x/$b|0उसने चाल चली
वास्तव में लूप-> डिक, फैक्टर-फाइंड के समान है। एक ही वेतन वृद्धि, शरीर कोई फर्क नहीं पड़ता, लेकिन दुर्भाग्य से अलग पूर्व निर्धारित और अलग पोस्ट की स्थिति है। डैंग; वहाँ गोल्फ -21 हो सकता है।
YAY मुझे एक समाधान मिला। काफी गोल्फ का एक सा लिया, लेकिन एक और काटा -4 (कोई: -9) और सभी बग / कमियां बंद कर दिया।

किसी भी अधिक क्षमता ... या मैं गोल्फ कर रहा हूँ?

— टाइटस
स्रोत

@ JörgHülsermann संकेत के लिए धन्यवाद।

— टाइटस

1

+$r$r|0एक बाइट को बचाने के बजाय । उसी के लिएif($x|0)

— जोर्ग हल्सरमैन

3

जावास्क्रिप्ट (ईएस 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 कोड लिया और उसका अनुवाद किया। सभी $s और कुछ को हटा सकता है ;, लेकिन vars को इनिशियलाइज़ करने की आवश्यकता ने उस लाभ में से कुछ को खा लिया। हालांकि दोनों को थोड़ा और जवाब देने के लिए गोल्फ का प्रबंधन किया गया।

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}

पहला संस्करण दशमलव 0 के लिए '' लौटाता है; तय करने के लिए +2 जोड़ें
दूसरे संस्करण के लिए स्ट्रिंग इनपुट की आवश्यकता है
दोनों फ़ायरफ़ॉक्स, एज और ओपेरा में परीक्षण किया

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
}

परीक्षण सूट

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

— टाइटस
स्रोत

1

ES5 में तीर संकेतन IIRC नहीं है। और यदि आप ES6 का उपयोग करने जा रहे हैं, तो .split('')=>.split``

— Zacharý

@ Zacharý Gna मुझे ध्यान देना चाहिए कि मैंने किस ब्राउज़र में इसका परीक्षण किया ... शायद फ़ायरफ़ॉक्स या ओपेरा। तो ES 6?

— टाइटस

हाँ, तीर संकेतन ES6 है।

— जकार्इ

1

ओह, कि मुझे गार्ड से पकड़ा, मैंने सोचा कि शीर्ष पर कोड ब्लॉक आपका समाधान था! बावजूद, मुझे नहीं लगता कि आपको कहने की ज़रूरत है f=। भी, हो r+=(x/(b/=j--)|0)सकता है r+=x/(b/=j--)|0?

— जकार्इ

2

पर्ल 6 , 66 65 60 बाइट्स

-1 किंग जोए को धन्यवाद

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

इसे ऑनलाइन आज़माएं!

— nwellnhof
स्रोत

1

GolfScript, 69 वर्ण

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

STDIN से इनपुट हमेशा की तरह लेता है और परिणाम प्रिंट करता है। ऑनलाइन टेस्ट ।

— हावर्ड
स्रोत

1

हास्केल, 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

अघोषित कोड

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

— StreakyCobra
स्रोत

अब तक सबसे पठनीय प्रविष्टि। हास्केल FTW!

— सोहम चौधरी

1

गणितज्ञ 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]

च [349]

z[f[349]]

24201

फैक्टरियल का दशमलव संख्या में रूपांतरण । प्रत्येक चरण पर QuotientRemainder[n,j!]बाएं से दाएं तक फैक्टरियल नंबर के अंकों पर पुनरावर्ती कार्य करता है j। QuotientRemainder[349, 5!], उदाहरण के लिए, रिटर्न {2, 109}इत्यादि।

दशमलव का तथ्यात्मक संख्या में रूपांतरण । दाएं से बाएं, शुद्ध कार्य, # (p++)! &प्रत्येक अंक को गुणा #करके, उपयुक्त तथ्य द्वारा गुणा करता है।

— DavidC
स्रोत

1

अजगर, 128 चरस

इसे चलाने में लगभग आधा घंटा लगता है, लेकिन यह छोटा है:

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 अंकों के फैक्टरैडिक नंबरों की एक सूची बनाता है, फिर एक लुकअप या इंडेक्स में परिवर्तित करता है।

यदि आप परीक्षण करना चाहते हैं, तो बस अपने आप को 6 अंकों के वैरेडिक नंबरों के 10**9साथ बदलें 10**6और प्रतिबंधित करें।

मैं तकनीकी रूप से range(10**9)इसके बजाय का उपयोग करके एक चरित्र को बचा सकता है xrange(10**9)। घर पर यह कोशिश मत करो।

— कीथ रान्डेल
स्रोत

बीच में कोई जगह की जरूरत नहीं है d+2औरfor

— 20

1

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

उत्पादन

— जेपीएमसी
स्रोत

2

मैं नए उत्तर के लिए 212 की गिनती करता हूं, 214 की नहीं। $ e को कोई आरंभीकरण (-6) की आवश्यकता नहीं है और foreach(range())इसे एक साधारण forलूप (-9) से बदला जा सकता है । मुझे विचार पसंद है, हालांकि।

— टाइटस

2

शुद्ध तथ्य के लिए गलत परिणाम। 24लौट आना चाहिए 1000लेकिन लौट आता है 400। तय: g(++$p)<$x-> g(++$p)<=$x(+1)

— टाइटस

@ अपने दोनों उत्तर के लिए धन्यवाद! मैंने अपना उत्तर अपडेट कर दिया। मैं आपकी सराहना करता हूं कि जब आप कहीं अधिक श्रेष्ठ प्रतीत होते हैं तो मेरे उत्तर को बेहतर बनाने में मेरी मदद करते हैं।

— JPMC 14

1

1) मैं आपसे 2 कम, फिर से: 204 नहीं, 206 की गिनती करता हूं। क्या आप अपने बाइट की गिनती में एक विंडोज लाइन ब्रेक शामिल करते हैं? 2) forनिर्माण में सिंटैक्स त्रुटि : 3 ,होना चाहिए ;) मेरे पास उस कोड पर 20 बाइट को बचाने के लिए एक और 7 बदलाव हैं। चाहिए कि वो?

— टाइटस

2

ठीक है, यह वास्तव में केवल 5 परिवर्तन है, लेकिन उनमें से एक के तीन भाग हैं। a) अप्रचलित दूसरा तर्क f () (-3) b) अप्रचलित रिक्त फंक्शन g (-1) c) अप्रचलित ब्रेसिज़ के लिए सही ब्रांच में (-4) d) सही और गलत ब्रांच स्वैप करें, ifस्थिति को उल्टा करें , फिर उपयोग करें int (-6) के लिए मेरी सेक्सी टाइप डाली गई। यह दशमलव 0 परिणाम को प्रभावित नहीं करेगा! ई) शेष forनिर्माण को एक बहुत अच्छे के साथ फिर से लिखा जा सकता है while(++$t<$c=strlen($x)): शरीर से पहले वेतन वृद्धि -> $ t को कोई आरंभीकरण की आवश्यकता नहीं है (-6)

— टाइटस

1

जेली, 5 बाइट्स

Æ!ŒṘ€

व्याख्या

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

* जेली सवाल की उम्र से छोटी है इसलिए मेरा जवाब गैर-जिम्मेदार है।

— DaggerOfMesogrecia
स्रोत

1

PPCG में आपका स्वागत है! मुझे लगता है कि जेली इस चुनौती से छोटी है, इसलिए आपको अपने जवाब को गैर-प्रतिस्पर्धी के रूप में चिह्नित करना चाहिए।

— लकोनी

ओह मुझे एहसास नहीं था कि यह एक नियम था। करूँगा।

— डैगरऑफएमेसोग्रेसिया

इस चुनौती का जवाब दोनों तरीकों से काम करने का नहीं है? यह केवल एक तरह से काम करने लगता है; आप इसे ठीक करना चाह सकते हैं। (एक अलग टिप्पणी पर, आप जेली में पूर्णांकों और तार के बीच परिवर्तित कर रहे हैं, यह आम तौर पर tersest के कुछ संयोजन का उपयोग करने के Vलिए और Ṿ।)

1

जेली , 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

क्यों `*)`काम करता है

¬तत्व-वार तार्किक नहीं है। जब एक पूर्णांक दिया जाता है, तो यह एकल शून्य हो जाता है, जो कि गलत है। हालांकि, जब एक तार दिया जाता है, तो प्रत्येक तत्व (वर्ण) शून्य में बदल जाता है, और संपूर्ण परिणाम शून्य का एक सरणी होता है जो कि सच है।

पूर्णांक के रूप में शून्य एक विशेष मामला है। यह "भाज्य -> पूर्णांक" मार्ग से गुजरता है, लेकिन यह अभी भी शून्य देता है जो सही है।

बिना तथ्यात्मक आधार के निर्मित, 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

— bubbler
स्रोत

0

के, १०२

"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

— tmartin
स्रोत

0

डी (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;}

Ungolfed और कार्यक्रम प्रविष्टि बिंदु के साथ

सभी कमांड लाइन तर्क के रूप में मुद्रित किए जाते हैं <original> -> <converted>। केवल फैक्टरैडिक का दशमलव वास्तव में लागू किया गया है x। xजब तक परिणाम इनपुट के बराबर नहीं होता तब तक दूसरा तरीका सभी दशमलव संख्याओं (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;
}

— mleise
स्रोत

मैं इसे बदलने के लिए संभव हो सकता है लगता है string nके लिए char[]n(मैं जानता हूँ कि मैं देर से यहाँ हूँ) एक बाइट को बचाने के लिए।

— जकार्ही

इसके अलावा, मुझे लगता है कि दो बाइट्स बचाने के लिए if(n[0]<48){while(r.text.x<n[1..$].to!int)r++;}बन सकता है if(n[0]<48)while(r.text.x<n[1..$].to!int)r++;।

— जकार्ही

0

VBA 225

टाइटस को मदद के लिए धन्यवाद! अभी भी कुछ और गोल्फ देख रहे हैं।

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

— Gaffi
स्रोत

मैं VBA नहीं जानता, लेकिन क्या bपहले वर्ण की तुलना करने के बजाय एक संख्यात्मक मान की जाँच करने का कोई तरीका है ?

— टाइटस

@ बिट्स एक संख्यात्मक जाँच है, और यहाँ बराबर होगा:, If Not IsNumeric(b) Thenलेकिन यह अधिक वर्ण लेता है। अब, मैं अंदर नहीं गया और सभी कोड की फिर से जांच की; IsNumericसमग्र रूप से ऐसा करने का थोड़ा बेहतर तरीका हो सकता है । - सुधार, यहाँ एक मामूली सुधार है। धन्यवाद!

— गफ्फि

: मैं एक और चार बाइट्स पाया For d=9To 1Step-1और Fact(d)> - For d=0To 8और Fact(9-d)और एक अन्य दो यदि आप For d=2To eऔरFact(e-d+1)*Mid(b,d,1)

— टाइटस

क्या इंट टू कास्ट को दूसरे तरीके से लिखा जा सकता है?

— टाइटस

@ टिट्स तुम देखो, मेरे चारों ओर हलकों चल रहा है। :) मैं अब tweak कर रहा हूँ ... Int () के लिए, मुझे नहीं लगता कि कोई सरल (छोटा) तरीका है, नहीं।

— गफी जूल

0

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

— जार्ग हुल्सरमन
स्रोत

0

पर्ल 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]}

— शॉन
स्रोत

0

एपीएल (एनएआरएस), 36 चार्ट, 72 बाइट्स

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

ऐसा लगता है कि 10 than (9..2) function पुनरावर्ती कार्य से बेहतर है, हॉवर्ड के लिए धन्यवाद अन्य एपीएल समाधान जो दिखाते हैं कि ... (भले ही मैं 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

— RosLuP
स्रोत

तथ्यात्मक संख्या प्रणाली से और उससे परिवर्तित करें

एपीएल, ३ ९ ३ characters अक्षर

पायथन 2.7 ( 163 157 152)

गोल्फक्राफ्ट ( 48 44 43 वर्ण)

PHP <7.1 178 171 170 168 164 155 147 144 138 126 123 बाइट्स

जावास्क्रिप्ट (ईएस 6) 139 137 122 113 111

पर्ल 6 , 66 65 60 बाइट्स

GolfScript, 69 वर्ण

हास्केल, 221 वर्ण

कोड गोल्फ

प्रयोग

अघोषित कोड

गणितज्ञ 213 177 175

अजगर, 128 चरस

PHP 231 214 204

उदाहरण

उत्पादन

जेली, 5 बाइट्स

जेली , 15 बाइट्स

यह काम किस प्रकार करता है

क्यों *)काम करता है

बिना तथ्यात्मक आधार के निर्मित, 25 बाइट्स

यह काम किस प्रकार करता है

के, १०२

डी (159 वर्ण)

Ungolfed और कार्यक्रम प्रविष्टि बिंदु के साथ

VBA 225

PHP , 124 बाइट्स

पर्ल 6 , 150 बाइट्स

एपीएल (एनएआरएस), 36 चार्ट, 72 बाइट्स

क्यों `*)`काम करता है