From acb4697ada2f834ca042899f2f8d08337701c3fc Mon Sep 17 00:00:00 2001 From: Filip Gralinski Date: Fri, 7 Dec 2018 21:11:15 +0100 Subject: [PATCH] Regexp --- regexp/Task301Test.py | 37 +++++++++++++++++++++++++++++++++++ regexp/Task302Test.py | 36 ++++++++++++++++++++++++++++++++++ regexp/Task303Test.py | 39 +++++++++++++++++++++++++++++++++++++ regexp/Task304Test.py | 41 +++++++++++++++++++++++++++++++++++++++ regexp/Task305Test.py | 45 +++++++++++++++++++++++++++++++++++++++++++ regexp/Task306Test.py | 39 +++++++++++++++++++++++++++++++++++++ regexp/Task307Test.py | 31 +++++++++++++++++++++++++++++ regexp/Task308Test.py | 41 +++++++++++++++++++++++++++++++++++++++ regexp/Task309Test.py | 42 ++++++++++++++++++++++++++++++++++++++++ regexp/Task310Test.py | 40 ++++++++++++++++++++++++++++++++++++++ regexp/Task311Test.py | 34 ++++++++++++++++++++++++++++++++ regexp/Task312Test.py | 40 ++++++++++++++++++++++++++++++++++++++ regexp/Task313Test.py | 43 +++++++++++++++++++++++++++++++++++++++++ regexp/Task314Test.py | 39 +++++++++++++++++++++++++++++++++++++ regexp/Task315Test.py | 40 ++++++++++++++++++++++++++++++++++++++ regexp/Task316Test.py | 39 +++++++++++++++++++++++++++++++++++++ regexp/Task317Test.py | 41 +++++++++++++++++++++++++++++++++++++++ regexp/Task318Test.py | 39 +++++++++++++++++++++++++++++++++++++ regexp/Task319Test.py | 41 +++++++++++++++++++++++++++++++++++++++ regexp/Task320Test.py | 39 +++++++++++++++++++++++++++++++++++++ regexp/Task321Test.py | 43 +++++++++++++++++++++++++++++++++++++++++ regexp/Task322Test.py | 40 ++++++++++++++++++++++++++++++++++++++ regexp/Task323Test.py | 35 +++++++++++++++++++++++++++++++++ regexp/Task324Test.py | 38 ++++++++++++++++++++++++++++++++++++ regexp/Task325Test.py | 37 +++++++++++++++++++++++++++++++++++ regexp/Task326Test.py | 40 ++++++++++++++++++++++++++++++++++++++ regexp/Task327Test.py | 39 +++++++++++++++++++++++++++++++++++++ regexp/Task328Test.py | 41 +++++++++++++++++++++++++++++++++++++++ regexp/Task329Test.py | 38 ++++++++++++++++++++++++++++++++++++ 29 files changed, 1137 insertions(+) create mode 100755 regexp/Task301Test.py create mode 100755 regexp/Task302Test.py create mode 100755 regexp/Task303Test.py create mode 100755 regexp/Task304Test.py create mode 100755 regexp/Task305Test.py create mode 100755 regexp/Task306Test.py create mode 100755 regexp/Task307Test.py create mode 100644 regexp/Task308Test.py create mode 100644 regexp/Task309Test.py create mode 100644 regexp/Task310Test.py create mode 100644 regexp/Task311Test.py create mode 100644 regexp/Task312Test.py create mode 100644 regexp/Task313Test.py create mode 100644 regexp/Task314Test.py create mode 100755 regexp/Task315Test.py create mode 100644 regexp/Task316Test.py create mode 100644 regexp/Task317Test.py create mode 100644 regexp/Task318Test.py create mode 100644 regexp/Task319Test.py create mode 100644 regexp/Task320Test.py create mode 100644 regexp/Task321Test.py create mode 100644 regexp/Task322Test.py create mode 100644 regexp/Task323Test.py create mode 100644 regexp/Task324Test.py create mode 100644 regexp/Task325Test.py create mode 100644 regexp/Task326Test.py create mode 100644 regexp/Task327Test.py create mode 100644 regexp/Task328Test.py create mode 100644 regexp/Task329Test.py diff --git a/regexp/Task301Test.py b/regexp/Task301Test.py new file mode 100755 index 0000000..b2bbee9 --- /dev/null +++ b/regexp/Task301Test.py @@ -0,0 +1,37 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 301 + +Napisz funkcję `letter_and_two_digits(string)`, która sprawdza +czy podany napis zawiera ciąg składający się z wielkiej litery +i dwóch cyfr. + +NAME: letter_and_two_digits +PARAMS: string +RETURN: bool +POINTS: 3 +""" + +import unittest +from Task301 import letter_and_two_digits + +class Task301Test(unittest.TestCase): + """Testy do zadania 301""" + + def test_sequence(self): + """Prosty test.""" + self.assertTrue(letter_and_two_digits("hahaA39dsdsd")) + self.assertTrue(letter_and_two_digits("G3923d")) + self.assertTrue(letter_and_two_digits("Z00")) + self.assertTrue(letter_and_two_digits("sssssssssssU23")) + self.assertFalse(letter_and_two_digits("Z0x0")) + self.assertFalse(letter_and_two_digits("dsdg34")) + self.assertFalse(letter_and_two_digits("G9")) + self.assertFalse(letter_and_two_digits("az33a")); + self.assertFalse(letter_and_two_digits("Ha3a5")); + + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task302Test.py b/regexp/Task302Test.py new file mode 100755 index 0000000..1f60036 --- /dev/null +++ b/regexp/Task302Test.py @@ -0,0 +1,36 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 302 + +Napisz funkcję `extract_minutes(string)`, która +z podanego napisu reprezentującego godzinę +w formacie typu "9:13", "18:44" wyciąga minuty. +Funkcja powinna zwracać napis "", jeśli podany +napis nie jest godziną. + +NAME: extract_minutes +PARAMS: string +RETURN: string +POINTS: 4 +""" + +import unittest +from Task302 import extract_minutes + +class Task302Test(unittest.TestCase): + """Testy do zadania 302""" + + def test_simple(self): + """Prosty test.""" + self.assertEqual(extract_minutes("9:13"), "13") + self.assertEqual(extract_minutes("18:44"), "44") + self.assertEqual(extract_minutes("23:59"), "59") + self.assertEqual(extract_minutes("0:00"), "00") + self.assertEqual(extract_minutes("25:14"), "") + self.assertEqual(extract_minutes("9:61"), "") + self.assertEqual(extract_minutes("x9:13y"), "") + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task303Test.py b/regexp/Task303Test.py new file mode 100755 index 0000000..26d9d6e --- /dev/null +++ b/regexp/Task303Test.py @@ -0,0 +1,39 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 303 + +Napisz funkcję `divisable_by_four(string)`, która +sprawdza, czy podany napis reprezentuje liczbę nieujemną podzielną +przez 4. Uwaga: cała "logika" rozwiązania powinna być zaszyta +w wyrażeniu regularnym, w szczególności proszę nie używać operatora +wyznaczania reszty. + +NAME: divisable_by_four +PARAMS: string +RETURN: bool +POINTS: 3 +""" + +import unittest +from Task303 import divisable_by_four + +class Task303Test(unittest.TestCase): + """Testy do zadania 303""" + + def test_simple(self): + """Prosty test.""" + self.assertTrue(divisable_by_four("32")) + self.assertFalse(divisable_by_four("33")) + self.assertFalse(divisable_by_four("-32")) + self.assertTrue(divisable_by_four("0")) + + for num in range(45000, 47000): + if num % 4 == 0: + self.assertTrue(divisable_by_four(str(num)), str(num)) + else: + self.assertFalse(divisable_by_four(str(num)), str(num)) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task304Test.py b/regexp/Task304Test.py new file mode 100755 index 0000000..dadd337 --- /dev/null +++ b/regexp/Task304Test.py @@ -0,0 +1,41 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 304 + +Napisz funkcję `split_list(string)`, która która zwraca listę powstałą +w wyniku podziału napisu. Separatorami mogą być przecinki otoczone +opcjonalnymi spacjami bądź pojedyncze dwukropki. + + +NAME: split_list +PARAMS: string +RETURN: list +POINTS: 2 +""" + +import unittest +from Task304 import split_list + +class Task304Test(unittest.TestCase): + """Testy do zadania 304""" + + def test_simple(self): + """Prosty test.""" + self.assertEqual( + split_list("foo, bar , sss:s"), + ['foo', 'bar', 'sss', 's']) + + + self.assertEqual( + split_list("foo"), + ['foo']) + + self.assertEqual( + split_list("bla : bla"), + ['bla ', ' bla']) + + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task305Test.py b/regexp/Task305Test.py new file mode 100755 index 0000000..401916d --- /dev/null +++ b/regexp/Task305Test.py @@ -0,0 +1,45 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 305 + +Napisać funkcję divisable_by_two(string), która sprawdza, czy +zadany napis reprezentuje nieujemną liczbę podzielną przez 2. +Napis nie powinien zawierać zer nieznaczących. +Uwaga: cała "logika" rozwiązania powinna być zaszyta +w wyrażeniu regularnym, w szczególności proszę nie używać operatora +wyznaczania reszty. + +NAME: divisable_by_two +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task305 import divisable_by_two + +class Task305Test(unittest.TestCase): + """Testy do zadania 305""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(divisable_by_two("222221")) + self.assertFalse(divisable_by_two("3")) + self.assertFalse(divisable_by_two("4 4")) + self.assertFalse(divisable_by_two("04")) + self.assertTrue(divisable_by_two("2")) + self.assertTrue(divisable_by_two("222222")) + self.assertFalse(divisable_by_two("1")) + self.assertTrue(divisable_by_two("4")) + self.assertFalse(divisable_by_two("0018")) + self.assertFalse(divisable_by_two("-20")) + self.assertTrue(divisable_by_two("88")) + self.assertTrue(divisable_by_two("0")) + self.assertTrue(divisable_by_two("16")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task306Test.py b/regexp/Task306Test.py new file mode 100755 index 0000000..8d602b2 --- /dev/null +++ b/regexp/Task306Test.py @@ -0,0 +1,39 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 306 + +Napisać funkcję is_power_of_hundred(string), która sprawdza, czy +zadany napis jest potęgą liczby 100. +Uwaga: cała "logika" rozwiązania powinna być zaszyta +w wyrażeniu regularnym. + +NAME: is_power_of_hundred +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task306 import is_power_of_hundred + +class Task306Test(unittest.TestCase): + """Testy do zadania 306""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_power_of_hundred("-100")) + self.assertTrue(is_power_of_hundred("10000")) + self.assertFalse(is_power_of_hundred("1001")) + self.assertTrue(is_power_of_hundred("1")) + self.assertTrue(is_power_of_hundred("1000000")) + self.assertFalse(is_power_of_hundred("10")) + self.assertFalse(is_power_of_hundred("2000")) + self.assertFalse(is_power_of_hundred("500")) + self.assertTrue(is_power_of_hundred("100")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task307Test.py b/regexp/Task307Test.py new file mode 100755 index 0000000..a92c3e8 --- /dev/null +++ b/regexp/Task307Test.py @@ -0,0 +1,31 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 307 + +Stworzyć funkcję `extract_phone_number(string_to_be_checked), która wydobywa z zadanego napisu numer telefonu. Zakładamy, że numer telefonu składa się z dwóch cyfr opcjonalnie poprzedzonych zerem, po których następuje spacja i 7 cyfr w formacie N-NNN-NNN. Jeśli zadany napis nie zawiera numeru telefonu, należy zwrócić "". + +NAME: is_phone_number +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task307 import extract_phone_number + +class Task307Test(unittest.TestCase): + """Testy do zadania 307""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertEqual(extract_phone_number("bla 61 5-555-555xyz"), "61 5-555-555"); + self.assertEqual(extract_phone_number("bla 061 5-555-555xyz"), "061 5-555-555"); + self.assertEqual(extract_phone_number("bla 61 5-555-45xyz"), ""); + self.assertEqual(extract_phone_number("bla 5-555-4555xyz"), ""); + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task308Test.py b/regexp/Task308Test.py new file mode 100644 index 0000000..8ec3fc4 --- /dev/null +++ b/regexp/Task308Test.py @@ -0,0 +1,41 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 308 + +Napisać funkcję is_horse_head(string), która sprawdza, czy +napis jest napisem złożonym z ciągu 5 wielkich liter i 4 wielkich +liter oddzielonych spacją, które wstukane na standardowym telefonie +dadzą taki sam numer jak przy wstukaniu napisu "HORSE HEAD". +Zakładamy standardowe mapowanie liter na cyfry w telefonie ("ABC" - +2, "DEF" - 3 itd.) + +NAME: is_horse_head +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task308 import is_horse_head + +class Task308Test(unittest.TestCase): + """Testy do zadania 308""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_horse_head("ZOSRE IDAD")) + self.assertFalse(is_horse_head("morse head")) + self.assertFalse(is_horse_head("MORSEHEAD")) + self.assertFalse(is_horse_head("AAAAAA BBBB")) + self.assertFalse(is_horse_head("MORSE HEAD")) + self.assertTrue(is_horse_head("HORSE HEAD")) + self.assertFalse(is_horse_head("AAAAA BBBB")) + self.assertTrue(is_horse_head("GOSRE IDAD")) + self.assertFalse(is_horse_head("0MORSE HEAD")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task309Test.py b/regexp/Task309Test.py new file mode 100644 index 0000000..17eceb3 --- /dev/null +++ b/regexp/Task309Test.py @@ -0,0 +1,42 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 309 + +Napisać funkcję is_movie_number(string), która sprawdza, czy +napis jest 9-cyfrowym numerem telefonu zapisanym w formacie +"NNN-NNN-NNN" badź "NNN NNN NNN" zaczynającym sie od kombinacji +"555". + +NAME: is_movie_number +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task309 import is_movie_number + +class Task309Test(unittest.TestCase): + """Testy do zadania 309""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_movie_number("555 000-000")) + self.assertFalse(is_movie_number("556 345-667")) + self.assertFalse(is_movie_number("556 345 6675")) + self.assertFalse(is_movie_number("055-555-555")) + self.assertTrue(is_movie_number("555 123 456")) + self.assertFalse(is_movie_number("505-324-555")) + self.assertTrue(is_movie_number("555-123-456")) + self.assertFalse(is_movie_number("555-000 000")) + self.assertTrue(is_movie_number("555 000 000")) + self.assertTrue(is_movie_number("555-000-000")) + self.assertFalse(is_movie_number("556 345 667")) + self.assertFalse(is_movie_number("551-233-455")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task310Test.py b/regexp/Task310Test.py new file mode 100644 index 0000000..3612909 --- /dev/null +++ b/regexp/Task310Test.py @@ -0,0 +1,40 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 310 + +Napisać funkcję is_football_result(string), która sprawdza, czy +napis reprezentuje wynik meczu piłkarskiego (dwie liczby oddzielone +dwukropkiem). Maksymalna liczba bramek wynosi 10. + +NAME: is_football_result +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task310 import is_football_result + +class Task310Test(unittest.TestCase): + """Testy do zadania 310""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_football_result("3")) + self.assertTrue(is_football_result("10:10")) + self.assertTrue(is_football_result("5:2")) + self.assertFalse(is_football_result("11:2")) + self.assertFalse(is_football_result("5-5")) + self.assertTrue(is_football_result("2:1")) + self.assertTrue(is_football_result("5:5")) + self.assertFalse(is_football_result(":3")) + self.assertFalse(is_football_result("3:101")) + self.assertFalse(is_football_result("xxxx")) + self.assertTrue(is_football_result("0:7")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task311Test.py b/regexp/Task311Test.py new file mode 100644 index 0000000..3af6fd4 --- /dev/null +++ b/regexp/Task311Test.py @@ -0,0 +1,34 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 311 + +Napisać funkcję is_nip_number(string), która sprawdza, czy +napis jest numerem NIP zapisanym w formacie xxx-xxx-xx-xx bądź +xxx-xx-xx-xxx. Nie trzeba brać pod uwagę sumy kontrolnej. + +NAME: is_nip_number +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task311 import is_nip_number + +class Task311Test(unittest.TestCase): + """Testy do zadania 311""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_nip_number("3454551234")) + self.assertTrue(is_nip_number("000-00-00-000")) + self.assertTrue(is_nip_number("345-45-12-334")) + self.assertFalse(is_nip_number("345-455-12-349")) + self.assertTrue(is_nip_number("345-455-12-34")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task312Test.py b/regexp/Task312Test.py new file mode 100644 index 0000000..aac7808 --- /dev/null +++ b/regexp/Task312Test.py @@ -0,0 +1,40 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 312 + +Napisać funkcję is_pin_code(string), która sprawdza, czy +napis jest 4-cyfrowym kodem PIN, przy czym zakładamy, że kod PIN +nie może składać się z samych zer. + +NAME: is_pin_code +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task312 import is_pin_code + +class Task312Test(unittest.TestCase): + """Testy do zadania 312""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertTrue(is_pin_code("7787")) + self.assertTrue(is_pin_code("8888")) + self.assertTrue(is_pin_code("5034")) + self.assertFalse(is_pin_code("WTF")) + self.assertTrue(is_pin_code("1112")) + self.assertTrue(is_pin_code("0123")) + self.assertTrue(is_pin_code("1111")) + self.assertTrue(is_pin_code("0300")) + self.assertFalse(is_pin_code("0000")) + self.assertFalse(is_pin_code("12345")) + self.assertTrue(is_pin_code("4655")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task313Test.py b/regexp/Task313Test.py new file mode 100644 index 0000000..0f20221 --- /dev/null +++ b/regexp/Task313Test.py @@ -0,0 +1,43 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 313 + +Napisać funkcję is_human_age(string), która sprawdza, czy +napis reprezentuje wiek człowieka, tzn. jest postaci typu "45 lat". +Maksymalny wiek - 99 lat. + +NAME: is_human_age +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task313 import is_human_age + +class Task313Test(unittest.TestCase): + """Testy do zadania 313""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_human_age("12 lata")) + self.assertTrue(is_human_age("99 lat")) + self.assertTrue(is_human_age("5 lat")) + self.assertTrue(is_human_age("1 rok")) + self.assertTrue(is_human_age("44 lata")) + self.assertTrue(is_human_age("11 lat")) + self.assertTrue(is_human_age("22 lata")) + self.assertTrue(is_human_age("4 lata")) + self.assertFalse(is_human_age("100 lat")) + self.assertFalse(is_human_age("112 lat")) + self.assertFalse(is_human_age("22 lat")) + self.assertTrue(is_human_age("2 lata")) + self.assertTrue(is_human_age("3 lata")) + self.assertTrue(is_human_age("12 lat")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task314Test.py b/regexp/Task314Test.py new file mode 100644 index 0000000..9a67ca1 --- /dev/null +++ b/regexp/Task314Test.py @@ -0,0 +1,39 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 314 + +Napisać funkcję is_male(string), która sprawdza, czy +napis reprezentuje imię i nazwisko mężczyzny. Imię i nazwisko to +przynajmniej dwuliterowy napis zaczynający się wielką literą, po +której następują małe litery. Dodatkowo imię nie może kończyć +się na "a". + +NAME: is_male +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task314 import is_male + +class Task314Test(unittest.TestCase): + """Testy do zadania 314""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_male("Joanna Kowalska")) + self.assertTrue(is_male("Oo Oo")) + self.assertTrue(is_male("Atanazy Bazakbal")) + self.assertTrue(is_male("Ai Oi")) + self.assertTrue(is_male("Ax Aa")) + self.assertFalse(is_male("Aa Ax")) + self.assertTrue(is_male("Kim Bo")) + self.assertTrue(is_male("Jan Maska")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task315Test.py b/regexp/Task315Test.py new file mode 100755 index 0000000..509b5be --- /dev/null +++ b/regexp/Task315Test.py @@ -0,0 +1,40 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 315 + +Napisać funkcję is_female(string), która sprawdza, czy +napis reprezentuje imię i nazwisko kobiety. Imię i nazwisko to +przynajmniej dwuliterowy napis zaczynający się wielką literą, po +której następują małe litery. Dodatkowo imię musi kończyć się +na "a". + +NAME: is_female +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task315 import is_female + +class Task315Test(unittest.TestCase): + """Testy do zadania 315""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertTrue(is_female("Joanna Kowalska")) + self.assertFalse(is_female("Ai Oi")) + self.assertTrue(is_female("Aa Ax")) + self.assertFalse(is_female("Kim Bo")) + self.assertFalse(is_female("Jan Maska")) + self.assertFalse(is_female("Oo Oo")) + self.assertTrue(is_female("Za Mysz")) + self.assertFalse(is_female("Atanazy Bazakbal")) + self.assertFalse(is_female("Ax Aa")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task316Test.py b/regexp/Task316Test.py new file mode 100644 index 0000000..f890490 --- /dev/null +++ b/regexp/Task316Test.py @@ -0,0 +1,39 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 316 + +Napisać funkcję is_acronym(string), która sprawdza, czy +napis jest akronimem (ciągiem co najmniej dwóch i co najwyżej +pięciu wielkich liter. Dodatkowo należy uwzględnić akronim +"PCMCIA". + +NAME: is_acronym +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task316 import is_acronym + +class Task316Test(unittest.TestCase): + """Testy do zadania 316""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertTrue(is_acronym("ATX")) + self.assertFalse(is_acronym("AAAAAA")) + self.assertFalse(is_acronym("P")) + self.assertTrue(is_acronym("ABCDE")) + self.assertFalse(is_acronym("Pc")) + self.assertTrue(is_acronym("PC")) + self.assertTrue(is_acronym("PCMCIA")) + self.assertTrue(is_acronym("ZZZZ")) + self.assertFalse(is_acronym("PCMCIB")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task317Test.py b/regexp/Task317Test.py new file mode 100644 index 0000000..92f25ba --- /dev/null +++ b/regexp/Task317Test.py @@ -0,0 +1,41 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 317 + +Napisać funkcję is_integer(string), która sprawdza, czy +napis reprezentuje liczbę całkowitą. Liczba nie powinna zawierać +zer nieznaczących. Liczby dodatnie mogą opcjonalnie zaczynać się +plusem. + +NAME: is_integer +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task317 import is_integer + +class Task317Test(unittest.TestCase): + """Testy do zadania 317""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertTrue(is_integer("+5")) + self.assertTrue(is_integer("-5")) + self.assertTrue(is_integer("3434343435")) + self.assertFalse(is_integer("-0")) + self.assertTrue(is_integer("0")) + self.assertFalse(is_integer("03434343435")) + self.assertFalse(is_integer("+0")) + self.assertFalse(is_integer("06")) + self.assertTrue(is_integer("100")) + self.assertTrue(is_integer("5")) + self.assertTrue(is_integer("-11110")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task318Test.py b/regexp/Task318Test.py new file mode 100644 index 0000000..f8be698 --- /dev/null +++ b/regexp/Task318Test.py @@ -0,0 +1,39 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 318 + +Napisać funkcję is_five_six_digit(string), która sprawdza, czy +napis reprezentuje liczbę pięcio- bądź sześciocyfrową. Liczba +nie powinna zawierać zer nieznaczących. + +NAME: is_five_six_digit +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task318 import is_five_six_digit + +class Task318Test(unittest.TestCase): + """Testy do zadania 318""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_five_six_digit("0123456")) + self.assertTrue(is_five_six_digit("123456")) + self.assertTrue(is_five_six_digit("100001")) + self.assertTrue(is_five_six_digit("10000")) + self.assertTrue(is_five_six_digit("99999")) + self.assertFalse(is_five_six_digit("333333333333")) + self.assertFalse(is_five_six_digit("012345")) + self.assertTrue(is_five_six_digit("999999")) + self.assertTrue(is_five_six_digit("12345")) + self.assertFalse(is_five_six_digit("9999")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task319Test.py b/regexp/Task319Test.py new file mode 100644 index 0000000..295a158 --- /dev/null +++ b/regexp/Task319Test.py @@ -0,0 +1,41 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 319 + +Napisać funkcję less_than(string), która sprawdza, czy +napis reprezentuje liczbę całkowitą nieujemną mniejszą niż 143. +Liczba nie powinna zawierać zer nieznaczących. + +NAME: less_than +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task319 import less_than + +class Task319Test(unittest.TestCase): + """Testy do zadania 319""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(less_than("098")) + self.assertFalse(less_than("05")) + self.assertTrue(less_than("142")) + self.assertTrue(less_than("139")) + self.assertTrue(less_than("78")) + self.assertFalse(less_than("143")) + self.assertTrue(less_than("103")) + self.assertTrue(less_than("99")) + self.assertTrue(less_than("0")) + self.assertFalse(less_than("1000")) + self.assertFalse(less_than("-1")) + self.assertTrue(less_than("5")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task320Test.py b/regexp/Task320Test.py new file mode 100644 index 0000000..91de065 --- /dev/null +++ b/regexp/Task320Test.py @@ -0,0 +1,39 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 320 + +Napisać funkcję is_domain_name(string), która sprawdza, czy +napis reprezentuje nazwę domenową. Zakładamy, że nazwa domenowa +składa się z 2 lub 3 członów oddzielonych kropkami. Każdy człon +to ciąg małych liter. + +NAME: is_domain_name +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task320 import is_domain_name + +class Task320Test(unittest.TestCase): + """Testy do zadania 320""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_domain_name("www.haha.bla.pl")) + self.assertTrue(is_domain_name("foo.tv")) + self.assertTrue(is_domain_name("bla.pl")) + self.assertFalse(is_domain_name("bla1.pl")) + self.assertTrue(is_domain_name("www.bla.pl")) + self.assertFalse(is_domain_name("foo..tv")) + self.assertTrue(is_domain_name("z.z")) + self.assertTrue(is_domain_name("x.y.z")) + self.assertFalse(is_domain_name("foo.pl.")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task321Test.py b/regexp/Task321Test.py new file mode 100644 index 0000000..726004c --- /dev/null +++ b/regexp/Task321Test.py @@ -0,0 +1,43 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 321 + +Napisać funkcję is_identifier(string), która sprawdza, czy +napis jest identyfikatorem (ciągiem liter, cyfr i podkreślników +nie zaczynających się cyfrą). + +NAME: is_identifier +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task321 import is_identifier + +class Task321Test(unittest.TestCase): + """Testy do zadania 321""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertTrue(is_identifier("Gitorah")) + self.assertTrue(is_identifier("z0000000")) + self.assertTrue(is_identifier("_____")) + self.assertTrue(is_identifier("godzilla")) + self.assertTrue(is_identifier("x")) + self.assertFalse(is_identifier("2")) + self.assertFalse(is_identifier("bla-bla")) + self.assertFalse(is_identifier("2_")) + self.assertFalse(is_identifier(";zmienna")) + self.assertFalse(is_identifier("zmienna$")) + self.assertFalse(is_identifier("90876z")) + self.assertTrue(is_identifier("_2")) + self.assertTrue(is_identifier("_a_")) + self.assertTrue(is_identifier("blo_34a")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task322Test.py b/regexp/Task322Test.py new file mode 100644 index 0000000..b820c68 --- /dev/null +++ b/regexp/Task322Test.py @@ -0,0 +1,40 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 322 + +Napisać funkcję is_temperature(string), która sprawdza, czy +napis jest liczbą całkowitą zakresu od -49 do 49. Liczba nie +powinna zawierać zer nieznaczących. + +NAME: is_temperature +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task322 import is_temperature + +class Task322Test(unittest.TestCase): + """Testy do zadania 322""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertTrue(is_temperature("50")) + self.assertTrue(is_temperature("-50")) + self.assertTrue(is_temperature("-9")) + self.assertFalse(is_temperature("7")) + self.assertFalse(is_temperature("-200")) + self.assertTrue(is_temperature("-21")) + self.assertTrue(is_temperature("18")) + self.assertTrue(is_temperature("0")) + self.assertTrue(is_temperature("49")) + self.assertFalse(is_temperature("100")) + self.assertTrue(is_temperature("-49")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task323Test.py b/regexp/Task323Test.py new file mode 100644 index 0000000..9a11043 --- /dev/null +++ b/regexp/Task323Test.py @@ -0,0 +1,35 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 323 + +Napisać funkcję are_stars(string), która sprawdza, czy +napis składa się z samych gwiazdek (co najmniej jednej). + +NAME: are_stars +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task323 import are_stars + +class Task323Test(unittest.TestCase): + """Testy do zadania 323""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(are_stars("*a")) + self.assertTrue(are_stars("***********")) + self.assertTrue(are_stars("**")) + self.assertFalse(are_stars("a*")) + self.assertTrue(are_stars("*")) + self.assertFalse(are_stars("+")) + self.assertTrue(are_stars("***")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task324Test.py b/regexp/Task324Test.py new file mode 100644 index 0000000..fa43c5c --- /dev/null +++ b/regexp/Task324Test.py @@ -0,0 +1,38 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 324 + +Napisać funkcję is_one_vowel(string), która sprawdza, czy +napis jest wyrazem zawierającym dokładnie jedną samogłoskę. +Należy uwzględnić małe litery alfabetu łacińskiego. + +NAME: is_one_vowel +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task324 import is_one_vowel + +class Task324Test(unittest.TestCase): + """Testy do zadania 324""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertTrue(is_one_vowel("dom")) + self.assertFalse(is_one_vowel("puko")) + self.assertTrue(is_one_vowel("u")) + self.assertFalse(is_one_vowel("ostrach")) + self.assertFalse(is_one_vowel("html")) + self.assertTrue(is_one_vowel("strach")) + self.assertFalse(is_one_vowel("strachy")) + self.assertFalse(is_one_vowel("aa")) + self.assertFalse(is_one_vowel("223")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task325Test.py b/regexp/Task325Test.py new file mode 100644 index 0000000..823ec80 --- /dev/null +++ b/regexp/Task325Test.py @@ -0,0 +1,37 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 325 + +Napisać funkcję is_dollar_sum(string), która sprawdza, czy +napis wyraża sumę w dolarach, tj. zaczyna się znakiem dolara, po +którym następuje liczba dodatnia (bez zer nieznaczących). + +NAME: is_dollar_sum +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task325 import is_dollar_sum + +class Task325Test(unittest.TestCase): + """Testy do zadania 325""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_dollar_sum("$")) + self.assertTrue(is_dollar_sum("$1")) + self.assertTrue(is_dollar_sum("$100")) + self.assertFalse(is_dollar_sum("10$100")) + self.assertFalse(is_dollar_sum("89")) + self.assertFalse(is_dollar_sum("$0098")) + self.assertTrue(is_dollar_sum("$67592234")) + self.assertTrue(is_dollar_sum("$89")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task326Test.py b/regexp/Task326Test.py new file mode 100644 index 0000000..3beed27 --- /dev/null +++ b/regexp/Task326Test.py @@ -0,0 +1,40 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 326 + +Napisać funkcję is_dna(string), która sprawdza, czy +napis jest niepustym ciągiem liter A, G, C, T, U, przy czym w jednym +ciągu może wystąpić albo T, albo U nie obie litery +równocześnie. + +NAME: is_dna +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task326 import is_dna + +class Task326Test(unittest.TestCase): + """Testy do zadania 326""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_dna("UAT")) + self.assertTrue(is_dna("AGCUUGGAAACU")) + self.assertTrue(is_dna("AGCTTGGAAACT")) + self.assertFalse(is_dna("89")) + self.assertTrue(is_dna("AAAAA")) + self.assertFalse(is_dna("aaa")) + self.assertFalse(is_dna("TAU")) + self.assertTrue(is_dna("G")) + self.assertTrue(is_dna("UAU")) + self.assertTrue(is_dna("TAT")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task327Test.py b/regexp/Task327Test.py new file mode 100644 index 0000000..1f4508f --- /dev/null +++ b/regexp/Task327Test.py @@ -0,0 +1,39 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 327 + +Napisać funkcję is_giggle(string), która sprawdza, czy +napis jest chichotem tzn. "hi" powtórzonym przynajmniej 2 razy, po +czym następuje opcjonalny ciąg wykrzykników. + +NAME: is_giggle +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task327 import is_giggle + +class Task327Test(unittest.TestCase): + """Testy do zadania 327""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_giggle("hi")) + self.assertFalse(is_giggle("ih!")) + self.assertTrue(is_giggle("hihi!!!!!!!!!")) + self.assertTrue(is_giggle("hihihihihihihihi")) + self.assertTrue(is_giggle("hihi")) + self.assertFalse(is_giggle("!!!!!")) + self.assertTrue(is_giggle("hihihi")) + self.assertFalse(is_giggle("hi!!!")) + self.assertFalse(is_giggle("!hi")) + self.assertTrue(is_giggle("hihihi!")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task328Test.py b/regexp/Task328Test.py new file mode 100644 index 0000000..e8376ba --- /dev/null +++ b/regexp/Task328Test.py @@ -0,0 +1,41 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 328 + +Napisać funkcję is_hmmmm(string), która sprawdza, czy +napis to "hmmm....." - 'm' występuje 2 lub więcej razy, kropki są +opcjonalne, ale jeśli występują muszą wystąpić przynajmniej 3 +razy. + +NAME: is_hmmmm +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task328 import is_hmmmm + +class Task328Test(unittest.TestCase): + """Testy do zadania 328""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertTrue(is_hmmmm("hmm...")) + self.assertFalse(is_hmmmm("hmmmm.....?!")) + self.assertFalse(is_hmmmm("ahmmmm.....")) + self.assertFalse(is_hmmmm("hhmmm.....")) + self.assertFalse(is_hmmmm("hm.....")) + self.assertFalse(is_hmmmm("mmm....")) + self.assertFalse(is_hmmmm("hmmm..")) + self.assertTrue(is_hmmmm("hmmmm......")) + self.assertFalse(is_hmmmm("hmmm.")) + self.assertTrue(is_hmmmm("hmm")) + self.assertTrue(is_hmmmm("hmmm....")) + +if __name__ == '__main__': + unittest.main() diff --git a/regexp/Task329Test.py b/regexp/Task329Test.py new file mode 100644 index 0000000..47b8a1a --- /dev/null +++ b/regexp/Task329Test.py @@ -0,0 +1,38 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 329 + +Napisać funkcję is_singing(string), która sprawdza, czy +napis jest śpiewem, tj. jest ciągiem sylab "li", "la", "lo" (co +najmniej dwóch), po którym następuje opcjonalny ciąg +wykrzykników. + +NAME: is_singing +PARAMS: string +RETURN: bool +POINTS: 9 +""" + +import unittest + +from Task329 import is_singing + +class Task329Test(unittest.TestCase): + """Testy do zadania 329""" + + def test_simple(self): + """Podstawowy test.""" + + self.assertFalse(is_singing("!!lala!!")) + self.assertFalse(is_singing("lol")) + self.assertFalse(is_singing("ola!")) + self.assertFalse(is_singing("luli")) + self.assertTrue(is_singing("lilala!!!")) + self.assertTrue(is_singing("lololali!")) + self.assertTrue(is_singing("lilili!!!!")) + self.assertTrue(is_singing("lala")) + +if __name__ == '__main__': + unittest.main()