def test_evenNumbers(self): """Teste le fonctionnement de la fonction 'utils.evenNumbers'.""" self.assertEqual(utils.evenNumbers(), list(range(0, 100, 2))) self.assertEqual([2, 4, 6, 8], utils.evenNumbers(2, 9)) with self.assertRaises(TypeError): utils.divisors(5, 4, 4) with self.assertRaises(TypeError): utils.divisors("b")
def amicable(n): d1 = sum(utils.divisors(n)) if sum(utils.divisors(d1)) == n: if d1 != n: return d1 else: return 0 else: return 0
def test_divisors(self): """Teste le fonctionnement de la fonction 'utils.divisors'.""" self.assertEqual([1, 2, 5, 10, 25, 50], utils.divisors(50)) self.assertEqual([], utils.divisors(-5)) self.assertEqual([1], utils.divisors(2, 1)) with self.assertRaises(TypeError): utils.divisors(5, 4, 4) with self.assertRaises(TypeError): utils.divisors() with self.assertRaises(TypeError): utils.divisors("b", 5)
def is_abundant(n: int) -> bool: total = 0 for divisor in utils.divisors(n): if divisor != n: total += divisor return total > n
def exo2_exec(): try: num = int(app.getEntry("two_num")) result = utils.divisors(num) resultStr = utils.arrayToStr(result) app.setLabel("two_result", resultStr) except TypeError: app.setLabel("two_result", "Un champ est vide!")
def main(): def next_triangle_number(triangle, last_n): return triangle + last_n + 1, last_n + 1 n = 1 triangle = 1 divs = [] while len(divs) < 499: triangle, n = next_triangle_number(triangle, n) divs = divisors(triangle) print(f'{triangle}: {len(divs)}')
def is_abundant(n): """ Returns true if the number given is abundant, sum of the divisors is greater than the number itself. >>> is_abundant(12) True >>> is_abundant(10) False """ return sum(divisors(n)) > n
def amicable_pairs(stop=10000): d = {} for i in range(2, stop + 1): amicable_cand = sum(divisors(i)) - i if i in d: if d[i] == amicable_cand: yield d[i], i else: d[amicable_cand] = i else: d[amicable_cand] = i
def solve(): '''Main function''' all_sums = set() limit = 28123 abundants = [n for n in xrange(1, limit) if sum(divisors(n)) > n] for i in abundants: for j in abundants: if i+j < limit: all_sums.add(i+j) else: break return sum(xrange(1, limit)) - sum(all_sums)
def test_geometricSuite(self): """Teste le fonctionnement de la fonction 'utils.geometricSuite'.""" self.assertEqual(utils.geometricSuite(2, 2), [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]) self.assertEqual(utils.geometricSuite(5, 5, 3), [5, 25, 125]) with self.assertRaises(TypeError): utils.divisors() with self.assertRaises(TypeError): utils.divisors(5, 4, 4) with self.assertRaises(TypeError): utils.divisors("b", 4)
def gcd(nums, res=[], sort=True): while len(nums) > 0: if len(nums) == 0: return np.prod(res) # remove the ones nums = [n for n in nums if n > 1] if sort: nums = sorted(nums) print(f"{nums} -- {res}") cand = nums.pop(0) divs = divisors(cand) for d in divs: nums = [int(round(n / d, 0)) if n % d == 0 else n for n in nums] res.append(d) gcd(nums, res, False) return np.prod(res)
def solve(N): ab_nonmult_nums = np.array([], dtype=int) ab_nums = np.array([], dtype=int) for n in np.arange(1, N + 1, dtype=int): if not np.all(np.mod(n, ab_nonmult_nums)): ab_nums = np.append(ab_nums, n) elif n < np.sum(utils.divisors(n)[:-1]): ab_nums = np.append(ab_nums, n) ab_nonmult_nums = np.append(ab_nonmult_nums, n) K = ab_nums.size L = np.where(ab_nums*2 > N)[0][0] ab_sums = np.zeros((L**2//2 + L + (K - L)*L, ), dtype=int) loc = 0 for ii in range(L): ab_sums[loc:loc + ab_nums.size - ii] = ab_nums[ii] + ab_nums[ii:] loc += ab_nums.size - ii ab_sums = ab_sums[np.where(ab_sums <= N)[0]] return utils.sum_1toN(N) - np.sum(np.unique(ab_sums))
def sum_of_divisors(n): return sum(divisors(n))
#!/usr/bin/python import utils if __name__ == "__main__": primes = utils.FastPrimeSieve(10001) n = [i for i in range(1,10001) if i not in primes] pairs = [] for number in n: s1 = sum(utils.divisors(number)) if s1 <= 10000: s2 = sum(utils.divisors(s1)) if s2 == number and s1 != number: pairs.append((number, s1)) print pairs sums = map(lambda x: x[0] + x[1], pairs) usums = list(set(sums)) print pairs print sums print usums print sum(usums)
def d(n): return sum(divisors(n))
def amicable(x): "return the couple if found" y = sum(divisors(x)[:-1]) if (x != y) and (sum(divisors(y)[:-1]) == x): return (x, y) return False
def prob_12(): for x in triangle2(): if len(divisors(x)) > 500: print x break
from utils import divisors def triangle_number(n): return n * (n + 1) // 2 i = 1 while True: v = triangle_number(i) if len(list(divisors(v))) > 500: print(v) break if i % 100 == 0: print(f"[{i}; {v}]") i += 1
So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be: 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ... Let us list the factors of the first seven triangle numbers: 1: 1 3: 1,3 6: 1,2,3,6 10: 1,2,5,10 15: 1,3,5,15 21: 1,3,7,21 28: 1,2,4,7,14,28 We can see that 28 is the first triangle number to have over five divisors. What is the value of the first triangle number to have over five hundred divisors?""" import utils if __name__ == '__main__': divisors = [] triangle_number = 1 n = 1 while len(divisors) <= 500: n += 1 triangle_number += n divisors = utils.divisors(triangle_number) print(triangle_number)
from utils import divisors a = [] # abundant numbers c = set(xrange(28124)) # numbers that cant be written as abundant numbers MAX = 28124 for x in xrange( 1, MAX ): if( sum( divisors( x, proper=True ) ) > x ): a.append( x ) for y in a: if x + y > MAX: break elif x + y in c: c.remove( x + y ) print sum( c )
def get_abundant(upto): from utils import divisors for abd in range(upto + 1): if sum(divisors(abd)) > 2 * abd: yield abd
def d(n: int) -> int: total = 0 for divisor in utils.divisors(n): if divisor != n: total += divisor return total
def get_abundant(upto): from utils import divisors for abd in range(upto+1): if sum(divisors(abd))>2*abd: yield abd
def d(n): """ Sums proper divisors of n """ return 0 if n <= 1 else sum(divisors(n)) - n
from itertools import combinations_with_replacement from utils import divisors abundant = filter(lambda n: sum(divisors(n)) > n, range(2, 29000)) u = set(range(1, 29000)) for i in combinations_with_replacement(abundant, 2): u.discard(sum(i)) print sum(u)
def test_abundant(num): return sum(divisors(num)) > num
def is_abundant(n): return sum(divisors(n)) > 2 * n
def d(n): a = sum(divisors(n)) - n b = sum(divisors(a)) - a return a != b and b == n, (a, b) if b > a else (b, a)
def dpd( n ): if n in pd: return pd[ n ] else: pd[ n ] = sum( divisors( n, proper=True ) ) return pd[ n ]
def d(n): return np.sum(utils.divisors(n)[:-1])
def odd_composites(): for i in utils.count_from(2): if i % 2 == 1 and len(list(utils.divisors(i))) > 2: yield i
print("2: 10 premiers diviseurs d'un nombre") print("3: Liste des nombres pairs inferieurs à 100") print("4: 10 premiers termes d'une suite géométrique") print("5: Convertisseur de décimal à binaire") exo = 0 while exo < 1 or exo > 5: exo = int(input("Choisissez un exercice (1-5) : ")) if (exo == 1): num1 = int(input("Nombre 1 : ")) num2 = int(input("Nombre 2 : ")) if (utils.divisible(num1, num2)): print(num1, "est divisible par", num2) else: print(num1, "n'est pas divisible par", num2) elif (exo == 2): num = int(input("Nombre : ")) result = utils.arrayToStr(utils.divisors(num)) print("Les diviseurs de", num, "sont", result) elif (exo == 3): result = utils.arrayToStr(utils.evenNumbers()) print("Les nombres pairs inférieurs à 100 sont", result) elif (exo == 4): u = int(input("u(0) : ")) q = int(input("q : ")) result = utils.arrayToStr(utils.geometricSuite(u, q)) print("Les dix premiers termes de cette suite sont", result) else: num = int(input("Nombre : ")) print(num, "en binaire fait", utils.toBinary(num))
def test_divisors(self): cases = {1:[], 2:[1], 3:[1], 4:[1,2], 6:[1,2,3], 28:[1,2,4,7,14]} for case in cases.keys(): result = utils.divisors(case) if result != cases[case]: self.fail("Got the wrong divisors for %s: %s " % (case, str(cases[case])))
def relevant_abundants(n): result = [] for i in range(1, n): if sum(divisors(i)) > i: result.append(i) return sorted(result)
def prod_is_pandigital(n): for d in utils.divisors(n): t = str(n) + str(d) + str(n // d) if ''.join(sorted(t)) == '123456789': return True return False
from utils import divisors, triangleGen for n in triangleGen(): if len( divisors( n ) ) > 500: break print n
__author__ = 'Moran' from utils import divisors num_of_divisors = 500 even_idx = 2 odd_idx = 1 now_odd = True while True: even_divisors = divisors(even_idx/2) odd_divisors = divisors(odd_idx) idx_divisors = {x*y for x in even_divisors for y in odd_divisors} if len(idx_divisors) > num_of_divisors: print odd_idx * even_idx / 2, idx_divisors break if now_odd: odd_idx += 2 else: even_idx += 2 now_odd = not now_odd
def is_abundant(n): return n < sum(utils.divisors(n))
""" Amicable pairs are numbers whose sums of divisors are equal to the other number. How many are there below 10000? This is a fairly naive attempt, which took 10s. The divisors method is slow. """ from utils import divisors limit = 10000 sds = {} aps = [] for i in range(limit): sd = sum(divisors(i)) sds[i] = sd for item in sds.keys(): try: if sds[sds[item]] == item and item != sds[item]: aps.append(item) except KeyError: # The sum may be bigger than the numbers in the dict pass print sum(aps)
def d(n): """ Sums proper divisors of n """ return 0 if n<=1 else sum(divisors(n))-n
def useful_divisors(terms): threshold = None if args.exhaustive else KEY_LENGTH_THRESHOLD return flatmap(lambda n: list(utils.divisors(n, threshold))[1:], terms)
from utils import divisors # Naive approach, for future reference: # 1. Find all abundant numbers up to 28123 # 2. Find all sums of abundant numbers: # - Given: Above 28123 can be written as sum of two abundant numbers # - Add all sums lte 28123 to set # 3. Create set of all numbers up to 28123 not in 2s set n = 28123 abundant_numbers = [i for i in range(1, n + 1) if sum(divisors(i)) > i] sums_of_abundant_numbers = set() for upper in reversed(range(0, len(abundant_numbers))): for lower in range(upper + 1): sum_ = abundant_numbers[upper] + abundant_numbers[lower] if sum_ > n: continue sums_of_abundant_numbers.add(sum_) print(sum([i for i in range(n + 1) if i not in sums_of_abundant_numbers]))