Vous devez écrire un programme ou une fonction qui a donné trois entiers positifs n b kcomme sorties d'entrée ou renvoie les derniers kchiffres avant les zéros de fin dans la breprésentation de base de n!.

Exemple

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

Contribution

• 3 entiers positifs n b koù 2 <= b <= 10.
• L'ordre des entiers d'entrée peut être choisi arbitrairement.

Sortie

• Une liste de chiffres retournés ou sortis sous forme de nombre entier ou de liste entière.
• Les zéros non significatifs sont facultatifs.
• Votre solution doit résoudre tout exemple de cas de test en moins d'une minute sur mon ordinateur (je ne testerai que les cas fermés. J'ai un PC inférieur à la moyenne.).

Exemples

Nouveaux tests ajoutés pour vérifier l'exactitude des soumissions. (Ils ne font pas partie de la règle d'exécution de moins d'une minute.)

Entrée => Sortie (avec le choix d'omettre les zéros non significatifs)

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

C'est le golf de code, donc l'entrée la plus courte gagne.

Dyalog APL , 23 octets

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

Ce programme fonctionne tant que la factorielle ne dépasse pas la limite de représentation interne. Dans Dyalog APL, la limite peut être augmentée de ⎕FR←1287.

Suppose que les variables n, b et k ont ​​été définies (par exemple n b k←7 5 4), mais si vous souhaitez plutôt demander n , b et k (dans cet ordre), remplacez les trois caractères par ⎕.

Mathematica, 57 48 octets

9 octets enregistrés grâce à @ 2012rcampion.

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

Python, 198 192 181 181 caractères

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

C'est assez rapide, ~ 23 secondes sur le plus grand exemple. Et pas de facteur intégré (je vous regarde, Mathematica!).

Pyth, 26 35 octets

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

C'est une fonction de 3 arguments, nombre, base, nombre de chiffres.

Manifestation.

Le cas de test le plus lent, le dernier, prend 15 secondes sur ma machine.

PARI / GP, 43 octets

La vitesse de négociation pour l'espace donne cet algorithme simple:

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

Chacun des cas de test s'exécute en moins d'une seconde sur ma machine.

Mathematica - 48 octets

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

Non golfé:

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

Exemple:

#!~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}} *)

Pour les cas les plus importants, le facteur limitant ne génère pas les chiffres:

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

La correspondance des motifs semble l'être O(n^2), ce qui fait que les deux derniers cas de test dépassent largement la minute.

Bash / coreutils / dc, 60 octets

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

Utilise le dcscript de ma réponse pour trouver le factoriel , sortie en base $2, avec sedpour couper les zéros de fin et tailpour sélectionner les derniers $3chiffres.

Haskell, 111 109 octets

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

Utilisation: f 158596 8 20->[3,7,2,1,2,4,7,6,7,0,0,4,4,2,2,5,4,6,1,4]

Prend environ 8 secondes pour f 359221 2 40mon ordinateur portable de 4 ans.

Comment ça marche: pliez la multiplication ( *) dans la liste [1..n]. Convertissez chaque résultat intermédiaire en base bsous la forme d'une liste de chiffres (le moins significatif en premier), supprimez les zéros non significatifs, puis prenez les premiers kchiffres et convertissez à nouveau en base 10. Enfin, convertissez à bnouveau en base , mais avec le chiffre le plus significatif en premier.

Python 3, 146 octets

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

Je ne suis pas sûr que les cas de test fonctionneront tous assez rapidement - les plus grands sont très lents (car ils parcourent le nombre).

Essayez-le en ligne ici (mais soyez prudent).

Java, 303 299 296 octets

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

Sur mon ordinateur, cela fait en moyenne un peu moins d'un tiers de seconde sur le 359221 2 40boîtier de test. Prend des entrées via des arguments de ligne de commande.

bc, 75 octets

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

Cela utilise certaines extensions GNU pour réduire la taille du code; un équivalent conforme à POSIX pèse 80 octets:

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

Pour garder les temps d'exécution raisonnables, nous coupons les zéros de fin ( while(!x%b)x/=b) et tronquons aux derniers kchiffres ( x%=b^k) lorsque nous calculons le factoriel ( for(x=1;n;)x*=n--).

Programme de test:

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

L'autonomie de la suite de tests complète est d'environ 4¼ secondes sur mon poste de travail de 2006.

PHP, 80 octets

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

Utilisé comme f(359221,2,40)pour le dernier cas de test. Fonctionne assez bien pour tous les cas de test.

Essayez ici!