Bir sayının tüm bölenlerini almanın en iyi yolu nedir?

İşte en aptalca yol:

def divisorGenerator(n):
    for i in xrange(1,n/2+1):
        if n%i == 0: yield i
    yield n

Elde etmek istediğim sonuç buna benziyor, ancak daha akıllı bir algoritma istiyorum (bu çok yavaş ve aptal :-)

Asal çarpanları ve çokluklarını yeterince hızlı bulabilirim. Bu şekilde faktör üreten bir jeneratörüm var:

(faktör1, çokluk1)
(faktör2, çokluk2)
(faktör3, çokluk3)
ve benzeri ...

yani çıktısı

for i in factorGenerator(100):
    print i

dır-dir:

(2, 2)
(5, 2)

Bunun yapmak istediğim şey için ne kadar yararlı olduğunu bilmiyorum (başka problemler için kodladım), yine de yapmak için daha akıllı bir yol istiyorum

for i in divisorGen(100):
    print i

bu çıktı:

1
2
4
5
10
20
25
50
100

GÜNCELLEME: Greg Hewgill'e ve onun "akıllı yolu" na çok teşekkürler :) 100000000'ün tüm bölenlerini hesaplamak, makinemde aptalca yolun aldığı 39'lara karşı 0,01 saniye sürdü, çok havalı: D

GÜNCELLEME 2: Bunun bu gönderinin kopyası olduğunu söylemeyi bırakın . Belirli bir sayının bölen sayısını hesaplamak, tüm bölenleri hesaplamak zorunda değildir. Bu farklı bir problem, eğer olmadığını düşünüyorsanız, wikipedia'da "Divisor işlevi" ni arayın. Yayınlamadan önce soruları ve cevabı okuyun, konunun ne olduğunu anlamadıysanız, sadece yararlı olmayan ve zaten verilen cevapları eklemeyin.

Senin Verilen factorGeneratorfonksiyon, burada olduğunu divisorGençalışması gerektiğini:

def divisorGen(n):
    factors = list(factorGenerator(n))
    nfactors = len(factors)
    f = [0] * nfactors
    while True:
        yield reduce(lambda x, y: x*y, [factors[x][0]**f[x] for x in range(nfactors)], 1)
        i = 0
        while True:
            f[i] += 1
            if f[i] <= factors[i][1]:
                break
            f[i] = 0
            i += 1
            if i >= nfactors:
                return

Bu algoritmanın genel verimliliği tamamen factorGenerator.

Shimi'nin söylediklerini genişletmek için, döngünüzü yalnızca 1'den n'nin kareköküne kadar çalıştırmalısınız. Sonra çifti bulmak için yapın n / ive bu tüm sorun alanını kapsayacaktır.

Yine belirtildiği gibi, bu bir NP veya 'zor' bir sorundur. Kapsamlı arama, bunu yapma şekliniz, garantili cevaplar için olduğu kadar iyidir. Bu gerçek, şifreleme algoritmaları ve benzerleri tarafından bunların güvenliğini sağlamak için kullanılır. Birisi bu sorunu çözerse, mevcut 'güvenli' iletişimimizin tamamı olmasa da çoğu güvensiz hale gelir.

Python kodu:

import math

def divisorGenerator(n):
    large_divisors = []
    for i in xrange(1, int(math.sqrt(n) + 1)):
        if n % i == 0:
            yield i
            if i*i != n:
                large_divisors.append(n / i)
    for divisor in reversed(large_divisors):
        yield divisor

print list(divisorGenerator(100))

Aşağıdakiler gibi bir liste çıkarması gerekir:

[1, 2, 4, 5, 10, 20, 25, 50, 100]

Buna zaten birçok çözüm olmasına rağmen, bunu gerçekten göndermem gerekiyor :)

Bu:

• okunabilir
• kısa
• kendi kendine yeten, kopyala ve yapıştır hazır
• hızlı (çok sayıda asal çarpanın ve bölenin olduğu durumlarda, kabul edilen çözümden> 10 kat daha hızlı)
• python3, python2 ve pypy uyumlu

Kod:

def divisors(n):
    # get factors and their counts
    factors = {}
    nn = n
    i = 2
    while i*i <= nn:
        while nn % i == 0:
            factors[i] = factors.get(i, 0) + 1
            nn //= i
        i += 1
    if nn > 1:
        factors[nn] = factors.get(nn, 0) + 1

    primes = list(factors.keys())

    # generates factors from primes[k:] subset
    def generate(k):
        if k == len(primes):
            yield 1
        else:
            rest = generate(k+1)
            prime = primes[k]
            for factor in rest:
                prime_to_i = 1
                # prime_to_i iterates prime**i values, i being all possible exponents
                for _ in range(factors[prime] + 1):
                    yield factor * prime_to_i
                    prime_to_i *= prime

    # in python3, `yield from generate(0)` would also work
    for factor in generate(0):
        yield factor

