आप एटकिन की चलनी, यहाँ वर्णित हैं: http://en.wikipedia.org/wiki/Sieve_of_Atkin

संख्या के सभी कारकों का निर्धारण - यह सिर्फ संख्या बाँटे का सवाल नहीं है? तुम तो आप एक या अधिक कारकों के सभी संयोजनों की जरूरत है कि क्या तय कर सकते हैं।

तो, एक संभावित एल्गोरिदम होगा:

factor(N)
    divisor = first_prime
    list_of_factors = { 1 }
    while (N > 1)
        while (N % divisor == 0)
            add divisor to list_of_factors
            N /= divisor
        divisor = next_prime
    return list_of_factors

यह तो आप पर निर्भर कारकों गठबंधन करने के लिए जवाब के बाकी निर्धारित करने के लिए है।

मैं सबसे कारगर विधि नहीं जानता, लेकिन मैं तो निम्न कार्य करें चाहते हैं:

• अभाज्य संख्या की एक तालिका बनाएं सब से कम या संख्या का वर्गमूल के बराबर primes खोजने के लिए (व्यक्तिगत रूप से, मैं एटकिन की चलनी का उपयोग करेंगे)
• सब से कम या संख्या का वर्गमूल के बराबर primes गणना और गुणा है कि दो से। संख्या का वर्गमूल एक पूर्णांक है, तो गिनती चर से एक घटाना।

काम करना चाहिए \ o /

आप की जरूरत है, मैं कुछ कल सी प्रदर्शित करने के लिए कोड कर सकते हैं।

एटकिन की चलनी एरेटोस्थेनेज की चलनी जो किसी दिए गए पूर्णांक तक सभी रूढ़ अंक देता है की एक अनुकूलित संस्करण है। आप और अधिक विस्तार के लिए इस गूगल में सक्षम होना चाहिए।

एक बार जब आप उस सूची है, यह प्रत्येक प्रधानमंत्री द्वारा अपनी संख्या को विभाजित करने कि उसके एक सटीक भाजक है देखने के लिए एक सरल बात (यानी, शेष शून्य है) है।

एक नंबर (एन) के लिए divisors की गणना के बुनियादी कदम हैं [इस वास्तविक कोड से परिवर्तित स्यूडोकोड है इसलिए मुझे आशा है कि मैं शुरू की त्रुटि नहीं है]:

for z in 1..n:
    prime[z] = false
prime[2] = true;
prime[3] = true;

for x in 1..sqrt(n):
    xx = x * x

    for y in 1..sqrt(n):
        yy = y * y

        z = 4*xx+yy
        if (z <= n) and ((z mod 12 == 1) or (z mod 12 == 5)):
            prime[z] = not prime[z]

        z = z-xx
        if (z <= n) and (z mod 12 == 7):
            prime[z] = not prime[z]

        z = z-yy-yy
        if (z <= n) and (x > y) and (z mod 12 == 11):
            prime[z] = not prime[z]

for z in 5..sqrt(n):
    if prime[z]:
        zz = z*z
        x = zz
        while x <= limit:
            prime[x] = false
            x = x + zz

for z in 2,3,5..n:
    if prime[z]:
        if n modulo z == 0 then print z

वहाँ एक हैं बहुत एटकिन की चलनी से फैक्टरिंग के लिए और अधिक तकनीक। उदाहरण के लिए मान लीजिए कि हम अच्छी तरह से 5893. कारक अपने sqrt 76.76 है चाहते हैं ... अब हम 5893 वर्ग के एक उत्पाद के रूप में लिखने के लिए कोशिश करेंगे। खैर (77 * 77 - 5893) = 36 जो 6 चुकता है, तो 5893 = 77 * 77 - 6 * 6 = (77 + 6 ) (77-6) = 83 * 71 । 5893 एक पूर्ण वर्ग था - अगर ऐसा काम नहीं किया था हम पर है कि क्या 78 * 78 ध्यान दिया है चाहते हैं। और इसी तरह। इस तकनीक के साथ आपको शीघ्रता से व्यक्तिगत अभाज्य संख्या परीक्षण द्वारा की तुलना में बहुत तेजी से n का वर्गमूल के पास कारकों के लिए परीक्षण कर सकते हैं। यदि आप एक चलनी के साथ बड़ी अभाज्य संख्या को खारिज करने के लिए इस तकनीक का जोड़ देते हैं तो आप अकेले चलनी के साथ की तुलना में काफी बेहतर फैक्टरिंग विधि होगा।

