Example #1
0
 def test_if_default_1_default_then_it_must_return_11(self):
     """
     No number of terms and second term given but first term is provided
     :return:
     """
     expected = [1, 1]
     actual = leonhard.generate_fibonacci_sequence(first_term=1)
     self.assertEqual(expected, actual)
Example #2
0
 def test_if_default_default_4_then_it_must_return_04(self):
     """
     No number of terms and first term given but second term is provided
     :return:
     """
     expected = [0, 4]
     actual = leonhard.generate_fibonacci_sequence(second_term=4)
     self.assertEqual(expected, actual)
Example #3
0
 def test_if_default_2_4_then_it_must_return_24(self):
     """
     No number of terms is given but first and second terms are provided
     :return:
     """
     expected = [2, 4]
     actual = leonhard.generate_fibonacci_sequence(first_term=2,
                                                   second_term=4)
     self.assertEqual(expected, actual)
Example #4
0
 def test_456_then_it_must_return_561117(self):
     """
     number_of_terms: 4
     first_term: 5
     second_term: 6
     :return:
     """
     expected = [5, 6, 11, 17]
     actual = leonhard.generate_fibonacci_sequence(4, 5, 6)
     self.assertEqual(expected, actual)
Example #5
0
 def test_811_then_it_must_return_1123581321(self):
     """
     number_of_terms: 8
     first_term: 1
     second_term: 1
     :return:
     """
     expected = [1, 1, 2, 3, 5, 8, 13, 21]
     actual = leonhard.generate_fibonacci_sequence(8, 1, 1)
     self.assertEqual(expected, actual)
Example #6
0
import itertools
from leonhard.leonhard import generate_fibonacci_sequence

for i in itertools.count(2):
    sequence = generate_fibonacci_sequence(i)
    x = max(sequence)
    if len(str(x)) == 1000:
        print(sequence.index(x))
        break
Example #7
0
 def test_if_number_of_terms_is_8_then_it_must_return_011235813(self):
     expected = [0, 1, 1, 2, 3, 5, 8, 13]
     actual = leonhard.generate_fibonacci_sequence(8)
     self.assertEqual(expected, actual)
Example #8
0
 def test_if_number_of_terms_is_3_then_it_must_return_011(self):
     expected = [0, 1, 1]
     actual = leonhard.generate_fibonacci_sequence(3)
     self.assertEqual(expected, actual)
Example #9
0
 def test_if_no_parameters_are_passed_then_it_must_return_01(self):
     expected = [0, 1]
     actual = leonhard.generate_fibonacci_sequence()
     self.assertEqual(expected, actual)
Example #10
0
 def test_if_second_term_is_not_integer_then_it_must_raise_a_type_error(
         self):
     with self.assertRaises(TypeError):
         leonhard.generate_fibonacci_sequence(2, 0, "a")
Example #11
0
 def test_if_first_term_is_provided_and_no_second_term_then_it_must_be_less_than_1(
         self):
     with self.assertRaises(ValueError):
         leonhard.generate_fibonacci_sequence(2, 5)
Example #12
0
 def test_if_second_term_is_less_than_first_then_it_must_raise_a_value_error(
         self):
     with self.assertRaises(ValueError):
         leonhard.generate_fibonacci_sequence(2, 1, 0)
Example #13
0
 def test_if_number_of_terms_is_less_than_2_then_it_must_raise_a_value_error(
         self):
     with self.assertRaises(ValueError):
         leonhard.generate_fibonacci_sequence(1)
Example #14
0
from leonhard import leonhard

# Get the factors of 10
# [1, 2, 5, 10]
print(leonhard.get_factors_of_positive_integer(10))

# Default fibonacci sequence
# Two terms, starting with 0 and 1
# [0, 1]
print(leonhard.generate_fibonacci_sequence())

# Fibonacci sequence with 5 terms, starting with 0 and 1
# [0, 1, 1, 2, 3]
print(leonhard.generate_fibonacci_sequence(5))

# Fibonacci sequence with 5 terms, starting with 3 and 6
# [3, 6, 9, 15, 24]
print(leonhard.generate_fibonacci_sequence(5, 3, 6))

# 600851475143 is not prime
print(leonhard.is_prime(600851475143))

# 7652413 is prime
print(leonhard.is_prime(7652413))

# Is a Pythagorean triplet
print(leonhard.is_pythagorean_triplet(3, 4, 5))

# Is not a Pythagorean triplet
print(leonhard.is_pythagorean_triplet(1, 2, 3))