इरेटोस्थनीज की छलनी क्या है?

इरेटोस्थनीज की छलनी एक एल्गोरिथ्म है जो किसी दी गई संख्या से छोटे सभी अभाज्य संख्याओं (prime numbers) को सूचीबद्ध करता है। यह एल्गोरिथ्म सरल है और इसे निम्नलिखित चरणों में लागू किया जा सकता है:

1. N तत्वों वाली एक बूलियन ऐरे बनाएँ और सभी तत्वों को true से इनिशियलाइज़ करें।
2. ऐरे के 0वें और 1ले तत्व को false सेट करें (क्योंकि 0 और 1 अभाज्य नहीं हैं)।
3. यदि ऐरे का दूसरा तत्व true है, तो 2 को अभाज्य के रूप में आउटपुट करें।
4. ऐरे में $2^2$ और उससे अधिक 2 के गुणजों (multiples) वाले तत्वों को false सेट करें ※
5. यदि ऐरे का तीसरा तत्व true है, तो 3 को अभाज्य के रूप में आउटपुट करें।
6. ऐरे में $3^2$ और उससे अधिक 3 के गुणजों वाले तत्वों को false सेट करें।
7. चौथे, 5वें, …, Nवें तत्वों के लिए यही प्रक्रिया दोहराएँ।

※ हम वर्गों (squares) से ऊपर के तत्वों को false सेट करते हैं क्योंकि वर्ग से छोटी संख्याओं पर पहले ही प्रक्रिया हो चुकी होती है।

Rust में कार्यान्वयन

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

fn main() {
    let n = 1000;
    let mut is_prime = vec![true; n+1];
    is_prime[0] = false;
    is_prime[1] = false;
    for i in 2..=n {
        if is_prime[i] {
            println!("{}", i);
            let mut j = i * i;
            while j <= n {
                is_prime[j] = false;
                j += i;
            }
        }
    }
}

थोड़ा अनुकूलित संस्करण

निम्नलिखित बिंदुओं को ध्यान में रखते हुए, हम थोड़ा तेज़ कार्यान्वयन बना सकते हैं:

• ऐरे को true के बजाय false से इनिशियलाइज़ करें (यह तेज़ है)।
• चूँकि 2 के गुणज अभाज्य नहीं होते हैं, इसलिए 2 के गुणजों को false सेट करने की प्रक्रिया को छोड़ दें।
• n तक लूप करने की आवश्यकता नहीं है; n के वर्गमूल तक अभाज्य संख्याओं को सूचीबद्ध करना, n से छोटे या उसके बराबर सभी अभाज्यों को खोजने के लिए पर्याप्त है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

fn main() {
    let n = 1000;
    let mut is_prime = vec![false; n+1];
    is_prime[2] = true;
    for i in (3..=n).step_by(2) {
        is_prime[i] = true;
    }
    for i in 3..=((n as f64).sqrt() as usize) {
        if is_prime[i] {
            let mut j = i * i;
            while j <= n {
                is_prime[j] = false;
                j += i * 2;
            }
        }
    }
    for i in (2..=n).filter(|&x| is_prime[x]) {
        println!("{}", i);
    }
}

संदर्भ

• इरेटोस्थनीज की छलनी