def solve(max_fib=int(4e6)):
#Fibonacci sequence
F = np.zeros(np.ceil(np.log(np.sqrt(5)*max_fib) / np.log(golden)),
dtype='int64')
fibonacci(F)
return F[F < int(4e6)][::3].sum()
def testFileoutput(self):
arguments = [0, 4]
correctResult = "1,1,2,3"
fibonacci(arguments)
with open('fib_sequence.txt', "r") as file:
content = file.read()
file.close()
self.assertEqual(correctResult, content)
def test_values(self):
"""
high level support for doing this and that.
"""
#self.assertAlmostEqual(fibonacci(83), [99194853094755497,True])
self.assertEqual(fibonacci(43), [433494437, True])
self.assertEqual(fibonacci(29), [514229, True])
self.assertEqual(fibonacci(0), [0, False])
def test_fibonacci():
# Special Cases
assert f.fibonacci(0) == 0
assert f.fibonacci(1) == 1
# Normal Cases
assert f.fibonacci(2) == 1
assert f.fibonacci(6) == 8
assert f.fibonacci(9) == 34
def test_fibonacci(): """ In this function we import fibonacci.py and test the function inside it against known values""" import fibonacci as fb assert fb.fibonacci(10) == 55 assert fb.fibonacci(5) == 5
def test_fibonacci():
"""
In this function we import fibonacci.py
and test the function inside it against
known values"""
import fibonacci as fb
assert fb.fibonacci(10) == 55
assert fb.fibonacci(5) == 5
def test_fibonacci(self):
# Test valid length input and verify result
self.assertEqual(fibonacci.fibonacci(0), [])
self.assertEqual(fibonacci.fibonacci(1), [0])
self.assertEqual(fibonacci.fibonacci(2), [0, 1])
self.assertEqual(fibonacci.fibonacci(5), [0, 1, 1, 2, 3])
self.assertEqual(fibonacci.fibonacci(10), [0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
# Test negative length input and expect exception
self.assertRaises(Exception, fibonacci.fibonacci, -4)
def test_fibonacci(self):
# Test valid length input and verify result
self.assertEqual(fibonacci.fibonacci(0), [])
self.assertEqual(fibonacci.fibonacci(1), [0])
self.assertEqual(fibonacci.fibonacci(2), [0,1])
self.assertEqual(fibonacci.fibonacci(5), [0,1,1,2,3])
self.assertEqual(fibonacci.fibonacci(10), [0,1,1,2,3,5,8,13,21,34])
# Test negative length input and expect exception
self.assertRaises(Exception, fibonacci.fibonacci, -4)
def even_fibs(value):
s = 0
i = 1
current_fib = fibonacci(i)
while current_fib < value:
if current_fib % 2 == 0:
s += current_fib
current_fib = fibonacci(i)
i += 1
print(s)
def test_fib(self):
"fibonacci sequence"
expected = np.array([0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89,
144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946,
17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229,
832040, 1346269, 2178309, 3524578, 5702887, 9227465,
14930352, 24157817, 39088169], dtype='int64')
F = np.zeros(expected.shape[0], dtype='int64')
fibonacci(F)
self.assert_((F == expected).all())
def test_fibonacciNumbers(self):
testResults = [
fibonacci.fibonacci(),
fibonacci.fibonacci(10, -1),
fibonacci.fibonacci(10, 50),
fibonacci.fibonacci(5, 5)
]
trueFibonacci = [[0, 1, 1, 2, 3, 5, 8, 13, 21, 34],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34],
[55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181],
[8, 13, 21, 34, 55]]
self.assertEqual(testResults, trueFibonacci)
def test_fibonacci(self):
self.assertAlmostEqual(fibonacci(1), 1)
self.assertAlmostEqual(fibonacci(2), 1)
self.assertAlmostEqual(fibonacci(3), 2)
self.assertAlmostEqual(fibonacci(4), 3)
self.assertAlmostEqual(fibonacci(5), 5)
self.assertAlmostEqual(fibonacci(6), 8)
self.assertAlmostEqual(fibonacci(7), 13)
self.assertAlmostEqual(fibonacci(8), 21)
self.assertAlmostEqual(fibonacci(40), 102334155)
infinity = float('inf')
self.assertAlmostEqual(fibonacci(infinity), infinity)
def test_faultyInputs(self):
testResults = [
fibonacci.fibonacci(),
fibonacci.fibonacci("x", "x"),
fibonacci.fibonacci(True, False),
fibonacci.fibonacci("aaaa"),
fibonacci.fibonacci(None, "eeeee")
]
expectedResults = [[0, 1, 1, 2, 3, 5, 8, 13, 21, 34],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]]
self.assertEqual(testResults, expectedResults)
def test_challenge4(self):
number = 10
fib_number = fibonacci(number)
print(str(fib_number) + " - " + num2words(fib_number))
# print(fibonacci(number))
print(numbers_into_words(fib_number))
def fib_list(max_index_num):
nacci = []
for index in range(max_index_num + 1):
value = fibonacci(index)
print "Fibonacci of", index, "is", value
nacci.append(value)
return nacci
def produce_model() -> None:
'''Building a Deep learning model for (index -> even Fibonacci number) predictions.
'''
#######
# Dataset
#######
full_fib_series = np.array(fibonacci(end=1000))
even_fib_series = np.array(full_fib_series[full_fib_series % 2 == 0],
dtype=np.float64)
DATASET_SIZE = 10000
# Output variable - even Fibonacci number
y_values = np.random.choice(even_fib_series, DATASET_SIZE)
# Input variable - index of y
x_values = np.empty(DATASET_SIZE, dtype=int)
for i in range(DATASET_SIZE):
x_values[i] = np.argwhere(even_fib_series == y_values[i])[0]
# Split dataset
TRAIN_SUBSET_SIZE = int(0.6 * DATASET_SIZE)
TEST_SUBSET_SIZE = int(0.2 * DATASET_SIZE + TRAIN_SUBSET_SIZE)
x_train, x_validation, x_test = np.split(
x_values, [TRAIN_SUBSET_SIZE, TEST_SUBSET_SIZE])
y_train, y_validation, y_test = np.split(
y_values, [TRAIN_SUBSET_SIZE, TEST_SUBSET_SIZE])
#######
# Model
#######
fmodel = FibonacciModel()
fmodel.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
training_results = fmodel.fit(x_train,
y_train,
validation_data=(x_validation, y_validation),
epochs=20,
batch_size=8,
verbose=2,
shuffle=True)
print('TRAIN {mae: %.2f}, {loss: %.2f}' %
(training_results.history['mae'][-1] * 100,
training_results.history['loss'][-1]))
print('VALID {mae: %.2f}, {loss: %.2f}\n' %
(training_results.history['val_mae'][-1] * 100,
training_results.history['val_loss'][-1]))
test_results = fmodel.evaluate(x_test, y_test)
print("TEST {%s: %.2f}, {loss: %.2f}\n" %
(fmodel.metrics_names[1], test_results[1] * 100, test_results[0]))
fmodel.summary()
try:
fmodel.save("fibmodel")
except IOError as e:
print("IOError: ", str(e))
def test_factorial(self):
a = [random.randint(1, 30) for _ in range(5)]
ans = _("The {}th fibonacci number is {} and you returned {}.")
for i in range(len(a)):
stu_ans = fibonacci.fibonacci(a[i])
corr_ans = corr.fibonacci(a[i])
self.assertEqual(corr_ans, stu_ans,
ans.format(a[i], corr_ans, stu_ans))
def test_fibonacci():
""" Checks Fibonacci functionality. """
assert hasattr(testfile, "fibonacci"), "Your Script must have an 'fibonacci'-function!"
assert testfile.fibonacci(0) == 0
assert testfile.fibonacci(1) == 1
assert testfile.fibonacci(2) == 1
assert testfile.fibonacci(3) == 2
assert testfile.fibonacci(6) == 8
assert testfile.fibonacci(10) == 55
assert testfile.fibonacci(12) == 144
assert testfile.fibonacci(20) == 6765
assert testfile.fibonacci(30) == 832040
def test_fibonacci(self):
self.assertEqual(fibonacci(1), 1)
self.assertEqual(fibonacci(5), 5)
self.assertEqual(fibonacci(11), 89)
with self.assertRaises(TypeError):
fibonacci(0.1)
fibonacci("s")
def main():
n = -1
while (n <= 0):
n = int(input("\n\tFibonacci Number to Calculate: "))
# fibonacci ( n ): Return the fibonacci number, the counter that takes to
# find that number, and a list of the fibonacci numbers before 'fibo'.
fibo, count, f = fibonacci(n)
print("\n\tFibonacci ( ", n, " ): ", fibo, "\n")
graph(count, fibo, f, n)
def findfib():
""" This function returns the first Fibonacci number that has a digit sum higher than 42. """
# delete the line below this and insert your own code
for num in range(1, 1000):
fib_num = fibonacci(num)
if digsum(fib_num) > 42:
return fib_num
break
def test_FIB(self):
self.assertEqual(fibonacci(0), 0)
self.assertEqual(fibonacci(1), 1)
self.assertEqual(fibonacci(2), 1)
self.assertEqual(fibonacci(3), 2)
self.assertEqual(fibonacci(4), 3)
self.assertEqual(fibonacci(5), 5)
self.assertEqual(fibonacci(6), 8)
def test_FIB(self):
self.assertEqual(fibonacci(0), 0)
self.assertEqual(fibonacci(1), 1)
self.assertEqual(fibonacci(2), 1)
self.assertEqual(fibonacci(3), 2)
self.assertEqual(fibonacci(4), 3)
self.assertEqual(fibonacci(5), 5)
self.assertEqual(fibonacci(6), 8)
def test_fibonacci_prime():
N = 10000
F = list(fibonacci(N))
nFP = [3, 4, 5, 7, 11, 13, 17, 23, 29, 43]
our_list = fibonacci_primes(N)
known_list = set([F[n] for n in nFP if n < len(F)])
assert len(known_list.difference(our_list)) == 0, 'We have a bug!'
print('Passed test!')
def main():
n = -1
while (n <= 0):
n = int(input("\n\tFibonacci Number to Calculate: "))
# fibonacci (n): devuelve el número de fibonacci, el contador que lleva a
# encuentrar ese número y una lista de los números de fibonacci antes de 'fibo'.
fibo, count, f = fibonacci(n)
print(f)
print("\n\tFibonacci ( ", n, " ): ", fibo, "\n")
graph(count, fibo, f, n)
def main():
n, parameters = -1, []
while (n <= 0):
n = int(input("\n\tFibonacci Number to Calculate: "))
# fibonacci ( n ): Return a list of tuples with the Fibonacci numbers
# and the Computational Time of the Algorithm [ ( F ( n ), T ( n ) ) ].
for i in range(1, n + 1):
parameters.append(fibonacci(i, 0))
print("\n\tFibonacci ( ", n, " ): ", parameters[len(parameters) - 1][0],
"\n")
graph(parameters[len(parameters) - 1], parameters, n)
def findfib():
""" This function returns the first Fibonacci number that has a digit sum higher than 42. """
n = 0
# I know its kind of messy
while True:
fibo = fibonacci(n)
if digsum(fibo) >= 42:
return fibo
n += 1
def main():
"""Run examples for the fibonacci generator"""
# Make a new fibonacci generator
f = fibonacci()
# Get the first five values from the generator
print("First five values of the fibonacci sequence")
print(list(islice(f, 5)))
print()
# Get the next five values from the generator
print("Next five values of the fibonacci sequence")
print(list(islice(f, 5)))
print()
# Recreate generator to start at beginning again
f = fibonacci()
# Multiply sequence by 5
# This is computed "lazily." This means that the multiplication
# will only occur when a value is requested from the generator
m = map(lambda x: x * 5, f)
print("Get first five values multiplied by 5")
print(list(islice(m, 5)))
print()
print("Get the next five values multiplied by 5")
print(list(islice(m, 5)))
print()
# Make sequence of only even numbers
# This also occurs lazily
f = filter(lambda x: x % 2 == 0, fibonacci())
print("Get first five even values")
print(list(islice(f, 5)))
print()
def test_not_integer(self):
with self.assertRaises(FibonacciError):
fibonacci(1.5)
with self.assertRaises(FibonacciError):
fibonacci('abc')
with self.assertRaises(FibonacciError):
fibonacci(None)
def post(self):
if not(flask.request.form["expression"].isdigit()):
result = "Please enter a positive integer."
flask.flash(result)
return self.get()
if not xml:
result = str(fibonacci(flask.request.form["expression"]))
flask.flash(result)
return self.get()
if xml:
result = str(fibonacci_xml_response(flask.request.form["expression"]))
flask.flash(result)
#return self.get()
return self.xml_response(result)
def test_fibonacci(self):
fib_values = {
0: 0,
1: 1,
2: 1,
3: 2,
10: 55,
17: 1597,
43: 433494437,
100: 354224848179261915075,
239: 39679027332006820581608740953902289877834488152161,
589: 554926040554257829308125788274680482815955849738659889938144313725789769599132698259438063468312512862179152906263350659689
}
for fibonacci_n, expected_fib in fib_values.items():
self.assertEqual(fibonacci(fibonacci_n), expected_fib)
def main():
n, parameters = -1, []
while (n <= 0):
n = int(input("\n\tFibonacci Number to Calculate: "))
# fibonacci (n): devuelve una lista de tuplas con los números de Fibonacci
# y el tiempo computacional del algoritmo [(F (n), T (n))].
for i in range(1, n + 1):
parameters.append(fibonacci(i, 0))
#va imprimiendo cada dupla de numeros fibonacci en la lista en cada iteracion del ciclo
print("\t", parameters)
print("\n\tFibonacci ( ", n, " ): ", parameters[len(parameters) - 1][0],
"\n")
# Imprime los números fibonacci guardados en la lista
print(len(parameters))
# Crea la gráfia con los parametros creados.
graph(parameters[len(parameters) - 1], parameters, n)
def test_fibonacci():
"""Test the fibonacci function (generator version)."""
with pytest.raises(ValueError):
fibonacci(-1)
assert fibonacci(0) == 0
assert fibonacci(8) == 21
assert fibonacci(64) == 10610209857723
# pylint: disable=line-too-long
assert fibonacci(
4096
) == 4612001732280431247456445708563614127173224997617390534215059226137357133453956236072775985077061637311848907129417864574275423997101439882308358166652317363373656716074141072814493065517475413688262677419077617088948496309673353922704120725679705669386361748442871720790233981292904246541321855474289727005675146240418903692583131115962989146454578739972233255840007113102596686397958930124518885822059783685448190039658062872691964066428723178769322339485834664335313247796472730324095846596733944704930052412653763777113749102514483039561246866695780115646150369678333299122486379683222039167477498691611996122878629556831081616202064636498715093853352203252703786287926199052408354498825123496861419106453928530148716831934981264321286848387438601077819789292236505514653845305057927646386419899455438488952785050077521931600327064840520442470066917947
def test_challenge4(self):
number = fibonacci(5)
print(f'{number} - {p.number_to_words(number)}')
number = fibonacci(10)
print(f'{number} - {p.number_to_words(number)}')
number = fibonacci(15)
print(f'{number} - {p.number_to_words(number)}')
number = fibonacci(20)
print(f'{number} - {p.number_to_words(number)}')
number = fibonacci(25)
print(f'{number} - {p.number_to_words(number)}')
number = fibonacci(30)
print(f'{number} - {p.number_to_words(number)}')
number = fibonacci(35)
print(f'{number} - {p.number_to_words(number)}')
def goldenratio_sequence(n):
"""
This function calculates the golden ratios between the numbers in the
fibonacci sequence.
The argument that it takes is the number of fibonacci numbers that want
to be used to estimate the golden ratio
The length of the list returned is 2 less than the number of fibonacci
numbers used
"""
fibList = fibonacci(n)
goldenRatio = []
for count in range(1, n - 1):
# Adding each of the new ratios to the end of the golden ratio list
goldenRatio.append(fibList[count + 1] / fibList[count])
return goldenRatio
def test_fibonacci_no_recursive(self):
# Test valid length input and verify result
self.assertEqual(fibonacci.fibonacci_non_recursive(0), [])
self.assertEqual(fibonacci.fibonacci_non_recursive(1), [0])
self.assertEqual(fibonacci.fibonacci_non_recursive(2), [0, 1])
self.assertEqual(fibonacci.fibonacci_non_recursive(5), [0, 1, 1, 2, 3])
self.assertEqual(fibonacci.fibonacci_non_recursive(10), [0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
# Test a long length input and verify the results between
# fibonacci.ibonacci_non_recursive(length) and fibonacci.fibonacci(length)
self.assertEqual(fibonacci.fibonacci_non_recursive(150), fibonacci.fibonacci(150))
# Test the result when base sequence input is specified
self.assertEqual(fibonacci.fibonacci_non_recursive(10), fibonacci.fibonacci_non_recursive(10, [0, 1, 1, 2, 3]))
self.assertEqual(
fibonacci.fibonacci_non_recursive(200),
fibonacci.fibonacci_non_recursive(200, fibonacci.fibonacci_non_recursive(100)),
)
# Test negative length input and expect exception
self.assertRaises(Exception, fibonacci.fibonacci_non_recursive, -2)
def test_fibonacci_no_recursive(self):
# Test valid length input and verify result
self.assertEqual(fibonacci.fibonacci_non_recursive(0), [])
self.assertEqual(fibonacci.fibonacci_non_recursive(1), [0])
self.assertEqual(fibonacci.fibonacci_non_recursive(2), [0,1])
self.assertEqual(fibonacci.fibonacci_non_recursive(5), [0,1,1,2,3])
self.assertEqual(fibonacci.fibonacci_non_recursive(10), [0,1,1,2,3,5,8,13,21,34])
# Test a long length input and verify the results between
# fibonacci.ibonacci_non_recursive(length) and fibonacci.fibonacci(length)
self.assertEqual(fibonacci.fibonacci_non_recursive(150),
fibonacci.fibonacci(150))
# Test the result when base sequence input is specified
self.assertEqual(fibonacci.fibonacci_non_recursive(10),
fibonacci.fibonacci_non_recursive(10, [0,1,1,2,3]))
self.assertEqual(fibonacci.fibonacci_non_recursive(200),
fibonacci.fibonacci_non_recursive(200, fibonacci.fibonacci_non_recursive(100)))
# Test negative length input and expect exception
self.assertRaises(Exception, fibonacci.fibonacci_non_recursive, -2)
def test_one():
assert fibonacci(1) == [1]
def test_two():
assert fibonacci(2) == [1,1]
def test_n():
for n in range (10,25):
assert len(fibonacci(n)) == n
def test_less_than_one():
assert fibonacci(0) == []
def test_fib_known_value(self):
"""fibonacci should return known value from known input list."""
for i in range(0, len(self.known_fibs)):
result = fibonacci.fibonacci(i)
self.assertEqual(self.known_fibs[i], result)
def test_finonacci_demais_resultados(self): self.assertEqual(fibonacci(3), 2) self.assertEqual(fibonacci(7), 13)
def test_fib():
import fibonacci as fb
assert fb.fibonacci(10)==55
assert fb.fibonacci(5) == 5
def test_fibonacci0(self): """ Test fibonacci(0). """ self.assertEqual(0, fibonacci(0))
def test_fibonacci(self):
for case in self.test_cases:
n = case[0]
a = case[1]
self.assertEqual(fibonacci.fibonacci(n),a)
def test_3(self): self.assertEqual(fibonacci.fibonacci(3), [0,1,1])
def test_fibonacci3(self): """ Test fibonacci(3). """ self.assertEqual(2, fibonacci(3))
def test_fibonacci2(self): """ Test fibonacci(2). """ self.assertEqual(1, fibonacci(2))
def test_fibonacci1(self): """ Test fibonacci(1). """ self.assertEqual(1, fibonacci(1))
def test_fibonacci(self):
self.assertEqual(0, fibonacci(0), "fibonacci(0) should equal 0")
self.assertEqual(1, fibonacci(1), "fibonacci(1) should equal 1")
self.assertEqual(1, fibonacci(2), "fibonacci(2) should equal 1")
self.assertEqual(2, fibonacci(3), "fibonacci(3) should equal 2")
self.assertEqual(3, fibonacci(4), "fibonacci(4) should equal 3")
def test_fibonacci_of_zero(self): self.assertEqual(fibonacci(0), 0)
def test_1(self): self.assertEqual(fibonacci.fibonacci(1), [0])
F_6 = 8
F_7 = 13
F_8 = 21
F_9 = 34
F_10 = 55
F_11 = 89
F_12 = 144
The 12th term, F12, is the first term to contain three digits.
What is the index of the first term in the Fibonacci sequence to contain 1000
digits?
'''
from sys import argv
from fibonacci import fibonacci
if __name__ == '__main__':
try:
digits = int(argv[1])
except IndexError:
digits = 1000
goal = 10 ** (digits - 1)
for i, f in enumerate(fibonacci(), 1):
if f >= goal:
print(i)
break
#!/usr/bin/python
from swampy.TurtleWorld import *
from fibonacci import fibonacci
world = TurtleWorld()
bob = Turtle()
print bob
for i in range(20):
fd(bob, fibonacci(i))
lt(bob, 90)
def test_2(self): self.assertEqual(fibonacci.fibonacci(2), [0,1])
while True:
r = fibo.next()[-9:]
k += 1
if k == 541:
print r
print 'trololo'
print 'lala', pandigital.is_pandigital(r)
if len(str(r)) < 9:
continue
s = str(r)
if k % 1000 == 0:
print k
if pandigital.is_pandigital(s):
f = str(fibonacci.fibonacci(k))
print k, s, f[0:9]
if pandigital.is_pandigital(f[0:9]):
print r
print
print f[0:9]
print f[-9:]
print
print k
break
#for i in range(3,2760):
#r = fibo.next()
#r1 = fibo1.next()
#if i == 2749:
#print i, r, r1, str(fibonacci.get_fibonacci(i)).replace('.','')[0:9]
def test_five():
assert fibonacci(5) == [1,1,2,3,5]
def test_fibonacci30(self): """ Test fibonacci(30). """ self.assertEqual(832040, fibonacci(30))
def test_fibonnacci_resultado_um(self): self.assertEqual(fibonacci(1), 1) self.assertEqual(fibonacci(2), 1)