और यह सिर्फ इतना है कि विकसित किया गया है तकनीक की एक बड़ी संख्या में से एक है। यह एक काफी सरल है। यह आप एक लंबे समय जानने के लिए, कहते हैं, पर्याप्त संख्या सिद्धांत फैक्टरिंग अण्डाकार घटता पर आधारित तकनीकों को समझने के लिए ले जाएगा। (मैं वे मौजूद पता है। मैं उन्हें समझ में नहीं आता।)

इसलिए जब तक आप छोटे पूर्णांक के साथ काम कर रहे हैं, मुझे लगता है कि समस्या अपने आप हल करने का प्रयास नहीं होता। इसके बजाय मैं की तरह कुछ का उपयोग करने के लिए एक रास्ता खोजने की कोशिश करता हूँ PARI एक अत्यंत कुशल समाधान लागू है कि पहले से ही पुस्तकालय। इसी के साथ मैं .05 सेकंड में 124321342332143213122323434312213424231341 की तरह एक यादृच्छिक 40 अंकों की संख्या कारक बन सकते हैं। (इसके गुणन, मामला आप आश्चर्य में है 29 * 439 * 1321 * 157907 * 284749 * 33843676813 * 4857795469949 । मैं काफी विश्वास है कि यह इस बाहर एटकिन की चलनी का उपयोग कर समझ नहीं आया कि हूँ ...)

आपके प्रश्न का उत्तर पूर्णांक के आकार पर बहुत निर्भर करता है। कम संख्या, जैसे कम तो 100 बिट के लिए तरीके, और संख्या के लिए ~ 1000 बिट (जैसे क्रिप्टोग्राफी में प्रयोग किया जाता के रूप में) पूरी तरह से अलग कर रहे हैं।

• सामान्य अवलोकन: http://en.wikipedia.org/wiki/Divisor_function

• छोटे के लिए मूल्यों nऔर कुछ उपयोगी संदर्भ: AOOOOO5: d (एन) (भी बुलाया ताऊ (n) या sigma_0 (एन)), एन के divisors की संख्या।

• वास्तविक दुनिया उदाहरण: पूर्णांकों का गुणन

मैं इससे सहमत नहीं है कि एटकिन की चलनी जाने का रास्ता है, क्योंकि यह आसानी से अधिक समय लग primality के लिए [1, एन] में हर नंबर की जांच करने के लिए इसे की तुलना में विभाग द्वारा संख्या को कम कर सकते हैं।

यहाँ कुछ कोड है कि, हालांकि थोड़ा hackier, आम तौर पर बहुत तेजी से है:

import operator
# A slightly efficient superset of primes.
def PrimesPlus():
  yield 2
  yield 3
  i = 5
  while True:
    yield i
    if i % 6 == 1:
      i += 2
    i += 2
# Returns a dict d with n = product p ^ d[p]
def GetPrimeDecomp(n):
  d = {}
  primes = PrimesPlus()
  for p in primes:
    while n % p == 0:
      n /= p
      d[p] = d.setdefault(p, 0) + 1
    if n == 1:
      return d
def NumberOfDivisors(n):
  d = GetPrimeDecomp(n)
  powers_plus = map(lambda x: x+1, d.values())
  return reduce(operator.mul, powers_plus, 1)

ps अजगर कोड काम कर रहा है यही कारण है कि इस समस्या को हल करने के लिए।

यह दिलचस्प सवाल बहुत कठिन की तुलना में यह लग रहा है, और यह जवाब नहीं किया गया है। प्रश्न 2 बहुत अलग सवाल तरीके पर निर्भर करता जा सकता है।

