Du vil ha Sil av Atkin, som beskrives her: http://en.wikipedia.org/wiki/Sieve_of_Atkin

Er ikke dette bare et spørsmål om facto antall - bestemme alle faktorer av nummeret? Du kan deretter bestemme om du trenger alle kombinasjoner av en eller flere faktorer.

Så, ville en mulig algoritme være:

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

Deretter er det opp til deg å kombinere faktorer for å finne resten av svaret.

Jeg vet ikke den mest effektive metoden, men jeg ville gjøre følgende:

• Lag en tabell over primtall for å finne alle primtall mindre enn eller lik kvadratroten av antall (Personlig ville jeg bruke sil av Atkin)
• Telle alle primtall mindre enn eller lik kvadratroten av antall og multiplisere det med to. Hvis kvadratroten av antall er et helt tall, og deretter trekke en fra tellevariabelen.

Bør arbeide \ o /

Hvis du trenger, kan jeg kode noe opp i morgen i C for å demonstrere.

Sikten av atkin er en optimalisert versjon for sikten med Eratosthenes som gir alle primtall opp til en gitt heltall. Du bør være i stand til å google dette for flere detaljer.

Når du har den listen, er det en enkel sak å dele nummeret ditt ved hver prime for å se om det er en eksakt divisor (dvs. er resten null).

De grunnleggende fremgangsmåten for beregning av delingstall for et antall (n) er [denne er pseudo omdannes fra fast kode slik jeg håper jeg ikke har innført feil]:

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

Det er en rekke flere teknikker til facto enn sil av Atkin. For eksempel anta at vi ønsker å faktor 5893. Vel sin sqrt er 76,76 ... Nå skal vi prøve å skrive 5893 som et produkt av firkanter. Brønn (77 * 77-5893) = 36 som er kvadrert 6, så 5893 = 77 * 77-6 * 6 = (77 + 6) (77-6) = 83 * 71. Hvis det ikke hadde jobbet vi ville ha sett på om 78 * 78-5893 var et perfekt kvadrat. Og så videre. Med denne teknikken kan du raskt teste for faktorer nær kvadratroten av n mye raskere enn ved å teste individuelle primtall. Hvis du kombinerer denne teknikken for å utelukke store primtall med en sil, vil du ha en mye bedre betraktning metoden enn med sil alene.

Og dette er bare ett av en lang rekke teknikker som har blitt utviklet. Dette er en ganske enkel en. Det vil ta deg lang tid å lære, sier nok tallteori til å forstå facto teknikker basert på elliptiske kurver. (Jeg vet at de eksisterer. Jeg forstår ikke dem.)

Derfor, med mindre du har å gjøre med små tall, ville jeg ikke prøve å løse det problemet selv. I stedet vil jeg prøve å finne en måte å bruke noe som PARI biblioteket som allerede har en svært effektiv løsning implementert. Med det kan jeg faktor en tilfeldig 40-sifret nummer som 124321342332143213122323434312213424231341 i ca 0,05 sekunder. (Sin faktorisering, i tilfelle du lurte, er 29 * 439 * 1321 * 157 907 * 284 749 * 33843676813 * 4857795469949. Jeg er ganske sikker på at det ikke finne ut dette ved hjelp av sikten fra Atkin ...)

Et svar på spørsmålet ditt avhenger mye av størrelsen på heltall. Metoder for små tall, for eksempel mindre enn 100 bit, og for tall ~ 1000 bit (for eksempel som anvendt i kryptografi) er helt annerledes.

• generell oversikt: http://en.wikipedia.org/wiki/Divisor_function

• verdier for liten nog noen nyttige referanser: AOOOOO5: d (n) (også kalt tau (n) eller sigma_0 (n)), idet antallet av divisorer in.

• real-world eksempel: faktorisering av heltall

Jeg er uenig at sikten fra Atkin er veien å gå, fordi det kan lett ta lengre tid å sjekke alle tall i [1, n] for primality enn det ville være å redusere antallet av splittelser.

Her er noen kode som, selv om litt hackier, er generelt mye raskere:

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 Det fungerer python kode for å løse dette problemet.

Det interessante spørsmålet er mye vanskeligere enn det ser ut, og det har ikke blitt besvart. Spørsmålet kan være priset inn 2 svært forskjellige spørsmål.

En gitt N, finne listen L N fremste faktorene

2 gitt L, beregner antall av unike kombinasjoner

Alle svarene jeg ser så langt viser til # 1 og unnlater å nevne det er ikke medgjørlig for enorme tall. For moderat størrelse N, til og med 64-bits tall, er det lett; for enorme N, kan facto problem å ta "forever". Offentlig nøkkel kryptering avhenger av dette.

Spørsmål # 2 trenger mer diskusjon. Når L inneholder bare unike tall, er det en enkel beregning ved hjelp av kombinasjonen formel for å velge k objekter fra n-elementer. Egentlig må man for å summere resultatene fra bruk av formelen mens varierende k fra 1 til sizeof (L). Imidlertid vil L vanligvis inneholde flere forekomster av flere primtall. For eksempel, L = {2,2,2,3,3,5} er faktorisering av N = 360. Nå er dette problem er ganske vanskelig!

Omarbeide # 2, gitt samling C inneholder k elementer, har en slik at elementet a a 'duplikater, og punkt b har b' duplikater, etc. hvor mange unike kombinasjoner av 1 til K-1 elementer er det? For eksempel, {2}, {2,2}, {2,2,2}, {2,3}, {2,2,3,3} må hver forekommer en gang og bare en gang hvis L = {2,2 , 2,3,3,5}. Hver slik enestående sub-samling er en unik divisor N ved å multiplisere elementene i det sub-samlingen.

Du kan prøve denne. Det er litt hackish, men det er rimelig fort.

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

Før du forplikte seg til en løsning vurdere at Sieve tilnærming ikke kan være et godt svar på det typiske tilfellet.

For en stund tilbake var det en førsteklasses spørsmålet, og jeg gjorde en gang test - for 32-bits heltall minst som avgjør om det var prime var tregere enn brute force. Det er to faktorer som skjer:

1) Når et menneske tar en stund å gjøre en divisjon de er veldig rask på datamaskinen - lik kostnaden av å se opp svaret.

2) Hvis du ikke har en førsteklasses tabell du kan lage en løkke som går helt i L1 cache. Dette gjør det raskere.

Når du har prime faktorisering, det er en måte å finne antall divisorene. Legg en til hver av eksponentene på hver enkelt faktor og deretter multiplisere eksponentene sammen.

For eksempel: 36 Primtallfaktorisering: 2 ^ 2 * 3 ^ 2 divisorer: 1, 2, 3, 4, 6, 9, 12, 18, 36 Antall divisorene: 9

Legg til en til hvert eksponent 2 ^ 3 * 3 ^ 3 Multipliser eksponenter: 3 * 3 = 9

Divisorene gjøre noe spektakulært: de dele helt. Hvis du ønsker å sjekke antall divisorene til et tall, nklart er det overflødig å omfatte hele spekteret, 1...n. Jeg har ikke gjort noen grundige undersøkelser for dette, men jeg løste Prosjekt Eulers problem 12 på Trekanttall . Min løsning for større enn 500 divisorene test løp for 309504 mikrosekunder (~ 0,3 s). Jeg skrev denne divisor funksjon for løsningen.

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

Til hver algoritme, det er et svakt punkt. Jeg trodde dette var svak mot primtall. Men siden Trekanttall er ikke ut, det tjente sin hensikt feilfritt. Fra min profilering, jeg tror det gjorde det ganske bra.

Happy Holidays.

@Yasky

Din divisorene funksjonen har en feil i at det ikke fungerer på riktig måte for perfekte firkanter.

Prøve:

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

Bare en linje
jeg har tenkt veldig carefuly om spørsmålet ditt, og jeg har prøvd å skrive en svært effektiv og performant kodebit å skrive ut alle divisorene til et gitt antall på skjermen vi trenger bare en linje med kode! (bruk alternativ -std = C99 mens kompilering via gcc)

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

