কোনও সংখ্যার সমস্ত বিভাজন পাওয়ার সর্বোত্তম উপায় কী?

Question 1

এখানে খুব বোবা উপায়:

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

আমি যে ফলাফলটি পেতে চাই তা একইরকম, তবে আমি একটি স্মার্ট অ্যালগরিদম চাই (এটি অত্যন্ত ধীর এবং বোবা :-)

আমি প্রাথমিক কারণগুলি এবং তাদের বহুগুণ দ্রুত খুঁজে পেতে পারি। আমি একটি জেনারেটর রয়েছি যা এইভাবে ফ্যাক্টর উত্পন্ন করে:

(গুণক 1, গুণনক 1)
(গুণক 2, গুণক 2)
(গুণক 3, গুণন 3)
এবং আরও ...

অর্থাত্ আউটপুট

for i in factorGenerator(100):
    print i

হ'ল:

(2, 2)
(5, 2)

আমি যা করতে চাই তার জন্য এটি কতটা দরকারী তা আমি জানি না (আমি অন্যান্য সমস্যার জন্য কোড করেছিলাম) যাইহোক, আমি বুদ্ধিমানভাবে তৈরি করার উপায় চাই

for i in divisorGen(100):
    print i

এটি আউটপুট:

আপডেট: গ্রেগ হিউগিল এবং তার "স্মার্ট ওয়ে" কে অনেক ধন্যবাদ :) 100000000 এর সমস্ত বিভাজক গণনা করা 391 দশকের বিপরীতে তার পথের সাথে 0.01 সেকেন্ড নিয়েছিল যে মাইন্ডটি খুব শীতল করেছে: ডি

আপডেট 2: এটি এই পোস্টের সদৃশ বলে বলা বন্ধ করুন । প্রদত্ত সংখ্যার বিভাজকের সংখ্যা গণনা করার জন্য সমস্ত বিভাজক গণনা করার দরকার নেই। এটি অন্যরকম সমস্যা, আপনি যদি ভাবেন যে এটি না হয় তবে উইকিপিডিয়ায় "ডিভায়ার ফাংশন" সন্ধান করুন। পোস্ট করার আগে প্রশ্ন এবং উত্তরটি পড়ুন, আপনি যদি বিষয়টি বুঝতে না পারেন তবে কেবল দরকারী এবং ইতিমধ্যে প্রদত্ত উত্তরগুলি যুক্ত করবেন না।

Question 2

আপনার factorGeneratorফাংশন দেওয়া , এখানে divisorGenকাজ করা উচিত:

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

এই অ্যালগরিদমের সামগ্রিক দক্ষতা সম্পূর্ণরূপে দক্ষতার উপর নির্ভর করবে factorGenerator।

Question 3

শিমি যা বলেছে তার প্রসারিত করতে আপনার লুপটি 1 থেকে n এর বর্গমূলের দিকে চালানো উচিত। তারপরে এই জুটিটি অনুসন্ধান করতে, করুন n / i, এবং এটি পুরো সমস্যার জায়গাগুলি .েকে দেবে।

যেমনটি উল্লেখ করা হয়েছিল, এটি একটি এনপি, বা 'কঠিন' সমস্যা। ক্লান্তিকর অনুসন্ধান, আপনি যেভাবে এটি করছেন, গ্যারান্টিযুক্ত উত্তরের জন্য এটি ততটা দুর্দান্ত। এই সত্যটি এনক্রিপশন অ্যালগরিদমগুলি এবং এগুলি সুরক্ষিত করতে সহায়তা করতে ব্যবহার করে। যদি কেউ এই সমস্যাটি সমাধান করেন তবে বেশিরভাগ ক্ষেত্রে যদি আমাদের বর্তমান 'সুরক্ষিত' যোগাযোগ ব্যবস্থা নিরাপদ না হয়।

পাইথন কোড:

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

যার ফলে একটি তালিকা আউটপুট করা উচিত:

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

Question 4

যদিও এর জন্য ইতিমধ্যে অনেকগুলি সমাধান রয়েছে, তবে আমাকে সত্যিই এটি পোস্ট করতে হবে :)

এটা হল:

পাঠযোগ্য
সংক্ষিপ্ত
স্ব অন্তর্ভুক্ত, অনুলিপি এবং পেস্ট প্রস্তুত
দ্রুত (অনেকগুলি মূল কারণ এবং বিভাজক ক্ষেত্রে,> গৃহীত সমাধানের চেয়ে 10 গুণ বেশি দ্রুত)
পাইথন 3, পাইথন 2 এবং পাইপির সাথে সঙ্গতিপূর্ণ

কোড:

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

Question 5

আমি মনে করি আপনি math.sqrt(n)এন / 2 এর পরিবর্তে থামতে পারেন ।

আমি আপনাকে উদাহরণ দেব যাতে আপনি এটি সহজে বুঝতে পারেন। এখন sqrt(28)হয় 5.29তাই ceil(5.29)হতে হবে 6. তাই আমি যদি আমি 6 থামবে তারপর আমি সব ভাজক পেতে পারেন হবে। কীভাবে?

প্রথমে কোডটি দেখুন এবং তারপরে চিত্রটি দেখুন:

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

এখন, নীচের চিত্রটি দেখুন:

যাক আমি ইতিমধ্যে যুক্ত করেছেন 1আমার ভাজক লিস্টে আমি দিয়ে শুরু i=2তাই