1 दिए गए एन, एन के प्रधानमंत्री कारकों की सूची एल लगता है

2 दी एल, अद्वितीय संयोजनों की संख्या की गणना

सभी जवाब मैं देख रहा हूँ अब तक # 1 देखें और यह भारी संख्या के लिए विनयशील नहीं है उल्लेख करने में विफल। के लिए मध्यम आकार एन, यहां तक ​​कि 64-बिट संख्या है, यह आसान है; विशाल एन के लिए, फैक्टरिंग समस्या "हमेशा के लिए" ले जा सकते हैं। सार्वजनिक कुंजी एन्क्रिप्शन इस पर निर्भर करता है।

प्रश्न # 2 अधिक चर्चा की जरूरत है। एल केवल अद्वितीय संख्या शामिल है, तो n मदों से कश्मीर वस्तुओं को चुनने के लिए संयोजन सूत्र का उपयोग कर एक साधारण गणना है। असल में, आप जबकि sizeof (एल) 1 से कश्मीर अलग सूत्र लागू से परिणाम योग करने के लिए की जरूरत है। हालांकि, एल आम तौर पर कई अभाज्य संख्या की अनेक गतिविधियां शामिल होंगे। उदाहरण के लिए, एल = {2,2,2,3,3,5} एन = 360 के गुणन अब इस समस्या को काफी मुश्किल है है!

# 2 restating, यह देखते हुए संग्रह सी कश्मीर आइटम वाले, इस तरह है कि आइटम एक एक 'डुप्लिकेट, और आइटम ख ख है' आदि K-1 के लिए आइटम देखते हैं 1 के कितने अद्वितीय संयोजन होते हैं डुप्लिकेट,? उदाहरण के लिए, {2}, {2,2}, {2,2,2} {2,3}, {2,2,3,3} प्रत्येक एक बार और केवल एक बार होने चाहिए यदि एल = {2,2 , 2,3,3,5}। प्रत्येक ऐसी अनोखी उप संग्रह उप संग्रह में आइटम गुणा करके एन की एक अद्वितीय भाजक है।

आप इस एक कोशिश कर सकते हैं। यह थोड़ा hackish है, लेकिन यह काफी तेज है।

def factors(n):
    for x in xrange(2,n):
        if n%x == 0:
            return (x,) + factors(n/x)
    return (n,1)

इससे पहले कि आप एक समाधान के लिए प्रतिबद्ध विचार है कि चलनी दृष्टिकोण विशिष्ट मामले में एक अच्छा जवाब नहीं हो सकता है।

कुछ समय पहले वहाँ एक प्रमुख सवाल था और मैं एक समय परीक्षण किया - 32-बिट पूर्णांक कम से कम निर्धारित करने के लिए अगर यह प्रधानमंत्री जानवर बल की तुलना में धीमी थी। वहाँ चल रहा दो कारक हैं:

1) एक मानव कुछ समय लगता है जबकि एक प्रभाग ऐसा करने के लिए वे कंप्यूटर पर बहुत जल्दी कर रहे हैं - जवाब को देख की लागत के समान है।

2) यदि आप आप एक पाश है कि एल 1 कैश में पूरी तरह से चलाता है बना सकते हैं एक प्रमुख तालिका नहीं है, तो। यह यह तेजी से बनाता है।

एक बार जब आप प्रधानमंत्री गुणन है, वहाँ divisors की संख्या को खोजने के लिए एक तरीका है। घातांक से प्रत्येक के लिए एक-एक व्यक्ति कारक पर जोड़े और फिर एक साथ एक्स्पोनेंट्स गुणा।

36 प्रधानमंत्री Factorization: उदाहरण के लिए 2 ^ 2 * 3 ^ 2 divisors: 1, 2, 3, 4, 6, 9, 12, 18, 36 divisors की संख्या: 9

3 * 3 = 9: प्रत्येक प्रतिपादक 2 ^ 3 * 3 ^ 3 गुणा एक्स्पोनेंट्स करने के लिए एक जोड़े

