def digit_cancelling_fractions():
lowest_nums = []
lowest_denoms = []
for den in range(10, 100):
if den % 10 == 0:
continue
for num in range(10, den):
num_digits = eulerlib.digits(num)
den_digits = eulerlib.digits(den)
if num % 10 == 0:
continue
digits_intersection = list(set(num_digits) & set(den_digits))
if len(digits_intersection) > 0:
num_digits.remove(digits_intersection[0])
den_digits.remove(digits_intersection[0])
num_lct = eulerlib.digits_to_int(num_digits)
den_lct = eulerlib.digits_to_int(den_digits)
cancelled_fraction = num_lct / den_lct
fraction = num / den
if fraction == cancelled_fraction:
lowest_nums.append(num_lct)
lowest_denoms.append(den_lct)
print('{} / {} = {} / {}'.format(num, den, num_lct, den_lct))
num_prod = eulerlib.product(lowest_nums)
den_prod = eulerlib.product(lowest_denoms)
gcd = eulerlib.gcd(num_prod, den_prod)
return den_prod / gcd
def solve():
colorsum = 0
qty = 0
fac7 = factorial(7)
for spectrum in partitions():
weight = product(nCr(10,c) for c in spectrum) * fac7 // \
product(factorial(len(list(gr))) for _, gr in groupby(spectrum))
colorsum += sum(1 for c in spectrum if c>0) * weight
qty += weight
#assert qty == nCr(70,20)
return sprintFFraction(9, colorsum, qty)
def solve():
for a in range(1, 10):
for b in range(1, 10):
ab = a*10 + b
for c in range(1, 10):
checkFrac(ab,b,c, a,c) # ab/bc = a/c
checkFrac(ab,c,b, a,c) # ab/cb = a/c
checkFrac(ab,a,c, b,c) # ab/ac = b/c
checkFrac(ab,c,a, b,c) # ab/ca = b/c
(nums, denoms) = zip(*fractions)
num = product(nums)
denom = product(denoms)
return denom // gcd(num, denom)
def seqmax(seq):
def uphill(start):
while start+N < len(seq) and (0 in seq[start:start+N]
or seq[start] < seq[start+N]):
start += 1
return start
def downhill(start):
while start+N < len(seq) and seq[start] >= seq[start+N]:
start += 1
return start
i = uphill(0)
maximum = product(seq[i:i+N])
while i+N < len(seq):
i = uphill(downhill(i))
maximum = max(maximum, product(seq[i:i+N]))
return max(maximum, product(seq[i:i+N]))
def solve():
allRed = Fraction(1, turns+1)
probability = Fraction(0)
for blueQty in range(turns//2 + 1, turns+1):
for combo in combinations(range(1, turns+1), blueQty):
probability += allRed / product(combo)
return int((1 - probability) / probability) + 1
def solve():
prevQty = 1
for i in itertools.count(2):
qty = product((k if p==2 else k+1) for p,k in factor(i+1))
# qty == number of divisors of i+1 (or of (i+1)//2 when i+1 is even)
if qty * prevQty > 500:
return i*(i+1)//2
prevQty = qty
def seqprod(start):
return product(int(c) for c in s[start:start+seqlen])
def solve():
n = 1
while product(k*2+1 for _,k in factor(n)) // 2 + 1 <= 1000:
n += 1
return n
def main(n: int):
digits = [D(10 ** i) for i in range(n)]
print(digits)
return lib.product(digits)
