N का अंतिम गैर-शून्य अंक!

Question

इनपुट के रूप में एक पूर्णांक 1 ≤ N as 1,000,000 को देखते हुए, N के अंतिम गैर-शून्य अंक का उत्पादन करता है ! , कहाँ ! भाज्य ( 1 से एन तक सभी संख्याओं का उत्पाद , समावेशी) है। यह OEIS अनुक्रम A008904 है ।

आपके प्रोग्राम को किसी भी वैध इनपुट के लिए एक उचित मशीन पर 10 सेकंड के भीतर समाप्त होने की आवश्यकता है।

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

1 => 1
2 => 2
3 => 6
4 => 4
5 => 2
6 => 2
7 => 4
8 => 2
9 => 8
10 => 8
100 => 4
1000 => 2
10000 => 8
100000 => 6
1000000 => 4

यह एक कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है!

Comments

एकल समारोह या पूरा कार्यक्रम?

— जॉय

@joey नहीं, वे केवल परीक्षण के मामले हैं। सिंगल इनपुट, सिंगल आउटपुट।

— fR0DDY

@joey पूरा कार्यक्रम।

— fR0DDY

एक पूर्ण कार्यक्रम के लिए आवश्यकता को हतोत्साहित किया जाता है ...

— एग्री द आउटगलर

@EriktheOutgolfer यह ~ 7 साल पहले से है, इसलिए मुझे नहीं लगता कि उस समय यह निर्धारित किया गया था

— NoOneIsHere

Answer 1

रूबी - 63 वर्ण

f=->n{n<2?1:6*[1,1,2,6,4,4,4,8,4,6][n%10]*3**(n/5%4)*f[n/5]%10}

स्रोत - http://oeis.org/A008904

सेकंड के तहत एक हज़ार अंकों तक का हैंडल।

परीक्षा

irb(main):014:0> for n in 2..6
irb(main):015:1> puts f[10**n]
irb(main):016:1> end
4
2
8
6
4

Answer 2

गणितज्ञ, 45 36 बाइट्स

