Nullen am Ende einer Fakultät

35

Schreiben Sie ein Programm oder eine Funktion, die die Anzahl der Nullen am Ende von n!Basis 10 ermittelt, wobei nes sich um eine eingegebene Zahl handelt (in einem beliebigen Format).

Es kann davon ausgegangen werden, dass nes sich um eine positive ganze Zahl handelt, was bedeutet, dass n!es sich auch um eine ganze Zahl handelt. Nach dem Komma stehen in keine Nullen n!. Es kann auch davon ausgegangen werden, dass Ihre Programmiersprache den Wert von nund verarbeiten kann n!.


Testfälle

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Das ist Code Golf. Es gelten Standardregeln. Der kürzeste Code in Bytes gewinnt.

Einreichungen

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

# Perl, 43 + 2 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

Arcturus
quelle
Können wir davon ausgehen, dass n! passt das in den nativen Integer-Typ unserer Sprachen?
Alex A.
@AlexA. Ja, du kannst.
Arcturus
Kann neine Eingabezeichenfolge sein?
Conor O'Brien
15
Ich denke, dies wäre eine bessere Frage, wenn Sie nicht annehmen n!dürften, dass sie in Ihren Integer-Typ passt! Na ja, vielleicht ein anderes Mal.
Ein Simmons

Antworten:

43

Python 2, 27 Bytes

f=lambda n:n and n/5+f(n/5)

Die Endung Nullen sind begrenzt durch Faktoren von 5. Die Anzahl der Vielfachen , 5dass es höchstens nist n/5(mit Boden Division), aber dies die wiederholten Faktoren in Vielfachen von nicht zählen 25, 125, .... Um diese zu erhalten, dividieren Sie ndurch 5 und wiederholen Sie den Vorgang.

xnor
quelle
19

Gelee , 5 Bytes

!Æfċ5

Verwendet den kontraproduktiven Ansatz, die Fakultät zu finden und sie dann erneut zu faktorisieren und in der Primfaktorisierung nach dem Exponenten von 5 zu suchen.

Probieren Sie es online!

!              Factorial
 Æf            List of prime factors, e.g. 120 -> [2, 2, 2, 3, 5]
   ċ5          Count number of 5s
Sp3000
quelle
4
Huch. Sprechen Sie über Kompromisse! Erhöhen Sie den Speicher und die Zeit um absurde Beträge, um den Code auf 5 Byte zu reduzieren.
Ross Presser
19

Mornington Crescent, 1949 1909 Bytes

Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Parsons Green
Take District Line to Cannon Street
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Blackfriars
Take Circle Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Blackfriars
Take District Line to Upminster
Take District Line to Temple
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Blackfriars
Take Circle Line to Hammersmith
Take District Line to Becontree
Take District Line to Cannon Street
Take District Line to Becontree
Take District Line to Cannon Street
Take District Line to Becontree
Take District Line to Blackfriars
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Angel
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

-40 Bytes dank NieDzejkob

Pfeffer
quelle
Und das ist jetzt meine am meisten aufgerufene Antwort.
pppery
3
Eine kurze Erklärung für diejenigen von uns, die herausgefordert sind, Mornington Crescentwäre cool. :)
Robert Benson
-40 Bytes mit kürzeren Zeilennamen, wo möglich.
NieDzejkob
18

Pyth, 6 Bytes

/P.!Q5

Probieren Sie es hier aus.

/    5   Count 5's in
 P        the prime factorization of
  .!Q      the factorial of the input.

Alternative 7-Byte :

st.u/N5

Das kumulative Reduzieren .u/N5teilt sich 5so oft, bis es eine Wiederholung erhält, was in diesem Fall geschieht, nachdem es 0 erreicht hat.

34 -> [34, 6, 1, 0]

Das erste Element wird dann entfernt ( t) und der Rest summiert ( s).

xnor
quelle
13

Eigentlich 10 Bytes

!$R;≈$l@l-

Probieren Sie es online!

Beachten Sie, dass der letzte Testfall fehlschlägt, wenn Seriously auf CPython ausgeführt wird, weil math.factorial eine C-Erweiterung verwendet wird (die auf 64-Bit-Ganzzahlen beschränkt ist). Seriously auf PyPy auszuführen, funktioniert jedoch einwandfrei.

