Nol di akhir faktorial

35

Tulis program atau fungsi yang menemukan jumlah nol pada akhir n!di basis 10, di mana nadalah nomor input (dalam format apa pun yang diinginkan).

Dapat diasumsikan bahwa nbilangan bulat positif, artinya n!bilangan bulat juga. Tidak ada nol setelah titik desimal di n!. Juga, dapat diasumsikan bahwa bahasa pemrograman Anda dapat menangani nilai ndan n!.


Uji kasus

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Ini kode golf. Aturan standar berlaku. Kode terpendek dalam byte menang.

Pengajuan

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

# Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat tautan nama bahasa yang kemudian akan muncul di cuplikan papan peringkat:

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

Papan peringkat

Berikut ini adalah Stack Snippet untuk menghasilkan leaderboard biasa dan gambaran umum pemenang berdasarkan bahasa.

Arcturus
sumber
Terkait
xnor
Bisakah kita berasumsi bahwa n! akan cocok dengan tipe integer asli bahasa kami?
Alex A.
@AlexA. Ya kamu bisa.
Arcturus
Dapat nberupa string input?
Conor O'Brien
15
Saya pikir ini akan menjadi pertanyaan yang lebih baik jika Anda tidak diizinkan untuk menganggap n!akan masuk ke dalam tipe integer Anda! Yah, mungkin lain kali.
A Simmons

Jawaban:

43

Python 2, 27 byte

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

Nol akhir dibatasi oleh faktor 5. Jumlah kelipatan 5yang paling banyak nadalah n/5(dengan pembagian lantai), tetapi ini tidak menghitung faktor berulang dalam kelipatan 25, 125, .... Untuk mendapatkannya, bagi ndengan 5 dan ulangi.

Tidak
sumber
19

Jelly , 5 byte

!Æfċ5

Menggunakan pendekatan kontraproduktif untuk menemukan faktorial lalu memfaktorkannya kembali, memeriksa eksponen 5 dalam factorisation utama.

Cobalah online!

!              Factorial
 Æf            List of prime factors, e.g. 120 -> [2, 2, 2, 3, 5]
   ċ5          Count number of 5s
Sp3000
sumber
4
Astaga. Bicara tentang trade-off! Untuk menurunkan kode menjadi 5 byte, tingkatkan memori dan waktu dengan jumlah yang tidak masuk akal.
Ross Presser
19

Mornington Crescent, 1949 1909 byte

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 byte terima kasih kepada NieDzejkob

pppery
sumber
Dan ini sekarang jawaban saya yang paling banyak dipilih.
pppery
3
Penjelasan singkat bagi kita yang Mornington Crescentditantang akan menjadi keren. :)
Robert Benson
-40 byte dengan menggunakan nama garis yang lebih pendek jika memungkinkan.
NieDzejkob
18

Pyth, 6 byte

/P.!Q5

Coba di sini.

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

Alternatif 7-byte :

st.u/N5

Kumulatif mengurangi .u/N5berulang-ulang lantai-terbagi 5sampai mendapat pengulangan, yang dalam hal ini terjadi setelah mencapai 0.

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

Elemen pertama kemudian dihapus ( t) dan sisanya dijumlahkan ( s).

Tidak
sumber
13

Sebenarnya 10 byte

!$R;≈$l@l-

Cobalah online!

Perhatikan bahwa test case terakhir gagal ketika menjalankan Serius pada CPython karena math.factorialmenggunakan ekstensi C (yang terbatas pada bilangan bulat 64-bit). Menjalankan Seriously on PyPy berfungsi dengan baik.

Penjelasan:

!$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
sumber
3
Oh wow, saya suka bagaimana metode ini tidak menggunakan pembagian dengan 5 trik.
Arcturus
Saya menghitung 12 byte yang satu ini
Score_Under
1
@Score_Under Sebenarnya menggunakan halaman kode CP437, bukan UTF-8. Setiap karakter adalah satu byte.
Mego
9

Haskell, 26 byte

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

Floor-membagi input dengan 5, kemudian menambahkan hasilnya ke fungsi yang dipanggil itu. Ekspresi (+)=<<fmengambil input xdan output x+(f x).