Last@Select[IntegerDigits[#!],#>0&]&

विजयी उत्तर के लिए बहुत पठनीय। :) (फिर से, अभी तक कोई गोल्फस्क्रिप्ट एंड कंपनी प्रस्तुत नहीं हुई है।)

यह मेरे मशीन पर लगभग 5 सेकंड में इनपुट 1,000,000 को संभालता है।

Comments

इस प्रश्न के लिए गणितज्ञ बहुत ही सही भाषा है।

— माइकल स्टर्न

Answer 3

अजगर - 75

n=input()
g=1
while n:
 g*=n
 while g%10<1:g/=10
 g%=10**9
 n-=1
print g%10

Answer 4

PARI / GP - 27 बाइट्स

यह आकार के लिए गति को बढ़ाता है - टेस्टकेस को एक लंबा समय लगता है (~ 6 सेकंड)।

n->n!/10^valuation(n!,5)%10

यह संस्करण बहुत तेज़ है (~ 15 माइक्रोसेकंड) लेकिन 81 बाइट लेता है:

n->r=1;while(n,r*=Mod(4,10)^(n\10%2)*[1,2,6,4,2,2,4,2,8][max(n%10,1)];n\=5);lift(r)

आप परीक्षण करने के लिए इस (गैर-गोल्फ वाले) कोड का उपयोग कर सकते हैं:

[%(10^n) | n <- [1..6]]

Answer 5

विंडोज पॉवरशेल, 53 56 59 60 63 73 90

($a=1).."$input"|%{$a="$($a*$_)".trim('0')%1e7}
$a%10

टिप्पणियाँ:

• 100,000 की संख्या के लिए एक मिनट से अधिक समय लेता है। हालांकि, अंत में शून्य को हटाने के लिए स्ट्रिंग में कनवर्ट करने की आवश्यकता होती है, गणना करने के लिए एक नंबर की आवश्यकता होती है, इसलिए रूपांतरण किसी भी मामले में अपरिहार्य हैं।

इतिहास:

• 2011-02-08 10:31 (90) - पहला प्रयास।
• 2011-02-08 10:33 (73) - मापांक फिसलने और जुड़ने से कम है।
• 2011-02-08 10:34 (63) - अनावश्यक ट्रिम।
• 2011-02-08 10:37 (60) - एक नंबर के लिए अनावश्यक डाली। मापांक करता है कि बस ठीक है, पहले से ही।
• 2011-02-08 10:40 (59) - कुछ अशुभ।
• 2011-02-08 11:00 (56) - मापुलस के छोटे होने से पहले मैंने क्या कहा था? आउटपुट पर भी लागू होता है।
• 2011-02-08 11:01 (53) - $inputएक स्ट्रिंग को कास्टिंग करना पर्याप्त है; कास्ट को intअंतर्निहित रूप से लागू किया जाता है।

Answer 6

पर्ल, 53 58 61 वर्ण

सभी व्हाट्सएप को हटाया जा सकता है, लेकिन मैंने इसे "पठनीयता" के लिए छोड़ दिया। नोट: स्लोन से कुछ मूर्खतापूर्ण स्पष्ट सूत्र का उपयोग नहीं कर रहा है।

sub f {
    $_ = $1 * ++$n || 1, /(.{1,7}?)0*$/ while $n < $_[0];
    $1 % 10
}

मेरी मशीन पर 8.7 सेकंड में f (10 ^ 6) की गणना करता है।

अद्यतन : ओपी चाहता था कि यह एक संपूर्ण कार्यक्रम हो:

$_ = $1 * ++$n || 1, /(.{1,7}?)0*$/ while $n < $ARGV[0];
print $1 % 10

जो इसे 55 अक्षर बनाता है।

Answer 7

CJam - 28

1ri{I)*_AbW%{}#A\#/1e7%}fIA%

आप इसे 10000 या तो के मानों के लिए http://cjam.aditsu.net/ पर आज़मा सकते हैं ; बड़ी संख्या के लिए आपको जावा दुभाषिया का उपयोग करना चाहिए । मेरे लैपटॉप पर लगभग 3 सेकंड में 1000000 रन।

स्पष्टीकरण:

दुर्भाग्य से सीधा समाधान बहुत धीमा है, इसलिए मैं प्रत्येक गुणा के बाद केवल अंतिम 7 अंक (अनुगामी शून्य से पहले) रख रहा हूं।

1           push 1 on the stack
ri          read a token and convert to integer
{           loop (for I from 0 to N - 1)
    I)      push I and increment
    *       multiply with the previous value (initially 1)
    _Ab     duplicate and convert to array of digits
    W%      reverse array
    {}#     find the position of the first non-zero digit
    A\#     raise 10 to that power
    /       divide, thus removing all trailing zeros
    1e7%    keep the remainder modulo 10000000
}fI         end for loop
A%          get the last digit

नोट: यह भाषा प्रश्न की तुलना में बहुत नई है।

Answer 8

गणितज्ञ, 34 बाइट्स

