ex 28, 29. 30, 32, 34, 36, 37 changed

Author: kiddopro

exercises/28-sequence-of-lines/solution.hide.py

@@ -1,10 +1,4 @@
-lines = []
-while True:
-    s = input("")
-    if s:
-        lines.append(s.upper())
-    else:
-        break;
+def lines(text):
+    return text.upper()
 
-for sentence in lines:
-    print (sentence)
+print(lines('Hello world'))

exercises/28-sequence-of-lines/test.py

@@ -1,11 +1,14 @@
 import pytest, io, sys, json, mock, re, os
 path = os.path.dirname(os.path.abspath(__file__))+'/app.py'
 
-@pytest.mark.it('The solution should return the expected output')
-def test_input_output(capsys, app):
+@pytest.mark.it('The function lines must exist')
+def test_function_existence(capsys, app):
+    assert app.lines
 
-    fake_input = ["Hello world Practice makes perfect"]
-    with mock.patch('builtins.input', lambda x: fake_input.pop(0)):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "HELLO WORLD PRACTICE MAKES PERFECT\n"
+@pytest.mark.it('The function should return the expected output')
+def test_expected_output(capsys, app):
+    assert app.lines("hello world") == "HELLO WORLD"
+
+@pytest.mark.it('The function should return the expected output')
+def test_another_output(capsys, app):
+    assert app.lines("LeT the WOrld know YoU") == "LET THE WORLD KNOW YOU"

exercises/29-remove-duplicate-words/solution.hide.py

@@ -1,3 +1,3 @@
-s = input("")
-words = [word for word in s.split(" ")]
-print (" ".join(sorted(list(set(words)))))
+def remove_duplicate_words(text):
+    words = text.split()
+    return (" ".join(sorted(list(set(words)))))

exercises/29-remove-duplicate-words/test.py

@@ -1,26 +1,18 @@
 import pytest, io, sys, json, mock, re, os
 
-@pytest.mark.it('Your solution should work as expected')
+@pytest.mark.it('The function remove_duplicate_words must exist')
+def test_function_existence(capsys, app):
+    app.remove_duplicate_words
+
+@pytest.mark.it('The function should return the expected output')
 def test_expected_output(capsys, app):
-    fake_input=['Hola como Hola']
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "Hola como\n"
+    assert app.remove_duplicate_words("hello world and practice makes perfect and hello world again") == "again and hello makes perfect practice world"
 
-@pytest.mark.it('Your solution should work as expected')
+@pytest.mark.it('The function should work with other entries')
 def test_expected_output_2(capsys, app):
-    fake_input=['ayer como ayer es hoy']
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "ayer como es hoy\n"
+    assert app.remove_duplicate_words("lets try this again with another try") == "again another lets this try with"
 
+@pytest.mark.it('The function should work with other entries')
+def test_expected_output_3(capsys, app):
+    assert app.remove_duplicate_words("Jacke was Named Jacke by his mother") == "Jacke Named by his mother was"
 
-@pytest.mark.it('Your solution should work as expected')
-def test_expected_output_no_repetead(capsys, app):
-    fake_input=['Hola como estas']
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "Hola como estas\n"

exercises/30-divisable-binary/solution.hide.py

@@ -1,8 +1,9 @@
-value = []
-items=[x for x in input("").split(',')]
-for p in items:
-    intp = int(p, 2)
-    if not intp%5:
-        value.append(p)
+def divisable_binary(text):
+    value=[]
+    items=[x for x in text.split(',')]
+    for p in items:
+        intp = int(p, 2)
+        if not intp%5:
+            value.append(p)
 
-print (','.join(value))
+    return (','.join(value))

exercises/30-divisable-binary/test.py

@@ -1,17 +1,17 @@
 import pytest, io, sys, json, mock, re, os
 
-@pytest.mark.it('Your solution should work as expected')
+@pytest.mark.it('The function divisable_binary must exist')
+def test_function_existence(capsys, app):
+    assert app.divisable_binary
+
+@pytest.mark.it('The function should return the expected output')
 def test_expected_output(capsys, app):
-    fake_input=['0100,0011,1010,1001']
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "1010\n"
+    assert app.divisable_binary("0100,0011,1010,1001") == "1010"
 
-@pytest.mark.it('Your solution should work with other parameters')
+@pytest.mark.it('The function should work with other parameters. testing with 1111,1000,0101,0000')
 def test_expected_output_2(capsys, app):
-    fake_input=['1111,1000,0101,0000']
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "1111,0101,0000\n"
+    assert app.divisable_binary("1111,1000,0101,0000") == "1111,0101,0000"
+
+@pytest.mark.it("The function should work with other parameters. Testing with 1000")
+def test_expected_output_3(capsys, app):
+    assert app.divisable_binary("1000,1000,1000,1000") == ""

exercises/32-numbers-of-letters-and-digits/solution.hide.py

@@ -1,11 +1,11 @@
-s = input("")
-d={"DIGITS":0, "LETTERS":0}
-for c in s:
-    if c.isdigit():
-        d["DIGITS"]+=1
-    elif c.isalpha():
-        d["LETTERS"]+=1
-    else:
-        pass
-print ("LETTERS", d["LETTERS"])
-print ("DIGITS", d["DIGITS"])
+def letters_and_digits(text):
+    d={"DIGITS":0, "LETTERS":0}
+    for c in text:
+        if c.isdigit():
+            d["DIGITS"]+=1
+        elif c.isalpha():
+            d["LETTERS"]+=1
+        else:
+            pass
+    
+    return ("LETTERS {} DIGITS {}".format(d['LETTERS'], d['DIGITS']))

exercises/32-numbers-of-letters-and-digits/test.py

@@ -1,17 +1,15 @@
-import mock, pytest
+import mock, pytest, io, sys 
 
-@pytest.mark.it('The solution should return the expected output')
+
+@pytest.mark.it('The function letters_and_digits must exist')
+def test_function_existence(capsys, app):
+    assert app.letters_and_digits
+
+
+@pytest.mark.it('The function should return the expected output')
 def test_output(capsys, app):
-    fake_input = ["hello world! 123"] #fake input
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out != "LETTERS 10 DIGITS 3\n"
+    app.letters_and_digits("hello world! 123") == "LETTERS 10 DIGITS 3"
 
-@pytest.mark.it('The solution should work with others inputs')
-def test_output_2(capsys, app):
-    fake_input = ["How are you 11111"] #fake input
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out != "LETTERS 9 DIGITS 5\n"
+@pytest.mark.it('The solution should work with other parameters')
+def test_another_entry(capsys, app):
+    assert app.letters_and_digits("My name is C200 and i live in apartment 3H") == "LETTERS 29 DIGITS 4"

exercises/34-a_aa_aaa_aaaa/solution.hide.py

@@ -1,6 +1,6 @@
-a = input("")
-n1 = int( "%s" % a )
-n2 = int( "%s%s" % (a,a) )
-n3 = int( "%s%s%s" % (a,a,a) )
-n4 = int( "%s%s%s%s" % (a,a,a,a) )
-print (n1+n2+n3+n4)
+def computed_value(param):
+    n1 = int( "%s" % param )
+    n2 = int( "%s%s" % (param,param) )
+    n3 = int( "%s%s%s" % (param,param,param) )
+    n4 = int( "%s%s%s%s" % (param,param,param,param) )
+    return (n1+n2+n3+n4)

exercises/34-a_aa_aaa_aaaa/test.py

@@ -1,10 +1,17 @@
 import io, sys, pytest, os, re, mock
 
-@pytest.mark.it('The solution should return the expected output')
-def test_convert_inputs(capsys, app):
-
-    fake_input = ["9"] #fake input
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "11106\n"
+@pytest.mark.it('The function computed_value must exist')
+def test_function_existence(capsys, app):
+    assert app.computed_value
+
+@pytest.mark.it('The function should return the expected output')
+def test_expected_output(capsys, app):
+    assert app.computed_value(9) == 11106
+
+@pytest.mark.it('The function should work with other enties. Testing with 123')
+def test_another_output(capsys, app):
+    assert app.computed_value(123) == 123246369492
+
+@pytest.mark.it('The function should work with other enties. Testing with 0')
+def test_with_zero(capsys, app):
+    assert app.computed_value(0) == 0

exercises/36-net-amount/solution.hide.py

@@ -1,15 +1,9 @@
-netAmount = 0
-while True:
-    s = input("")
-    if not s:
-        break
-    values = s.split(" ")
-    operation = values[0]
-    amount = int(values[1])
-    if operation=="D":
-        netAmount+=amount
-    elif operation=="W":
-        netAmount-=amount
-    else:
-        pass
-print (netAmount)
+def net_amount(param):
+    netAmount = 0
+    values = param.split()
+    for x in range(len(values)):
+        if values[x] == 'D':
+            netAmount+=int(values[x+1])
+        elif values[x] == 'W':
+            netAmount-=int(values[x+1])
+    return netAmount

exercises/36-net-amount/test.py

@@ -1,11 +1,22 @@
 import pytest, io, sys, json, mock, re, os
 path = os.path.dirname(os.path.abspath(__file__))+'/app.py'
 
+@pytest.mark.it('The function net_amount must exist')
+def test_function_existence(capsys, app):
+    assert app.net_amount
+
+@pytest.mark.it('The function net_amount must exist')
+def test_function_existence(capsys, app):
+    assert app.net_amount
+    
 @pytest.mark.it('The solution should return the expected output')
 def test_output(capsys, app):
-    fake_input = ["D 300 D 300 W 200 D 100"] #fake input
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "500\n"
+    assert app.net_amount("D 300 D 300 W 200 D 100") == 500
+
+@pytest.mark.it('The solution should work with other parameters. Testing with "W 300 D 300 W 200 D 300"')
+def test_output_2(capsys, app):
+    assert app.net_amount("W 300 D 300 W 200 D 300") == 100
 
+@pytest.mark.it('The solution should work with other parameters. Testing with "W 300 D 300 W 200 D 300"')
+def test_output_negative(capsys, app):
+    assert app.net_amount("W 300 D 300 W 200 W 300") == -500

exercises/37-validity-of-password/solution.hide.py

@@ -1,22 +1,23 @@
 import re
-value = []
-items=[x for x in input("").split(',')]
-for p in items:
-    if len(p)<6 or len(p)>12:
-        continue
-    else:
-        pass
-    if not re.search("[a-z]",p):
-        continue
-    elif not re.search("[0-9]",p):
-        continue
-    elif not re.search("[A-Z]",p):
-        continue
-    elif not re.search("[$#@]",p):
-        continue
-    elif re.search("\s",p):
-        continue
-    else:
-        pass
-    value.append(p)
-print (",".join(value))
+def valid_password(password):
+    value = []
+    items=[x for x in password.split(',')]
+    for p in items:
+        if len(p)<6 or len(p)>12:
+            continue
+        else:
+            pass
+        if not re.search("[a-z]",p):
+            continue
+        elif not re.search("[0-9]",p):
+            continue
+        elif not re.search("[A-Z]",p):
+            continue
+        elif not re.search("[$#@]",p):
+            continue
+        elif re.search("\s",p):
+            continue
+        else:
+            pass
+        value.append(p)
+    return (",".join(value))

exercises/37-validity-of-password/test.py

@@ -1,26 +1,19 @@
 import pytest, io, sys, json, mock, re, os
 path = os.path.dirname(os.path.abspath(__file__))+'/app.py'
 
-@pytest.mark.it('Your solution should work as expected')
+
+@pytest.mark.it('The function valid_password must exist')
+def test_function_existence(capsys, app):
+    assert app.valid_password
+
+@pytest.mark.it('The function should return the expected output')
 def test_expected_output(capsys, app):
-    fake_input=['ABd1234@1,a F1#,2w3E*,2We3345']
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "ABd1234@1\n"
+    assert app.valid_password("ABd1234@1,a F1#,2w3E*,2We3345") == "ABd1234@1"
 
 @pytest.mark.it('Your solution should work as expected for valid passwords')
 def test_expected_another_output(capsys, app):
-    fake_input=['Lmd4567@2,a F1#,2w3E*,2We3345']
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "Lmd4567@2\n"
+    assert app.valid_password("Lmd4567@2,a F1#,2w3E*,2We3345") == "Lmd4567@2"
 
 @pytest.mark.it('Your solution should work as expected when there is no valid password input')
 def test_expected_output_no_valid_entries(capsys, app):
-    fake_input=['ABd12,a F1#,2w3E*,2We3345']
-    with mock.patch('builtins.input', lambda x: fake_input.pop()):
-        app()
-        captured = capsys.readouterr()
-        assert captured.out == "\n"
+    assert app.valid_password("ABd12,a F1#,2w3E*,2We3345") == ""