PyClasses/Algorithms.py

#Python/myClasses/Algorithms.py
#Matthew Ellison
# Created: 01-27-19
#Modified: 02-09-19
#This is a file that contains a few algorithms that I have used several times

import math

#This function returns a list with all the prime numbers <= goalNumber
def getPrimes(goalNumber: int):
	primes = []
	foundFactor = False

	#If the number is 0 or negative return an empty list
	if(goalNumber <= 1):
		return primes
	#Otherwise the number is at least 2, therefore 2 should be added to the list
	else:
		primes.append(2)

	#We can now start at 3 and skip all even numbers, because they cannot be prime
	for possiblePrime in range(3, goalNumber + 1, 2): #Need goalNumber + 1 to account for goalNumber being prime
		#Check all current primes, up to sqrt(possiblePrime), to see if there is a divisor
		primesCnt = 0
		#We can safely assume that there will at lease be 1 element in the primes list because of 2 being added before the loop
		topPossibleFactor = math.ceil(math.sqrt(possiblePrime))
		while(primes[primesCnt] <= topPossibleFactor):
			if((possiblePrime % primes[primesCnt]) == 0):
				foundFactor = True
				break
			else:
				primesCnt += 1
			#Check if the index has gone out of range
			if(primesCnt >= len(primes)):
				break
	
		#If you didn't find a factor then the current number must be prime
		if(not foundFactor):
			primes.append(possiblePrime)
		else:
			foundFactor = False

	primes.sort()
	return primes

#This function gets a certain number of primes
def getNumPrimes(numberOfPrimes: int):
	primes = []
	foundFactor = False

	#If the number is 0 or negative return an empty list
	if(numberOfPrimes < 1):
		return primes
	#Otherwise there is at lease 1, meaning 2 will be the first entry
	else:
		primes.append(2)

	#Loop through every odd number starting at 3 until you reach the correct number of entries looking for a prime number
	possiblePrime = 3	#Holds the next possible prime number
	while((len(primes) < numberOfPrimes) and (possiblePrime > 0)):
		#Loop through all primes we have already found, up to sqrt(possiblePrime), checking for a factor
		primesCnt = 0
		#We can safely assume that there will at lease be 1 element in the primes list because of 2 being added before the loop
		topPossibleFactor = math.ceil(math.sqrt(possiblePrime))
		while(primes[primesCnt] <= topPossibleFactor):
			#If you find a factor the number is not a prime so raise the flag and break the loop
			if((possiblePrime % primes[primesCnt]) == 0):
				foundFactor = True
				break
			else:
				primesCnt += 1
			#Check if the index has gone out of bounds and break the loop if it has
			if(primesCnt >= len(primes)):
				break

		#If you don't find a factor then this number is prime so add it to the list
		if(not foundFactor):
			primes.append(possiblePrime)
		#If it wasn't prime simply reset the flag
		else:
			foundFactor = False
		#Increment to the next possible prime number
		possiblePrime += 2

	#Everything should already be in order, but sort it just in case
	primes.sort()

	#Return the list with all the prime numbers
	return primes
	

#This is a function that returns all the factors of goalNumber
def getFactors(goalNumber: int):
	#You need to get all the primes up to this number
	primes = getPrimes(math.ceil(math.sqrt(goalNumber)))	#If there is a prime it must be <= sqrt(num)
	factors = []

	#You need to step through each prime and see if it is a factor in the number
	cnt = 0
	while((cnt < len(primes)) and (goalNumber > 1)):
		#If the prime is a factor you need to add it to the factor list
		if((goalNumber % primes[cnt]) == 0):
			factors.append(primes[cnt])
			goalNumber /= primes[cnt]
		#Otherwise advance the location in primes you are looking at
		#By not advancing if the prime is a factor you allow for multiple of the same prime number as a factor
		else:
			cnt += 1

	#If you didn't get any factors the number itself must be a prime
	if(len(factors) == 0):
		factors.append(goalNumber)
		goalNumber /= goalNumber

	#If for some reason the goalNumber is not 0 print an error message
	if(goalNumber > 1):
		print("There was an error in getFactors(). A leftover of " + str(goalNumber))
	
	#Return the list of factors
	return factors

#This function returns all the divisors of goalNumber
def getDivisors(goalNumber: int) -> list:
	divisors = []
	#Start by checking that the number is positive
	if(goalNumber <= 0):
		return divisors
	#If the number is 1 return just itself
	elif(goalNumber == 1):
		divisors.append(1)
	#Otherwise add 1 and itself to the list
	else:
		divisors.append(1)
		divisors.append(goalNumber)

	#Start at 3 and loop through all numbers < (goalNumber / 2 ) looking for a number that divides it evenly
	topPossibleDivisor = math.ceil(math.sqrt(goalNumber))
	for possibleDivisor in range(2, topPossibleDivisor + 1):		#Add one because we need <= goalNumber/2
		#If you find one add it and the number it creates to the list
		if((goalNumber % possibleDivisor) == 0):
			divisors.append(possibleDivisor)
			#Account for the possibility sqrt(goalNumber) being a divisor
			if(possibleDivisor != topPossibleDivisor):
				divisors.append(goalNumber / possibleDivisor)

	#Sort the list before returning for neatness
	divisors.sort()
	#Return the list
	return divisors

#This function returns the numth Fibonacci number
def getFib(goalSubscript: int) -> int:
	#Setup the variables
	fibNums = [1, 1, 0]	#A list to keep track of the Fibonacci numbers. It need only be 3 long because we only need the one we are working on and the last 2

	#If the number is <= 0 return 0
	if(goalSubscript <= 0):
		return 0

	#Loop through the list, generating Fibonacci numbers until it finds the correct subscript
	fibLoc = 2
	while(fibLoc < goalSubscript):
		fibNums[fibLoc % 3] = fibNums[(fibLoc - 1) % 3] + fibNums[(fibLoc - 2) % 3]
		fibLoc += 1

	#Return the propper number. The location counter is 1 off of the subscript
	return fibNums[(fibLoc - 1) % 3]

#This function returns a list of all Fibonacci numbers <= num
def getAllFib(goalNumber: int) -> list:
	#Setup the variables
	fibNums = []	#A list to save the Fibonacci numbers

	#If the number is <= 0 return an empty list
	if(goalNumber <= 0):
		return fibNums

	#This means that at least 2 1's are elements
	fibNums.append(1)
	fibNums.append(1)

	#Loop to generate the rest of the Fibonacci numbers
	while(fibNums[len(fibNums) - 1] <= goalNumber):
		fibNums.append(fibNums[len(fibNums) - 1] + fibNums[len(fibNums) - 2])

	#At this point the most recent number is > goalNumber, so remove it
	fibNums.pop()
	return fibNums

#This function returns the product of all elements in the list
def prod(nums: list) -> int:
	#Setup the variables
	product = 1		#Start at 1 because of working with multiplication

	#Loop through every element in a list and multiply them together
	for num in nums:
		product *= num

	#Return the product of all elements
	return product