Mod[#!/10^IntegerExponent[#!],10]&

Answer 9

05AB1E , 4 बाइट्स

!0м¤

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

व्याख्या

!0    # Push the factorial of the input and 0
  м   # Remove the occurences of 0 in the factorial
   ¤  # Push the last element, implicit display

Comments

TIO संस्करण अंतिम परीक्षण मामले पर (60 के दशक) समाप्त हो गया - आप इसे "उचित मशीन" पर 10s में कैसे प्राप्त कर सकते हैं?

— टॉबी स्पाइट

Answer 10

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

!Ṛȯ/

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

व्याख्या

इस तथ्य का उपयोग करता है कि जब Ṛ(किसी सूची को उल्टा करते हैं; वेक्टर नहीं करता है) एक पूर्णांक पर लागू होता है जो स्वचालित रूप से Dपहले (अंक) लेता है ।

इनपुट 8 के साथ:

!Ṛȯ/
!     Factorial: 8! = 40320
 Ṛ    Reverse: [0,2,3,0,4]
   /  Reduce by...
  ȯ   ...logical OR: ((((0ȯ2)ȯ3)ȯ0)ȯ4) = first truthy element = 2

मुझे नहीं लगता कि एक बाइट "पहला सत्य तत्व" है (जो ȯ/कार्य करता है), लेकिन अगर वहाँ है तो यह तीन बाइट्स को छोटा किया जा सकता है।

Answer 11

जावा (ओपनजेडके 8) , 62 बाइट्स

n->{long f=n;for(;n>1||f%10==0;)f=n>1?f*--n:f/10;return f%10;}

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

@ केविन क्रूज़सेन के समान लेकिन लूप के संयोजन से 5 बाइट्स बचाता है।

Comments

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट! आशा है कि आप चारों ओर छड़ी!

— R

PPCG में आपका स्वागत है! मैं @Riker, महान पहली पोस्ट से सहमत हूं। अच्छी तरह से छोरों के संयोजन से मेरे कोड को पूरा किया। आप गोल्फ 1 अधिक बदलकर अपना वर्तमान जवाब में बाइट कर सकते हैं ||के साथ |, और की जगह एक अतिरिक्त बाइट ==0के साथ <1। यहां रहने का आनंद!

— केविन क्रूज़सेन

Answer 12

सी, 150 140 135 बाइट्स

r,d;f(k,x){r=x<5?3:f(k+1,x/5);return(d=x%5)?r*"33436"[d]*(1<<d*k%4)%5:r;}main(int c,char**v){c=atoi(*++v);printf("%d",c<2?1:2*f(0,c));}

यह ASCII प्रणालियों के लिए संस्करण है; EBCDIC सिस्टम के लिए, या एक पोर्टेबल प्रोग्राम के 33436साथ स्ट्रिंग को बदलें ।11214\1\1\2\1\4

सी समाधान एक पूर्ण कार्यक्रम प्रदान करने की आवश्यकता से थोड़ा बाधित होता है; हालाँकि, यह पूरी तरह से सवाल का जवाब देता है।

इसे ऑनलाइन आज़माएं (जावास्क्रिप्ट की आवश्यकता है):

• केवल 1000000
• सभी टेस्टकेस के साथ लूप

व्याख्या

यह n के कम से कम महत्वपूर्ण शून्य शून्य में उल्लिखित एल्गोरिथ्म पर आधारित है ! , चारों ओर मोड़ दिया ताकि हम पांच की उच्चतम शक्ति को खोजने के लिए पुनरावृत्ति करें, और बाहर निकलने के तरीके पर गणना करें। स्थिरांक की तालिकाएं बहुत बड़ी थीं, इसलिए मैंने उन्हें पिछले अवशेषों r, वर्तमान अंक dऔर पुनरावृत्ति गहराई के बीच संबंध ढूंढकर कम किया k:

     0    1       2       3    4  =d
  0  0  3×2^k  1×2^2k  3×2^3k  2
  1  1  1×2^k  2×2^2k  1×2^3k  4
r 2  2  2×2^k  4×2^2k  2×2^3k  3
  3  3  3×2^k  3×2^2k  3×2^3k  2
  4  4  4×2^k  4×2^2k  4×2^3k  1

के लिए r>0, यह एक स्थिर समय rबार हल करता है 2^dk(mod 5); स्थिरांक a[]नीचे हैं (गोल्फ कोड में झुका हुआ)। हम यह भी देखते हैं कि (2^4)%51 है, इसलिए हम सीमा को कम करने से बचने के लिए प्रतिपादक को कम कर सकते हैं int।

const int a[] = { 1, 1, 2, 1, 4 };
int f(int k, int x){
    int r = x<5 ? 3 : f(k+1,x/5); /* residue - from recursing to higher-order quinary digits */
    int d = x%5;
    if (!d)
        return r;
    return r * a[d] * (1<<d*k%4) % 5;
}

int main(int c, char **v)
{
    c = atoi(*++v);
    printf("%d",
           c<2
           ? 1                  /* special-case 0 & 1 */
           : 2*f(0,c));         /* otherwise, it's 2 times r */
}

टेस्ट:

$ for i in 100 1000 10000 100000; do echo $i: `./694 $i`; done
100: 4
1000: 2
10000: 8
100000: 6
1000000: 4

प्रदर्शन भी सम्मानजनक है। 32-बिट वाले सिस्टम के लिए यहां अधिकतम इनपुट है int:

$ time ./694 2147483647
8
real    0m0.001s
user    0m0.000s
sys     0m0.000s

मुझे अधिकतम 64-बिट के साथ भी समान समय मिला int।

Comments

यह नोट करने के लिए ब्याज हो सकता है कि 2147483647!19 बिलियन अंक, और (2^63-1)!170,000,000,000,000,000,000,000 से अधिक अंक हैं, इसलिए यह तथ्य की गणना पर एक बड़ी जीत है। 1000000!वर्तमान हार्डवेयर पर गणना करने के लिए प्रश्न में निर्दिष्ट व्यवहार्य है; यह केवल 5 digit मिलियन अंक है। :-)

— टोबी स्पाइट

Answer 13

PHP - 105

 <?foreach(explode("\n",`cat`)as$n)if($n){$f=rtrim(gmp_strval(gmp_fact($n)),'0');echo substr($f,-1)."\n";}

दिए गए टेस्टकेस के साथ 10 सेकंड के तहत चलता है।

Answer 14

python3

239 शुल्क

10000 ~ 3.2 सेकंड में कर सकते हैं (Ideone ने मुझे 8 सेकंड में काट दिया, मुझे यकीन है कि इसे 10 सेकंड से अधिक समय लगेगा हालांकि :()

from functools import *
N=100
r=range
s=(p for p in r(2,N)if all(p%n>0for n in r(2,p)))
f=lambda n,x:n//x+(n//x>0and f(n//x,x)or 0)
e=list([p,f(N,p)]for p in s)
e[0][1]-=e[2][1]
e[2][1]=0
print(reduce(lambda x,y:x*y,map(lambda x:x[0]**x[1],e))%10)

python2.6

299 शुल्क (थोड़ा तेज)

from itertools import *
N=100000
r=xrange
def s(c=count(2)):
        while 1:p=c.next();c=ifilter(p.__rmod__,c);yield p
f=lambda n,x:n//x+(n//x>0and f(n//x,x)or 0)
e=[[p,f(N,p)]for p in takewhile(lambda x:x<N,s())]
e[0][1]-=e[2][1]
e[2][1]=0
print(reduce(lambda x,y:x*y,map(lambda x:pow(x[0],x[1],10),e))%10)

Answer 15

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

f n=head$dropWhile(=='0')$reverse$show$product[1..n]
main=interact(show.f.read)

(शायद 1,000,000 सेकंड में गणना करने के लिए संकलित करने की आवश्यकता होगी! 10 सेकंड में)।

Comments

दो वर्ण सहेजें, (cf codegolf.stackexchange.com/questions/607/find-the-factorial/… ) के foldl1साथ प्रतिस्थापित करें । लेकिन क्या आपने वास्तव में 1000000 के साथ कोशिश की है! ? product

— जेबी

पुनश्च: एक पूर्ण कार्यक्रम नहीं।

— जेबी

क्षमा करें, इससे पहले कि टिप्पणियों में स्पष्ट किया गया था। मैं इसे अपडेट करूंगा।

— 16

Answer 16

जे - ४२ ४० अक्षर

एक पूरा कार्यक्रम। इस प्रोग्राम को एक फाइल में सेव करें और साथ रन करें jconsole script.ijs 1234। ध्यान दें कि यह प्रोग्राम किसी परिणाम को प्रिंट करने के बाद दुभाषिया से बाहर नहीं निकलता है। टाइप करें ^Dया exit]0दुभाषिया से बाहर निकलें।

