Вы хотите решето Аткин, описано здесь: 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

Именно тогда до вас, чтобы объединить факторы, чтобы определить, остальную часть ответа.

Я не знаю, самый эффективный метод, но я хотел бы сделать следующее:

• Создание таблицы простых чисел, чтобы найти все простые числа меньше или равно квадратному корню из числа (Лично я хотел бы использовать решето Аткин)
• Количество всех простых чисел меньше или равна квадратному корню из числа и умножить на два. Если квадратный корень из числа представляет собой целое число, затем вычесть один из переменного счетчика.

Должен работать \ о /

Если вам нужно, я могу закодировать что-то завтра в C, чтобы продемонстрировать.

Сито Аткин представляет собой оптимизированную версию решета Эратосфена, который дает все простые числа до заданного целого числа. Вы должны быть в состоянии Google это более подробно.

Если у вас есть этот список, это простой вопрос, чтобы разделить число на каждом штрих, чтобы увидеть, если это точный делитель (т.е. остаток равен нуль).

Основные шаги счетных делителей для числа (п) [это псевдокод преобразуются из реального кода, так что я надеюсь, что я не представил ошибок]:

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. Если это не сработало , мы бы смотрели на ли 78 * 78 - был 5893 идеальный квадрат. И так далее. С помощью этого метода вы можете быстро проверить факторы вблизи квадратного корня из п гораздо быстрее , чем при тестировании отдельных простых чисел. Если вы объедините эту технику для исключающие больших простых чисел с ситом, вы будете иметь гораздо лучший метод факторинга чем только с одним ситом.

И это только один из большого числа методов, которые были разработаны. Это довольно просто. Это займет у Вас много времени, чтобы узнать, скажем, достаточно теории чисел, чтобы понять методы факторинга, основанные на эллиптических кривых. (Я знаю, что они существуют. Я их не понимаю.)

Поэтому , если вы имеете дело с небольшими целыми числами, я никогда бы не попытаться решить эту проблему самостоятельно. Вместо этого я бы попытаться найти способ использовать что - то вроде ПАРИ библиотеки , которая уже имеет высокоэффективное решение реализовано. При том , что я могу фактор случайный 40 - значный номер , как 124321342332143213122323434312213424231341 примерно за 0,05 секунды. (Его факторизации, в случае , если Вы задавались вопросом , является * 439 29 * 1321 * 157907 * 284749 * 33843676813 * 4857795469949. Я совершенно уверен , что это не понять это с помощью сита Аткин ...)

Ответ на ваш вопрос в значительной степени зависит от размера целого числа. Методы небольших количествах, например, менее 100 бит, а для чисел ~ 1000 бит (например, используется в криптографии), совершенно различны.

• Общий обзор: http://en.wikipedia.org/wiki/Divisor_function

• Значения для малых nи некоторые полезные ссылки: AOOOOO5: г (п) (также называемый тау (п) или sigma_0 (п)), число делителей п.

• Реальный пример: разложение на множители целых чисел

Я не согласен, что решето Аткин является путь, потому что он легко может занять больше времени, чтобы проверить каждое число в [1, п] для простоты, чем это было бы, чтобы сократить число разделениями.

Вот код, который, хотя и немного дилетантский, как правило, гораздо быстрее:

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 дано N, найти список L простых факторов N в

2 дано L, рассчитать количество уникальных комбинаций

Все ответы я вижу до сих пор относятся к # 1 и не упомянуть это не послушное для огромных чисел. Для среднего размера N, даже 64-битных чисел, это легко; для огромного N, проблема факторинга может занять «навсегда». Шифрование с открытым ключом зависит от этого.

Вопрос № 2 нуждается в большем количестве обсуждения. Если L содержит только уникальные номера, это простой расчет с использованием комбинации формулы для выбора K объектов из п элементов. На самом деле, вы должны суммировать результаты от применения формулы при варьировании K от 1 до SizeOf (L). Однако, L, как правило, содержит несколько вхождений нескольких простых чисел. Например, L = {2,2,2,3,3,5} является факторизация N = 360. Теперь эта проблема довольно сложно!

Подтвердив # 2, данный набор С, содержащую элементы K, таким образом, что элемент А имеет «дубликатов, а пункт Ь имеет B» дубликатов и т.д., сколько уникальных комбинаций 1 до K-1 элементы есть? Например, {2}, {2,2}, {2,2,2}, {2,3}, {2,2,3,3} должно происходить каждый раз и только один раз, если L = {2,2 , 2,3,3,5}. Каждый такой уникальный суб-коллекция представляет собой уникальный делитель N путем умножения элементов в суб-коллекции.

