जावा प्रोग्राम: संख्या के फैक्टोरियल में अनुगामी शून्यों की गिनती

उदाहरण

import java.io.*; 

public class Demo { 
    static int trailingZero(int num) { 
        int count = 0; 
        for (int i = 5; num / i >= 1; i *= 5) { 
            count += num / i; 
        } 
        return count; 
    } 
    
    public static void main(String[] args) { 
        int num = 1000000; 
        System.out.println(num + " फैक्टोरियल में अनुगामी शून्यों की संख्या है: " + trailingZero(num)); 
    } 
}

आउटपुट

1000000 फैक्टोरियल में अनुगामी शून्यों की संख्या है: 249998

व्याख्या: Demo क्लास में 'trailingZero' नामक एक फंक्शन होता है जो काउंट मान को 0 से आरंभ करता है, और उस संख्या के माध्यम से पुनरावृति करता है जिसके फैक्टोरियल के शून्यों की संख्या ढूंढनी है। यह काउंट फंक्शन से आउटपुट के रूप में लौटाया जाता है। मुख्य फंक्शन में, 'num' का मान परिभाषित किया जाता है, और इस संख्या को पैरामीटर के रूप में पास करके फंक्शन को कॉल किया जाता है। प्रासंगिक संदेश कंसोल पर प्रदर्शित होते हैं।

गणितीय सिद्धांत:

फैक्टोरियल में अनुगामी शून्य 10 के गुणनखंडों से आते हैं = 2 × 5।

चूंकि 2 के गुणनखंड 5 से अधिक होते हैं, 5 के गुणनखंडों की गिनती करें:

trailingZeros(n!) = ⌊n/5⌋ + ⌊n/25⌋ + ⌊n/125⌋ + ⌊n/625⌋ + ...

1,000,000 के लिए सत्यापन:

⌊1000000/5⌋     = 200,000
⌊1000000/25⌋    =  40,000
⌊1000000/125⌋   =   8,000
⌊1000000/625⌋   =   1,600
⌊1000000/3125⌋  =     320
⌊1000000/15625⌋ =      64
⌊1000000/78125⌋ =      12
⌊1000000/390625⌋=       2
⌊1000000/1953125⌋=      0 (रुकें)
कुल = 249,998 ✓

किनारे के मामले:

n < 5: 0 शून्य (0! = 1, 1! = 1, 2! = 2, 3! = 6, 4! = 24)
n = 5: 1 शून्य (120)
n = 10: 2 शून्य (3628800)

बड़े n के लिए BigInteger संस्करण:

import java.math.BigInteger;

public static int trailingZerosBig(int n) {
    BigInteger fact = BigInteger.ONE;
    for (int i = 2; i <= n; i++) {
        fact = fact.multiply(BigInteger.valueOf(i));
    }
    String str = fact.toString();
    int count = 0;
    for (int i = str.length() - 1; i >= 0 && str.charAt(i) == '0'; i--) {
        count++;
    }
    return count;
}
// केवल छोटे n के लिए व्यावहारिक (n < 10000)