Disingkat dari:

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

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

Ekspresi non-rekursif memberi 28 byte:

f n=sum[n`div`5^i|i<-[1..n]]
Tidak
sumber
Apakah icounter dari 1..n?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Ya, meski hanya log_5(n)penting, sisanya memberi 0.
xnor
8

MATL , 9 byte

:"@Yf5=vs

Cobalah online!

Ini berfungsi untuk angka yang sangat besar, karena menghindari penghitungan faktorial.

Seperti jawaban lain, ini mengeksploitasi fakta bahwa jumlah kali 2muncul sebagai pembagi faktorial lebih besar atau sama dengan jumlah kali 5muncul.

:     % 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
sumber
6

05AB1E, 5 byte

Akan menjadi 4 byte jika kami dapat menjamin n> 4

Kode:

Î!Ó7è

Penjelasan:

Î        # 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

Alternatif, lebih cepat, solusi 6 byte: Terinspirasi oleh jawaban MATL dari Luis Mendo

LÒ€`5QO

Penjelasan:

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

Edit: solusi yang dihapus menggunakan ¢ (hitungan) karena semua bilangan prima yang mengandung 5 akan dihitung sebagai 5 misalnya 53.

Sunting 2: menambahkan solusi yang lebih efisien untuk input yang lebih tinggi sebagai perbandingan.

Emigna
sumber
Ya, alih-alih , 5Qharus bekerja. Jawaban yang bagus! :)
Adnan
Saya akan uji pada input yang lebih besar dengan komentar "tidak akan ini gagal jika output adalah> 9", tetapi implementasi anak 05AB1E tentang Óadalah lambat
Sp3000
Btw, kode pertama juga bisa Î!Ó2é. Bug telah diperbaiki kemarin .
Adnan
Jika Anda menggunakan utf-8, Î!Ó7èadalah 8 byte, dan solusi "6 byte" adalah 10 byte
Score_Under
@Score_Di bawah Ya itu benar. Namun, 05AB1E menggunakan pengkodean CP-1252.
Adnan
6

Matlab (59) (54)(39)

Hei dawg !!!! kami mendengarmu menyukai matematika ....

  @(n)sum(fix(n./5.^(1:fix(log(n)/1.6))))
  • Ini berdasarkan jawaban yang saya buat dalam ulasan kode .

  • lebih jauh dari apa yang disebutkan dalam jawaban saya dalam tinjauan kode, rumus untuk jumlah nol dalam faktorial (n) adalah Jumlah (n / (5 ^ k)) di mana k bervariasi antara 1 dan log_5 (n)

  • Satu-satunya alasan sepele mengapa tidak bisa bermain golf adalah karena log5tidak tersedia di matlab sebagai builtin, jadi saya mengganti log (5) dengan 1,6, tidak masalah karena itu akan tetap lantai.

Cobalah

Abr001am
sumber
Beberapa pertanyaan. 1. Bagaimana Anda menjalankan ini di Matlab? 2. Apa hasil untuk n = 1?
Stuart Bruff
@StuartBruff untuk menjalankan jenis ini ans (1) dan itu mengembalikan 0.
Abr001am
BAIK. Terima kasih. Menarik. Saya belum pernah menggunakan fungsi menangani banyak di Matlab, jadi agak bingung bagaimana cara menjalankannya ... mengapa ans () tidak diperhitungkan total? Namun, jawaban yang rapi, saya mencobanya di Mathcad tetapi harus memodifikasi batas atas jumlah karena Mathcad autodecrements variabel penjumlahan jika "atas" kurang dari batas "lebih rendah" (dan karenanya pertanyaan saya tentang 0).
Stuart Bruff
5

Mathematica, 20 byte

IntegerExponent[#!]&

IntegerExponentmenghitung nol. Untuk bersenang-senang, inilah versi yang tidak menghitung faktorial:

Tr[#~IntegerExponent~5&~Array~#]&
LegionMammal978
sumber
Saya pikir Arraymenghemat satu byte pada solusi kedua.
Martin Ender
5

C, 28 byte

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

Penjelasan

Jumlah nol tambahan sama dengan jumlah balita yang membentuk faktorial. Dari semua itu 1..n, seperlima dari mereka berkontribusi lima, jadi kita mulai dengan n/5. Dari jumlah tersebut n/5, yang kelima adalah kelipatan dari 25, jadi berkontribusi lima tambahan, dan seterusnya. Kita berakhir dengan f(n) = n/5 + n/25 + n/125 + ..., yaitu f(n) = n/5 + f(n/5). Kita perlu menghentikan rekursi ketika nmencapai nol; kami juga memanfaatkan titik sekuens ?:untuk membagi nsebelum penambahan.

Sebagai bonus, kode ini jauh lebih cepat daripada yang mengunjungi masing-masing 1..n (dan jauh, lebih cepat daripada menghitung faktorial).

Program uji

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

Uji keluaran

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

Toby Speight
sumber
+1 untuk penjelasan yang luar biasa
Titus
4

JavaScript ES6, 20 byte

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

Taktik yang sama seperti pada jawaban xnor, tetapi lebih pendek.

Conor O'Brien
sumber
4

Julia, 34 31 30 byte

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

Ini adalah fungsi anonim yang menerima semua jenis bilangan bulat yang ditandatangani dan mengembalikan bilangan bulat. Untuk menyebutnya, tetapkan ke variabel. Kasus uji yang lebih besar memerlukan kelulusan nsebagai jenis yang lebih besar, seperti a BigInt.

Kami menghitung faktorial n(menggunakan secara manual prodlebih pendek dari built-in factorial), mendapatkan array digitsdalam urutan terbalik,find indeks elemen bukan-nol, mendapatkan indeks pertama seperti itu, dan mengurangi 1.

Cobalah online! (termasuk semua kecuali test case terakhir karena yang terakhir terlalu lama)

Menyimpan satu byte berkat Dennis!

Alex A.
sumber
3

C, 36

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

Metode yang sama dengan jawaban @ xnor tentang penghitungan 5s, tetapi hanya menggunakan loop sederhana sebagai ganti rekursi.

Ideone .

Trauma Digital
sumber
@TobySpeight ini dia.
Digital Trauma
3

Retina , 33 byte

Mengambil input di unary.

Mengembalikan output di unary.

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

(Perhatikan garis-makan garis.)

Cobalah online!

Bagaimana itu bekerja:

Tahap pertama:

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

Sedikit tidak berbulu:

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

Apa fungsinya:

  • Pertama, temukan jumlah terbesar 11111yang bisa dicocokkan.
  • Ganti dengan nomor itu
  • Secara efektif membagi lantai dengan 5 .
  • Lookahead (?=1)memastikan bahwa angka itu positif.
  • The +`berarti ulangi sampai idempoten.
  • Jadi, tahap pertama adalah "pembagian lantai berulang dengan 5"

