From 3c8e9314b6b36b3721d9df50ffd7dc20bfb2fc7d Mon Sep 17 00:00:00 2001 From: Christian Clauss Date: Thu, 25 Jul 2019 09:49:00 +0200 Subject: [PATCH] Travis CI: Add a flake8 test for unused imports (#1038) --- .travis.yml | 2 +- graphs/bfs.py | 21 +- maths/volume.py | 10 +- other/primelib.py | 390 +++++++++++++++---------------- project_euler/problem_13/sol1.py | 10 +- 5 files changed, 212 insertions(+), 221 deletions(-) diff --git a/.travis.yml b/.travis.yml index bea512264..6d432c660 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,7 +6,7 @@ before_install: pip install --upgrade pip setuptools install: pip install -r requirements.txt before_script: - black --check . || true - - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + - flake8 . --count --select=E9,F401,F63,F7,F82 --show-source --statistics script: - mypy --ignore-missing-imports . - pytest . --doctest-modules diff --git a/graphs/bfs.py b/graphs/bfs.py index 6bbdd9e25..ebbde0c82 100644 --- a/graphs/bfs.py +++ b/graphs/bfs.py @@ -16,10 +16,19 @@ while Q is non-empty: """ -import collections +G = {'A': ['B', 'C'], + 'B': ['A', 'D', 'E'], + 'C': ['A', 'F'], + 'D': ['B'], + 'E': ['B', 'F'], + 'F': ['C', 'E']} def bfs(graph, start): + """ + >>> ''.join(sorted(bfs(G, 'A'))) + 'ABCDEF' + """ explored, queue = set(), [start] # collections.deque([start]) explored.add(start) while queue: @@ -31,11 +40,5 @@ def bfs(graph, start): return explored -G = {'A': ['B', 'C'], - 'B': ['A', 'D', 'E'], - 'C': ['A', 'F'], - 'D': ['B'], - 'E': ['B', 'F'], - 'F': ['C', 'E']} - -print(bfs(G, 'A')) +if __name__ == '__main__': + print(bfs(G, 'A')) diff --git a/maths/volume.py b/maths/volume.py index 171bc538f..38de7516d 100644 --- a/maths/volume.py +++ b/maths/volume.py @@ -6,8 +6,6 @@ Wikipedia reference: https://en.wikipedia.org/wiki/Volume from math import pi -PI = pi - def vol_cube(side_length): """Calculate the Volume of a Cube.""" @@ -39,9 +37,7 @@ def vol_right_circ_cone(radius, height): volume = (1/3) * pi * radius^2 * height """ - import math - - return (float(1) / 3) * PI * (radius ** 2) * height + return (float(1) / 3) * pi * (radius ** 2) * height def vol_prism(area_of_base, height): @@ -71,7 +67,7 @@ def vol_sphere(radius): V = (4/3) * pi * r^3 Wikipedia reference: https://en.wikipedia.org/wiki/Sphere """ - return (float(4) / 3) * PI * radius ** 3 + return (float(4) / 3) * pi * radius ** 3 def vol_circular_cylinder(radius, height): @@ -80,7 +76,7 @@ def vol_circular_cylinder(radius, height): Wikipedia reference: https://en.wikipedia.org/wiki/Cylinder volume = pi * radius^2 * height """ - return PI * radius ** 2 * height + return pi * radius ** 2 * height def main(): diff --git a/other/primelib.py b/other/primelib.py index c371bc1b9..c000213a7 100644 --- a/other/primelib.py +++ b/other/primelib.py @@ -16,7 +16,7 @@ primeFactorization(number) greatestPrimeFactor(number) smallestPrimeFactor(number) getPrime(n) -getPrimesBetween(pNumber1, pNumber2) +getPrimesBetween(pNumber1, pNumber2) ---- @@ -39,34 +39,36 @@ goldbach(number) // Goldbach's assumption """ +from math import sqrt + + def isPrime(number): """ input: positive integer 'number' returns true if 'number' is prime otherwise false. """ - import math # for function sqrt - + # precondition assert isinstance(number,int) and (number >= 0) , \ "'number' must been an int and positive" - + status = True - - # 0 and 1 are none primes. + + # 0 and 1 are none primes. if number <= 1: status = False - - for divisor in range(2,int(round(math.sqrt(number)))+1): - + + for divisor in range(2,int(round(sqrt(number)))+1): + # if 'number' divisible by 'divisor' then sets 'status' - # of false and break up the loop. + # of false and break up the loop. if number % divisor == 0: status = False break - + # precondition - assert isinstance(status,bool), "'status' must been from type bool" - + assert isinstance(status,bool), "'status' must been from type bool" + return status # ------------------------------------------ @@ -75,37 +77,37 @@ def sieveEr(N): """ input: positive integer 'N' > 2 returns a list of prime numbers from 2 up to N. - + This function implements the algorithm called - sieve of erathostenes. - + sieve of erathostenes. + """ - + # precondition assert isinstance(N,int) and (N > 2), "'N' must been an int and > 2" - + # beginList: conatins all natural numbers from 2 upt to N beginList = [x for x in range(2,N+1)] - ans = [] # this list will be returns. - + ans = [] # this list will be returns. + # actual sieve of erathostenes for i in range(len(beginList)): - + for j in range(i+1,len(beginList)): - + if (beginList[i] != 0) and \ (beginList[j] % beginList[i] == 0): beginList[j] = 0 - - # filters actual prime numbers. + + # filters actual prime numbers. ans = [x for x in beginList if x != 0] - + # precondition - assert isinstance(ans,list), "'ans' must been from type list" - + assert isinstance(ans,list), "'ans' must been from type list" + return ans - + # -------------------------------- @@ -114,203 +116,201 @@ def getPrimeNumbers(N): input: positive integer 'N' > 2 returns a list of prime numbers from 2 up to N (inclusive) This function is more efficient as function 'sieveEr(...)' - """ - + """ + # precondition assert isinstance(N,int) and (N > 2), "'N' must been an int and > 2" - - ans = [] - - # iterates over all numbers between 2 up to N+1 + + ans = [] + + # iterates over all numbers between 2 up to N+1 # if a number is prime then appends to list 'ans' for number in range(2,N+1): - + if isPrime(number): - + ans.append(number) - + # precondition assert isinstance(ans,list), "'ans' must been from type list" - + return ans # ----------------------------------------- - + def primeFactorization(number): """ - input: positive integer 'number' + input: positive integer 'number' returns a list of the prime number factors of 'number' """ - import math # for function sqrt - # precondition assert isinstance(number,int) and number >= 0, \ "'number' must been an int and >= 0" - + ans = [] # this list will be returns of the function. # potential prime number factors. - factor = 2 + factor = 2 quotient = number - - + + if number == 0 or number == 1: - + ans.append(number) - - # if 'number' not prime then builds the prime factorization of 'number' + + # if 'number' not prime then builds the prime factorization of 'number' elif not isPrime(number): - + while (quotient != 1): - + if isPrime(factor) and (quotient % factor == 0): ans.append(factor) quotient /= factor else: factor += 1 - + else: ans.append(number) - + # precondition - assert isinstance(ans,list), "'ans' must been from type list" - + assert isinstance(ans,list), "'ans' must been from type list" + return ans - + # ----------------------------------------- - + def greatestPrimeFactor(number): """ input: positive integer 'number' >= 0 returns the greatest prime number factor of 'number' """ - + # precondition assert isinstance(number,int) and (number >= 0), \ "'number' bust been an int and >= 0" - - ans = 0 - + + ans = 0 + # prime factorization of 'number' primeFactors = primeFactorization(number) - ans = max(primeFactors) - + ans = max(primeFactors) + # precondition - assert isinstance(ans,int), "'ans' must been from type int" - + assert isinstance(ans,int), "'ans' must been from type int" + return ans - + # ---------------------------------------------- - - + + def smallestPrimeFactor(number): """ input: integer 'number' >= 0 returns the smallest prime number factor of 'number' """ - + # precondition assert isinstance(number,int) and (number >= 0), \ "'number' bust been an int and >= 0" - - ans = 0 - + + ans = 0 + # prime factorization of 'number' primeFactors = primeFactorization(number) - + ans = min(primeFactors) # precondition - assert isinstance(ans,int), "'ans' must been from type int" - + assert isinstance(ans,int), "'ans' must been from type int" + return ans - - + + # ---------------------- - + def isEven(number): """ input: integer 'number' returns true if 'number' is even, otherwise false. - """ + """ # precondition - assert isinstance(number, int), "'number' must been an int" + assert isinstance(number, int), "'number' must been an int" assert isinstance(number % 2 == 0, bool), "compare bust been from type bool" - + return number % 2 == 0 - + # ------------------------ - + def isOdd(number): """ input: integer 'number' returns true if 'number' is odd, otherwise false. - """ + """ # precondition - assert isinstance(number, int), "'number' must been an int" + assert isinstance(number, int), "'number' must been an int" assert isinstance(number % 2 != 0, bool), "compare bust been from type bool" - + return number % 2 != 0 - + # ------------------------ - - + + def goldbach(number): """ Goldbach's assumption input: a even positive integer 'number' > 2 returns a list of two prime numbers whose sum is equal to 'number' """ - + # precondition assert isinstance(number,int) and (number > 2) and isEven(number), \ "'number' must been an int, even and > 2" - + ans = [] # this list will returned - + # creates a list of prime numbers between 2 up to 'number' primeNumbers = getPrimeNumbers(number) - lenPN = len(primeNumbers) + lenPN = len(primeNumbers) # run variable for while-loops. i = 0 j = None - + # exit variable. for break up the loops loop = True - + while (i < lenPN and loop): - + j = i+1 - - + + while (j < lenPN and loop): - + if primeNumbers[i] + primeNumbers[j] == number: loop = False ans.append(primeNumbers[i]) ans.append(primeNumbers[j]) - + j += 1 i += 1 - + # precondition assert isinstance(ans,list) and (len(ans) == 2) and \ (ans[0] + ans[1] == number) and isPrime(ans[0]) and isPrime(ans[1]), \ "'ans' must contains two primes. And sum of elements must been eq 'number'" - + return ans - + # ---------------------------------------------- def gcd(number1,number2): @@ -319,173 +319,173 @@ def gcd(number1,number2): input: two positive integer 'number1' and 'number2' returns the greatest common divisor of 'number1' and 'number2' """ - + # precondition assert isinstance(number1,int) and isinstance(number2,int) \ and (number1 >= 0) and (number2 >= 0), \ "'number1' and 'number2' must been positive integer." - rest = 0 - + rest = 0 + while number2 != 0: - + rest = number1 % number2 number1 = number2 number2 = rest # precondition assert isinstance(number1,int) and (number1 >= 0), \ - "'number' must been from type int and positive" - + "'number' must been from type int and positive" + return number1 - + # ---------------------------------------------------- - + def kgV(number1, number2): """ Least common multiple input: two positive integer 'number1' and 'number2' returns the least common multiple of 'number1' and 'number2' """ - + # precondition assert isinstance(number1,int) and isinstance(number2,int) \ and (number1 >= 1) and (number2 >= 1), \ "'number1' and 'number2' must been positive integer." - + ans = 1 # actual answer that will be return. - + # for kgV (x,1) if number1 > 1 and number2 > 1: - + # builds the prime factorization of 'number1' and 'number2' primeFac1 = primeFactorization(number1) primeFac2 = primeFactorization(number2) - + elif number1 == 1 or number2 == 1: - + primeFac1 = [] primeFac2 = [] ans = max(number1,number2) - + count1 = 0 count2 = 0 - + done = [] # captured numbers int both 'primeFac1' and 'primeFac2' - + # iterates through primeFac1 for n in primeFac1: - + if n not in done: - + if n in primeFac2: - + count1 = primeFac1.count(n) count2 = primeFac2.count(n) - + for i in range(max(count1,count2)): ans *= n - + else: - + count1 = primeFac1.count(n) - + for i in range(count1): ans *= n - + done.append(n) - + # iterates through primeFac2 for n in primeFac2: - + if n not in done: - + count2 = primeFac2.count(n) - + for i in range(count2): ans *= n - + done.append(n) - + # precondition assert isinstance(ans,int) and (ans >= 0), \ - "'ans' must been from type int and positive" - + "'ans' must been from type int and positive" + return ans - + # ---------------------------------- - + def getPrime(n): """ Gets the n-th prime number. input: positive integer 'n' >= 0 returns the n-th prime number, beginning at index 0 """ - + # precondition assert isinstance(n,int) and (n >= 0), "'number' must been a positive int" - + index = 0 ans = 2 # this variable holds the answer - + while index < n: - + index += 1 - - ans += 1 # counts to the next number - + + ans += 1 # counts to the next number + # if ans not prime then - # runs to the next prime number. + # runs to the next prime number. while not isPrime(ans): ans += 1 - + # precondition assert isinstance(ans,int) and isPrime(ans), \ - "'ans' must been a prime number and from type int" - + "'ans' must been a prime number and from type int" + return ans - + # --------------------------------------------------- - + def getPrimesBetween(pNumber1, pNumber2): """ input: prime numbers 'pNumber1' and 'pNumber2' pNumber1 < pNumber2 returns a list of all prime numbers between 'pNumber1' (exclusiv) - and 'pNumber2' (exclusiv) + and 'pNumber2' (exclusiv) """ - + # precondition assert isPrime(pNumber1) and isPrime(pNumber2) and (pNumber1 < pNumber2), \ "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'" - + number = pNumber1 + 1 # jump to the next number - + ans = [] # this list will be returns. - + # if number is not prime then - # fetch the next prime number. + # fetch the next prime number. while not isPrime(number): number += 1 - + while number < pNumber2: - + ans.append(number) - + number += 1 - - # fetch the next prime number. + + # fetch the next prime number. while not isPrime(number): number += 1 - + # precondition assert isinstance(ans,list) and ans[0] != pNumber1 \ and ans[len(ans)-1] != pNumber2, \ "'ans' must been a list without the arguments" - + # 'ans' contains not 'pNumber1' and 'pNumber2' ! return ans - + # ---------------------------------------------------- def getDivisors(n): @@ -493,25 +493,23 @@ def getDivisors(n): input: positive integer 'n' >= 1 returns all divisors of n (inclusive 1 and 'n') """ - + # precondition assert isinstance(n,int) and (n >= 1), "'n' must been int and >= 1" - from math import sqrt - ans = [] # will be returned. - + for divisor in range(1,n+1): - + if n % divisor == 0: ans.append(divisor) - - + + #precondition assert ans[0] == 1 and ans[len(ans)-1] == n, \ "Error in function getDivisiors(...)" - - + + return ans @@ -523,18 +521,18 @@ def isPerfectNumber(number): input: positive integer 'number' > 1 returns true if 'number' is a perfect number otherwise false. """ - + # precondition assert isinstance(number,int) and (number > 1), \ "'number' must been an int and >= 1" - + divisors = getDivisors(number) - + # precondition assert isinstance(divisors,list) and(divisors[0] == 1) and \ (divisors[len(divisors)-1] == number), \ "Error in help-function getDivisiors(...)" - + # summed all divisors up to 'number' (exclusive), hence [:-1] return sum(divisors[:-1]) == number @@ -545,13 +543,13 @@ def simplifyFraction(numerator, denominator): input: two integer 'numerator' and 'denominator' assumes: 'denominator' != 0 returns: a tuple with simplify numerator and denominator. - """ - + """ + # precondition assert isinstance(numerator, int) and isinstance(denominator,int) \ and (denominator != 0), \ "The arguments must been from type int and 'denominator' != 0" - + # build the greatest common divisor of numerator and denominator. gcdOfFraction = gcd(abs(numerator), abs(denominator)) @@ -559,46 +557,46 @@ def simplifyFraction(numerator, denominator): assert isinstance(gcdOfFraction, int) and (numerator % gcdOfFraction == 0) \ and (denominator % gcdOfFraction == 0), \ "Error in function gcd(...,...)" - + return (numerator // gcdOfFraction, denominator // gcdOfFraction) - + # ----------------------------------------------------------------- - + def factorial(n): """ input: positive integer 'n' returns the factorial of 'n' (n!) """ - + # precondition assert isinstance(n,int) and (n >= 0), "'n' must been a int and >= 0" - + ans = 1 # this will be return. - + for factor in range(1,n+1): ans *= factor - + return ans - + # ------------------------------------------------------------------- - + def fib(n): """ input: positive integer 'n' returns the n-th fibonacci term , indexing by 0 - """ - + """ + # precondition assert isinstance(n, int) and (n >= 0), "'n' must been an int and >= 0" - + tmp = 0 fib1 = 1 ans = 1 # this will be return - + for i in range(n-1): - + tmp = ans ans += fib1 fib1 = tmp - + return ans diff --git a/project_euler/problem_13/sol1.py b/project_euler/problem_13/sol1.py index 983347675..e36065ec8 100644 --- a/project_euler/problem_13/sol1.py +++ b/project_euler/problem_13/sol1.py @@ -3,18 +3,12 @@ Problem Statement: Work out the first ten digits of the sum of the following one-hundred 50-digit numbers. """ -from __future__ import print_function -import os - -try: - raw_input # Python 2 -except NameError: - raw_input = input # Python 3 def solution(array): """Returns the first ten digits of the sum of the array elements. - + + >>> import os >>> sum = 0 >>> array = [] >>> with open(os.path.dirname(__file__) + "/num.txt","r") as f: