ex 011 to 020

Author: kiddopro

exercises/013-sum_of_digits/test.py

@@ -6,7 +6,7 @@ def test_for_functon_existence(capsys, app):
 
 @pytest.mark.it('The function must return something')
 def test_for_return(capsys, app):
-    assert app.digits_sum(123) == None
+    assert app.digits_sum(123) != None
 
 @pytest.mark.it('The function must return a number')
 def test_for_output_type(capsys, app):

exercises/014-digit_after_decimal_point/solution.hide.py

@@ -0,0 +1,10 @@
+#Complete the function to return the first digit to the right of the decimal point.
+import math
+def first_digit(num):
+  return int(str(math.floor(num*10)/10)[-1])
+  
+
+
+
+#Invoke the function with a positive real number. ex. 34.33
+print(first_digit(2.6))

exercises/014-digit_after_decimal_point/test.py

@@ -6,7 +6,7 @@ def test_for_functon_existence(capsys, app):
 
 @pytest.mark.it('The function must return something')
 def test_for_return(capsys, app):
-    assert app.first_digit(1.2) == None
+    assert app.first_digit(1.2) != None
 
 @pytest.mark.it('The function must return a number')
 def test_for_output_type(capsys, app):

exercises/015-car_route/README.es.md

@@ -9,7 +9,7 @@ Un vehículo puede cubrir una distancia de `N` kilómetros por día ¿Cuántos d
 ## Ejemplo de entrada:
 
 ```py
-car_route(700,750)
+car_route(20,40)
 ```
 
 ## Ejemplo de salida:

exercises/015-car_route/README.md

@@ -9,7 +9,7 @@ A car can cover distance of `N` kilometers per day. How many days will it take t
 ## Example input:
 
 ```py
-car_route(700)
+car_route(20,40)
 ```
 
 ## Example output:

exercises/015-car_route/solution.hide.py

@@ -0,0 +1,9 @@
+#Complete the function to return the amount of days it will take to cover a route.
+#HINT: You may need to import the math module for this exercise.
+import math
+def car_route(n,m):
+  return int(math.ceil(m/n))
+
+
+#Invoke the function with two intergers.
+print(car_route())

exercises/015-car_route/test.py

@@ -12,9 +12,21 @@ def test_import_random():
 def test_for_functon_existence(capsys, app):
     assert callable(app.car_route)
 
-@pytest.mark.it('We tried to pass 659 and 1857 as parameter and it did not return 3!')
+@pytest.mark.it('The function mus return something')
+def test_function_return(capsys, app):
+    assert app.car_route(659, 1857) != None
+
+@pytest.mark.it('The function must return a number')
+def test_function_return_type(capsys, app):
+    assert type(app.car_route(659, 1857)) == type(1)
+
+@pytest.mark.it('We tried to pass 20 and 40 as parameter and it did not return 2!')
 def test_for_file_output(capsys, app):
-    assert app.car_route(659, 1857) == math.ceil(1857 / 659)
+    assert app.car_route(20, 40) == 2
+
+@pytest.mark.it('We tried to pass 20 and 900 as parameter and it did not return 45!')
+def test_for_file_output2(capsys, app):
+    assert app.car_route(20, 900) == 45
 
 
 

exercises/016-century/solution.hide.py

@@ -0,0 +1,13 @@
+#Complete the function to return the respective number of the century
+#HINT: You may need to import the math module.
+import math
+def century(year):
+  if year % 100 == 0:
+    return math.floor(year/100) 
+  else:
+    return math.floor(year/100 +1)
+
+
+
+#Invoke the function with any given year. 
+print(century(2022))

exercises/016-century/test.py

@@ -13,10 +13,23 @@ def test_import_random():
 def test_for_functon_existence(capsys, app):
     assert callable(app.century)
 
-@pytest.mark.it('We tried to pass 1801 as parameter and it did not return 19!')
+@pytest.mark.it('The function must return something')
+def test_function_return(capsys, app):
+    assert app.century(19001) != None
+
+@pytest.mark.it('The function must return a number')
+def test_function_return_type(capsys, app):
+    assert type(app.century(19001)) == type(1)
+
+@pytest.mark.it('We tried to pass 2000 as parameter and it did not return 20!')
 def test_for_file_output(capsys, app):
-  if app.century(1801) % 100 == 0:
-    assert app.century(1801) == math.floor(1801/100) 
-  else:
-    assert app.century(1801) == math.floor(1801/100 +1)
+  assert app.century(2000) == 20
+
+@pytest.mark.it('We tried to pass 2000 as parameter and it did not return 21!')
+def test_for_file_output2(capsys, app):
+  assert app.century(2001) == 21
+
+@pytest.mark.it('We tried to pass 2000 as parameter and it did not return 21!')
+def test_for_file_output3(capsys, app):
+  assert app.century(2101) == 22
 

exercises/017-total_cost/solution.hide.py