Jika inputnya 100 (dalam unary), maka teksnya sekarang:

;;1111;11111111111111111111

Tahap kedua:

;

Hanya menghapus semua titik koma.

Biarawati Bocor
sumber
2

Ruby, 22 byte

Salah satu dari beberapa kali di mana Ruby 0menjadi benar adalah masalah untuk jumlah byte.

f=->n{n>0?f[n/=5]+n:0}
Nilai Tinta
sumber
tunggu, mengapa 0kebenaran?
Conor O'Brien
2
@ CᴏɴᴏʀO'Bʀɪᴇɴ Di Ruby, nildan falseitu falsey, dan tidak ada yang lain. Ada banyak kasus di mana membantu dalam golf, karena 0menjadi jujur ​​berarti indeks dan fungsi indeks regex di Ruby kembali niljika tidak ada yang cocok -1, dan beberapa di mana itu adalah masalah, seperti string kosong masih menjadi kebenaran.
Value Ink
@ KevinLau-notKenny Itu masuk akal.
Conor O'Brien
2

Perl 6 , 23 byte

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

Saya bisa membuatnya lebih pendek jika ^...ditambahkan ke Perl 6 {sum $_,*div 5^...0} .
Seharusnya lebih hemat memori untuk angka yang lebih besar jika Anda menambahkan lazypengubah antara sumdan generator urutan.

