Was ist der beste Weg, um alle Teiler einer Zahl zu bekommen?

Ergänzen, was Shimi hat gesagt, Sie sollte nur läuft die Schleife von 1 bis zur Quadratwurzel von n ist. Dann finden Sie das paar, tun n /i, und das deckt das ganze problem Raum.

Da wurde auch festgestellt, dies ist ein NP oder "schwierig" problem. Erschöpfende Suche, die Art und Weise Sie es tun, ist ungefähr so gut wie es geht für garantierte Antworten. Diese Tatsache wird von Verschlüsselungs-algorithmen und dergleichen zu schützen. Wenn jemand um dieses problem zu lösen, die meisten, wenn nicht alle unsere aktuellen 'sichere' Kommunikation dargestellt werden unsicher.

Python-code:

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

Sollte eine Liste ausgeben wie:

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

InformationsquelleAutor der Antwort Matthew Scharley

Ich wie Greg Lösung, aber ich wünschte, es war mehr wie python.
Ich glaube, es wäre schneller und besser lesbar;
so nach einiger Zeit der Codierung kam ich mit diesem.

Die ersten beiden Funktionen sind notwendig, um das kartesische Produkt von Listen.
Und kann wiederverwendet werden whnever dieses problem entsteht.
Übrigens, ich mußte das selbst, wenn jemand weiß, eine standard-Lösung für dieses problem gibt, fühlen Sie bitte sich frei, mich zu Kontaktieren.

"Factorgenerator" kehrt nun ein Wörterbuch. Und dann das Wörterbuch zugeführt wird "Teiler", die Sie verwendet, zu generieren, wird zunächst eine Liste von Listen, wobei jede Liste ist die Liste der Faktoren von der form p^n mit p Primzahl.
Dann machen wir das kartesische Produkt von diesen Listen, und wir endlich mit Greg' Lösung zu generieren, ist der divisor.
Wir Sortieren Sie und geben Sie Sie zurück.

Habe es getestet und es scheint ein wenig schneller als die Vorherige version. Getestet habe ich es als Teil eines größeren Programms, also kann ich nicht wirklich sagen, wie viel ist es schneller wenn.

Pietro Speroni (pietrosperoni dot)

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)

P. S.
es ist das erste mal, dass ich bin Entsendung auf stackoverflow.
Ich freue mich für jedes feedback.

InformationsquelleAutor der Antwort Pietro Speroni

Angepasst CodeReview, hier ist eine Variante, die funktioniert mit 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))

InformationsquelleAutor der Antwort YvesgereY

Hier ist eine intelligente und schnelle Möglichkeit, es zu tun für zahlen bis etwa 10**16 in reinem Python-3.6,

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

InformationsquelleAutor der Antwort Bruno Astrolino

Hier ist meine Lösung. Es scheint dumm, aber funktioniert gut...und ich war auf der Suche nach der richtigen Teiler, so dass die Schleife gestartet von i = 2.

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

InformationsquelleAutor der Antwort Amber Xue

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

InformationsquelleAutor der Antwort user3697453