Sie wollen das Sieb des Atkin, hier beschrieben: http://en.wikipedia.org/wiki/Sieve_of_Atkin

Ist das nicht nur eine Frage der Anzahl Factoring - Bestimmung aller Faktoren der Zahl? Sie können dann entscheiden, ob Sie alle Kombinationen von einem oder mehreren Faktoren benötigen.

So ist ein möglicher Algorithmus wä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

Es ist dann an Ihnen, die Faktoren zu kombinieren, um den Rest der Antwort zu bestimmen.

Ich weiß nicht die effizienteste Methode, aber ich würde wie folgt vorgehen:

• Erstellen Sie eine Tabelle der Primzahlen alle finden Primzahlen kleiner oder gleich der Quadratwurzel aus der Anzahl (Ich persönlich würde das Sieb des Atkin verwenden)
• Zählen Sie alle Primzahlen kleiner oder gleich der Quadratwurzel aus der Anzahl und multiplizieren die durch zwei. Wenn die Quadratwurzel der Zahl eine ganze Zahl ist, subtrahiert dann eine von der Zählvariable.

Sollte funktionieren \ o /

Wenn Sie brauchen, kann ich etwas morgen in C-Code zu demonstrieren.

Das Sieb von Atkin ist eine optimierte Version des Sieb des Eratosthenes, die bis zu einer bestimmten ganzzahligen alle Primzahlen gibt. Sie sollten dies für weitere Details Google können.

Sobald Sie diese Liste haben, ist es eine einfache Sache, Ihre Nummer durch jede Primzahl zu teilen, um zu sehen, ob es eine genaue Divisor ist (dh Rest ist Null).

Die grundlegenden Schritte, um die Teilern für eine Anzahl (n) der Berechnung sind [diese Pseudo-Code aus echten Code umgewandelt wird, so hoffe ich, ich habe keine Fehler eingeführt]:

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

Es gibt eine Menge mehr Techniken zu Factoring als das Sieb des Atkin. Zum Beispiel nehmen wir an 5893. Nun seine sqrt 76.76 ist Faktor wollen ... Jetzt werden wir versuchen , 5893 als Produkt der Quadrate zu schreiben. Well (77 * 77 bis 5893) = 36, 6 quadriert wird, so 5893 = 77 * 77-6 * 6 = (77 + 6) (77-6) = 83 * 71. Wenn das nicht gearbeitet hatte , würden wir geschaut haben , ob 78 * 78-5893 war ein perfekter Platz. Und so weiter. Mit dieser Technik können testen Sie schnell für Faktoren in der Nähe der Quadratwurzel von n viel schneller als von den einzelnen Primzahlen zu testen. Wenn Sie diese Technik für den Ausschluß aus großen Primzahlen mit einem Sieb kombinieren, werden Sie ein viel besseres Factoring Verfahren haben als mit dem Sieb allein.

Und das ist nur eine von einer Vielzahl von Techniken, die entwickelt wurden. Dies ist ein ziemlich einfacher. Es würde Sie eine lange Zeit, sagen wir, genug Zahlentheorie zu lernen, die Factoring-Techniken auf Basis elliptischer Kurven zu verstehen. (Ich weiß, dass sie existieren. Ich verstehe sie nicht.)

Deshalb , wenn Sie mit kleinen ganzen Zahlen zu tun hat , würde ich versuchen , dieses Problem nicht selbst zu lösen. Stattdessen würde ich versuchen , einen Weg zu finden , so etwas wie das verwenden PARI - Bibliothek , die bereits eine hocheffiziente Lösung implementiert hat. Damit kann ich eine zufällige 40 - stellige Nummer wie 124321342332143213122323434312213424231341 in etwa 0,05 Sekunden Faktor. (Die Faktorisierung, falls Sie sich gefragt, ist 29 * 439 * 1321 * 157907 * 284749 * 33843676813 * 4857795469949 . Ich bin sehr zuversichtlich , dass es ist nicht diesen heraus das Sieb von Atkin mit ...)

Eine Antwort auf Ihre Frage hängt stark von der Größe der ganzen Zahl. Verfahren für eine kleine Anzahl, beispielsweise weniger als 100 Bit und für die Zahlen bis 1000 Bit (wie in der Kryptographie verwendet wird) sind völlig verschieden.

• Überblick: http://en.wikipedia.org/wiki/Divisor_function

• Werte für kleine nund einige nützliche Referenzen: AOOOOO5: d (n) (auch tau (n) oder sigma_0 (n) bezeichnet), die Anzahl der Teiler von n ist .

• Praxisbeispiel: Faktorisierung von ganzen Zahlen

Ich bin nicht einverstanden, dass das Sieb des Atkin ist der Weg zu gehen, weil es leicht länger dauern könnte jede Zahl in [1, n] für primality zu überprüfen, als wäre es die Anzahl von Divisionen zu reduzieren.

Hier einige Code, der, wenn auch etwas hackier, in der Regel viel schneller:

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 Das ist , Python - Code arbeiten , um dieses Problem zu lösen.

Diese interessante Frage ist viel schwieriger, als es aussieht, und es wird nicht beantwortet. Die Frage lässt sich in zwei sehr unterschiedliche Fragen berücksichtigt werden.

1 gegeben N, finden Sie die Liste L von Primfaktoren von N

2 gegeben L berechnet Anzahl von einzigartigen Kombinationen

Alle Antworten Ich beziehe mich so weit sehen zu # 1 und nicht zu erwähnen, es nicht lenkbar für enorme Zahlen. Für mittlere Größe N, auch 64-Bit-Zahlen ist es leicht; für enormen N kann das Faktorisierungsproblem nehmen „für immer“. Public-Key-Verschlüsselung hängt davon ab.

Frage 2 braucht mehr Diskussion. Wenn L nur eindeutige Zahlen enthält, ist es eine einfache Berechnung der Kombination Formel für die Wahl k Objekte aus n Elementen verwenden. Eigentlich müssen Sie aus der Anwendung der Formel die Ergebnisse zusammenzufassen, während k variiert von 1 bis sizeof (L). Allerdings wird L in der Regel mehrere Vorkommen von mehreren Primzahlen enthalten. Zum Beispiel L = {2,2,2,3,3,5} ist die Faktorisierung von N = 360. Nun ist dieses Problem sehr schwierig ist!

Neuformulierung # 2, gegeben Sammlung C enthalten k Elemente, so dass Punkt A hat eine ‚Duplikate und Punkt b hat b‘ Duplikate etc., wie viele einzigartige Kombinationen von 1 bis k-1 Produkte gibt es? Beispiel: {2}, {2,2}, {2,2,2}, {2,3}, {2,2,3,3} muss jeweils einmal vorkommen und nur einmal, wenn L = {2,2 , 2,3,3,5}. Jede solche einzigartige Untersammlung ist ein eindeutiger Teiler von N durch die Elemente in der Untersammlung multipliziert wird.

Sie könnten versuchen diese. Es ist ein bisschen hackish, aber es ist ziemlich schnell.

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

Bevor Sie zu einer Lösung verpflichten bedenkt, dass der Sieve Ansatz nicht eine gute Antwort im typischen Fall sein könnte.

Vor einiger Zeit gab es eine Primzahl Frage und ich habe Test eine Zeit - für 32-Bit-Integer zumindest zu bestimmen, ob es war prime als Brute-Force langsamer war. Es gibt zwei Faktoren los:

1) Während ein Mensch eine Weile dauert, auf dem Computer eine Division sind sie sehr schnell zu tun - ähnlich wie die Kosten für die Antwort nach oben.

2) Wenn Sie nicht über eine erstklassige Tabelle Sie können eine Schleife bilden, die vollständig in dem L1-Cache läuft. Dies macht es schneller.

Sobald Sie die Primfaktorzerlegung haben, gibt es eine Möglichkeit, die Anzahl der Teiler zu finden. Fügen Sie ein zu jedem der Exponenten auf jedem einzelnen Faktor und dann die Exponenten miteinander multiplizieren.

Zum Beispiel: 36 Prime Faktorisierung: 2 ^ 2 * 3 ^ 2 Divisoren: 1, 2, 3, 4, 6, 9, 12, 18, 36 Anzahl der Teiler: 9

Fügen eines zu jedem Exponenten 2 ^ 3 * 3 ^ 3 Multiply Exponenten: 3 * 3 = 9

Teilern tun etwas Spektakuläres: sie vollständig teilen. Wenn Sie die Anzahl der Teiler für eine Reihe überprüfen möchten, nist es eindeutig überflüssig das gesamte Spektrum zu überbrücken, 1...n. Ich habe keine in eingehenden Untersuchungen dafür getan , aber ich gelöst Projekt Euler Problem 12 auf Dreieckszahlen . Meine Lösung für die mehr als 500 Teilern Test lief für 309.504 Mikrosekunden (~ 0,3s). Ich schrieb diese Divisor - Funktion für die Lösung.

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

Zu jedem Algorithmus gibt es eine Schwachstelle. Ich dachte, das war schwach gegen Primzahlen. Aber da Dreieckszahlen werden nicht gedruckt, diente es seinen Zweck einwandfrei. Aus meiner Profilierung, ich denke, es ist ziemlich gut tat.

Schöne Ferien.

@Yasky

Ihre Teilerfunktion hat einen Fehler, dass es nicht richtig für perfekte Quadrate funktioniert.

Versuchen:

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

Nur eine Zeile
habe ich sehr carefuly über Ihre Frage nachgedacht und ich habe versucht , eine hocheffiziente und performant Stück Code zu schreiben , um alle Teiler eine gegebene Zahl auf dem Bildschirm drucken wir nur eine Zeile Code benötigen! (verwenden Sie die Option -std = c99 während über gcc kompilieren)

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