Divisors कुछ शानदार करती हैं: वे पूरी तरह से विभाजित करते हैं। आप एक संख्या के लिए divisors की संख्या की जांच करना चाहते हैं, nयह स्पष्ट रूप से पूरे स्पेक्ट्रम को पार करने वाली अनावश्यक, है 1...n। मैं इस के लिए किसी भी में गहराई से अनुसंधान नहीं किया है, लेकिन मैं हल त्रिकोणीय नंबर पर परियोजना यूलर समस्या 12 । के लिए मेरे समाधान अधिक से अधिक तो 500 divisors परीक्षण 309,504 माइक्रोसेकंड (~ 0.3s) के लिए भाग गया। मैं समाधान के लिए इस भाजक समारोह लिखा था।

int divisors (int x) {
    int limit = x;
    int numberOfDivisors = 1;

    for (int i(0); i < limit; ++i) {
        if (x % i == 0) {
            limit = x / i;
            numberOfDivisors++;
        }
    }

    return numberOfDivisors * 2;
}

हर एल्गोरिथ्म करने के लिए, वहाँ एक कमजोर बिंदु है। मुझे लगा कि यह रूढ़ अंक के खिलाफ कमजोर थी। लेकिन चूंकि त्रिकोणीय संख्या मुद्रित नहीं कर रहे हैं, यह अपने उद्देश्य दोषरहित कार्य किया। मेरी रूपरेखा से, मुझे लगता है कि यह बहुत अच्छा प्रदर्शन किया।

छुट्टियां आनंददायक हों।

@Yasky

आपका divisors समारोह है कि यह सही वर्गों के लिए सही ढंग से काम नहीं करता है में एक बग है।

प्रयत्न:

int divisors(int x) {
    int limit = x;
    int numberOfDivisors = 0;

    if (x == 1) return 1;

    for (int i = 1; i < limit; ++i) {
        if (x % i == 0) {
            limit = x / i;
            if (limit != i) {
                numberOfDivisors++;
            }
            numberOfDivisors++;
        }
    }

    return numberOfDivisors;
}

केवल एक पंक्ति
मैं अपने प्रश्न के बारे में बहुत carefuly में सोचा है और मैं कोड का एक अत्यधिक कुशल और performant टुकड़ा लिखने के लिए स्क्रीन हम बस कोड का एक लाइन की आवश्यकता पर दी गई संख्या के सभी divisors मुद्रित करने के लिए कोशिश की है! (उपयोग विकल्प = c99 जीसीसी के माध्यम से संयोजित करते समय -std)

for(int i=1,n=9;((!(n%i)) && printf("%d is a divisor of %d\n",i,n)) || i<=(n/2);i++);//n is your number

divisors के नंबरों को खोजने के लिए आप (1 और 2 को छोड़कर सभी पूर्णांक संख्या के लिए सही ढंग से काम) के बाद बहुत बहुत तेजी से समारोह का उपयोग कर सकते

int number_of_divisors(int n)
{
    int counter,i;
    for(counter=0,i=1;(!(n%i) && (counter++)) || i<=(n/2);i++);
    return counter;
}

या आप एक भाजक के रूप में संख्या को देखते हुए इलाज करता है, तो (सभी पूर्णांक संख्या के लिए सही ढंग से काम 1 और 2 को छोड़कर)

int number_of_divisors(int n)
{
    int counter,i;
    for(counter=0,i=1;(!(n%i) && (counter++)) || i<=(n/2);i++);
    return ++counter;
}

नोट: दो ऊपर कार्यों नंबर 1 को छोड़कर सभी सकारात्मक पूर्णांक संख्या के लिए सही ढंग से काम करता है और 2 तो यह सभी नंबरों कि 2 से अधिक हैं, लेकिन यदि आप 1 और 2 को कवर करने की आवश्यकता है, तो आपको निम्न कार्यों में से एक का उपयोग कर सकते के लिए कार्यात्मक है (एक छोटे से और धीमा)