Вы можете попробовать это. Это немного хак, но это достаточно быстро.

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

Прежде чем совершить решение считать, что подход Сита не может быть хорошим ответом в типичном случае.

Некоторое время назад было главным вопросом, и я сделал испытание временем - для 32-разрядных целых чисел, по крайней мере, определяющих, если он был премьер был медленнее, чем грубая сила. Есть два фактора, идущие на:

1) В то время как человек занимает некоторое время, чтобы сделать разделение они очень быстро на компьютере - аналогично стоимости отрываясь ответ.

2) Если вы не имеете основную таблицу вы можете сделать петлю, которая работает полностью в кэше L1. Это делает его быстрее.

Если у вас есть разложение на простые множители, есть способ, чтобы найти число делителей. Добавьте один к каждому из показателей по каждому отдельному фактору, а затем умножить показатели вместе.

Например: 36 простые множители: 2 ^ 2 * 3 ^ 2 Делители: 1, 2, 3, 4, 6, 9, 12, 18, 36 Количество делителей: 9

Добавьте один к каждому экспоненту 2 ^ 3 * 3 ^ 3 Умножить показатели: 3 * 3 = 9

Делители сделать что - то захватывающее: они делят полностью. Если вы хотите , чтобы проверить количество делителей для ряда, nон явно избыточен , чтобы охватить весь спектр, 1...n. Я не делал никаких углубленных исследований для этого , но я решил проблему Project Эйлера 12 на треугольных чисел . Мое решение для больше чем 500 делители теста баллотировался 309504 микросекунд (~ 0.3с). Я написал эту функцию делителей для решения.

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

Ваша функция делители есть ошибка в том, что он не работает правильно для совершенных квадратов.

Пытаться:

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

Просто одна линия
я думал очень Точную о вашем вопросе , и я попытался написать высокоэффективную и производительную часть кода Для печати всех делителей данного числа на экране нам нужно только одну строку кода! (вариант использования -std = C99 при компиляции с помощью 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

для нахождения числа делителей вы можете использовать следующую очень очень быстро функцию (работу правильно для всех целого числа, кроме 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  .

Вот прямой O (SQRT (п)) алгоритм. Я использовал это , чтобы решить 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  

Теория чисел учебников называть делителем подсчета функции тау. Первый интересный факт заключается в том, что это мультипликативная, то есть. τ (аb) = τ (а) τ (б), когда а и б не имеют общего множителя. (Доказательство: каждая пара делителей а и Ь дает четкий делитель AB).

Теперь заметим, что для ра штрихом, т (р ** к) = к + 1 (степени р). Таким образом, вы можете легко вычислить т (п) от его факторизации.

Однако факторизация большое количество может быть медленным (безопасность RSA crytopraphy зависит от произведения двух больших простых чисел будучи трудно факторизовать). Это предполагает этот оптимизированный алгоритм

1. Тест, если число простое (быстро)
2. Если да, то вернуть 2
3. В противном случае, факторизовать номер (медленный , если несколько больших простых факторов)
4. Вычислить т (п) от профакторизованного

Далее программа C, чтобы найти количество делителей заданного числа.

Сложность алгоритма выше О (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++)
{
    ...
}

Вот функция, которую я написал. это худшее время сложность O (SQRT (п)), лучшее время с другой стороны, это O (журнал (п)). Это дает вам все простые делители вместе с числом его появления.

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 и то количество divisors.I сделал это нарочно, так что она определяет делителей быстрее:

Pls отметить, что CMD varriable Cant значения поддержки над 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

Я проверил ваш код и сделал некоторые улучшения, теперь еще быстрее. Я также протестировал с @ هومن جاویدپور кода, это также быстрее, чем его код.

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 корня максимальной возможной N и вычислить экспоненту каждого простого фактора числа. Число делителей N (N = р1 ^ р2 ^ б ^ p3 C ...) является (а + 1) (Ь + 1) (с + 1), потому что это так же, как подсчитать способ объединить штрих число этих факторов (и это будет подсчитывать количество делителей). Это очень быстро, если вы предвычисления простых чисел

Более подробная информация об этом методе:

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