Bei einer Ganzzahl von 1 ≤ N ≤ 1.000.000 als Eingabe wird die letzte Ziffer von N ungleich Null ausgegeben ! wo ! ist die Fakultät (das Produkt aller Zahlen von 1 bis einschließlich N ). Dies ist die OEIS-Sequenz A008904 .

Ihr Programm muss innerhalb von 10 Sekunden auf einem vernünftigen Computer für eine gültige Eingabe beendet sein.

Testfälle

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

Dies ist ein Code-Golf, also gewinnt der kürzeste Code in Bytes!

Ruby - 63 Zeichen

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}

Quelle - http://oeis.org/A008904

Verarbeitet bis zu tausend Stellen in weniger als einer Sekunde.

Prüfung

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

Mathematica, 45 36 Bytes

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

Sehr gut lesbar für eine gewinnende Antwort. :) (Es gibt aber noch keinen Beitrag von GolfScript & Co.)

Dies erledigt die Eingabe von 1.000.000 in ca. 5 Sekunden auf meinem Computer.

Python - 75

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

PARI / GP - 27 Bytes

Dies tauscht Geschwindigkeit gegen Größe - der Testfall dauert lange (~ 6 Sekunden).

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

Diese Version ist viel schneller (~ 15 Mikrosekunden), benötigt aber 81 Bytes:

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)

Mit diesem Code (ohne Golf) können Sie Folgendes testen:

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

Windows PowerShell, 53 56 59 60 63 73 90

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

Anmerkungen:

• Dauert länger als eine Minute für eine Zahl nahe 100.000. Das Entfernen von Nullen am Ende erfordert jedoch eine Konvertierung in einen String. Für Berechnungen ist eine Zahl erforderlich, sodass die Konvertierungen in jedem Fall unvermeidlich sind.

Geschichte:

• 2011-02-08 10:31 (90) - Erster Versuch.
• 2011-02-08 10:33 (73) - Der Modul ist kürzer als das Schneiden und Verbinden.
• 2011-02-08 10:34 (63) - Unnötiger Zuschnitt.
• 2011-02-08 10:37 (60) - Unnötige Besetzung einer Nummer. Modulus macht das schon ganz gut.
• 2011-02-08 10:40 (59) - Einige Inlining.
• 2011-02-08 11:00 (56) - Was habe ich vorhin über die Verkürzung des Moduls gesagt? Gilt auch für die Ausgabe.
• 2011-02-08 11:01 (53) - Es reicht aus, $inputauf eine Zeichenfolge zu werfen . Die Umwandlung in intwird implizit angewendet.

Perl, 53 58 61 Zeichen

Alle Leerzeichen können entfernt werden, aber ich habe es für "Lesbarkeit" belassen. Hinweis: Verwenden Sie keine alberne explizite Formel von Sloane.

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

Berechnet f (10 ^ 6) in 8,7 Sekunden auf meinem Computer.

Update : OP wollte, dass es ein ganzes Programm ist:

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

Das sind 55 Zeichen.

CJam - 28

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

Sie können es unter http://cjam.aditsu.net/ für Werte bis zu 10000 oder so versuchen . Für größere Zahlen sollten Sie den Java-Interpreter verwenden . 1000000 läuft in ca. 3 Sekunden auf meinem Laptop.

Erläuterung:

Leider ist die einfache Lösung zu langsam, so dass ich nach jeder Multiplikation nur die letzten 7 Ziffern (vor den nachgestellten Nullen) behalte.

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

Hinweis: Diese Sprache ist viel neuer als die Frage.

Mathematica, 34 Bytes

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

05AB1E , 4 Bytes

!0м¤

Probieren Sie es online!

Erläuterung

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

Gelee , 4 Bytes

!Ṛȯ/

Probieren Sie es online!

Erläuterung

Verwendet die Tatsache, dass, wenn Ṛ(eine Liste umkehren; nicht vektorisieren) auf eine Ganzzahl angewendet wird, diese automatisch verwendet wirdD (Ziffern) verwendet wird.

Mit Eingang 8:

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

Ich glaube nicht, dass es ein Ein-Byte-Element "first truthy element" gibt (das ȯ/als solches fungiert), aber wenn es ein solches Element gibt, kann es auf insgesamt drei Byte verkürzt werden.

Java (OpenJDK 8) , 62 Byte

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

Probieren Sie es online!

Ähnlich wie @Kevin Cruijssen, spart jedoch 5 Bytes durch Kombinieren der Schleifen.

