def main():
i = 647
while True:
s1 = set(pyprimes.factors(i))
s2 = set(pyprimes.factors(i + 1))
s3 = set(pyprimes.factors(i + 2))
s4 = set(pyprimes.factors(i + 3))
if len(s1) == 4 and len(s2) == 4 and len(s3) == 4 and len(s4) == 4:
print i
break
i += 1
def main():
all = []
for d in xrange(2, 1000001):
for n in xrange(int(d * 0.428571428570), int(d * 0.428571428572) + 1):
all.append((float(n) / float(d), n, d))
all = sorted(all)
index = all.index((float(3) / float(7), 3, 7))
for i in xrange(index - 1, -1, -1):
x, n, d = all[i]
if set(pyprimes.factors(n)).isdisjoint(set(pyprimes.factors(d))):
print n
break
def findCoPrimeNos(n):
if (pyprimes.isprime(n)):
coPrimeNos = [num for num in xrange(1, n)]
return coPrimeNos
primeFactors = pyprimes.factors(n)
coPrimeNos = [
num for num in xrange(1, n)
if (not checkDivisibleAny(num, primeFactors))
]
return coPrimeNos
def factorizations(x):
factorization, listes = factors(x), [[x]]
for n_factors in range(1, len(factorization)):
for combination in combinations(factorization, n_factors):
p = product(combination)
for facto in factorizations(x / p):
liste = [p]
liste.extend(facto)
liste = sorted(liste)
if liste not in listes:
listes.append(liste)
return listes
def is_ddp_new(o,d):
for i in range(1,100):
facts = pyprimes.factors(d - i)
if len(set(facts)) == 1:
p, k = facts[0], len(facts)
eo, ed = erdos_order(p, k), erdos_degree(p, k)
if p == 2:
eo += 1
if o - eo > d - ed:
print(eo,ed,p,k)
return True
else:
return False
def all_divisors_primes(n):
finalset = []
primefactors = factors(n)
powerset = chain.from_iterable(combinations(
primefactors, r) for r in range(1, len(primefactors) + 1))
for s in powerset:
divisor = 1
for d in s:
divisor *= d
finalset.append(divisor)
finalset.insert(0, 1)
return list(set(finalset))
def fap(n):
nums = set()
primes = set(pyprimes.factors(n))
for i, prime in enumerate(primes):
if i % 100 == 0:
print str(i) + "/" + str(len(primes)) + "..."
mult = 1
while True:
if mult % 10 ** 6 == 0:
print str(float(prime * mult) / float(n)) + "%"
if prime * mult > n:
break
nums.add(prime * mult)
mult += 1
return nums
def findDivsorsOf(testNum): pFactors = set(pyprimes.factors(testNum)) nonpFactors = set([]) for fact in pFactors: i = 2 while fact*i < testNum: if testNum % (fact*i) == 0: nonpFactors.add(fact * i) i += 1 nonpFactors.add(1) nonpFactors.add(testNum) if testNum in pFactors: pFactors.remove(testNum) if testNum in nonpFactors: nonpFactors.remove(testNum) return pFactors.union(nonpFactors)
def test(num): fact = pyprimes.factors(num) return len(fact)==2 and len(set(fact))==2
def coprime(k, n):
return set(pyprimes.factors(k)).intersection(set(pyprimes.factors(n))) == set()
import pyprimes
total = 0
for i in xrange(1, 5000000):
total += sum(pyprimes.factors(15000000+i))
total -= sum(pyprimes.factors(1+i))
print total + sum(pyprimes.factors(20000000))
# Project Euler problem 3
# Largest prime factor
# We go module searching in the PyPi for what we want
from pyprimes import factors
if __name__ == "__main__":
"""
Oftentimes, it's more about finishing the problem than getting the most
efficient solution. Go look for the pyprimes module on PyPi and install it
to run this code.
TIP: PyPi has almost everything you've ever wanted. Unfortunately, Python
hasn't fully transitioned to 3 yet.
"""
print(max(factors(600851475143)))
from utils import product
from pyprimes import factors
from itertools import combinations
target = 2 * 2 * 2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23
count, primes = 0, list(set(factors(target)))
for i in xrange(len(primes) + 1):
for comb in combinations(primes, i):
count += (-1) ** i * product(comb)
R = abs(count) * target / product(primes)
print target
print R
print target - 1
print R / float(target - 1)
print 15499. / 94744.
print R / float(target - 1) < 15499. / 94744.
def rad(n):
return reduce(operator.mul, set(pyprimes.factors(n)))
def get_factors(num_str):
factors = []
for i in range(2, 11):
num = int(num_str, i)
factors.append(str(pyprimes.factors(num)[0]))
return factors
def totient(n):
factors = list(set(pyprimes.factors(n)))
result = 1
for p in factors:
result = result * (1 - (1 / p))
return round(result * n)
"""Largest prime factor [Problem 3](https: // projecteuler.net / problem=3) The prime factors of 13195 are 5, 7, 13 and 29. What is the largest prime factor of the number 600851475143 ?""" from pyprimes import factors number = 600851475143 factors = factors(number) print(max(factors))
# imports
import pyprimes as prime
import pandas as pd
import random as rn
import bokeh.plotting as bk
from bokeh.objects import ColumnDataSource
############### Getting data and arranging in Data.Frame
# Take in value and check that it's not such a huge number
num = abs(int(raw_input("Give me a number: ")))
while (num>= 1000000000000):
num = int(raw_input("Give me a smaller number (<1,000,000,000,000): " ))
# Find prime factorization of number and store factors (not 1) in DataFrame
data = prime.factors(num)
df = pd.DataFrame(data, columns=["prime"])
# Output to html
bk.output_file("primes.html", title="Prime Factor Visualization")
# Randomly generate int(x,y) positions for each factor (bound to 10, maybe 7)
# Positions must be unique in either x or y
# This could be cleaner
x=[]
y=[]
for factor in data:
xcoord = rn.randint(0,10)
ycoord = rn.randint(0,10)
x.append(xcoord)
y.append(ycoord)
def consecutiveWorks(looplength, i): for j in xrange(looplength): if not(len(set(pyprimes.factors(i+j)))) == looplength: return False return True
import pyprimes
max = 50
i = 0
curr = 0
print "Case #1:"
while (i < max):
num = "1{0}1".format("{0:014b}".format(curr))
is_prime = False
arr = []
for base_1 in range(9):
base = base_1 + 2
if pyprimes.miller_rabin(int(num, base)):
is_prime = True
break
else:
arr.append(str(pyprimes.factors(int(num, base))[0]))
if not is_prime:
print num + ' ' + ' '.join(arr)
i += 1
curr += 1
"""Largest prime factor
[Problem 3](https: // projecteuler.net / problem=3)
The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ?"""
from pyprimes import factors
import time
start = time.perf_counter_ns()
number = 600851475143
largest_prime_factor = max(factors(number))
end = time.perf_counter_ns()
message = "Greatest prime factor of '{0:,d}': '{1:,d}'\nElapsed: {2:,d} ns".format(
number, largest_prime_factor, end - start)
print(message)
a1=1
a2=2
while(a2 <= 4000000):
na2=a1+a2
a1=a2
a2=na2
if(a1 % 2 == 0):
sums=sums+a1
print(sums)
#######3. Largest Prime Factor
### Pyprimes
import scipy
import pyprimes
pyprimes
pyprimes.factors(600851475143)
max(pyprimes.factors(600851475143))
####
n=600851475143
i=2
while (i * i < n):
if(n % i == 0):
n=n/i
i=i+1
print(n)
####### 4. Palindrome Product
list_a = ['1','2','3','4','5','6','7','8']
list_a[::-1]