Erläuterung:

!$R;≈$l@l-
!           factorial of input
 $R         stringify, reverse
   ;≈$      make a copy, cast to int, then back to string (removes leading zeroes)
      l@l-  difference in lengths (the number of leading zeroes removed by the int conversion)
Mego
quelle
3
Oh wow, ich mag, wie diese Methode nicht das Teilen durch 5 Tricks verwendet.
Arcturus
Ich zähle 12 Bytes auf diesem
Score_Under
1
@Score_Under Verwendet tatsächlich die CP437-Codepage, nicht UTF-8. Jedes Zeichen ist ein Byte.
Mego
9

Haskell, 26 Bytes

f 0=0
f n=(+)=<<f$div n 5

Floor dividiert die Eingabe durch 5und fügt das Ergebnis der aufgerufenen Funktion hinzu. Der Ausdruck (+)=<<fnimmt eine Eingabe xund Ausgaben x+(f x).

Gekürzt ab:

f 0=0
f n=div n 5+f(div n 5)

f 0=0
f n|k<-div n 5=k+f k

Ein nicht rekursiver Ausdruck ergab 28 Bytes:

f n=sum[n`div`5^i|i<-[1..n]]
xnor
quelle
Ist iein Zähler von 1..n?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Ja, aber log_5(n)der Rest gibt 0.
xnor
8

MATL , 9 Bytes

:"@Yf5=vs

Probieren Sie es online!

Dies funktioniert bei sehr großen Zahlen, da die Fakultät nicht berechnet wird.

Wie bei anderen Antworten wird auch hier die Tatsache ausgenutzt, dass die Häufigkeit des 2Auftretens als Teiler der Fakultät größer oder gleich der Häufigkeit des Auftretens ist 5.

:     % Implicit input. Inclusive range from 1 to that
"     % For each
  @   %   Push that value
  Yf  %   Array of prime factors
  5=  %   True for 5, false otherwise
  v   %   Concatenate vertically all stack contents
  s   %   Sum
Luis Mendo
quelle
6

05AB1E, 5 Bytes

Wäre 4 Bytes, wenn wir garantieren könnten, dass n> 4 ist

Code:

Î!Ó7è

Erläuterung:

Î        # push 0 then input
  !      # factorial of n: 10 -> 2628800
   Ó     # get primefactor exponents -> [8, 4, 2, 1]
    7è   # get list[7] (list is indexed as string) -> 2
         # implicit output of number of 5s or 0 if n < 5

Alternative, viel schnellere 6-Byte-Lösung: Inspiriert von Luis Mendos MATL-Antwort

LÒ€`5QO

Erläuterung:

L         # push range(1,n) inclusive, n=10 -> [1,2,3,4,5,6,7,8,9,10]
 Ò        # push prime factors of each number in list -> [[], [2], [3], [2, 2], [5], [2, 3], [7], [2, 2, 2], [3, 3], [2, 5]]
  €`      # flatten list of lists to list [2, 3, 2, 2, 5, 2, 3, 7, 2, 2, 2, 3, 3, 2, 5]
    5Q    # and compare each number to 5 -> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
      O   # sum -> 2

Bearbeiten: Entfernte Lösungen mit ¢ (count), da alle Primzahlen mit 5 als 5 gezählt würden, z. B. 53.

Edit 2: Es wurde eine effizientere Lösung für höhere Eingaben als Vergleich hinzugefügt.

Emigna
quelle
Ja, statt , 5Qsollte funktionieren. Gute Antwort! :)
Adnan
Ich wollte auf größeren Eingängen mit dem Kommentar "Wäre dies nicht scheitern, wenn die Ausgabe> 9 wäre" testen, aber die Implementierung von Boy 05AB1E Óist langsam
Sp3000
Übrigens kann der erste Code auch sein Î!Ó2é. Der Fehler wurde gestern behoben .
Adnan
Wenn Sie utf-8 verwenden, sind Î!Ó7èes 8 Byte, und die "6 Byte" -Lösung ist 10 Byte
Score_Under
@Score_Under Ja das ist richtig. 05AB1E verwendet jedoch die CP-1252-Codierung.
Adnan
6

Matlab (59) (54)(39)