C 150 140 135 Bytes

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

Dies ist die Version für ASCII-Systeme. Ersetzen Sie die Zeichenfolge 33436durch11214 für ein EBCDIC-System oder durch \1\1\2\1\4für ein tragbares Programm.

C-Lösungen werden durch die Anforderung, ein vollständiges Programm bereitzustellen, etwas behindert. Dies beantwortet jedoch die Frage vollständig.

Probieren Sie es online aus (erfordert Javascript):

• Nur 1000000
• Schleife mit allen Testfällen

Erläuterung

Es basiert auf dem Algorithmus, der in der am wenigsten signifikanten Nicht-Null-Ziffer von n angegeben ist! , drehte sich um, damit wir die höchste Potenz von fünf finden und die Berechnung auf dem Weg nach draußen durchführen. Die Konstantentabellen waren zu groß, deshalb habe ich sie reduziert, indem ich eine Beziehung zwischen dem vorherigen Rest r, der aktuellen Ziffer dund der Rekursionstiefe gefunden habe 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

Denn r>0dies löst sich zu konstanten Zeiten rauf 2^dk(mod 5); Die Konstanten sind a[]unten angegeben (im Golf Code angegeben). Wir beobachten auch, dass dies (2^4)%51 ist, so dass wir den Exponenten reduzieren können, um ein Überlaufen des Bereichs von zu vermeiden 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 */
}

Tests:

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

Auch die Leistung ist respektabel. Hier ist eine maximale Eingabe für ein System mit 32-Bit int:

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

Ich habe die gleichen Timings auch mit maximal 64-Bit int.

PHP - 105

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

Läuft mit dem angegebenen Testfall unter 10 Sekunden.

Python3

Kann 10000 in ~ 3,2 Sekunden erledigen (Ideone schneidet mich nach 8 Sekunden ab, ich bin mir aber sicher, dass es länger als 10 Sekunden dauern wird :()

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

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)

Haskell, 78 Zeichen

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

(Müsste wahrscheinlich kompiliert werden, um 1.000.000 zu berechnen! In 10 Sekunden).

J - 42 40 Zeichen

Ein ganzes Programm. Speichern Sie dieses Programm in einer Datei und führen Sie es mit aus jconsole script.ijs 1234. Beachten Sie, dass dieses Programm den Interpreter nach dem Drucken eines Ergebnisses nicht beendet. Geben Sie ^Doder ein exit]0, um den Interpreter zu beenden.

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

Hier ist eine Erklärung:

