Task2

blend.sh

@@ -14,7 +14,7 @@ mkdir arena
 cp -R $STUDENT_DIR/* arena/
 ln -s ../$STUDENT_DIR/.git arena/.git
 
-#mkdir -p arena/regexp
+mkdir -p arena/regexp
 #mkdir -p arena/automata
 
 rm -rf arena/odp arena/$PREFIX

regexp/Task301Test.py

@@ -0,0 +1,37 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task302Test.py

@@ -0,0 +1,36 @@
+#!/usr/bin/python3
+# -*- 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 "<NONE>", 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"), "<NONE>")
+        self.assertEqual(extract_minutes("9:61"), "<NONE>")
+        self.assertEqual(extract_minutes("x9:13y"), "<NONE>")
+
+if __name__ == '__main__':
+    unittest.main()

regexp/Task303Test.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task304Test.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task305Test.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task306Test.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task307Test.py

@@ -0,0 +1,31 @@
+#!/usr/bin/python3
+# -*- 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ć "<NONE>".
+
+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"), "<NONE>");
+        self.assertEqual(extract_phone_number("bla 5-555-4555xyz"), "<NONE>");
+
+if __name__ == '__main__':
+    unittest.main()

regexp/Task308Test.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task309Test.py

@@ -0,0 +1,42 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task310Test.py

@@ -0,0 +1,40 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task311Test.py

@@ -0,0 +1,34 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task312Test.py

@@ -0,0 +1,40 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task313Test.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task314Test.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task315Test.py

@@ -0,0 +1,40 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task316Test.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task317Test.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task318Test.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task319Test.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task320Test.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task321Test.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task322Test.py

@@ -0,0 +1,38 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+Zadanie 322
+
+Napisać funkcję is_temperature(string), która sprawdza, czy
+napis jest liczbą całkowitą z 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("-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()

regexp/Task323Test.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task324Test.py

@@ -0,0 +1,38 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task325Test.py

@@ -0,0 +1,37 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task326Test.py

@@ -0,0 +1,40 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task327Test.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task328Test.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python3
+# -*- 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()

regexp/Task329Test.py

@@ -0,0 +1,38 @@
+#!/usr/bin/python3
+# -*- 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()

vars

@@ -4,8 +4,8 @@ DEFAULT_POINT_LIMIT=15
 POINT_LIMIT=15
 
 # 1 - intro/
-# 2 - regexp/
-# 3 - automata/
+# 3 - regexp/
+# 2 - automata/
 
 typeset -A TIME_LIMITS
 set -A TIME_LIMITS \