Hey dawg !!!! Wir haben gehört, dass du Mathe magst ...

  @(n)sum(fix(n./5.^(1:fix(log(n)/1.6))))
  • Dies basiert auf meiner Antwort in der Codeüberprüfung .

  • weiter als in meiner Antwort in der Codeüberprüfung erwähnt, lautet die Formel für die Anzahl der Nullen in der Fakultät (n) Summe (n / (5 ^ k)), wobei k zwischen 1 und log_5 (n) variiert.

  • Der einzige triviale Grund, warum es nicht Golfspieler werden kann, ist, dass log5es in Matlab nicht als eingebautes Programm verfügbar ist. Daher habe ich log (5) durch 1.6 ersetzt. Das spielt keine Rolle, da es sowieso mit Fußboden ausgelegt sein wird.

Versuche es

Abr001am
quelle
Einige Fragen. 1. Wie läuft das eigentlich in Matlab? 2. Was ist das Ergebnis für n = 1?
Stuart Bruff
@StuartBruff, um diesen Typ ans (1) auszuführen, und es gibt 0 zurück.
Abr001am
OKAY. Vielen Dank. Interessant. Ich habe in Matlab nicht viel mit Funktionshandles gearbeitet, daher war ich ein wenig verwirrt, wie man es ausführt ... warum zählt das ans () nicht zur Gesamtsumme? Gute Antwort, ich habe es in Mathcad versucht, musste aber die obere Grenze der Summe ändern, da Mathcad die Summationsvariable automatisch dekrementiert, wenn die "obere" unter der "unteren" Grenze liegt (und daher meine Frage zu 0).
Stuart Bruff
5

Mathematica, 20 Bytes