Penjelasan:

{ # 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
}

Uji:

#! /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

(Baris terakhir itu agak menyesatkan, karena MoarVM harus memulai, memuat kompiler dan runtime Perl, mengkompilasi kode, dan menjalankannya. Jadi sebenarnya dibutuhkan sekitar satu setengah detik totalnya.
Itu masih jauh lebih cepat daripada itu adalah untuk memeriksa hasil tes terakhir dengan WolframAlpha.com)

Brad Gilbert b2gills
sumber
2

Mathcad, [tbd] byte

masukkan deskripsi gambar di sini

Mathcad adalah semacam "papan tulis" matematika yang memungkinkan entri 2D ekspresi, teks dan plot. Ini menggunakan simbol matematika untuk banyak operasi, seperti penjumlahan, diferensiasi dan integrasi. Operator pemrograman adalah simbol khusus, biasanya dimasukkan sebagai kombinasi kontrol keyboard tunggal dan / atau bergeser pada tombol standar.

Apa yang Anda lihat di atas adalah persis bagaimana lembar kerja Mathcad terlihat seperti yang diketikkan dan saat Mathcad mengevaluasinya. Misalnya, mengubah n dari 2016 ke nilai lain akan menyebabkan Mathcad memperbarui hasil dari 502 ke apa pun nilai baru tersebut.

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


Metode penilaian ekivalensi byte Mathcad belum ditentukan. Mengambil kesetaraan simbol, solusinya membutuhkan sekitar 24 "byte" (operator sementara hanya dapat dimasukkan menggunakan kombinasi tombol "ctl-]" (atau dari bilah alat)). Metode Matlab Agawa001 memakan waktu sekitar 37 byte ketika diterjemahkan ke dalam Mathcad (operator penjumlahan dimasukkan oleh ctl-shft- $).

Stuart Bruff
sumber
Kedengarannya alat yang menakjubkan untuk menangani, saya tidak akan mengunduhnya sebentar!
Abr001am
2

dc, 12 byte

[5/dd0<f+]sf

Ini mendefinisikan fungsi fyang mengkonsumsi inputnya dari atas stack, dan meninggalkan outputnya di atas stack. Lihat jawaban C saya untuk dasar matematika. Kami berulang kali membaginya dengan 5, mengumpulkan nilai-nilai pada tumpukan, lalu menambahkan semua hasil:

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

Program uji

# 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

Uji keluaran

./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
sumber
1

Jolf, 13 byte

Ώmf?H+γ/H5ΏγH

Menentukan fungsi rekursif yang dipanggil pada input. Coba di sini!

Ώ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
sumber
1

J, 28 17 16 byte

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

Hampir sama dengan teknik non-rekursif dari jawaban xnor.


Ini versi yang lebih lama yang saya simpan di sini karena saya pribadi lebih menyukainya, dengan kecepatan 28 byte:

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

Meskipun tidak diperlukan, saya telah memasukkan x:dalam kasus uji untuk presisi yang diperpanjang.

   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

Angka terakhir tidak berfungsi dengan fungsi ini.

Penjelasan

Ini bekerja dengan menghitung n!, mengubahnya menjadi string, dan memeriksa setiap anggota untuk kesetaraan dengan '0'. Untukn = 15 , proses ini adalah:

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

Sekarang, kita gunakan ;._1untuk membagi daftar pada elemen pertama (nol), meninju setiap hasil split, menghasilkan kotak yang diisi dengan ace ( a:) atau menjalankan1 s, seperti:

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

