बस primes के बारे में (तेजी से वृद्धिशील तरीकों की गणना के लिए)

एक बार जब आपने गंभीरता से सोचा कि प्रथम से एन तक के अनुक्रमों की गणना करने के लिए न्यूनतम क्या आवश्यक है? हम अपनी जरूरत की हर चीज लेते हैं और अनावश्यक त्यागते हैं - एक सफल रणनीति का नुस्खा। इस मामले में, सभी तेज संचालन को सेवा में लेना और विभाजन जैसे सभी श्रम-गहन लोगों को त्यागना आवश्यक है। और जिसने विभाजन कार्यों के माध्यम से अभाज्य संख्याओं का वर्णन करने का निर्णय लिया, उसने मानवता पर एक चाल चली है। मिलेनिया बीत गया, और लोग अभी भी साझा करना जारी रखते हैं ...

पहला कोड:

public HashMap<Long, Long> serialPrimes() {
   long range = Long.parseLong(this.range.getText().toString());
   HashMap<Long, Long> primes = new HashMap<>(); //    
   HashMap<Long, ArrayList<Long>> spectres = new HashMap<>(); //     
   HashMap<Long, ArrayList<Long>> toppings = new HashMap<>(); //      
   for(long i = 2; i < range; i++){
       if(toppings.keySet().contains(i)) { //      ,     i
           //  
           ArrayList<Long> spectre = toppings.get(i);
           spectres.put(i, spectre);
           toppings.remove(i);
           for(long spectreValue : spectre) {
               //      
               long topping = primes.get(spectreValue) + spectreValue;
               primes.put(spectreValue, topping);
               //    
               if(toppings.keySet().contains(topping)) {
                   toppings.get(topping).add(spectreValue);
               } else {
                   ArrayList<Long> newSpectre = new ArrayList<>();
                   newSpectre.add(spectreValue);
                   toppings.put(topping, newSpectre);
               }
           }
       } else { //      ,     i
           //   
           primes.put(i, i + i); //       ,   
   //   
           //     
           ArrayList<Long> newSpectre = new ArrayList<>();
           newSpectre.add(i);
           toppings.put(i + i, newSpectre);
       }
   }
   return primes;
}

अब एक स्पष्टीकरण।

, .

API P2P .

, -.

3 :

:

• , 2 ()
• T
• ,
• 2*n (, 2[4])
• 4[2]
• ,
• ( , )

, .

1.500.000. , 2 . -, 3.000.000. 96 , 14 ( , ).

2 से 3.000.000 तक की सीमा में 216.816 प्रिम्स हैं।

Android उदाहरण

पुनश्च: संचालन की सुस्ती के बावजूद, अपराधों की श्रेणी की गणना एराटोस्थनीज की छलनी से की जाती है या केवल सादगी के लिए व्यक्तिगत संख्या की जांच की जाती है। लेकिन जब उनके पूर्ण अनुक्रम की आवश्यकता होती है, तो ऊपर वर्णित के अनुसार लगभग उसी शिरा में सोचना आवश्यक है।
लेकिन छलनी अभी भी सभी नंबरों पर पुनरावृत्त होती है, परीक्षणित संख्या को उनमें विभाजित करने की कोशिश कर रही है। इसका एकमात्र "लाभ" यह है कि यह मध्यवर्ती गणनाओं को संग्रहीत करने में स्मृति को बर्बाद नहीं करता है। लेकिन, शायद, इस एल्गोरिथम द्वारा सभी पिछले अपराधों को खोजने की तुलना में एक नंबर की जांच करने में अधिक समय लगता है।