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
""" 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)