@@ -0,0 +1,10 @@
+#Complete the function to return the total cost in dollars and cents of N cupcakes. 
+#Remember you can return multiple parameters => return a, b
+def total_cost(d,c,n):
+    return ((((d*100)+c)*n)//100, (((d*100)+c)*n)%100)
+    
+
+
+
+#Invoke the function with three intergers: cost(dollars and cents) & number of cupcakes.
+print(total_cost(15,22,4))

exercises/017-total_cost/test.py

@@ -6,8 +6,24 @@
 def test_for_functon_existence(capsys, app):
     assert callable(app.total_cost)
 
+@pytest.mark.it('The function must return something')
+def test_function_return(capsys, app):
+    assert app.total_cost(15, 22, 4) != None
+  
+@pytest.mark.it('The function must return a tuple')
+def test_function_return_type(capsys, app):
+    assert type(app.total_cost(15, 22, 4)) == type((60, 88))
+  
+@pytest.mark.it('The function must return a tuple of numbers')
+def test_function_return_type_parameters(capsys, app):
+    result = app.total_cost(15, 22, 4)
+    assert type(result[0]) == type(1) and type(result[1]) == type(1)
+  
 @pytest.mark.it('We tried to pass 15, 22, 4 as parameters and it did not return (60, 88)!')
 def test_for_file_output(capsys, app):
-
-    assert app.total_cost(15, 22, 4) == ((((15*100)+22)*4)//100, (((15*100)+22)*4)%100)
+    assert app.total_cost(15, 22, 4) == (60, 88)
+  
+@pytest.mark.it('We tried to pass 10, 15, 4 as parameters and it did not return (20, 30)!')
+def test_for_file_output2(capsys, app):
+    assert app.total_cost(15, 22, 4) == (60, 88)
 

exercises/018-day_of_week/solution.hide.py

@@ -0,0 +1,9 @@
+#Complete the function to return the number of day of the week for k'th day of year. 
+def day_of_week(k):
+  
+  return (3+k)%7
+
+
+
+#Invoke function day_of_week with an interger between 0 and 6 (number for days of week)
+print(day_of_week(1))

exercises/018-day_of_week/test.py

@@ -6,8 +6,19 @@
 def test_for_functon_existence(capsys, app):
     assert callable(app.day_of_week)
 
-@pytest.mark.it('Something went wrong! We tried to pass 56 as parameter and it did not return 3!Keep trying!')
+@pytest.mark.it('The function must return something')
+def test_function_return(capsys, app):
+    assert app.day_of_week(1) != None
+
+@pytest.mark.it('The function must return a number')
+def test_function_return_type(capsys, app):
+    assert type(app.day_of_week(1)) == type(1)
+
+@pytest.mark.it('Something went wrong! We tried to pass 1 as parameter and it did not return 4! Keep trying!')
 def test_for_file_output(capsys, app):
+    assert app.day_of_week(1) == 4
 
-    assert app.day_of_week(56) == (3+56)%7
+@pytest.mark.it('Something went wrong! We tried to pass 46 as parameter and it did not return 4! Keep trying!')
+def test_for_file_output2(capsys, app):
+    assert app.day_of_week(46) == 0
 

exercises/019-digital_clock/solution.hide.py

@@ -0,0 +1,6 @@
+#Complete the function to return how many hrs and min are displayed on the 24th digital clock.
+def digital_clock(n):
+  return ((n // 60), (n % 60))
+
+#Invoke the function with any interger (seconds after midnight)
+print(digital_clock(150))

exercises/019-digital_clock/test.py

@@ -6,8 +6,19 @@
 def test_for_functon_existence(capsys, app):
     assert callable(app.digital_clock)
 
+@pytest.mark.it('The function must return something')
+def test_function_return(capsys, app):
+    assert app.digital_clock(194) != None
+
+@pytest.mark.it('The function must return a tuple')
+def test_function_return_type(capsys, app):
+    assert type(app.digital_clock(194)) == type((3, 14))
+
 @pytest.mark.it('We tried to pass 194 as parameter and it did not return (3, 14)!Keep Trying!')
 def test_for_file_output(capsys, app):
+    assert app.digital_clock(194) == (3, 14)
 
-    assert app.digital_clock(194) == ((194 // 60), (194 % 60))
+@pytest.mark.it('We tried to pass 150 as parameter and it did not return (2, 50)! Keep Trying!')
+def test_for_file_output(capsys, app):
+    assert app.digital_clock(150) == (2,30)
 

exercises/020-factorial/solution.hide.py

@@ -4,4 +4,14 @@ def fact(x):
     return x * fact(x - 1)
 
 x=int(input())
-print fact(x)
+print (fact(x))
+
+
+# or
+
+# Your code here
+import math
+def factorial(num):
+    return math.factorial(num)
+
+print(factorial(8))

exercises/020-factorial/test.py

@@ -9,6 +9,14 @@ def test_factorial_exists(app):
     except AttributeError:
         raise AttributeError("The function 'factorial' should exist on app.py")
 
+@pytest.mark.it('The function must return something')
+def test_function_return(capsys, app):
+    assert app.factorial(8) != None
+
+@pytest.mark.it('The function must return a tuple')
+def test_function_return_type(capsys, app):
+    assert type(app.factorial(8)) == type(1)
+
 @pytest.mark.it('Testing the function factorial with the number 8, it should return 40320')
 def test_factorial_8(app):
     try: