बेस में एक फैक्टरियल के अंतिम नॉनजेरो अंक

Question

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो n b kइनपुट आउटपुट के रूप में तीन पॉजिटिव पूर्णांक देता है या kके आधार bप्रतिनिधित्व में पीछे चल रहे शून्य से पहले अंतिम अंक लौटाता है n!।

उदाहरण

n=7 b=5 k=4
factorial(n) is 5040
5040 is 130130 in base 5
the last 4 digits of 130130 before the trailing zeros are 3013
the output is 3013

इनपुट

• 3 सकारात्मक पूर्णांक n b kजहां 2 <= b <= 10।
• इनपुट पूर्णांकों का क्रम मनमाने ढंग से चुना जा सकता है।

उत्पादन

• पूर्णांक या पूर्णांक सूची के रूप में लौटे अंकों की सूची या आउटपुट।
• अग्रणी शून्य वैकल्पिक हैं।
• आपके समाधान को मेरे कंप्यूटर पर एक मिनट के तहत किसी भी उदाहरण के परीक्षण के मामले को हल करना है (मैं केवल करीबी मामलों का परीक्षण करूंगा। मेरे पास एक नीचे-औसत पीसी है।)।

उदाहरण

प्रस्तुतियाँ की शुद्धता की जाँच के लिए नए परीक्षण जोड़े गए। (वे 1 मिनट के रनटाइम नियम का हिस्सा नहीं हैं।)

इनपुट => आउटपुट (अग्रणी शून्य को छोड़ने के विकल्प के साथ)

3 10 1  =>  6

7 5 4  =>  3013

3 2 3  =>  11

6 2 10  =>  101101

9 9 6  =>  6127

7 10 4  =>  504

758 9 19  =>  6645002302217537863

158596 8 20  =>  37212476700442254614

359221 2 40  =>  1101111111001100010101100000110001110001

New tests:
----------

9 6 3  =>  144

10 6 3  =>  544

यह कोड-गोल्फ है, इसलिए सबसे छोटी प्रविष्टि जीतती है।

Comments

मेरे कंप्यूटर पर एक मिनट से कम समय के लिए लक्ष्य करना थोड़ा मुश्किल है अगर हमें कोई भी जानकारी नहीं है।

— डेनिस

चाहेंगे 7 5 3उत्पादन "013" या "13"?

— क्लाउडीयू

@ चालुडीयू 7 10 4परीक्षण मामले के आधार पर मैं कहता हूं13

— माल्टीसेन

@ कलुआयू "अग्रणी शून्य वैकल्पिक हैं।" इसलिए दोनों संस्करण सही है।

— बेतरतीब

हम स्वीकार करना चाहिए किसी भी सकारात्मक पूर्णांक के लिए nया k? या हम उन्हें भाषा के पूर्णांक प्रकार की सीमा तक सीमित कर सकते हैं?

— टोबे स्पाइट

Answer 1

दिल्लोग एपीएल , 23 बाइट्स

⌽k↑⌽{⍵↓⍨-⊥⍨0=⍵}b⊥⍣¯1⊢!n

यह कार्यक्रम तब तक काम करता है जब तक कि यह तथ्य आंतरिक प्रतिनिधित्व सीमा से अधिक न हो। Dyalog APL में, सीमा को बढ़ाया जा सकता है ⎕FR←1287।

मान लेता है कि चर n, b, और k सेट किए गए हैं (उदा n b k←7 5 4), लेकिन यदि आप n , b , और k (उस क्रम में) के लिए संकेत देना चाहते हैं , तो तीन वर्णों को प्रतिस्थापित करें ⎕।

Comments

मेरे द्वारा फेंके गए प्रत्येक परीक्षण मामले को मेरी मशीन (M540) पर लगभग 11 माइक्रोसेकंड में गणना की गई थी।

— Adám

Answer 2

गणितज्ञ, ५ 57 ४ 57 बाइट्स

@ 2012rcampion के लिए 9 बाइट्स को सहेजा गया।

IntegerString[#!/#2^#!~IntegerExponent~#2,##2]&

Comments

मैंने वास्तव में कभी भी गणितज्ञ का उपयोग नहीं किया है, लेकिन क्या आप b2 बाइट्स को बचाने के लिए तर्कों के क्रम को स्वैप नहीं कर सकते हैं ?

— फ्राइअमईएग्गमैन

@FryAmTheEggman मैं गोल्फ समुदाय के लिए नया हूँ, तर्क आदेश "कोषेर" स्वैप कर रहा है?

— २०१२ आर्कम्पियन

आप वास्तव में 47 प्राप्त कर सकते हैं: IntegerString[#!#2^-#!~IntegerExponent~#2,##2]&(यह और आपके मूल दोनों काफी तेज हैं)

— 2012rcampion

पूछने वाले ने लिखा: "इनपुट पूर्णांकों का क्रम मनमाने ढंग से चुना जा सकता है।" इनपुट के तहत, इसलिए इस मामले में यह निश्चित रूप से ठीक है

— FryAmTheEggman

@ फ़िर वाह, ऐसा लग रहा है कि मैंने काफी करीब से नहीं पढ़ा। हालाँकि, SlotSequenceमैंने अपनी टिप्पणी में जिस ट्रिक का इस्तेमाल किया था , वह केवल वर्तमान ऑर्डर के साथ काम करती है, इसलिए आप और अधिक नहीं बचा सकते।

— २०१२ आर्कम्पियन

Answer 3

पायथन, 198 192 181 वर्ण

def F(n,b,k):
 p=5820556928/8**b%8;z=0;e=f=x=1
 while n/p**e:z+=n/p**e;e+=1
 z/=1791568/4**b%4;B=b**(z+k)
 while x<=n:f=f*x%B;x+=1
 s='';f/=b**z
 while f:s=str(f%b)+s;f/=b
 return s

यह काफी तेज़ है, सबसे बड़े उदाहरण पर ~ 23 सेकंड। और कोई फैक्टरियल बिल्डिन (मैं आपको देख रहा हूँ, गणितज्ञ!)।

Comments

[2,3,2,5,3,7,2,3,5][b-2]int('232537235'[b-2])3 बाइट्स बचाने के लिए किया जा सकता है। [1,1,2,1,1,1,3,2,1][b-2]इसी तरह।

— रैंडमरा

उत्तरार्द्ध के लिए, एक लुकअप तालिका 111973>>2*(b-2)&3और भी छोटी है। यह पूर्व के लिए बाइट्स की समान संख्या है ( 90946202>>3*(b-2)&7)।

— Sp3000

nvm ऐसा लगता है कि आप उच्च अंकों वाली चीज़ के बारे में सही थे

— Sp3000

मेरा मानना ​​है कि आप इसे एक कार्यक्रम बनाकर कुछ बाइट्स बचा सकते हैं, न कि एक फंक्शन।

— FryAmTheEggman

Answer 4

पायथ, 26 35 बाइट्स

M?G%GHg/GHH.N>ju%g*GhHT^T+YslNN1T_Y

यह 3 तर्कों, संख्या, आधार, अंकों की संख्या का एक कार्य है।

प्रदर्शन।

सबसे धीमा परीक्षण मामला, अंतिम एक, मेरी मशीन पर 15 सेकंड लेता है।

Comments

@ Sp3000 मैंने एक फिक्स जोड़ा जो मुझे लगता है कि पर्याप्त होना चाहिए।

— isaacg

Answer 5

PARI / जीपी, 43 बाइट्स

अंतरिक्ष के लिए ट्रेडिंग की गति इस सरल एल्गोरिदम की पैदावार देती है:

(n,b,k)->digits(n!/b^valuation(n!,b)%b^k,b)

परीक्षण के प्रत्येक मामले मेरी मशीन पर एक सेकंड से भी कम समय में चलते हैं।

Answer 6

गणितज्ञ - 48 बाइट्स

#!~IntegerDigits~#2/.{l__,0...}:>{l}~PadLeft~#3&

Ungolfed:

Function[{n, b, k},
  IntegerDigits[n!, b] (* list of the base-b digits in n! *)
  /. {l__, 0...} (* match a sequence of elements l and some number of zeros*)
                 (* lucky for me, __ defaults to match the shortest number *)
     :> PadLeft[List[l], k] (* pad l to be k elements long with zeros on the left *)
                            (* this truncates the list if it is too long*)
]

---

उदाहरण:

#!~IntegerDigits~#2/.{l__,0...}:>{l}~PadLeft~#3 &
%[758, 9, 19] // Timing

(* {0.031250, {6, 6, 4, 5, 0, 0, 2, 3, 0, 2, 2, 1, 7, 5, 3, 7, 8, 6, 3}} *)

---

सबसे बड़े मामलों के लिए, सीमित कारक अंक उत्पन्न नहीं कर रहा है:

Length@IntegerDigits[359221!, 2] // Timing
(* {0.109375, 6111013} 6.1M digits in 100 ms *)

पैटर्न मिलान प्रतीत होता है O(n^2), जिससे पिछले दो परीक्षण मामले एक मिनट के निशान से अधिक दूर हो जाते हैं।

Answer 7

बैश / कोरुटिल्स / डीसी, 60 बाइट्स

dc<<<"1 `seq -f%g* $1`$2op"|sed -r s/0+$//|tail -c$(($3+1))

आधार का उत्पादन करने , अनुगामी शून्य को ट्रिम करने और अंतिम अंकों को चुनने के लिए dcस्क्रिप्ट का उपयोग मेरे उत्तर से स्क्रिप्ट का उपयोग करता है ।$2sedtail$3

Comments

मुझे यह स्वीकार करना होगा कि 40-बिट बेस -2 टेस्टकेस के साथ यह बहुत धीमा है। मैंने revपीछे हटने को कम करने के लिए सेड के काम को आसान बनाने की कोशिश की , लेकिन यह dcसीपीयू खा रहा है ...

— टोबी स्पीट

Answer 8

हास्केल, 111 109 बाइट्स

import Data.Digits
f n b k=digits b$foldl(((unDigits b.reverse.take k.snd.span(<1).digitsRev b).).(*))1[1..n]

उपयोग: f 158596 8 20->[3,7,2,1,2,4,7,6,7,0,0,4,4,2,2,5,4,6,1,4]

के बारे में 8 सेकंड लेता है f 359221 2 40मेरे 4 साल पुराने लैपटॉप पर लगते हैं।

यह कैसे काम करता है: *सूची में गुणा ( ) को मोड़ो [1..n]। प्रत्येक मध्यवर्ती परिणाम को bअंकों की एक सूची के रूप में आधार में परिवर्तित करें (कम से कम महत्वपूर्ण पहले), अग्रणी जीरो पट्टी, फिर पहले kअंक लें और फिर से आधार 10 में परिवर्तित करें। अंत में bफिर से आधार में परिवर्तित करें, लेकिन पहले सबसे महत्वपूर्ण अंक के साथ।

Comments

मेरे दिमाग में यह विचार था, कि मैं इसे matlab का उपयोग करके व्याख्या कर रहा था, क्या संयोग है: D

— Abr001am

Answer 9

पायथन 3, 146 बाइट्स

import math
i,f=input(),int
n=i.split()
e=math.factorial(f(n[0]))
d=''
while e>0:
 d=str((e%f(n[1])))+d;e=e//f(n[1])
print(d.strip('0')[-f(n[2]):])

मुझे यकीन नहीं है कि परीक्षण के मामले सभी तेजी से चलेंगे - बड़े लोग बहुत धीमे हैं (क्योंकि यह संख्या के माध्यम से लूपिंग है)।

इसे यहाँ ऑनलाइन आज़माएँ (लेकिन सावधान रहें)।

Answer 10

जावा, 303 299 296 बाइट्स

import java.math.*;interface R{static void main(String[]a){BigInteger c=new BigInteger(a[1]),b=c.valueOf(1);for(int i=new Integer(a[0]);i>0;i--){b=b.multiply(b.valueOf(i));while(b.mod(c).equals(b.ZERO))b=b.divide(c);b=b.mod(c.pow(new Integer(a[2])));}System.out.print(b.toString(c.intValue()));}}

मेरे कंप्यूटर पर, यह 359221 2 40टेस्टकेस पर सेकंड के एक तिहाई से थोड़ा कम है । कमांड लाइन तर्कों के माध्यम से इनपुट लेता है।

Answer 11

बीसी, 75 बाइट्स

define void f(n,b,k){
obase=b
for(x=1;n;x%=b^k){
x*=n--
while(!x%b)x/=b}
x}

यह कोड आकार को कम करने के लिए कुछ GNU एक्सटेंशन का उपयोग करता है; 80 बाइट्स में एक POSIX- अनुरूप बराबर वजन:

define f(n,b,k){
obase=b
for(x=1;n;x%=b^k){
x*=n--
while(x%b==0)x/=b}
return(x)}

रन टाइम को उचित रखने के लिए, हम ट्रेलिंग जीरो ( while(!x%b)x/=b) को ट्रिम करते हैं और फाइनल में जाते हैंk अंक ( x%=b^k) को काटते हैं क्योंकि हम फैक्टरियल ( for(x=1;n;)x*=n--) की गणना करते हैं ।

परीक्षण कार्यक्रम:

f(3, 10, 1)
f(7, 5, 4)
f(3, 2, 3)
f(6, 2, 10)
f(9, 9, 6)
f(7, 10, 4)
f(758, 9, 19)
f(158596, 8, 20)
f(359221, 2, 40)
f(9, 6, 3)
f(10, 6, 3)
quit

पूर्ण परीक्षण सूट का रनटाइम मेरे 2006-विंटेज वर्कस्टेशन पर लगभग 4 on सेकंड है।

Comments

यह मेरा अब तक का पहला bcकार्यक्रम है (गोल्फ या नहीं), इसलिए किसी भी सुझाव का विशेष रूप से स्वागत है ...

— टोबे स्पीट

Answer 12

PHP, 80 बाइट्स

function f($a,$b,$c){echo substr(rtrim(gmp_strval(gmp_fact($a),$b),"0"),-1*$c);}

इसके समान इस्तेमाल किया f(359221,2,40)पिछले परीक्षण के मामले के । सभी परीक्षण मामलों के लिए बहुत आसानी से चलता है।

यहाँ कोशिश करो!