int number_of_divisors(int n)
{
    int counter,i;
    for(counter=0,i=1;(!(n%i) && (counter++)) || i<=(n/2);i++);
    if (n==2 || n==1)
    {
    return counter;
    }
    return ++counter;
}

या

int number_of_divisors(int n)
{
    int counter,i;
for(counter=0,i=1;(!(i==n) && !(n%i) && (counter++)) || i<=(n/2);i++);
    return ++counter;
}

छोटा सुंदर होता है :)

अभाज्य संख्या विधि यहाँ बहुत स्पष्ट है। पी [] अभाज्य संख्या से कम या बराबर वर्ग = sqrt (एन) की एक सूची है;

for (int i = 0 ; i < size && P[i]<=sq ; i++){
          nd = 1;
          while(n%P[i]==0){
               n/=P[i];
               nd++;
               }
          count*=nd;
          if (n==1)break;
          }
      if (n!=1)count*=2;//the confusing line :D :P .

     i will lift the understanding for the reader  .
     i now look forward to a method more optimized  .

यहाँ एक सीधे आगे ओ (sqrt (एन)) एल्गोरिथ्म है। मैं इस प्रयोग किया जाता हल करने के लिए परियोजना यूलर

def divisors(n):
    count=2 # accounts for 'n' and '1'
    i=2
    while(i**2 < n):
        if(n%i==0):
            count+=2
        i+=1
    count+=(1 if i**2==n else 0)
    return count  

संख्या सिद्धांत पाठ्यपुस्तकों भाजक गिनती समारोह ताऊ कहते हैं। पहले दिलचस्प तथ्य यह है कि यह गुणक है, यानी है। τ (ab) = τ (क) τ (ख), ए और बी कोई आम कारक है जब। (सबूत: ए और बी के divisors के प्रत्येक जोड़ी अब एक अलग भाजक देता है)।

अब ध्यान दें कि पा प्रधानमंत्री, τ (पी ** k) = k + 1 (पी की शक्तियां) के लिए। इस प्रकार आप आसानी से अपने गुणनखंड से τ (एन) की गणना कर सकते हैं।

हालांकि factorising बड़ी संख्या धीमी गति से (आरएसए crytopraphy की सुरक्षा factorise के लिए कड़ी मेहनत की जा रही दो बड़ी अभाज्य संख्या की उत्पाद पर निर्भर करता है) हो सकता है। यही कारण है कि इस अनुकूलित एल्गोरिथ्म पता चलता है

1. टेस्ट करता है, तो नंबर प्रधानमंत्री है (तेज)
2. यदि हां, तो वापसी 2
3. अन्यथा, संख्या गुणनखंडों (धीमी अनेक बड़े अभाज्य गुणकों हैं)
4. गुणनखंड से τ (एन) की गणना करें

निम्नलिखित एक सी कार्यक्रम दी गई संख्या के divisors की संख्या मिल रहा है।

उपरोक्त एल्गोरिथ्म की जटिलता ओ (sqrt (एन)) है।

इस एल्गोरिथ्म सही ढंग से संख्या जो पूर्ण वर्ग के साथ-साथ संख्या जो पूर्ण वर्ग नहीं कर रहे हैं के लिए काम करेंगे।

ध्यान दें कि लूप के UPPERLIMIT एल्गोरिथ्म सबसे कारगर है की संख्या का वर्ग-रूट को तैयार है।

ध्यान दें कि एक अलग चर में UPPERLIMIT भंडारण भी समय बचाता है, आप पाश के लिए की हालत खंड में sqrt समारोह नहीं बुलाना चाहिए, यह भी अपने कम्प्यूटेशनल समय बचाता है।

#include<stdio.h>
#include<math.h>
int main()
{
    int i,n,limit,numberOfDivisors=1;
    printf("Enter the number : ");
    scanf("%d",&n);
    limit=(int)sqrt((double)n);
    for(i=2;i<=limit;i++)
        if(n%i==0)
        {
            if(i!=n/i)
                numberOfDivisors+=2;
            else
                numberOfDivisors++;
        }
    printf("%d\n",numberOfDivisors);
    return 0;
}