সুতরাং সমস্ত পুনরাবৃত্তির শেষে যেমন আমি আমার তালিকায় ভাগফল এবং বিভাজক যুক্ত করেছি 28 এর সমস্ত বিভাজন জনবহুল।

উত্স: কোনও সংখ্যার বিভাজক কীভাবে নির্ধারণ করবেন

Question 6

আমি গ্রেগ দ্রবণ পছন্দ করি, তবে আমি আশা করি এটি আরও অজগর মতো। আমি মনে করি এটি দ্রুত এবং আরও পাঠযোগ্য হবে; কোডিংয়ের কিছু সময় পরে আমি এই সাথে বেরিয়ে এসেছি।

কার্টেসিয়ান তালিকাগুলি তৈরি করতে প্রথম দুটি ফাংশন প্রয়োজন। এবং এই সমস্যাটি যেখানেই দেখা দেয় তার পুনরায় ব্যবহার করা যেতে পারে। যাইহোক, আমি নিজেই এটিকে প্রোগ্রাম করেছিলাম, যদি কেউ এই সমস্যার কোনও মানক সমাধানের কথা জানেন তবে দয়া করে বিনা দ্বিধায় আমার সাথে যোগাযোগ করুন।

"ফ্যাক্টজোরনেটর" এখন একটি অভিধান প্রদান করে। এবং তারপরে অভিধানটি "বিভাগকারী" হিসাবে খাওয়ানো হয়েছে, যিনি এটি প্রথমে তালিকার একটি তালিকা তৈরি করতে ব্যবহার করেন, যেখানে প্রতিটি তালিকা পি প্রাইম সহ পি p n ফর্মের কারণগুলির তালিকা। তারপরে আমরা সেই তালিকাগুলির কার্টেসিয়ান পণ্য তৈরি করি এবং অবশেষে বিভাজক তৈরির জন্য গ্রেগের সমাধানটি ব্যবহার করি। আমরা তাদের বাছাই এবং তাদের ফিরে।

আমি এটি পরীক্ষা করেছি এবং এটি আগের সংস্করণটির থেকে কিছুটা দ্রুত গতিতে বলে মনে হচ্ছে। আমি এটি আরও বড় প্রোগ্রামের অংশ হিসাবে পরীক্ষা করেছি, তাই এটি তত দ্রুত হলেও আমি সত্যিই বলতে পারি না।

পিট্রো স্পেরোনি (পাইট্রোস্পেরনি ডট এটি)

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)

পিএস এটি প্রথমবারের মতো আমি স্ট্যাকওভারফ্লোতে পোস্ট করছি। আমি কোন প্রতিক্রিয়া জন্য অপেক্ষা করছি।

Question 7

খাঁটি পাইথন ৩. in-তে প্রায় 10 ** 16 পর্যন্ত সংখ্যার জন্য এটি করার একটি স্মার্ট এবং দ্রুত উপায়,

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

Question 8

আমি কেবল ভবিষ্যতের রেফারেন্সের জন্য আনিভার্থের (যেহেতু আমি এটি সবচেয়ে পাইথোনিক হিসাবে বিশ্বাস করি) এর কিছুটা সংশোধিত সংস্করণ যুক্ত করতে যাচ্ছি।

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

Question 9

কোডআরভিউ থেকে গৃহীত , এখানে একটি রূপ রয়েছে যা এর সাথে কাজ করে 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))

Question 10

পুরানো প্রশ্ন, তবে এখানে আমার গ্রহণ:

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

আপনি এর সাথে প্রক্সি করতে পারেন:

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

দ্রষ্টব্য: যে ভাষাগুলি সমর্থন করে তাদের জন্য এটি পুনরুক্তি হতে পারে।

Question 11

ধরে নিই যে factorsফাংশনটি n এর উপাদানগুলি ফেরৎ দেয় (উদাহরণস্বরূপ, factors(60)[2, 2, 3, 5] তালিকাটি ফেরত দেয়), এখানে n এর বিভাজনগুলি গণনা করার জন্য একটি ফাংশন রয়েছে :

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

Question 12

এখানে আমার সমাধান। এটি বোবা বলে মনে হচ্ছে তবে ভাল কাজ করে ... এবং আমি সমস্ত সঠিক বিভাজনকারী খুঁজতে চেষ্টা করছিলাম যাতে লুপটি 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

Question 13

যদি আপনি কেবল তালিকা বোধগম্যতা এবং অন্য কিছু আপনার জন্য গুরুত্বপূর্ণ ব্যবহার করে না তবে যত্নশীল!

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)

Question 14

আপনার পিসিতে যদি প্রচুর পরিমাণে মেমরি থাকে তবে একটি ব্রুট সিঙ্গল লাইন নম্পতির সাথে দ্রুত পর্যাপ্ত হতে পারে:

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

আমার ধীর পিসিতে 1 এস এরও কম সময় নেয়।

Question 15

জেনারেটর ফাংশনের মাধ্যমে আমার সমাধানটি হ'ল:

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

Question 16

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

Question 17

আমার জন্য এটি ভাল কাজ করে এবং এটি পরিষ্কারও রয়েছে (পাইথন 3)

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

খুব দ্রুত নয় তবে আপনি যেমন চান ঠিক তেমন লাইন দিয়ে বিভাজনগুলি লাইন করে দেন, এছাড়াও আপনি যদি সত্যিই চান তবে আপনি list.append (n) এবং list.append (নম্বর) করতে পারেন