echo([:{:@(#~*)10&#.inv@*)/1+i.".>{:ARGV

यहाँ एक स्पष्टीकरण है:

• x #. yyआधार xसंख्या के रूप में पूर्णांक वेक्टर की व्याख्या करता है ; उदाहरण के लिए, 10 #. 1 2 3 4पैदावार 1234।
• u invएक क्रिया के विलोम पैदावार u। विशेष रूप से, आधार संख्या के रूप में x #. inv yप्रतिनिधित्व yकरता है x; उदाहरण के लिए, 10 #. 1234पैदावार 1 2 3 4। सूचना , जिसे -1 बार लागू किया गया है, के invरूप में परिभाषित किया गया ^:_1है u।
• x * yका उत्पाद है xऔर y, इस प्रकार उत्पाद के x 10&#.inv@* yआधार -10 का प्रतिनिधित्व करता है xऔर y।
• x # yप्रतियां n के मई के आइटम yअक्सर के रूप में के रूप में एन के मई के आइटम x; जब xबूलियन्स का एक वेक्टर होता है, तो xकौन सी वस्तुओं का चयन yकरना है। उदाहरण के लिए, 1 0 1 0 # 1 2 3 4पैदावार 1 3।
• * yके संकेत देता है y।
• x u~ yका प्रतिवर्त है u, जो कि, जैसा है y u x।
• इस प्रकार, उस y #~ * yसभी वस्तुओं की एक वेक्टर पैदावार yसकारात्मक है। टैसीट नोटेशन में, यह हुक के रूप में लिखा जा सकता है (#~ *)।
• {: yमें अंतिम आइटम देता है y।
• एक साथ इकट्ठे होने पर, हमें टैसीट वाक्यांश मिलता है ([:{:@(#~*)10&#.inv@*)।
• u/ yहै कमी की y, कि है, dyadic क्रिया uके तत्वों के बीच डाला y। उदाहरण के लिए, पैदावार की +/1 2 3 4तरह 1 + 2 + 3 + 4है 10।
• इस प्रकार, वाक्यांश ([:{:@(#~*)10&#.inv@*)/ yके आइटम के उत्पाद का अंतिम अंक प्राप्त होता है y।
• ARGV कमांड लाइन के तर्कों का एक बॉक्सिंग वेक्टर है।
• ".>{:ARGV अंतिम तर्क को एक संख्या के रूप में अनबॉक्स और व्याख्या किया गया है।
• i. yसे प्राकृतिक संख्याओं की गणना करता 0है y - 1।
• इस प्रकार, 1+i. yसे प्राकृतिक संख्या प्राप्त 1करता है y। मैं यहां >: वेतन वृद्धि भी कर सकता था , लेकिन 1+पात्रों की समान लागत पर स्पष्ट हूं ।
• पूरा कार्यक्रम सिर्फ क्रिया (अंतिम कमांड लाइन तर्क में संख्या 1+i.".>{:ARGVका वेक्टर) पर लागू होता है और परिणाम के साथ प्रिंट करता है ।1([:{:@(#~*)10&#.inv@*)/echo

Answer 17

पाइट , 5 बाइट्स

!₫ą0⦋

स्पष्टीकरण:

         Implicit input (n)
!        n!
 ₫       Reverse the digits of (n!) - this disregards leading zeroes after reversal
  ą      Convert to array of digits
   0⦋    Get the first element

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

Answer 18

आर , 63 55 51 46 बाइट्स

तथ्यात्मक गणना करता है, अंतिम गैर-शून्य अंक निकालता है। मूल संरचना प्रदान करने के लिए Giuseppe का धन्यवाद।

(y=(gamma(scan()+1))%/%10^(0:1e5)%%10)[!!y][1]

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

वैकल्पिक रूप से, मेरा पुराना 51-बाइट उत्तर:

भाज्य की गणना करता है, वर्ण में परिवर्तित करता है, सभी 0s को हटाता है , और फिर अंतिम वर्ण लेता है। सहेजे गए 2 बाइट्स Giuseppe की बदौलत।

substring(x<-gsub("0","",gamma(scan())+1),nchar(x))

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

Comments

gamma(x+1)से कम हैfactorial(x)

— Giuseppe

स्ट्रिंग रूपांतरण के बिना, सबसे अच्छा मैं पाने में कामयाब रहा (y=(x<-gamma(scan()+1))%/%10^(0:nchar(x))%%10)[!!y][1]54 बाइट्स पर।

— ग्यूसेप

@Giuseppe हम 46-बाइट समाधान के nchar(x)साथ बदल सकते 1e5हैं! जाना अच्छा है।

— rturnbull

Answer 19

> <> , 25 बाइट्स

v:a%:?n-a,!
1
>$::?!.1-}*

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

0 संभालती है! साथ ही साथ। -vध्वज के माध्यम से मूल्य पारित किया गया ।

Comments

टेस्ट केस 1000TIO पर कोई आउटपुट नहीं देता - क्या गलत है?

— टोबी स्पाइट

Answer 20

पर्ल 6 ,  26  35 बाइट्स

{[*](1..$_)~~/.*<(<-[0]>/}

कोशिश करो

---

एक पूर्ण कार्यक्रम के रूप में:

put [*](1..@*ARGS[0])~~/.*<(<-[0]>/

कोशिश करो

विस्तारित:

{
  [*]( 1..$_ ) # reduce using &infix:« * »
  ~~           # match with
  /
    .*         # any number of values (so it matches from the end)
    <(         # only capture the following
    <-[0]>     # any value but 0 (negated character class)
  /
}

Answer 21

सी (जीसीसी) , 72 बाइट्स (फ़ंक्शन)

f(n,d)long long n,d;{for(d=1;n;d%=10000)for(d*=n--;d%10<1;d/=10);d%=10;}

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

सी (जीसीसी) , 101 ९९ बाइट्स (पूरा कार्यक्रम)

main(){long long n,d=1;for(scanf("%lld",&n);n;d%=10000)for(d*=n--;d%10<1;d/=10);printf("%d",d%10);}

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

यह सवाल सिर्फ 8 साल पुराना है, इसलिए "वाजिब मशीन" वापस तो पहले जैसी नहीं है, लेकिन मैं अपने कंप्यूटर पर ~ .01 सेकंड का समय पा रहा हूं, जब सभी टेस्ट केस एक साथ कर रहे हैं, तो जब तक कि कंप्यूटर की गति में वृद्धि न हो। इस पिछले दशक में 1000 के कारक से, यह ठीक होना चाहिए।

Comments

मूर का कानून अभी भी (थोड़े) को पकड़ रहा है, इसलिए यह लगभग x16 गुना तेज होना चाहिए

— ASCII- केवल

इसके अलावा, एक फ़ंक्शन ठीक है

— एएससीआईआई-केवल

Answer 22

++ , 11 बाइट्स जोड़ें

L,RB*EDBFEZ

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

Answer 23

अटैची , 26 बाइट्स

Last@`\&:(All@V)@Digits@`!

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

व्याख्या

Last@`\&:(All@V)@Digits@`!

यह 4 कार्यों की एक रचना है:

• `! - यह फैक्टरियल ऑपरेटर का एक कार्यात्मक संस्करण है
• Digits - यह भाज्य के अंक प्राप्त करता है
• \&:(All@V)- यह एक चयन समारोह है। यह बायें-बन्धन ( &:) से कार्य करता All@Vहै \, जो कि चयन है। बदले में, All@Vपरीक्षण का एक छोटा तरीका है यदि कोई संख्या 0. नहीं है। यह अपने इनपुट को एक वेक्टर में कास्टिंग करके काम करता है, 0 -> [0]तो यदि सभी सदस्य सत्य हैं (तो 0 नहीं)। इससे अंक का अंक बिना 0s देता है।
• Last - यह केवल इस सरणी का अंतिम सदस्य प्राप्त करता है।

Comments

यह अविश्वसनीय रूप से धीमा लगता है - टीआईओ ने 100000 परीक्षण मामले पर समय (1 मिनट) निकाला - आपको 10 सेकंड में 1000000 परिणाम कैसे मिला?

— टोबी स्पाइट

@TobySpeight जब मैंने इस चुनौती का जवाब दिया, तो यह विशेष आवश्यकता नहीं थी (संशोधन इतिहास की जांच करें)।

— कॉनर ओ'ब्रायन

आह, मुझे इतिहास देखना चाहिए था! आपने प्रश्न में सभी टेस्टकेस को सत्यापित किया था, हालांकि?

— स्पीट

ऐसा लगता है कि इस अवधि के दौरान उत्तरों की हड़बड़ी थी कि समय सीमा को प्रश्न से हटा दिया गया था - यह दुर्भाग्यपूर्ण है, वास्तव में।

— टोबी स्पाइट

@TobySpeight हां, मैंने किया। यह दुर्भाग्यपूर्ण है, और मैं इस बारे में नीति के बारे में सुनिश्चित नहीं हूं।

— कॉनर ओ'ब्रायन

Answer 24

एपीएल (डायलॉग यूनिकोड) , 18 15 बाइट्स

{⊢/⍵/⍨0≠⍎¨⍵}⍕∘!

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

टैसिट उपसर्ग फ़ंक्शन। एकल परीक्षण मामले के लिए सही अंक लौटाता है, या कई परीक्षण मामलों के लिए अंकों की एक स्ट्रिंग होती है।

3 बाइट्स के लिए @ Adám और @ErikTheOutgolfer को धन्यवाद।

कैसे?

{⊢/⍵/⍨0≠⍎¨⍵}⍕∘! ⍝ Main function. Argument is a number following the !.
              ! ⍝ Factorial
             ∘  ⍝ then
            ⍕   ⍝ Format (stringify)
        ⍎¨⍵}    ⍝ Execute (turn to number) each digit of the argument
      0≠        ⍝ Check if each is ≠0. This returns a boolean vector
     ⍨          ⍝ Swap arguments for the following fn/op
   ⍵/           ⍝ Replicate. This takes a boolean vector as left arg and returns the truthy elements of the right arg. E.g.: 1 1 0/1 2 3 → 1 2.
{⊢/             ⍝ Reduce. This returns the rightmost (last) element of a vector argument.

Answer 25

एपीएल नारस, 28 बाइट्स, 14 चार्ट

{↑≠v/v←⌽⍎¨⍕!⍵}

मुझे पता नहीं क्यों लेकिन यह परीक्षा पास करता है:

  q←{↑≠v/v←⌽⍎¨⍕!⍵}       
  q¨1 2 3 4 5 6 7 8 9 10 11 12 13 14
1 2 6 4 2 2 4 2 8 8 8 6 8 2 

Answer 26

AWK , 47 57 बाइट्स

{for(p=$1;--$1;p=(p*$1)%1e4)while(!(p%10))p/=10;$0=p%10}1

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

मूल समाधान ने "बड़े" इनपुट मूल्यों को बहुत अच्छी तरह से संभाल नहीं किया। -Mइसे काम करने के लिए मजबूर कर सकता है , लेकिन इसके लिए बहुत अधिक प्रसंस्करण समय की आवश्यकता होती है।

Comments

हाँ, @TobySpeight, बहुत अच्छा infनहीं है %। :(

— रॉबर्ट बेन्सन

आह ... मेरे द्वारा पूछे गए प्रश्न के संस्करण को देखते हुए, बड़ी संख्या की आवश्यकता नहीं थी।

— रॉबर्ट बेन्सन

Answer 27

जाप , 6 बाइट्स

कुछ अलग-अलग 6-बायर्स के साथ आया लेकिन मुझे यह सबसे अच्छा लगा। मुझे यकीन है कि 5 में इसे करने का एक तरीका होना चाहिए, हालांकि।

Êsw ìv

कोशिश करो

---

व्याख्या

Êइनपुट के भाज्य की गणना करता है, sइसे एक स्ट्रिंग में परिवर्तित करता है और एक पूर्णांक पर वापस जाने के बाद wइसे उलट ìदेता है, परिणाम को अंकों की एक सरणी में परिवर्तित करता है और vपहले तत्व को लौटाता है।

---

वैकल्पिक

Êì w æ
ÊìÈf Ì
Êì f o
Êsw sg
Êìf ìo
Êìf ìÌ

Comments

सभी परीक्षण मामलों को निष्पादित करने में कितना समय लगता है?

— टोबे स्पाइट

@TobySpeight; यह कोशिश करने के लिए लिंक का पालन करके परीक्षण करना बहुत आसान है। ध्यान दें कि पिछले 4 परीक्षण मामले विफल हो जाएंगे क्योंकि उनके फैक्टरियल जावास्क्रिप्ट के अधिकतम पूर्णांक से बड़े हैं।

— झबरा

तो यह वास्तव में समस्या को हल नहीं करता है? प्रश्न कहता है कि इसे 1 ≤ N it 1,000,000 के लिए सफल होना चाहिए । अन्य उत्तर प्रदर्शित करते हैं कि आपको उत्तर की गणना करने के लिए भाज्य को स्टोर करने में सक्षम होने की आवश्यकता नहीं है।

— टोबी स्पाइट

मैंने ऑनलाइन परीक्षण की कोशिश की, लेकिन यह पहली बार मेरे द्वारा परीक्षण किए गए परीक्षण (1000) पर था।

— टोबी स्पाइट

Answer 28

पर्ल 5 , 36 + 10 ( -p -Mbigint) = 46 बाइट्स

$"=$_;$_*=$"while$"-=1;($_)=/(.)0*$/

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

Comments

टीआईओ संस्करण पहले दो परीक्षण के मामलों में विफल रहता है जिनकी मैंने कोशिश की थी: 1000000 ⇒ f( 4 होना चाहिए ) और 100 ⇒ 7( 4 होना चाहिए )

— टॉबी स्पाईट

यह एक int के आकार को ओवरफ्लो कर रहा है। नया संस्करण bigint का उपयोग करके काम करता है। प्रदर्शन अभी भी कुछ वांछित होने के लिए छोड़ देता है क्योंकि यह एक क्रूर बल गणना है। इसका मतलब है कि यह बड़ी संख्या के लिए TIO पर कई बार आउट हो जाता है।

— Xcali