के रूप में इस संख्या का वर्ग-जड़ खोजने के लिए की जरूरत को हटा ऊपर के बजाय पाश के लिए आप निम्न पाश जो और भी अधिक कुशल है उपयोग कर सकते हैं।

for(i=2;i*i<=n;i++)
{
    ...
}

यहाँ एक समारोह है कि मैंने लिखा है। यह सबसे बुरा समय जटिलता हे है (sqrt (एन)), सबसे अच्छा समय दूसरी ओर (लॉग (एन)) हे है। यह अपने घटना की संख्या के साथ आप सभी प्रमुख divisors देता है।

public static List<Integer> divisors(n) {   
    ArrayList<Integer> aList = new ArrayList();
    int top_count = (int) Math.round(Math.sqrt(n));
    int new_n = n;

    for (int i = 2; i <= top_count; i++) {
        if (new_n == (new_n / i) * i) {
            aList.add(i);
            new_n = new_n / i;
            top_count = (int) Math.round(Math.sqrt(new_n));
            i = 1;
        }
    }
    aList.add(new_n);
    return aList;
}

यह एक कुशल समाधान है:

#include <iostream>
int main() {
  int num = 20; 
  int numberOfDivisors = 1;

  for (int i = 2; i <= num; i++)
  {
    int exponent = 0;
    while (num % i == 0) {
        exponent++; 
        num /= i;
    }   
    numberOfDivisors *= (exponent+1);
  }

  std::cout << numberOfDivisors << std::endl;
  return 0;
}

यह कंप्यूटिंग संख्या divissors का सबसे बुनियादी तरीका है:

class PrintDivisors
{
    public static void main(String args[])
    {

    System.out.println("Enter the number");

    // Create Scanner object for taking input
    Scanner s=new Scanner(System.in);

    // Read an int
    int n=s.nextInt();

        // Loop from 1 to 'n'
        for(int i=1;i<=n;i++)
        {

            // If remainder is 0 when 'n' is divided by 'i',
            if(n%i==0)
            {
            System.out.print(i+", ");
            }
        }

    // Print [not necessary]    
    System.out.print("are divisors of "+n);

    }
}

यह कुछ मैं जस्टिन उत्तर के आधार पर के साथ आया है। यह कुछ अनुकूलन की आवश्यकता हो सकती।

n=int(input())

a=[]
b=[]

def sieve(n):
    np = n + 1
    s = list(range(np)) 
    s[1] = 0
    sqrtn = int(n**0.5)
    for i in range(2, sqrtn + 1): 
        if s[i]:
            s[i*i: np: i] = [0] * len(range(i*i, np, i))
    return filter(None, s)

k=list(sieve(n))

for i in range(len(k)):
        if n%k[i]==0:
                a.append(k[i])

a.sort()

for i in range(len(a)):
        j=1
        while n%(a[i]**j)==0: 
                j=j+1
        b.append(j-1)

nod=1

for i in range(len(b)):
        nod=nod*(b[i]+1)

print('no.of divisors of {} = {}'.format(n,nod))

मुझे लगता है कि यह है कि क्या आप for.I देख रहे हैं आप के लिए वास्तव में क्या पूछा करता है। इसे कॉपी करके उस Notepad.Save में के रूप में * .bat.Run.Enter Number.Multiply प्रक्रिया 2 से चिपकाएं और thats divisors.I की संख्या बनाया है कि उद्देश्य पर तो यह divisors तेजी से निर्धारित:

Pls ध्यान दें कि एक अध्यक्ष एवं प्रबंध निदेशक 999999999 से अधिक varriable नहीं कर सकते समर्थन मूल्यों

@echo off

modecon:cols=100 lines=100

:start
title Enter the Number to Determine 
cls
echo Determine a number as a product of 2 numbers
echo.
echo Ex1 : C = A * B
echo Ex2 : 8 = 4 * 2
echo.
echo Max Number length is 9
echo.
echo If there is only 1 proces done  it
echo means the number is a prime number
echo.
echo Prime numbers take time to determine
echo Number not prime are determined fast
echo.