IntegerExponent[#!]&

IntegerExponentzählt die Nullen. Zum Spaß ist hier eine Version, die die Fakultät nicht berechnet:

Tr[#~IntegerExponent~5&~Array~#]&
LegionMammal978
quelle
Ich denke, Arrayspart ein Byte bei der zweiten Lösung.
Martin Ender
5

C 28 Bytes

f(n){return(n/=5)?n+f(n):n;}

Erläuterung

Die Anzahl der nachgestellten Nullen entspricht der Anzahl der Fünfer, aus denen sich die Fakultät zusammensetzt. Von all dem 1..nträgt ein Fünftel eine Fünf bei, also fangen wir an n/5. Von diesen n/5ist ein Fünftel ein Vielfaches von 25, tragen also weitere fünf bei und so weiter. Wir landen mit f(n) = n/5 + n/25 + n/125 + ..., was ist f(n) = n/5 + f(n/5). Wir müssen die Rekursion beenden, wenn nNull erreicht wird. Wir nutzen auch den Sequenzpunkt ?:, um nvor der Addition zu teilen .

Als Bonus ist dieser Code viel schneller als derjenige, der jeden besucht 1..n (und viel schneller als die Berechnung der Fakultät).

Testprogramm

#include<stdio.h>
#include<stdlib.h>
int main(int argc, char **argv) {
    while(*++argv) {
        int i = atoi(*argv);
        printf("%d: %d\n",i,f(i));
    }
}

Ausgang testen

1: 0
4: 0
5: 1
24: 4
25: 6
124: 28
125: 31
666: 165
2016: 502
2147483644: 536870901
2147483647: 536870902

Toby Speight
quelle
+1 für eine hervorragende Erklärung
Titus
4

JavaScript ES6, 20 Byte

f=x=>x&&x/5+f(x/5)|0

Gleiche Taktik wie bei xnors Antwort, aber kürzer.

Conor O'Brien
quelle
4

Julia, 34 31 30 Bytes

n->find(digits(prod(1:n)))[]-1

Dies ist eine anonyme Funktion, die jeden vorzeichenbehafteten Ganzzahltyp akzeptiert und eine Ganzzahl zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu. Die größeren Testfälle erfordern das Bestehen nals größerer Typ, wie z BigInt.

Wir berechnen die Fakultät von n(die manuelle Verwendung prodist kürzer als die eingebaute factorial), erhalten ein Array digitsin umgekehrter Reihenfolge, finddie Indizes der Nicht-Null-Elemente, erhalten den ersten solchen Index und subtrahieren 1.

Probieren Sie es online! (Beinhaltet alle bis auf den letzten Testfall, da der letzte zu lange dauert)

Dank Dennis ein Byte gespart!

Alex A.
quelle
3

C, 36

r;f(n){for(r=0;n/=5;)r+=n;return r;}

Die gleiche Methode wie bei @ xnor, bei der 5s gezählt werden, jedoch nur eine einfache for-Schleife anstelle einer Rekursion verwendet wird.

Ideone .

Digitales Trauma
quelle
@TobySpeight los gehts.
Digitales Trauma
3

Retina , 33 Bytes

Nimmt unäre Eingaben auf.

Gibt die Ausgabe in Unary zurück.

+ `^ (? = 1) (1 {5}) * 1 *
$ # 1 $ * 1; $ # 1 $ *
;

(Beachten Sie den nachfolgenden Zeilenumbruch.)

Probieren Sie es online!

Wie es funktioniert:

Die erste Stufe:

+`^(?=1)(1{5})*1*
$#1$*1;$#1$*

Leicht ungolfed:

+`^(?=1)(11111)*1*\b
$#1$*1;$#1$*1

Was es macht:

  • Erstens, finden Sie die größte Anzahl 11111, die abgeglichen werden kann.
  • Ersetzen Sie durch diese Nummer
  • Effektiv teilt Boden durch 5.
  • Der Lookahead (?=1)versichert, dass die Zahl positiv ist.
  • Die +`Mittel wiederholen sich bis zum Idempotenten.
  • So ist die erste Stufe "wiederholte Unterteilung durch 5"

Wenn die Eingabe 100 ist (in Unary), lautet der Text jetzt:

;;1111;11111111111111111111

Zweite Etage:

;

Entfernt einfach alle Semikolons.

Undichte Nonne
quelle
2

Ruby, 22 Bytes

Eines der wenigen Male, in denen die 0Wahrheit des Rubins ein Problem für die Byteanzahl ist.

f=->n{n>0?f[n/=5]+n:0}
Wert Tinte
quelle
warte, warum ist 0wahr?
Conor O'Brien
2
@ CᴏɴᴏʀO'Bʀɪᴇɴ In Ruby nilund falsesind Falsche, und sonst ist nichts. Es gibt viele Fälle, in denen beim Golfen 0geholfen wird , da Wahrhaftigkeit bedeutet, dass die Index- und Regex-Indexfunktionen in Ruby zurückgegeben werden, nilwenn es keine Übereinstimmung gibt -1, und einige Fälle, in denen dies ein Problem darstellt, z. B. wenn leere Zeichenfolgen immer noch wahr sind.
Value Ink
@ KevinLau-notKenny Das macht Sinn.
Conor O'Brien
2

Perl 6 , 23 Bytes

{[+] -$_,$_,*div 50}
{sum -$_,$_,*div 5...0}

Ich könnte es kürzer machen, wenn ^...es zu Perl 6 hinzugefügt würde {sum $_,*div 5^...0}.
Bei größeren Zahlen sollte es speichereffizienter sein, wenn Sie lazyzwischen sumund dem Sequenzgenerator einen Modifikator einfügen.

Erläuterung:

{ # implicitly uses $_ as its parameter
  sum

    # produce a sequence
    -$_,     # negate the next value
     $_,     # start of the sequence

     * div 5 # Whatever lambda that floor divides its input by 5

             # the input being the previous value in the sequence,
             # and the result gets appended to the sequence

     ...     # continue to do that until:

     0       # it reaches 0
}

Prüfung:

#! /usr/bin/env perl6

use v6.c;
use Test;

my @test = (
     1,   0,
     5,   1,
   100,  24,
   666, 165,
  2016, 502,
  1234567891011121314151617181920,
        308641972752780328537904295461,

  # [*] 5 xx 100
  7888609052210118054117285652827862296732064351090230047702789306640625,
        1972152263052529513529321413206965574183016087772557511925697326660156,
);

plan @test / 2;

# make it a postfix operator, because why not
my &postfix:<!0> = {[+] -$_,$_,*div 5...0}

for @test -> $input, $expected {
  is $input!0, $expected, "$input => $expected"
}

diag "runs in {now - INIT now} seconds"
1..7
ok 1 - 1 => 0
ok 2 - 5 => 1
ok 3 - 100 => 24
ok 4 - 666 => 165
ok 5 - 2016 => 502
ok 6 - 1234567891011121314151617181920 => 308641972752780328537904295461
ok 7 - 7888609052210118054117285652827862296732064351090230047702789306640625 => 1972152263052529513529321413206965574183016087772557511925697326660156
# runs in 0.0252692 seconds

(Diese letzte Zeile ist leicht irreführend, da MoarVM starten, den Perl 6-Compiler und die Laufzeit laden, den Code kompilieren und ausführen muss. Es dauert also insgesamt ungefähr anderthalb Sekunden.
Das ist immer noch erheblich schneller als es ist war das Ergebnis des letzten Tests mit WolframAlpha.com zu überprüfen)

Brad Gilbert b2gills
quelle
2

Mathcad, [tbd] Bytes

Bildbeschreibung hier eingeben

Mathcad ist eine Art mathematisches "Whiteboard", das die 2D-Eingabe von Ausdrücken, Text und Zeichnungen ermöglicht. Es werden mathematische Symbole für viele Operationen wie Summation, Differenzierung und Integration verwendet. Programmieroperatoren sind spezielle Symbole, die normalerweise als einzelne Tastenkombinationen von Steuerung und / oder Umschalttaste auf einer Standardtaste eingegeben werden.

Was Sie oben sehen, ist genau, wie das Mathcad-Arbeitsblatt so aussieht, wie es eingegeben und wie es von Mathcad ausgewertet wird. Wenn Sie beispielsweise n von 2016 auf einen anderen Wert ändern, aktualisiert Mathcad das Ergebnis von 502 auf den neuen Wert.

http://www.ptc.com/engineering-math-software/mathcad/free-download


Die Methode zur Bewertung der Byte-Äquivalenz von Mathcad muss noch ermittelt werden. Bei einer Symboläquivalenz benötigt die Lösung etwa 24 "Bytes" (der while-Operator kann nur über die Tastenkombination "ctl-]" (oder über eine Symbolleiste) eingegeben werden. Die Matlab-Methode von Agawa001 benötigt bei der Übersetzung in Mathcad ca. 37 Byte (der Summationsoperator wird mit ctl-shft- $ eingegeben).

Stuart Bruff
quelle
Hört sich umwerfend an, ich erspare keinen zweiten Download!
13.
2

Gleichstrom, 12 Bytes

[5/dd0<f+]sf

Dies definiert eine Funktion, fdie ihre Eingabe vom oberen Ende des Stapels verbraucht und ihre Ausgabe am oberen Ende des Stapels belässt. Siehe meine C-Antwort für die mathematische Basis. Wir teilen wiederholt durch 5, akkumulieren die Werte auf dem Stapel und addieren dann alle Ergebnisse:

5/d   # divide by 5, and leave a copy behind
d0<   # still greater than zero?
f+    # if so, apply f to the new value and add

Testprogramm

# read input values
?
# print prefix
[  # for each value
    # print prefix
    [> ]ndn[ ==> ]n
    # call f(n)
    lfx
    # print suffix
    n[  
]n
    # repeat for each value on stack
    z0<t
]
# define and run test function 't'
dstx

Ausgang testen

./79762.dc <<<'1234567891011121314151617181920 2016 666 125 124 25 24 5 4 1'
1 ==> 0  
4 ==> 0  
5 ==> 1  
24 ==> 4  
25 ==> 6  
124 ==> 28  
125 ==> 31  
666 ==> 165  
2016 ==> 502  
1234567891011121314151617181920 ==> 308641972752780328537904295461  
Toby Speight
quelle
1

Jolf, 13 Bytes

Ώmf?H+γ/H5ΏγH

Definiert eine rekursive Funktion, die am Eingang aufgerufen wird. Probieren Sie es hier aus!

Ώmf?H+γ/H5ΏγH  Ώ(H) = floor(H ? (γ = H/5) + Ώ(γ) : H)
Ώ              Ώ(H) =
       /H5                           H/5
      γ                         (γ =    )
     +    Ώγ                              + Ώ(γ)
   ?H       H               H ?                  : H
 mf                   floor(                        )
               // called implicitly with input
Conor O'Brien
quelle
1

J, 28 17 16 Bytes

<.@+/@(%5^>:@i.)

Ziemlich dasselbe wie die nicht-rekursive Technik aus der Antwort von xnor.


Hier ist eine ältere Version, die ich hier behalten habe, weil es mir persönlich besser gefällt und ich mit 28 Bytes anfange:

+/@>@{:@(0<;._1@,'0'&=@":@!)

Obwohl nicht benötigt, habe ich x:in die Testfälle für erweiterte Präzision aufgenommen.

   tf0 =: +/@>@{:@(0<;._1@,'0'&=@":@!@x:)
   tf0 5
1
   tf0 100
24

   tf0g =: tf0"0
   tf0g 1 5 100 666 2016
0 1 24 165 502

Die letzte Nummer funktioniert mit dieser Funktion nicht.

Erläuterung

Dies funktioniert, indem berechnet n!, in eine Zeichenfolge konvertiert und jedes Element auf Gleichheit mit überprüft wird '0'. Denn n = 15dieser Prozess wäre:

15
15! => 1307674368000
": 1307674368000 => '1307674368000'
'0' = '1307674368000' => 0 0 1 0 0 0 0 0 0 0 1 1 1

Nun ;._1teilen wir die Liste auf das erste Element (Null) auf , wobei wir jedes Teilungsergebnis boxen und eine Box mit Assen ( a:) oder Läufen von 1s erhalten, wie folgt:

┌┬─┬┬┬┬┬┬┬─────┐
││1│││││││1 1 1│
└┴─┴┴┴┴┴┴┴─────┘

Wir erhalten einfach das letzte Mitglied ( {:), entpacken es ( >) und addieren es +/, wobei wir die Anzahl der Nullen erhalten.

Hier ist die besser lesbare Version:

split =: <;._1@,
tostr =: ":
is =: =
last =: {:
unbox =: >
sum =: +/
precision =: x:
n =: 15

NB. the function itself
tf0 =: sum unbox last 0 split '0' is tostr ! precision n
tf0 =: sum @ unbox @ last @ (0 split '0'&is @ tostr @ ! @ precision)
tf0 =: +/ @ > @ {: @ (0 <;._1@, '0'&= @ ": @ ! )
Conor O'Brien
quelle
>:@i.kann geschrieben werden 1+i., um ein Byte zu speichern.
Algorithmushai
Ihre ältere Version kann [:#.~'0'=":@!durch Ändern der Methode zum Zählen der nachgestellten Einsen in 13 Bytes umgewandelt werden.
Cole
1

Python 3, 52 Bytes

g=lambda x,y=1,z=0:z-x if y>x else g(x,y*5,z+x//y)
Magenta
quelle
Dies funktioniert nicht, probieren Sie die Testfälle.
spätestens
Es sollte jetzt funktionieren.
Magenta
1

RETURN , 17 Bytes

[$[5÷\%$F+][]?]=F

Try it here.

Rekursiver Operator Lambda. Verwendung:

[$[5÷\%$F+][]?]=F666F

Erläuterung

[             ]=F  Lambda -> Operator F
 $                 Check if top of stack is truthy
  [       ][]?     Conditional
   5÷\%$F+         If so, do x/5+F(x/5)
Mama Fun Roll
quelle
1

Perl, 24 22 + 1 ( -pFlag) = 23 Bytes

$\+=$_=$_/5|0while$_}{

Verwenden von:

> echo 2016 | perl -pe '$\+=$_=$_/5|0while$_}{'

Volles Programm:

while (<>) {
# code above added by -p
    while ($_) {
        $\ += $_ = int($_ / 5);
    }
} {
# code below added by -p
    print;  # prints $_ (undef here) and $\
}
Denis Ibaev
quelle
1

Java, 38 Bytes

int z(int n){return n>0?n/5+z(n/5):0;}

Volles Programm mit ungolfed Methode:

import java.util.Scanner;

public class Q79762{
    int zero_ungolfed(int number){
        if(number == 0){
            return 0;
        }
        return number/5 + zero_ungolfed(number/5);
    }
    int z(int n){return n>0?n/5+z(n/5):0;}
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        System.out.println(new Q79762().zero_ungolfed(n));
        System.out.println(new Q79762().z(n));
    }
}
Undichte Nonne
quelle
1

J, 7 Bytes

Monadische Funktion, rechts argumentierend.

3{:@q:!

Wenn xpositiv, werden x q: ydie Exponenten in einer Primfaktorisierung von ynur für die ersten xPrimzahlen zurückgegeben. Die 3-rd-Primzahl ist 5 und steht {:am Ende einer Liste.

Beachten Sie, dass Sie ganze Zahlen mit einem xam Ende eingeben müssen, andernfalls werden sie von J als Gleitkommazahlen behandelt.

   3{:@q:! 100x
24
   3{:@q:! 666x
165
   3{:@q:! 2016x
502

Probieren Sie es selbst bei tryj.tk jedoch, dass sich dieser Online-Dolmetscher beschwert, wenn Sie etwas versuchen, das größer als 1343 ist.

Wenn Sie etwas wollen, das n nicht berechnet ! und daher muss es nicht in eine ganze Zahl passen, verwenden Sie die rekursive Lösung <.@%&5(+$:@)^:*. (tryj.tk meckert immer noch bei großen Eingaben.)

algorithmshark
quelle
1

Ruby, 70 61 51 49 Bytes

Version 3 mit Dank an Kenny Lau und daniero

->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}

Bearbeiten: Es hat sich herausgestellt, dass Sie durch Zuordnen to_i vor Ihnen zwei Bytes sparen können reduce. Seltsam: P

Diese Funktion subtrahiert die Summe der nfünf Stellen der Basis von nund dividiert das Ergebnis durch 4. Dies bezieht sich auf die Summe der geometrischen Reihen1+5+25+..+5**n = (5**n+1)/4 .

Betrachten Sie als Beispiel (erneut dank Kenny Lau) 358( 2413in Basis 5) minus der 5-stelligen Basis.

2413-2-4-1-3 
= (2000-2) + (400-4) + (10-1) + (3-3)
# consider that 1000-1=444 and you'll see why every 5**n is multiplied by 4
= 2*444 + 4*44 + 1*4 + 3*0
= 2*(4*5**0+4*5**1+4*5**2) + 4*(4*5**0+4*5**1) + 1*(4*5**0) + 3*()
= 348

Teilen Sie 348durch 4und Sie bekommen f(358) = 87.

Version 2 mit Dank an Kenny Lau

->n{s=(1..n).reduce(:*).to_s;s.size-s.reverse.to_i.to_s.size}

Diese Funktion berechnet n!und subtrahiert dann das sizevon n!vom sizevon (n!).reverse.to_i.to_s, wodurch alle Nullen entfernt werden und somit das sizevon den Nullen selbst zurückgegeben wird.

Version 1

->n{s=n.to_s(5).chars;(0...s.size).reduce{|a,b|a+(s[0,b]*'').to_i(5)}}

Dies ist eine Variation der "Wie viele 5s gibt es in der Primfaktorisierung von n!?" Trick, der Rubys einfache integrierte Basisumwandlung verwendet.

Der Golf ist ein bisschen wie ein Schmerz aber, mit der Umwandlung von Integerbis Stringzu Array, einen Teil des für die Heimelf Arrayund Umwandeln dass Stringzu Integerwieder für die reduce. Anregungen zum Golfen sind willkommen.

Sherlock9
quelle
Es ist etwas kürzer zuzuordnen, to_ibevor es reduziert wird: ->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}(spart zwei Bytes)
daniero
@daniero das hätte ich nicht erwartet. Danke: D
Sherlock9
1

Dyalog APL , 9 Bytes

⊥⍨'0'=⍕!⎕

Aufforderung zur Eingabe der Nummer

! faktorisieren

stringifizieren

'0'= Überprüfen Sie die Gleichheit mit dem Zeichen Null

⊥⍨ zähle nachfolgende Wahrheiten *


* Es handelt sich buchstäblich um eine gemischte Basis-Basis-10-Konvertierung, wobei die Boolesche Liste sowohl als Zahl als auch als Basis verwendet wird:

⊥⍨0 1 0 1 1ist das Gleiche wie 0 1 0 1 1⊥⍨0 1 0 1 1das, 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)was wiederum zwei ist (die Anzahl der nachgestellten Einsen).

Adam
quelle