Bence math.sqrt(n)n / 2 yerine durabilirsin .

Kolayca anlayabilmeniz için size örnek vereceğim. Şimdi sqrt(28)ise 5.29bu yüzden ceil(5.29)ben o zaman ben tüm bölenler alabilirsiniz olacak 6 duracaktır eğer 6. Yani olacaktır. Nasıl?

Önce kodu görün ve ardından resme bakın:

import math
def divisors(n):
    divs = [1]
    for i in xrange(2,int(math.sqrt(n))+1):
        if n%i == 0:
            divs.extend([i,n/i])
    divs.extend([n])
    return list(set(divs))

Şimdi aşağıdaki resme bakın:

Lets Zaten eklemiş söylemek 1benim bölenler listesine ve ben ile başlayan i=2bu yüzden

Dolayısıyla, tüm yinelemelerin sonunda, bölüm ve bölenleri listeme ekledikçe, 28'in tüm bölenleri doldurulur.

Kaynak: Bir sayının bölenleri nasıl belirlenir

Greg çözümünü beğendim, ama keşke daha fazla python gibi olsaydı. Daha hızlı ve daha okunaklı olacağını hissediyorum; bu yüzden bir süre kodlamadan sonra bununla çıktım.

Listelerin kartezyen çarpımını yapmak için ilk iki işleve ihtiyaç vardır. Ve bu problemin ortaya çıktığı her yerde tekrar kullanılabilir. Bu arada, bunu kendim programlamam gerekiyordu, eğer bu sorun için standart bir çözüm bilen varsa, lütfen benimle iletişime geçmekten çekinmeyin.

"Factorgenerator" artık bir sözlük döndürüyor. Ve sonra sözlük "bölenler" e beslenir, bu onu ilk olarak bir liste listesi oluşturmak için kullanır, burada her liste p üssü ile p ^ n formunun faktörlerinin listesidir. Sonra bu listelerin kartezyen çarpımını yaparız ve sonunda bölen oluşturmak için Greg'in çözümünü kullanırız. Onları ayırıyoruz ve iade ediyoruz.

Test ettim ve önceki sürümden biraz daha hızlı görünüyor. Daha büyük bir programın parçası olarak test ettim, bu yüzden ne kadar hızlı olduğunu gerçekten söyleyemem.

Pietro Speroni (pietrosperoni nokta)

from math import sqrt


##############################################################
### cartesian product of lists ##################################
##############################################################

def appendEs2Sequences(sequences,es):
    result=[]
    if not sequences:
        for e in es:
            result.append([e])
    else:
        for e in es:
            result+=[seq+[e] for seq in sequences]
    return result


def cartesianproduct(lists):
    """
    given a list of lists,
    returns all the possible combinations taking one element from each list
    The list does not have to be of equal length
    """
    return reduce(appendEs2Sequences,lists,[])

##############################################################
### prime factors of a natural ##################################
##############################################################

def primefactors(n):
    '''lists prime factors, from greatest to smallest'''  
    i = 2
    while i<=sqrt(n):
        if n%i==0:
            l = primefactors(n/i)
            l.append(i)
            return l
        i+=1
    return [n]      # n is prime


##############################################################
### factorization of a natural ##################################
##############################################################

def factorGenerator(n):
    p = primefactors(n)
    factors={}
    for p1 in p:
        try:
            factors[p1]+=1
        except KeyError:
            factors[p1]=1
    return factors

def divisors(n):
    factors = factorGenerator(n)
    divisors=[]
    listexponents=[map(lambda x:k**x,range(0,factors[k]+1)) for k in factors.keys()]
    listfactors=cartesianproduct(listexponents)
    for f in listfactors:
        divisors.append(reduce(lambda x, y: x*y, f, 1))
    divisors.sort()
    return divisors



print divisors(60668796879)

PS, stackoverflow'a ilk kez gönderiyorum. Herhangi bir geri bildirim için sabırsızlanıyorum.

İşte saf Python 3.6'da 10 ** 16'ya kadar olan sayılar için bunu yapmanın akıllı ve hızlı bir yolu,

from itertools import compress

def primes(n):
    """ Returns  a list of primes < n for n > 2 """
    sieve = bytearray([True]) * (n//2)
    for i in range(3,int(n**0.5)+1,2):
        if sieve[i//2]:
            sieve[i*i//2::i] = bytearray((n-i*i-1)//(2*i)+1)
    return [2,*compress(range(3,n,2), sieve[1:])]

def factorization(n):
    """ Returns a list of the prime factorization of n """
    pf = []
    for p in primeslist:
      if p*p > n : break
      count = 0
      while not n % p:
        n //= p
        count += 1
      if count > 0: pf.append((p, count))
    if n > 1: pf.append((n, 1))
    return pf

def divisors(n):
    """ Returns an unsorted list of the divisors of n """
    divs = [1]
    for p, e in factorization(n):
        divs += [x*p**k for k in range(1,e+1) for x in divs]
    return divs

n = 600851475143
primeslist = primes(int(n**0.5)+1) 
print(divisors(n))

CodeReview'den uyarlanan , işte birlikte çalışan bir varyant num=1!

from itertools import product
import operator

def prod(ls):
   return reduce(operator.mul, ls, 1)

def powered(factors, powers):
   return prod(f**p for (f,p) in zip(factors, powers))


def divisors(num) :

   pf = dict(prime_factors(num))
   primes = pf.keys()
   #For each prime, possible exponents
   exponents = [range(i+1) for i in pf.values()]
   return (powered(primes,es) for es in product(*exponents))

Gelecekte referans olması için Anivarth'ın biraz revize edilmiş bir versiyonunu (en pitonik olduğuna inandığım gibi) ekleyeceğim.

from math import sqrt

def divisors(n):
    divs = {1,n}
    for i in range(2,int(sqrt(n))+1):
        if n%i == 0:
            divs.update((i,n//i))
    return divs

Eski soru, ama işte benim fikrim:

def divs(n, m):
    if m == 1: return [1]
    if n % m == 0: return [m] + divs(n, m - 1)
    return divs(n, m - 1)

Şunlarla proxy yapabilirsiniz:

def divisorGenerator(n):
    for x in reversed(divs(n, n)):
        yield x

NOT: Destekleyen diller için bu, kuyruk özyinelemeli olabilir.

factorsİşlevin n'nin faktörlerini döndürdüğünü varsayarsak (örneğin, factors(60)[2, 2, 3, 5] listesini döndürür), burada n'nin bölenlerini hesaplamak için bir işlev vardır :

function divisors(n)
    divs := [1]
    for fact in factors(n)
        temp := []
        for div in divs
            if fact * div not in divs
                append fact * div to temp
        divs := divs + temp
    return divs

İşte benim çözümüm. Aptalca görünüyor ama iyi çalışıyor ... ve tüm uygun bölenleri bulmaya çalışıyordum, böylece döngü i = 2'den başladı.

import math as m 

def findfac(n):
    faclist = [1]
    for i in range(2, int(m.sqrt(n) + 2)):
        if n%i == 0:
            if i not in faclist:
                faclist.append(i)
                if n/i not in faclist:
                    faclist.append(n/i)
    return facts

Yalnızca liste anlamalarını kullanmayı önemsiyorsanız ve sizin için başka hiçbir şey önemli değilse!

from itertools import combinations
from functools import reduce

def get_devisors(n):
    f = [f for f,e in list(factorGenerator(n)) for i in range(e)]
    fc = [x for l in range(len(f)+1) for x in combinations(f, l)]
    devisors = [1 if c==() else reduce((lambda x, y: x * y), c) for c in set(fc)]
    return sorted(devisors)

Bilgisayarınızda tonlarca bellek varsa, kaba bir tek satır numpy ile yeterince hızlı olabilir:

N = 10000000; tst = np.arange(1, N); tst[np.mod(N, tst) == 0]
Out: 
array([      1,       2,       4,       5,       8,      10,      16,
            20,      25,      32,      40,      50,      64,      80,
           100,     125,     128,     160,     200,     250,     320,
           400,     500,     625,     640,     800,    1000,    1250,
          1600,    2000,    2500,    3125,    3200,    4000,    5000,
          6250,    8000,   10000,   12500,   15625,   16000,   20000,
         25000,   31250,   40000,   50000,   62500,   78125,   80000,
        100000,  125000,  156250,  200000,  250000,  312500,  400000,
        500000,  625000, 1000000, 1250000, 2000000, 2500000, 5000000])

Yavaş bilgisayarımda 1 saniyeden az sürer.

Jeneratör işlevi aracılığıyla çözümüm:

def divisor(num):
    for x in range(1, num + 1):
        if num % x == 0:
            yield x
    while True:
        yield None

return [x for x in range(n+1) if n/x==int(n/x)]

Benim için bu iyi çalışıyor ve aynı zamanda temiz (Python 3)

def divisors(number):
    n = 1
    while(n<number):
        if(number%n==0):
            print(n)
        else:
            pass
        n += 1
    print(number)

Çok hızlı değil ancak bölenleri istediğiniz gibi satır satır döndürür, ayrıca gerçekten istiyorsanız list.append (n) ve list.append (number) yapabilirsiniz.