def euler(self):
self.wm_attributes("-disable", True)
self.toplevel_dialog = tk.Toplevel(self)
self.toplevel_dialog.minsize(300, 100)
self.toplevel_dialog.transient(self)
self.toplevel_dialog.protocol("WM_DELETE_WINDOW", self.Close_Toplevel)
l = len(self.couple)
lg = len(self.sommets)
if lg >= 2:
g1 = Euler(lg)
for i in range(l):
g1.addEdge(self.couple[i][0], self.couple[i][1])
self.var = g1.test()
self.label = tk.Label(self.toplevel_dialog, text=self.var)
self.label.pack(side='top')
else:
self.label = tk.Label(self.toplevel_dialog,
text="Votre requette ne peut etre traiter")
self.label.pack(side='top')
self.yes_button = ttk.Button(self.toplevel_dialog,
text='Retour',
width=25,
command=self.Close_Toplevel)
self.yes_button.pack(side='right', fill='x', expand=True)
def det_M(seq):
div1 = set(Euler.factoring(seq[0]))
div2 = set(Euler.factoring(seq[1]))
check = div2.difference(div1)
if 3 in check or 7 in check:
return 1
else:
return -1
def main(limit): # Returns the number of unique numbers below limit that are the sum of a # prime square, prime cube, and prime fourth power. fourth_powers = [x ** 4 for x in Euler.prime_sieve(int(limit ** (1/4.0) + 1))] third_powers = [x ** 3 for x in Euler.prime_sieve(int(limit ** (1/3.0) + 1))] second_powers = [x ** 2 for x in Euler.prime_sieve(int(limit ** (1/2.0) + 1))] result = [] for x in fourth_powers: for y in third_powers: for z in second_powers: if x+y+z < limit: result.append(x+y+z) return len(set(result))
def main(n): # Returns the nth prime number. counter = 0 testnum = 1 while counter < n: testnum = Euler.nextPrime(testnum) counter += 1 return testnum
def main(limit): # Iterates through each number less than limit testing for primeness. # Counter is multiplied by each prime number for the a number of times # equal to the greatest number of times that prime divides a number less # than or equal to the limit. For example, 2 divides 8 3 times (8 = 2*2*2), # so when limit == 10 counter is multiplied by 2^3. counter = 1 for x in range(2, limit+1): if Euler.isPrime(x): counter *= (x ** math.floor(math.log(limit, x))) return counter
def permutePrimes(prime, character):
# Replaces each instance of character in prime with 0-9 and
# returns a list of each resulting number that is also prime
digits = [x for x in range(10)]
digits = list(filter(lambda x: x != character, digits))
answers = [prime]
for x in digits:
testnum = replaceDigit(prime, character, x)
if Euler.isPrime(testnum) == True:
if len(str(testnum)) == len(str(prime)):
answers.append(testnum)
return answers
def naiveResilience(num):
if(num==1): return 0/num
if(Euler.isPrime(num,Euler.currPrimes)): return (num-1)/num
count = 1
for i in range(2,num):
hit = False
b = math.sqrt(num)
for p in Euler.currPrimes:
if(p>b): break
if(i%p==0 and num%p==0):
hit = True
break
if(not hit): count+=1
return count/num
def evaluate_prime(prime):
# Evaluates a prime number and adds a key: value pair to prime_table
# with a list containing each set of pairs for that prime organized by
# number of pairs
candidate = Euler.previous_prime(prime)
answer = [] # This will be the value we return
finished = False
pairs = [prime]
while finished == False:
while candidate > 2:
if is_pair(prime, candidate) == True:
pairs.append(candidate)
candidate -= 2
if len(pairs) > 1:
answer.append((len(pairs), pairs))
candidate = Euler.previous_prime(pairs[-1])
pairs = pairs[:-1]
if len(pairs) < 2:
finished = True
if len(answer) == 0:
prime_table[prime] = False
else:
prime_table[prime] = answer
def measurement(q,rN):
'''
R = Rotation from N frame to B frame
'''
R = Euler.quat2DCM(q)
rB1 = (R@rN[0:3])
rB2 = (R@rN[3:6])
y = np.append(rB1,rB2)
C = np.zeros([6,6])
C[0:3,0:3] = 2*SkewSymmetric(rB1)
C[3:6,0:3] = 2*SkewSymmetric(rB2)
return y,R,C
def euler243():
target = 15499/94744
currentD = 1
nextFactor = 2
currFactorIndex = 0
currR = 1
while(currR>=target):
print('Current index '+str(currFactorIndex))
print('Current D '+str(currentD))
currFactorIndex+=1
if(len(Euler.currPrimes)<=currFactorIndex):
Euler.currPrimes = Euler.primesList(nextFactor*2,Euler.currPrimes)
nextFactor = Euler.currPrimes[currFactorIndex]
currentD*=nextFactor
currR = naiveResilience(currentD)
print('D'+str(currentD))
print('R'+str(currR))
def euler243Heuristic():
target = 15499/94744
currentD = 1
nextFactor = 2
currFactorIndex = 0
currR = 1
while(currR>=target or True):
currFactorIndex+=1
if(len(Euler.currPrimes)<=currFactorIndex):
Euler.currPrimes = Euler.primesList(nextFactor*2,Euler.currPrimes)
nextFactor = Euler.currPrimes[currFactorIndex]
currentD*=nextFactor
currR = pseudoResilience(currFactorIndex)
if(currR<target):
print('Pseudo hit on Index '+str(currFactorIndex))
print(currentD)
print(currR)
print('D'+str(currentD))
print('R'+str(currR))
import Euler
lim = 10**14
primes = Euler.prime_sieve(lim)
def digit_sum(num):
if num < 10:
return num
first = num % 10
return first + digit_sum(num // 10)
def is_harshad(num):
# print("is_harshad", num)
return num % digit_sum(num) == 0
def is_right_harshad(num):
# print("is_right_harshad", num)
if num <= 10:
return True
return is_harshad(num) and is_right_harshad(num // 10)
def is_strong_harshad(num):
# print("is_strong_harshad", num)
if not is_harshad(num):
return False
# if not Euler.is_prime(num // digit_sum(num)):
# return False
def func(x):
ans = list(set(Euler.factoring(x)))
ans.sort()
return ans
def tagainiso(n, m):
re = list(set(Euler.factoring(n)) & set(Euler.factoring(m)))
if re == [1]:
re = []
return re
# Problem 69: totient maximum
import time, Euler
t1 = time.clock()
answer = 1
n = 0
for x in range(2, 10001):
rp_counter = 1
for y in range(2,x):
if Euler.highest_common_factor(x,y) == 1:
rp_counter += 1
ratio = x/rp_counter
if ratio > answer:
answer = ratio
n = x
print(n, " has the largest ratio: ", answer)
t2 = time.clock()
print("Execution time: ", str(t2-t1)[:5])
import Euler ans = 0 #p = Euler.generate_palindrome(1, 1000000) p = Euler.generate_palindrome(1, 1000000000) for i in p: if(Euler.is_palin(i,2)): ans+=i print ans
def ObjFunc(M, h, K, Y0, sigma, eta, C, W):
YM = E.Euler(M, h, K, Y0, sigma)
projv = eta(np.dot(YM, W))
return (1 / 2) * nl.norm(projv - C)**2
# Samuel Svenningsen (altock)
# Project Euler Problem 6
import Euler
if __name__ == '__main__':
print Euler.sum_square_difference(100)
3. 4213 + 3124 = 7337
349は, 3回の操作を経て回文数になる.
まだ証明はされていないが, 196のようないくつかの数字は回文数にならないと考えられている.
反転したものを足すという操作を経ても回文数にならないものをLychrel数と呼ぶ.
先のような数の理論的な性質により, またこの問題の目的のために,
Lychrel数で無いと証明されていない数はLychrel数だと仮定する.
更に, 10000未満の数については以下を仮定してよい.
1. 50回未満の操作で回文数になる
2. まだ誰も回文数まで到達していない
実際, 10677が50回以上の操作を必要とする最初の数である:
4668731596684224866951378664 (53回の操作で28桁のこの回文数になる).
驚くべきことに, 回文数かつLychrel数であるものが存在する.
最初の数は4994である.
10000未満のLychrel数の個数を答えよ.
"""
import time
import Euler
time1 = time.time()
s = 0
for i in range(1, 10000):
k = i
for n in range(1, 50):
k += int(str(k)[::-1])
if Euler.is_kaibun(k):
s += 1
break
answer = 9999 - s
print(answer)
print(time.time() - time1, "Seconds")
import Euler a = 0 for i in range(1,101): for j in range(1,101): if( Euler.binomial(i, j) > 1000000 ): a+= 1 print a
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
project euler problem 41
n桁の数がPandigitalであるとは, 1からnまでの数を各桁に1つずつもつことである.
例えば2143は4桁のPandigital数であり, かつ素数である.
n桁のPandigitalな素数の中で最大の数を答えよ.
"""
import Euler
import time
time1 = time.time()
answer = 0
for i in range(9999999, 1000000, -1):
if Euler.pandigital_check(i) * Euler.primecheck(i):
answer = i
break
if answer == 0:
for i in range(9999, 1000, -1):
if Euler.pandigital_check(i) * Euler.primecheck(i):
answer = i
break
print(answer)
print(time.time() - time1, "seconds")
# Samuel Svenningsen (altock)
# Project Euler Problem 4
import Euler
if __name__ == '__main__':
print Euler.largest_palindrome_product(100, 1000)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
project euler problem 91
素数の2乗と素数の3乗と素数の4乗の和で表される最小の数は28である. 50未満のこのような数は丁度4つある.
28 = 2^2 + 2^3 + 2^4
33 = 3^2 + 2^3 + 2^4
49 = 5^2 + 2^3 + 2^4
47 = 2^2 + 3^3 + 2^4
では, 50,000,000未満の数で, 素数の2乗と素数の3乗と素数の4乗の和で表される数は何個あるか?
"""
import time
import Euler
t0 = time.time()
primes = Euler.prime_make(7080)
answerlist = []
for x in primes: # 7079**2>50000000
for y in [i for i in primes if i < 374]: # 374**3>50000000
for z in [k for k in primes if k < 90]: # 89**4>50000000
num = x ** 2 + y ** 3 + z ** 4
if num < 50000000:
answerlist.append(num)
answerlist = list(set(answerlist))
answerlist.sort()
print(len(answerlist))
print(time.time() - t0, "seconds")
# Samuel Svenningsen (altock)
# Project Euler Problem 9
import sys
import Euler
# Brute-forcing it
if __name__ == '__main__':
for i in xrange(1, 1000):
for j in xrange(i + 1, 1000):
for k in xrange(j + 1, 1000):
# if this is 0 then we know that their sum is 1000
num = i + j + k - 1000
if Euler.is_pythagorean(i, j, k) and not num:
print i * j * k
sys.exit()
elif num > 0:
break
def Wgrad(M, h, K, Y0, sigma, eta, C, W):
YM = E.Euler(M, h, K, Y0, sigma)
y = np.dot(YM, W)
return np.dot(YM.T, etader(y)*(eta(y) - C))
渦巻きに新しい層を付け加えよう.
すると辺の長さが9の渦巻きが出来る.
以下, この操作を繰り返していく.
対角線上の素数の割合が10%未満に落ちる最初の辺の長さを求めよ.
"""
import time
import math
import Euler
time1 = time.time()
amount = 0
p_amount = 0
c = 0
add_count = 0
add_num = 2
i = 1
while True:
if amount != 0 and math.sqrt(i) % 1 == 0 and int(math.sqrt(i)) % 2 == 1:
if p_amount * 10 <= amount:
break
if add_count == 4:
add_count = 0
add_num += 2
i += add_num
add_count += 1
amount += 1
if Euler.primecheck(i):
p_amount += 1
print(math.sqrt(i), i)
print(time.time() - time1, "Seconds")
def solve(q, dt, f0):
if q == 1:
T = 6
else:
T = (1 / float(q - 1)) - 0.1
return p1.euler(uprime(q), f0, np.arange(0, T, dt))
# Samuel Svenningsen (altock)
# Project Euler Problem 2
import Euler
if __name__ == '__main__':
cur = 1
fib = Euler.fib_iterator()
value = 0
while cur < 4000000:
if not cur % 2:
value += cur
cur = fib.next()
print value
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
project euler problem 187
合成数とは2つ以上の素因数を含む整数のことである.
例えば15 = 3 × 5, 9 = 3 × 3, 12 = 2 × 2 × 3が合成数である.
30以下には丁度2つの素因数を含む合成数 (異なる素因数でなくてもよい) が,
10個存在する. 4, 6, 9, 10, 14, 15, 21, 22, 25, 26がそうである.
合成数n < 10^8について, 丁度2つの素因数を含む合成数 (異なる素因数でなくてもよい) の数を答えよ.
"""
import time
import Euler
t0 = time.time()
primes = tuple(Euler.prime_make(50000000))
answer_count = 0
for i in primes:
if int(i) > 10000:
break
print(i)
for j in primes:
if j < i:
continue
if int(i) * int(j) >= 10 ** 8:
break
answer_count += 1
print(answer_count)
print(time.time() - t0, "seconds")
# Problem 58: Spiral primes
import time
import Euler
t1 = time.clock()
diagonal = 1
primes = []
non_primes = [1]
side_length = 3
ratio = 1
while ratio > 1/10: # Change to: while found = False
for x in range(4):
diagonal += side_length - 1
if Euler.isPrime(diagonal) == True:
primes.append(diagonal)
else:
non_primes.append(diagonal)
ratio = len(primes) / (len(primes) + len(non_primes))
side_length += 2
t2 = time.clock()
print("Side length = ", side_length - 2)
print(str(t2-t1)[:9])
from Euler import * e = Euler() print(e.divTriNumber(500))
# Samuel Svenningsen (altock)
# Project Euler Problem 10
# import Euler_7
import Euler
if __name__ == '__main__':
# NOTE: Sieve was too slow
# erast = Euler_7.sieve()
# erast.get_ith_prime(145000)
# summation = sum(erast.list)
# while erast.get_highest() < 2000000:
# summation += erast.next()
# print summation - erast.get_highest()
summation = 2
for i in xrange(3, 2000000, 2):
if Euler.is_prime(i):
summation += i
print summation
# Samuel Svenningsen (altock)
# Project Euler Problem 3
import Euler
if __name__ == '__main__':
print Euler.greatest_factor(600851475143)
# Samuel Svenningsen (altock)
# Project Euler Problem 7
import Euler
if __name__ == '__main__':
erast = Euler.sieve()
print erast.get_ith_prime(50001)
import Euler import math a = 100000000 b = 10000 m = [] ans = 0 sum=0 for i in range(1,b+1): sum=i*i for j in range (i+1, b+1): sum+=j*j if(j>a): break if( Euler.is_palindromic(sum) and ( sum not in m) ): m.append(sum) print sum ans+=sum print ans
def main():
global L, primes
for n in range(2, L):
if Euler.is_prime(n):
print n
y_Euler.append(y1)
y_RK.append(y2)
y_theory.append(y3)
#print("y2, y3=", y2, y3)
time.append(t)
return [y_Euler, y_RK, y_theory, time]
###########################
# Тест из методички
from_ = 0
to_ = 1
dt = 0.1
func_arr = [func_test_0, func_test_1, func_test_2, func_test_3]
y_start = [1, 1, 1, 1]
[res_x, res_y] = Euler.Euler(y_start, from_, to_, dt, func_arr)
[res_x_RK, res_y_RK] = RungeKutt.RungeKutt(y_start, 0, 1, 0.1, func_arr)
[y_Euler, y_RK, y_theory, time] = seminar_alg(dt, from_, to_)
print('Seminar Euler\n', y_Euler, '\n')
print('My Euler\n', res_y, '\n')
print('Seminar RK\n', y_RK, '\n')
print('My RK\n', res_y_RK, '\n')
'''fig = plt.figure()
subplot = fig.add_subplot(121)
subplot.set_title('методичка')
subplot.plot(time, y_theory, 'black', label='Seminar theory')
subplot.plot(time, y_Euler, 'm', label = 'Seminar Euler')
print(currentD)
print(currR)
print('D'+str(currentD))
print('R'+str(currR))
def pseudoResilience(primeN):
currentR = 1
for i in range(0,primeN+1):
currentR*=((Euler.currPrimes[i])-1)/(Euler.currPrimes[i])
return currentR
CurrentWildcardLists = [[]]
PossibleChars = ['1','2','3','4','5','6','7','8','9','0','*']
Euler.primesList(100000,Euler.currPrimes)
print('sdf')
def starifiedList(stars,num):
if(stars==1):
starOne = []
for i in range(0,len(str(num))):
starOne.append(str(num)[0:i]+"*"+str(num)[i+1:])
return starOne
lastStarified = starifiedList(stars-1,num)
for currLast = #todo loop through and whatever
# Samuel Svenningsen (altock)
# Project Euler Problem 4
import Euler
if __name__ == '__main__':
print Euler.largest_palindrome_product(100, 1000)
"""
project euler problem 135
正の整数x, y, z が等差数列として与えられたとき、
x2 - y2 - z2 = n がちょうど2個の解を持つような最小の正の整数 n は、n = 27である。
34^2 − 27^2 − 20^2 = 12^2 − 9^2 − 6^2 = 27
n = 1155 は、方程式がちょうど10個の解を持つ最小の値である。
ちょうど10個の解を持つような n は、100万までにいくつ存在するか?
"""
import time
import Euler
time1 = time.time()
n = 0
check = 0
count = 0
primelist = Euler.prime_make(1000000)
print(time.time() - time1)
while n < 1000000:
n += 1
if n in primelist:
continue
x = 0
while x <= n / 2:
x += 1
if n % x == 0 and n / x > x and (n / x - x) % 2 == 0:
check += 1
if check == 10:
count += 1
check = 0
if time.time() - time1 > 60:
break
# Samuel Svenningsen (altock)
# Project Euler Problem 1
import Euler
if __name__ == '__main__':
print Euler.multiples_sum(3, 5, 1000)
plt.title("Residual plot")
plt.show()
def get_accuracy(YM, W):
projv = eta(np.dot(YM, W))
guess = np.around(projv)
diff = guess - C
wrong_guesses = np.count_nonzero(diff)
accuracy = (1 - wrong_guesses / n)
return accuracy
#arguments
Eargs = (M, h, K, Y0, sigma)
OFargs = (M, h, K, Y0, sigma, eta, C, W)
GCargs = (M, h, K, Y0, sigma, eta, C, W, eps)
Targs = (M, h, K, Y0, sigma, eta, C, W, eps, TOL, tau)
K, W, res_list = T.Train(*Targs)
res_plot(res_list)
#Training data accuracy
YM = E.Euler(M, h, K, Y0, sigma)
accu = get_accuracy(YM, W)
print("Accuracy on training set: " + str(accu))
#Test data accuracy
Y0, C = mcp.YC(n, 50, False)
YM = E.Euler(M, h, K, Y0, sigma)
accu = get_accuracy(YM, W)
print("Accuracy on test set: " + str(accu))
def nCr(n, r): return Euler.factorial(n) / (Euler.factorial(r) * Euler.factorial(n-r))
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
....
上から8行見るとパスカルの三角形は12個の異なる数を含む.
1, 2, 3, 4, 5, 6, 7, 10, 15, 20, 21, 35である.
任意の素数の二乗がnを割り切らないとき, 正整数nが平方因子を持たないと言う.
先ほどの12個の数字を見ると, 4, 20以外は平方因子を持たない.
従って, 最初の8行の平方因子を持たない異なる数の和は105になる.
パスカルの三角形の最初の51行に含まれる平方因子を持たない異なる数の和を答えよ.
"""
import time
import math
import Euler
time1 = time.time()
sosu = Euler.prime_make(50000)
trilist = [x for x in range(1, 50)]
answerlist = []
for i in range(2, 51):
for j in range(int(i)):
trilist.append(
(math.factorial(i) / (math.factorial(j) * math.factorial(i - j))))
trilist = list(set(trilist))
for k in trilist:
check = 1
for l in sosu:
if k % (l ** 2) == 0:
check = 0
break
if check == 1:
answerlist.append(k)
current_max_num_factors = 0
list_of_highly_composite_numbers = []
list_of_highly_composite_num_factors = []
while 1:
# if i>1000:
# break
i += 1
# print i, Euler.miller_rabin(i)
# make sure not a prime first since we know primes only have 2 factors ( 1 and i ). will short circuit on primes
if ( not Euler.miller_rabin(i) ): # if it is a composite number
nf = dlibrary.find_number_of_factors_fast(i)
if ( nf > current_max_num_factors ):
current_max_num_factors = nf
print "%60d %30d" % (i, nf)
# list_of_highly_composite_numbers.append( i )
# list_of_highly_composite_num_factors.append( nf )
# for n in range(0,len(list_of_highly_composite_numbers)):
# print "%10d %10d" % (list_of_highly_composite_numbers, list_of_highly_composite_num_factors)