Kami sederhana mendapatkan anggota terakhir ({: ), unbox itu ( >), dan melakukan penjumlahan di atasnya +/, menghasilkan jumlah nol.

Ini adalah versi yang lebih mudah dibaca:

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
sumber
>:@i.dapat ditulis 1+i.untuk menyimpan byte.
algorithmshark
Versi lama Anda dapat dibuat menjadi [:#.~'0'=":@!13 byte dengan mengubah metode penghitungan trailing 1s.
cole
1

Python 3, 52 byte

g=lambda x,y=1,z=0:z-x if y>x else g(x,y*5,z+x//y)
Magenta
sumber
Ini tidak berhasil, coba test case.
xnor
Itu seharusnya bekerja sekarang.
Magenta
1

Pyke, 5 byte

SBP5/

Coba di sini!

S     -    range(1,input()+1)
 B    -   product(^)
  P   -  prime_factors(^)
   5/ - count(^, 5)
Biru
sumber
1

KEMBALI , 17 byte

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

Try it here.

Lambda operator rekursif. Pemakaian:

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

Penjelasan

[             ]=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
sumber
1

Perl, 24 22 +1 ( -pbendera) = 23 byte

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

Menggunakan:

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

Program lengkap:

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

Java, 38 byte

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

Program lengkap, dengan metode ungolfed:

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));
    }
}
Biarawati Bocor
sumber
1

J, 7 byte

Fungsi monadik, mengambil argumen di sebelah kanan.

3{:@q:!

Jika xpositif, x q: ykembalikan eksponen dalam faktorisasi utama y, hanya untuk xbilangan prima pertama . The 3prime -rd adalah 5 dan {:mengambil ekor daftar.

Perhatikan bahwa Anda harus memasukkan bilangan bulat dengan xdi akhir, atau J akan memperlakukannya sebagai float.

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

Cobalah sendiri di tryj.tk , meskipun diperingatkan bahwa penerjemah online ini akan mengeluh jika Anda mencoba sesuatu yang lebih besar dari 1343.

Jika Anda menginginkan sesuatu yang tidak menghitung n ! dan karenanya tidak memerlukannya masuk dalam bilangan bulat, gunakan solusi rekursif <.@%&5(+$:@)^:*. (tryj.tk masih cengeng pada input besar.)

algoritme hiu
sumber
1

Ruby, 70 61 51 49 byte

Versi 3 dengan terima kasih kepada Kenny Lau dan daniero

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

Sunting: Ternyata Anda dapat menyimpan dua byte dengan memetakan to_i sebelum Andareduce . Aneh: P

Fungsi ini mengurangi jumlah ndigit basis 5 dari ndan kemudian membagi hasilnya dengan 4. Ini terkait dengan jumlah deret geometri 1+5+25+..+5**n = (5**n+1)/4.

Sebagai contoh (sekali lagi, dengan terima kasih kepada Kenny Lau), pertimbangkan 358( 2413pada basis 5) dikurangi basisnya 5 digit.

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

Bagi 348dengan 4dan Anda dapatkan f(358) = 87.

Versi 2 dengan terimakasih untuk Kenny Lau

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

Fungsi ini menghitung n!kemudian mengurangi yang sizedari n!dari sizedari (n!).reverse.to_i.to_s, yang menghilangkan semua nol, dengan demikian, mengembalikan sizedari nol sendiri.

Versi 1

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

Ini variasi dari "Berapa banyak 5yang ada di faktorisasi utaman! ?" trik yang menggunakan builtin konversi basis sederhana Ruby.

Golf adalah sedikit rasa sakit meskipun, dengan mengkonversi dari Integerke Stringke Array, meraih bagian dari Arraydan mengkonversi yang untuk Stringke Integerlagi untuk reduce. Setiap saran bermain golf dipersilakan.

Sherlock9
sumber
Ini sedikit lebih pendek untuk dipetakan to_isebelum mengurangi: ->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}(menghemat dua byte)
daniero
@daniero saya tidak akan mengharapkan itu. Terima kasih: D
Sherlock9
1

Dyalog APL , 9 byte

⊥⍨'0'=⍕!⎕

meminta nomor

! memfaktorkan

merangkai

'0'= periksa kesetaraan ke karakter nol

⊥⍨ menghitung trailing trues *


* Secara harfiah ini adalah konversi basis campuran ke basis-10, menggunakan daftar boolean sebagai angka dan basis:

⊥⍨0 1 0 1 1sama dengan 0 1 0 1 1⊥⍨0 1 0 1 1yang 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)mana lagi adalah dua (jumlah trailing 1s).

Adm
sumber