for å finne antall divisorene kan du bruke følgende veldig veldig fort funksjon (fungere korrekt for alle heltall unntatt 1 og 2)

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

eller hvis du behandler gitt antall som divisor (arbeid på riktig måte for alle heltall unntatt 1 og 2)

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

MERK: to ovennevnte funksjoner fungerer korrekt for alle positive heltall unntatt nummer 1 og 2, slik den er funksjonell for alle tall som er større enn to, men hvis du trenger for å dekke 1 og 2, kan du bruke en av følgende funksjoner (litt langsommere)

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

ELLER

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

Smått er godt :)

primtallet metoden er veldig klar her. P [] er en liste over primtall mindre enn eller lik den sq = sqrt (n);

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  .

Her er en rett frem O (sqrt (n)) algoritme. Jeg brukte denne til å løse prosjektet Euler

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  

Tallteori lærebøker ringe divisor-telling funksjon tau. Den første interessant faktum er at det er multiplikativ, altså. τ (ab) = τ (a) τ (b), når A og B ikke har noen felles faktor. (Prøve: hvert par av divisorene til a og b gir en distinkt divisor av ab).

Nå oppmerksom på at for pa prime, τ (p ** k) = k + 1 (krefter p). Således kan man lett beregne τ (n) fra dens faktorisering.

Men factorising store tall kan være treg (sikkerheten til RSA crytopraphy avhenger av produktet av to store primtall er vanskelig å faktor). Som antyder dette optimalisert algoritme

1. Test hvis tallet er primtall (rask)
2. Hvis ja, tilbake 2
3. Ellers faktor antall (treg hvis flere store primfaktorer)
4. Beregn τ (n) fra faktorisering

Følgende er et C-program for å finne antall divisorene til et gitt tall.

Kompleksiteten av algoritmen ovenfor er O (sqrt (n)).

Denne algoritmen vil fungere riktig for antall som er perfekt torget samt de tallene som er ikke perfekt kvadrat.

Legg merke til at den UPPERLIMIT av sløyfen er angitt med kvadratroten av antall for å få den mest effektive algoritmen.

Legg merke til at lagring av UPPERLIMIT i en egen variabel sparer også tid, bør du ikke kalle sqrt funksjon i tilstanden delen av for loop, dette sparer også din regnetid.

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

I stedet for den ovenfor for loop kan du også bruke følgende løkke som er enda mer effektiv som dette fjerner behovet for å finne kvadratroten av antall.

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

Her er en funksjon som jeg skrev. er det verste tiden kompleksitet er O (sqrt (n)), beste tid på den annen side er O (log (n)). Det gir deg alle Primtallsdivisorer sammen med antall sin forekomst.

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

Dette er en effektiv løsning:

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

Dette er den mest grunnleggende måten å beregne antall 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);

    }
}

Dette er noe jeg kom opp med basert på Justin svar. Det kan kreve litt optimalisering.

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))

Jeg tror dette er hva du leter for.Jeg gjør akkurat det du ba om. Kopier og lim det inn Notepad.Save som * .bat.Run.Enter Number.Multiply prosessen ved 2 og dvs antall divisors.I gjort det med vilje slik at det bestemme divisorene raskere:

Pls oppmerksom på at en CMD varriable skrånende verdier som støttes løpet 999999999

@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

Jeg testet koden din og gjort noen forbedringer, nå er det enda raskere. Jeg har også testet med @ هومن جاویدپور kode, dette er også raskere enn hans kode.

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

Jeg antar dette vil være nyttig samt presis

script.pyton

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

Prøv noe langs disse linjene:

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

Du kan precompute primtall opp til sqaure roten av maks mulige N og beregne eksponent for hver viktigste faktor for et tall. Antallet divisorene n (n = p1 ^ a ^ p2 p3 b ^ c ...) er (a + 1) (b + 1) (k + 1), fordi det er den samme som teller den måten å kombinere det viktigste antall av disse faktorer (og dette vil telle antallet av divisors). Dette er veldig raskt hvis du precompute primtall

Mer detaljert info om denne metoden:

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