set /p number=Enter Number : 
if %number% GTR 999999999 goto start

echo.
set proces=0
set mindet=0
set procent=0
set B=%Number%

:Determining

set /a mindet=%mindet%+1

if %mindet% GTR %B% goto Results

set /a solution=%number% %%% %mindet%

if %solution% NEQ 0 goto Determining
if %solution% EQU 0 set /a proces=%proces%+1

set /a B=%number% / %mindet%

set /a procent=%mindet%*100/%B%

if %procent% EQU 100 set procent=%procent:~0,3%
if %procent% LSS 100 set procent=%procent:~0,2%
if %procent% LSS 10 set procent=%procent:~0,1%

title Progress : %procent% %%%



if %solution% EQU 0 echo %proces%. %mindet% * %B% = %number%
goto Determining

:Results

title %proces% Results Found
echo.
@pause
goto start

@Kendall

मैं अपने कोड का परीक्षण किया और कुछ सुधार किए, अब यह और भी तेज है। मैं भी جاویدپور कोड هومن साथ @ परीक्षण किया यह भी अपने कोड से तेज है।

long long int FindDivisors(long long int n) {
  long long int count = 0;
  long long int i, m = (long long int)sqrt(n);
  for(i = 1;i <= m;i++) {
    if(n % i == 0)
      count += 2;
  }
  if(n / m == m && n % m == 0)
    count--;
  return count;
}

मैं साथ ही लगता है कि सटीक रूप में यह एक आसान हो जाएगा

script.pyton

>>>factors=[ x for x in range (1,n+1) if n%x==0] print len(factors)

इन पंक्तियों के साथ कुछ प्रयास करें:

int divisors(int myNum) {
    int limit = myNum;
    int divisorCount = 0;
    if (x == 1) 
        return 1;
    for (int i = 1; i < limit; ++i) {
        if (myNum % i == 0) {
            limit = myNum / i;
            if (limit != i)
                divisorCount++;
            divisorCount++;
        }
    }
    return divisorCount;
}

आप अभाज्य संख्या अधिकतम संभव एन के sqaure जड़ से ऊपर precompute और एक नंबर के हर प्रधानमंत्री कारक के प्रतिपादक की गणना कर सकते हैं। n के divisors (n = p1 ^ एक p2 ^ b p3 ^ ग ...) की संख्या (a + 1) (ख + 1) (ग + 1), क्योंकि यह एक ही है के रूप में प्रधानमंत्री गठबंधन के रास्ते गिनती इस कारकों की संख्या (और इस divisors की संख्या की गणना होगी)। यह बहुत तेजी से होता है, तो आप रूढ़ अंक precompute

इस विधि के बारे में अधिक विस्तृत जानकारी:

https://mathschallenge.net/library/number/number_of_divisors

https://www.math.upenn.edu/~deturck/m170/wk2/numdivisors.html

http://primes.utm.edu/glossary/xpage/tau.html

#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;

int divisors_count(const vector<int>& primes, int n)
{
    int divisors = 1;
    for (int i = 0; i < primes.size(); ++i) {
        int factor = primes[i];
        int factor_exponent = 0;
        while (n % factor == 0) {
            ++factor_exponent;
            n /= factor;
        }
        divisors *= (factor_exponent + 1);
    }
    if (n > 1) 
        return 2*divisors; // prime factor > sqrt(MAX_N)
    return divisors;
}

int main()
{
    const int MAX_N = 1e6;
    int max_factor = sqrt(MAX_N);

    vector<char> prime(max_factor + 1, true);
    for (int i = 3; i <= max_factor; i += 2) {
        if (prime[i]) {
            for (int j = 3*i; j <= max_factor; j += 2*i) {
                prime[j] = false;
            }   
        }
    }

    vector<int> primes;
    primes.reserve(max_factor/2);
    primes.push_back(2);
    for (int i = 3; i <= max_factor; i += 2) {
        if (prime[i]) {
            primes.push_back(i);
        }
    }

    int n;
    while (cin >> n) {
        cout << divisors_count(primes, n) << endl;
    }
}