• x #. yinterpretiert den ganzzahligen Vektor yals Basiszahl x; zum Beispiel 10 #. 1 2 3 4Ausbeuten 1234.
• u invergibt die Umkehrung eines Verbs u. Insbesondere x #. inv ystellt yals xBasiszahl; zum Beispiel 10 #. 1234Ausbeuten 1 2 3 4. Beachten Sie, dass dies invals -1-mal angewendet definiert ^:_1ist u.
• x * yist das Produkt von xund y, so x 10&#.inv@* yergibt sich eine Base-10-Darstellung des Produktes von xund y.
• x # ykopiert das n- te Element von yso oft wie das n- te Element von x; Wann xist ein Vektor von Booleschen Werten, der xauswählt, welche Elemente genommen werden sollen y. Zum Beispiel 1 0 1 0 # 1 2 3 4Erträge 1 3.
• * yergibt das Zeichen vony .
• x u~ yist das Reflexiv vonu , das heißt das gleiche wie y u x.
• Somit y #~ * yergibt sich ein Vektor aller Elemente y, die positiv sind. In stillschweigender Schreibweise kann dies mit einem Haken als geschrieben werden (#~ *).
• {: yergibt den letzten Eintrag in y.
• zusammengebaut bekommen wir den stillschweigenden Satz ([:{:@(#~*)10&#.inv@*).
• u/ yist die Reduktion des ydyadischen Verbs uzwischen Elementen von y. Zum Beispiel +/1 2 3 4ist wie 1 + 2 + 3 + 4und ergibt 10.
• Somit ([:{:@(#~*)10&#.inv@*)/ yergibt die Phrase die letzte Ziffer des Produkts der Artikel von y.
• ARGV ist ein umrahmter Vektor der Befehlszeilenargumente.
• ".>{:ARGV ist das letzte Argument, das als Zahl interpretiert wird.
• i. yberechnet natürliche Zahlen von 0bis y - 1.
• Somit 1+i. yergeben sich natürliche Zahlen von 1bis y. Ich hätte hier auch >: Inkrement verwenden können , ist aber 1+bei gleichen Zeichenkosten klarer.
• Das gesamte Programm wendet einfach 1+i.".>{:ARGV(der Vektor 1der Zahl im letzten Befehlszeilenargument) auf das Verb an ([:{:@(#~*)10&#.inv@*)/und gibt das Ergebnis mit aus echo.

Pyt , 5 Bytes

!₫ą0⦋

Erläuterung:

         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

Probieren Sie es online!

R , 63 55 51 46 Byte

Berechnet Fakultät, extrahiert die letzte Ziffer ungleich Null. Vielen Dank an Giuseppe für die Bereitstellung der Grundstruktur.

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

Probieren Sie es online!

Alternativ meine alte 51-Byte-Antwort:

Berechnet Fakultät, konvertiert in Zeichen, entfernt alle 0s und nimmt dann das letzte Zeichen. 2 Bytes dank Giuseppe gespeichert.

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

Probieren Sie es online!

> <> 25 Bytes

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

Probieren Sie es online!

Griffe 0! auch richtig. Wert, der über das -vFlag übergeben wurde.

Perl 6 ,  26  35 Bytes

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

Versuch es

Als volles Programm:

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

Versuch es

Erweitert:

{
  [*]( 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)
  /
}

C (gcc) , 72 Bytes (Funktion)

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

Probieren Sie es online!

C (gcc) , 101 99 Bytes (gesamtes Programm)

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

Probieren Sie es online!

Diese Frage ist gerade mal 8 Jahre alt, also ist "vernünftige Maschine" nicht die gleiche wie damals, aber ich bekomme Zeiten von ~ 0,01 Sekunden auf meinem Computer, wenn ich alle Testfälle zusammen mache, es sei denn, die Geschwindigkeit der Computer hat zugenommen um den Faktor 1000 in diesem letzten Jahrzehnt sollte es in Ordnung sein.

Add ++ , 11 Bytes

L,RB*EDBFEZ

Probieren Sie es online!

Attache , 26 Bytes

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

Probieren Sie es online!

Erläuterung

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

Dies ist eine Komposition aus 4 Funktionen:

• `! - Dies ist eine funktionale Version des Fakultätsoperators
• Digits - Dies erhält die Ziffern der Fakultät
• \&:(All@V)- Dies ist eine Auswahlfunktion. Es funktioniert durch linkes Bonden ( &:) der Funktion All@Vnach\ , die ausgewählt ist. Dies All@Vist eine kurze Möglichkeit, um zu testen, ob eine Zahl ungleich 0 ist. Die Eingabe wird in einen Vektor umgewandelt0 -> [0] wandelt um und fragt dann ab, ob alle diese Mitglieder wahr sind (dh nicht 0). Dies ergibt die Ziffern der Zahl ohne 0s.
• Last - Dies erhält einfach das letzte Mitglied dieses Arrays.

APL (Dyalog Unicode) , 18 15 Bytes

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

Probieren Sie es online!

Tacit-Präfix-Funktion. Gibt die richtige Ziffer für einen einzelnen Testfall oder eine Ziffernfolge für mehrere Testfälle zurück.

Vielen Dank an @ Adám und @ErikTheOutgolfer für jeweils 3 Bytes.

Wie?

{⊢/⍵/⍨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.

APL NARS, 28 Byte, 14 Zeichen

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

Ich weiß nicht warum, aber dies besteht den Test:

  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 

AWK , 47 57 Bytes

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

Probieren Sie es online!

Die ursprüngliche Lösung handhabte "große" Eingabewerte nicht sehr gut. Könnte hinzufügen -M, um es zum Arbeiten zu zwingen, aber das erfordert auch viel mehr Verarbeitungszeit.

Japt , 6 Bytes

Kam mit ein paar verschiedenen 6-Byte, aber ich mochte dieses am besten. Ich bin davon überzeugt, dass es einen Weg geben muss, dies in 5 zu tun.

Êsw ìv

Versuch es

Erläuterung

Êberechnet die Fakultät der Eingabe, skonvertiert sie in einen String und zurück in eine Ganzzahl, nachdem wsie umgekehrt wurde, ìkonvertiert das Ergebnis in ein Array von Ziffern und vgibt das erste Element zurück.

Alternativen

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

Perl 5 , 36 + 10 ( -p -Mbigint) = 46 Bytes

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

Probieren Sie es online!