für Zahlen von Teilern zu finden, können Sie die folgende sehr sehr schnelle Funktion (Arbeit richtig für alle Integer-Zahl außer 1 und 2) verwenden

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

oder wenn Sie die Nummer als Divisor (Arbeit richtig für alle Integer-Zahl außer 1 und 2) zu behandeln gegeben

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

HINWEIS: zwei oben genannten Funktionen korrekt funktioniert für alle positive ganze Zahl außer Nummer 1 und 2, so ist es für alle Zahlen funktionalen, die größer als 2 sind, aber wenn Sie benötigen 1 und 2 abdecken, können Sie eine der folgenden Funktionen (ein wenig Langsamer)

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

ODER

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

klein ist schön :)

die Primzahl Methode ist hier sehr klar. P [] ist eine Liste der Primzahl kleiner als oder gleich dem Quadrat = 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  .

Hier ist ein straight forward O (sqrt (n)) Algorithmus. Ich verwendet , um dieses zu lösen Project 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  

Zahlentheorie Lehrbücher nennen die Divisor-Zählfunktion tau. Die erste interessante Tatsache ist, dass es multiplikativ, dh. τ (ab) = τ (a) τ (b), wenn a und b haben keinen gemeinsamen Faktor. (Beweis: jedes Paar von Teilern von a und b gibt einen deutlichen Teiler von ab).

Nun beachten Sie, dass für pa prime, τ (p ** k) = k + 1 (die Potenzen von p). So können Sie leicht τ (n) aus der Faktorisierung berechnen.

Allerdings Faktorisierung große Zahlen können langsam sein (die Sicherheit von RSA crytopraphy hängt vom Produkt aus zwei großen Primzahlen schwer zu faktorisieren ist). Das legt nahe, diese optimierte Algorithmus

1. Testen Sie, ob die Zahl prim ist (schnell)
2. Wenn ja, 2 zurückkehren
3. Andernfalls Faktorisierung die Anzahl (langsam , wenn mehrere große Primfaktoren)
4. Berechnen τ (n) aus der Faktorisierung

Im Folgenden ist ein C-Programm die Anzahl der Teiler einer gegebenen Zahl zu finden.

Die Komplexität des obigen Algorithmus ist O (sqrt (n)).

Dieser Algorithmus funktioniert richtig für die Zahl, die ebenso wie die Zahlen Quadratzahl sind, die nicht perfekt quadratisch sind.

Beachten Sie, dass die Obergrenze der Schleife auf die Quadratwurzel der Zahl festgelegt wird, um den Algorithmus zu haben, am effizientesten ist.

Beachten Sie, dass die Obergrenze in einer separaten Variable speichert auch die Zeit speichert, sollten Sie die Funktion sqrt im Bedingungsteil der for-Schleife nicht nennen, dies auch Ihre Rechenzeit spart.

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

Anstelle der oben für die Schleife können Sie auch die folgende Schleife verwenden, die effizient noch mehr ist, da dies die Notwendigkeit entfernt die Quadratwurzel der Anzahl zu finden.

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

Hier ist eine Funktion, die ich geschrieben habe. es ist schlimmste Zeit Komplexität O (sqrt (n)), beste Zeit, auf der anderen Seite ist O (log (n)). Es gibt Ihnen alle Primteilern zusammen mit der Anzahl seiner Vorkommen.

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

Dies ist eine effiziente Lösung:

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

Dies ist die einfachste Art und Weise die Anzahl divissors der Berechnung:

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

    }
}

Das ist etwas, was ich kam mit basierend auf Justin Antwort. Es könnte einige Optimierung erfordern.

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

Ich denke, das ist, was Sie suchen for.I tut genau das, was Sie gefragt. Kopieren und einfügen es in Notepad.Save als * .bat.Run.Enter Number.Multiply den Prozess von 2 und das ist die Anzahl der divisors.I gemacht, dass absichtlich so das es die Teilern bestimmt schneller:

Pls beachten Sie, dass ein CMD varriable kippen Stützwerte über 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

Getestet habe ich den Code und einige Verbesserungen gemacht, jetzt ist es sogar noch schneller. Ich habe auch mit @ هومن جاویدپور Code getestet, ist dies auch schneller als sein Code.

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

Ich denke, das wird man auch präzise praktisch sein

script.pyton

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

Versuchen Sie, etwas in diese Richtung:

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

Sie können Primzahlen bis zur sqaure Wurzel des maximal möglichen N vorauszuzuberechnen und die Exponenten eines jeden Primfaktor einer Zahl berechnen. Die Anzahl der Teiler von n (n = p1 p2 ^ a ^ b ^ p3 ... c) (a + 1) (b + 1) (c + 1), da es das gleiche ist, wie die Art und Weise Zählung der prime kombinieren diese Faktoren Zahlen (und dies wird die Anzahl der Teiler zählen). Das ist sehr schnell, wenn Sie die Primzahlen precompute

Ausführlichere Informationen zu dieser Methode:

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