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
def d(n):
return sum(divisors(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]))
