Compare commits
No commits in common. "master" and "master" have entirely different histories.
@ -1,41 +0,0 @@
|
||||
#!/usr/bin/python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 200
|
||||
|
||||
Napisz funkcję `abc_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
napisy zaczynające się od a, kończące się na c i zawierające w środku
|
||||
dowolną liczbę znaków b
|
||||
|
||||
NAME: abc_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 1
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task200 import abc_automaton
|
||||
|
||||
class Task200Test(unittest.TestCase):
|
||||
"""Testy do zadania 200"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = abc_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("ac"))
|
||||
self.assertTrue(automaton.accepts("abc"))
|
||||
self.assertTrue(automaton.accepts("abbbbbbbbbbc"))
|
||||
|
||||
self.assertFalse(automaton.accepts("a"))
|
||||
self.assertFalse(automaton.accepts("c"))
|
||||
self.assertFalse(automaton.accepts("bbbc"))
|
||||
self.assertFalse(automaton.accepts("abcabc"))
|
||||
self.assertFalse(automaton.accepts(""))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,47 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 201
|
||||
|
||||
Napisz funkcję `is_initial_state_a_final_one(automaton)`, która
|
||||
sprawdza, czy stan początkowy automatu jest równocześnie
|
||||
stanem końcowym. Należy używać metod klasy (nie odwoływać
|
||||
się bezpośrednio do pól!).
|
||||
|
||||
NAME: is_initial_state_a_final_one
|
||||
PARAMS: automaton
|
||||
RETURN: bool
|
||||
POINTS: 2
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task201 import is_initial_state_a_final_one
|
||||
from deterministic_automaton import DeterministicAutomaton
|
||||
|
||||
class Task201Test(unittest.TestCase):
|
||||
"""Testy do zadania 201"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = DeterministicAutomaton()
|
||||
|
||||
state_a = automaton.add_state()
|
||||
state_b = automaton.add_state()
|
||||
|
||||
automaton.mark_as_initial(state_b)
|
||||
|
||||
self.assertFalse(is_initial_state_a_final_one(automaton))
|
||||
|
||||
automaton.mark_as_final(state_a)
|
||||
|
||||
self.assertFalse(is_initial_state_a_final_one(automaton))
|
||||
|
||||
automaton.mark_as_final(state_b)
|
||||
|
||||
self.assertTrue(is_initial_state_a_final_one(automaton))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,49 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 202
|
||||
|
||||
Napisz funkcję `get_number_of_final_states(automaton)`, która oblicza
|
||||
liczbę stanów końcowych automatu. Należy używać metod klasy (nie
|
||||
odwoływać się bezpośrednio do pól!).
|
||||
|
||||
|
||||
NAME: get_number_of_final_states
|
||||
PARAMS: automaton
|
||||
RETURN: int
|
||||
POINTS: 2
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task202 import get_number_of_final_states
|
||||
from deterministic_automaton import DeterministicAutomaton
|
||||
|
||||
class Task202Test(unittest.TestCase):
|
||||
"""Testy do zadania 202"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = DeterministicAutomaton()
|
||||
|
||||
state_a = automaton.add_state()
|
||||
state_b = automaton.add_state()
|
||||
state_c = automaton.add_state()
|
||||
|
||||
automaton.mark_as_initial(state_b)
|
||||
|
||||
self.assertEqual(get_number_of_final_states(automaton), 0)
|
||||
|
||||
automaton.mark_as_final(state_a)
|
||||
|
||||
self.assertEqual(get_number_of_final_states(automaton), 1)
|
||||
|
||||
automaton.mark_as_final(state_c)
|
||||
automaton.mark_as_final(state_b)
|
||||
|
||||
self.assertEqual(get_number_of_final_states(automaton), 3)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,51 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 203
|
||||
|
||||
Napisz funkcję `get_number_of_transitions(automaton, symbol)`, która
|
||||
oblicza liczbę przejść automatu etykietowanych zadanym symbolem.
|
||||
Należy używać metod klasy (nie odwoływać się bezpośrednio do pól!).
|
||||
|
||||
|
||||
NAME: get_number_of_transitions
|
||||
PARAMS: automaton, char
|
||||
RETURN: int
|
||||
POINTS: 3
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task203 import get_number_of_transitions
|
||||
from deterministic_automaton import DeterministicAutomaton
|
||||
|
||||
class Task203Test(unittest.TestCase):
|
||||
"""Testy do zadania 203"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = DeterministicAutomaton()
|
||||
|
||||
state_a = automaton.add_state()
|
||||
state_b = automaton.add_state()
|
||||
state_c = automaton.add_state()
|
||||
|
||||
automaton.mark_as_initial(state_b)
|
||||
automaton.mark_as_final(state_a)
|
||||
|
||||
self.assertEqual(get_number_of_transitions(automaton, 'b'), 0)
|
||||
|
||||
automaton.add_transition(state_b, 'a', state_a)
|
||||
|
||||
self.assertEqual(get_number_of_transitions(automaton, 'a'), 1)
|
||||
self.assertEqual(get_number_of_transitions(automaton, 'b'), 0)
|
||||
|
||||
automaton.add_transition(state_b, 'b', state_a)
|
||||
automaton.add_transition(state_a, 'b', state_b)
|
||||
automaton.add_transition(state_c, 'b', state_a)
|
||||
|
||||
self.assertEqual(get_number_of_transitions(automaton, 'b'), 3)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,52 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 204
|
||||
|
||||
Napisz funkcję `get_number_of_loops(automaton, symbol)`, która
|
||||
oblicza liczbę pętli (tj. przejść od stanu z powrotem do danego
|
||||
stanu) w zadanym automacie etykietowanych zadanym symbolem.
|
||||
|
||||
NAME: get_number_of_loops
|
||||
PARAMS: automaton, char
|
||||
RETURN: int
|
||||
POINTS: 2
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task204 import get_number_of_loops
|
||||
from deterministic_automaton import DeterministicAutomaton
|
||||
|
||||
class Task204Test(unittest.TestCase):
|
||||
"""Testy do zadania 204"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = DeterministicAutomaton()
|
||||
|
||||
state_a = automaton.add_state()
|
||||
state_b = automaton.add_state()
|
||||
state_c = automaton.add_state()
|
||||
|
||||
automaton.mark_as_initial(state_b)
|
||||
automaton.mark_as_final(state_a)
|
||||
|
||||
self.assertEqual(get_number_of_loops(automaton, 'b'), 0)
|
||||
|
||||
automaton.add_transition(state_b, 'a', state_a)
|
||||
|
||||
self.assertEqual(get_number_of_loops(automaton, 'a'), 0)
|
||||
self.assertEqual(get_number_of_loops(automaton, 'b'), 0)
|
||||
|
||||
automaton.add_transition(state_b, 'b', state_b)
|
||||
automaton.add_transition(state_c, 'b', state_c)
|
||||
automaton.add_transition(state_a, 'a', state_a)
|
||||
automaton.add_transition(state_a, 'b', state_b)
|
||||
|
||||
self.assertEqual(get_number_of_loops(automaton, 'a'), 1)
|
||||
self.assertEqual(get_number_of_loops(automaton, 'b'), 2)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 205
|
||||
|
||||
Napisz funkcję `haha_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje śmiechy
|
||||
tj. napisy typu "hahaha!!!", gdzie ha powtarza
|
||||
się przynajmniej dwa razy, wykrzyknik występuje dowolną liczbę
|
||||
razy (przynajmniej raz).
|
||||
|
||||
NAME: haha_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task205 import haha_automaton
|
||||
|
||||
class Task205Test(unittest.TestCase):
|
||||
"""Testy do zadania 205"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = haha_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("hahaha!!!!!!!!!"))
|
||||
self.assertTrue(automaton.accepts("haha!"))
|
||||
self.assertTrue(automaton.accepts("hahahaha!!"))
|
||||
self.assertFalse(automaton.accepts("ha!!!!!"))
|
||||
self.assertFalse(automaton.accepts("hahaha"))
|
||||
self.assertFalse(automaton.accepts("hahoha"))
|
||||
self.assertFalse(automaton.accepts("!!haha"))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,38 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 206
|
||||
|
||||
Napisz funkcję `big_no_automaton()`, która tworzy i zwraca automat,
|
||||
który akceptuje "Big NO!" tj. napisy typu "NOO...OO!", gdzie "O"
|
||||
powtarza się przynajmniej 5 razy (zob.
|
||||
http://tvtropes.org/pmwiki/pmwiki.php/Main/BigNo).
|
||||
|
||||
NAME: big_no_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task206 import big_no_automaton
|
||||
|
||||
class Task206Test(unittest.TestCase):
|
||||
"""Testy do zadania 206"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = big_no_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("NOOOOO!"))
|
||||
self.assertTrue(automaton.accepts("NOOOOOOOOOOOOOOOO!"))
|
||||
self.assertFalse(automaton.accepts("NOOOO!"))
|
||||
self.assertFalse(automaton.accepts("NOOOOOO!!!!!!"))
|
||||
self.assertFalse(automaton.accepts("NOOOOOO"))
|
||||
self.assertFalse(automaton.accepts("ONOOOOO!"))
|
||||
self.assertFalse(automaton.accepts(""))
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,47 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 207
|
||||
|
||||
Napisz funkcję `three_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
napisy reprezentujące liczby podzielne przez 3. Automat
|
||||
nie powinien akceptować napisów zaczynających
|
||||
nieznaczącymi zerami (np. "033").
|
||||
|
||||
NAME: three_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task207 import three_automaton
|
||||
|
||||
class Task207Test(unittest.TestCase):
|
||||
"""Testy do zadania 207"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = three_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("3"))
|
||||
self.assertTrue(automaton.accepts("0"))
|
||||
self.assertTrue(automaton.accepts("12"))
|
||||
self.assertTrue(automaton.accepts("324"))
|
||||
self.assertTrue(automaton.accepts("333333"))
|
||||
self.assertTrue(automaton.accepts("30003"))
|
||||
self.assertTrue(automaton.accepts("513"))
|
||||
|
||||
self.assertFalse(automaton.accepts("00"))
|
||||
self.assertFalse(automaton.accepts("012"))
|
||||
self.assertFalse(automaton.accepts("0000324"))
|
||||
self.assertFalse(automaton.accepts("1"))
|
||||
self.assertFalse(automaton.accepts("2"))
|
||||
self.assertFalse(automaton.accepts("5"))
|
||||
self.assertFalse(automaton.accepts("1111"))
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,49 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 208
|
||||
|
||||
Napisz funkcję `twenty_five_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
napisy reprezentujące liczby podzielne przez 25. Automat
|
||||
może akceptować napisy zaczynające
|
||||
nieznaczącymi zerami (np. "075"). Nie powinien akceptować natomiast
|
||||
samego zera ("0").
|
||||
|
||||
NAME: twenty_five_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task208 import twenty_five_automaton
|
||||
|
||||
class Task208Test(unittest.TestCase):
|
||||
"""Testy do zadania 208"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = twenty_five_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("25"))
|
||||
self.assertTrue(automaton.accepts("50"))
|
||||
self.assertTrue(automaton.accepts("75"))
|
||||
self.assertTrue(automaton.accepts("100"))
|
||||
self.assertTrue(automaton.accepts("1098375"))
|
||||
self.assertTrue(automaton.accepts("333325"))
|
||||
self.assertTrue(automaton.accepts("17150"))
|
||||
|
||||
self.assertTrue(automaton.accepts("025"))
|
||||
self.assertTrue(automaton.accepts("0000175"))
|
||||
self.assertFalse(automaton.accepts("1"))
|
||||
self.assertFalse(automaton.accepts("2"))
|
||||
self.assertFalse(automaton.accepts("5"))
|
||||
self.assertFalse(automaton.accepts("10"))
|
||||
self.assertFalse(automaton.accepts("45"))
|
||||
self.assertFalse(automaton.accepts("124"))
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 209
|
||||
|
||||
Napisz funkcję `monsters_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
wyłącznie napisy "Godzilla", "Ghidora" oraz "Mothra"
|
||||
i żadnych innych.
|
||||
|
||||
NAME: monsters_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task209 import monsters_automaton
|
||||
|
||||
class Task209Test(unittest.TestCase):
|
||||
"""Testy do zadania 209"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = monsters_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("Godzilla"))
|
||||
self.assertTrue(automaton.accepts("Ghidora"))
|
||||
self.assertTrue(automaton.accepts("Mothra"))
|
||||
|
||||
self.assertFalse(automaton.accepts("Biollante"))
|
||||
self.assertFalse(automaton.accepts(""))
|
||||
self.assertFalse(automaton.accepts("Godzil"))
|
||||
self.assertFalse(automaton.accepts("Kojot"))
|
||||
self.assertFalse(automaton.accepts("Godzra"))
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,45 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 210
|
||||
|
||||
Napisz funkcję `abc_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
napisy składające z dowolnej liczby
|
||||
znaków 'a', po których następuje dowolna liczba
|
||||
znaków 'b', po których następuje dowolna liczba
|
||||
znaków 'c'. "Dowolna" oznacza także zero.
|
||||
|
||||
NAME: abc_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task210 import abc_automaton
|
||||
|
||||
class Task210Test(unittest.TestCase):
|
||||
"""Testy do zadania 210"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = abc_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts(""))
|
||||
self.assertTrue(automaton.accepts("abc"))
|
||||
self.assertTrue(automaton.accepts("aaaaaaaabccc"))
|
||||
self.assertTrue(automaton.accepts("bbbccc"))
|
||||
self.assertTrue(automaton.accepts("ac"))
|
||||
self.assertTrue(automaton.accepts("abbbbbbbbbbbbbb"))
|
||||
|
||||
self.assertFalse(automaton.accepts("ba"))
|
||||
self.assertFalse(automaton.accepts("cccbbbaaa"))
|
||||
self.assertFalse(automaton.accepts("baba"))
|
||||
self.assertFalse(automaton.accepts("abcca"))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,41 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 211
|
||||
|
||||
Napisz funkcję `kot_automaton()`, która tworzy i zwraca automat, który
|
||||
akceptuje napisy "kos", "kot", "kat", "lot", "lat" i nie akceptuje
|
||||
żadnych innych napisów.
|
||||
|
||||
NAME: kot_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task211 import kot_automaton
|
||||
|
||||
class Task211Test(unittest.TestCase):
|
||||
"""Testy do zadania 211"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = kot_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("kos"))
|
||||
self.assertTrue(automaton.accepts("kot"))
|
||||
self.assertTrue(automaton.accepts("kat"))
|
||||
self.assertTrue(automaton.accepts("lot"))
|
||||
self.assertTrue(automaton.accepts("lat"))
|
||||
|
||||
self.assertFalse(automaton.accepts("ko"))
|
||||
self.assertFalse(automaton.accepts(""))
|
||||
self.assertFalse(automaton.accepts("los"))
|
||||
self.assertFalse(automaton.accepts("kota"))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,41 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 212
|
||||
|
||||
Napisz funkcję `negation_automaton()`, która tworzy i zwraca automat
|
||||
akceptujący wszystkie napisy nad alfabetem "abcd"
|
||||
z wyjątkiem napisu "abba".
|
||||
|
||||
NAME: negation_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task212 import negation_automaton
|
||||
|
||||
class Task212Test(unittest.TestCase):
|
||||
"""Testy do zadania 212"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = negation_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("abbb"))
|
||||
self.assertTrue(automaton.accepts("baca"))
|
||||
self.assertTrue(automaton.accepts("dddddd"))
|
||||
self.assertTrue(automaton.accepts("abbaa"))
|
||||
self.assertTrue(automaton.accepts("abb"))
|
||||
self.assertTrue(automaton.accepts("ab"))
|
||||
self.assertTrue(automaton.accepts(""))
|
||||
|
||||
self.assertFalse(automaton.accepts("abba"))
|
||||
self.assertFalse(automaton.accepts("xa"))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 213
|
||||
|
||||
Napisz funkcję `tricky_automaton()`, która tworzy i zwraca automat
|
||||
akceptujący wszystkie napisy złożone z napisu "abc" powtórzonego
|
||||
dowolną liczbę razy (ale przynajmniej raz) oraz napis "a".
|
||||
|
||||
NAME: tricky_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task213 import tricky_automaton
|
||||
|
||||
class Task213Test(unittest.TestCase):
|
||||
"""Testy do zadania 213"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = tricky_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("a"))
|
||||
self.assertTrue(automaton.accepts("abc"))
|
||||
self.assertTrue(automaton.accepts("abcabc"))
|
||||
self.assertTrue(automaton.accepts("abcabcabcabcabc"))
|
||||
|
||||
self.assertFalse(automaton.accepts("ab"))
|
||||
self.assertFalse(automaton.accepts(""))
|
||||
self.assertFalse(automaton.accepts("abca"))
|
||||
self.assertFalse(automaton.accepts("abcabca"))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,44 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 214
|
||||
|
||||
Napisz funkcję `hex_automaton()`, która tworzy i zwraca automat
|
||||
akceptujący napisy reprezentujące liczby szesnastkowo.
|
||||
Cyfry szesnastkowe mogą być reprezentowane za pomocą małych
|
||||
bądź wielkich liter, ale konsekwentnie ("a0f9" i "A0F9" ma być akceptowane,
|
||||
"a0F9" i "A0f9" - nie). Liczba może zawierać zera nieznaczące na początku.
|
||||
|
||||
NAME: hex_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task214 import hex_automaton
|
||||
|
||||
class Task214Test(unittest.TestCase):
|
||||
"""Testy do zadania 214"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = hex_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("a0f9"))
|
||||
self.assertTrue(automaton.accepts("A0F9"))
|
||||
self.assertTrue(automaton.accepts("0"))
|
||||
self.assertTrue(automaton.accepts("0B000"))
|
||||
self.assertTrue(automaton.accepts("DDDD"))
|
||||
self.assertTrue(automaton.accepts("baca"))
|
||||
|
||||
self.assertFalse(automaton.accepts("gg"))
|
||||
self.assertFalse(automaton.accepts("a0F9"))
|
||||
self.assertFalse(automaton.accepts("A0f9"))
|
||||
self.assertFalse(automaton.accepts("Baca"))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,48 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 215
|
||||
|
||||
Napisz funkcję `four_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
napisy reprezentujące liczby podzielne przez 4. Automat
|
||||
nie powinien akceptować napisów zaczynających
|
||||
nieznaczącymi zerami (np. "044").
|
||||
|
||||
NAME: four_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task215 import four_automaton
|
||||
|
||||
class Task215Test(unittest.TestCase):
|
||||
"""Testy do zadania 215"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = four_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("4"))
|
||||
self.assertTrue(automaton.accepts("0"))
|
||||
self.assertTrue(automaton.accepts("12"))
|
||||
self.assertTrue(automaton.accepts("324"))
|
||||
self.assertTrue(automaton.accepts("1052"))
|
||||
self.assertTrue(automaton.accepts("444444"))
|
||||
|
||||
self.assertFalse(automaton.accepts("012"))
|
||||
self.assertFalse(automaton.accepts("0000324"))
|
||||
self.assertFalse(automaton.accepts("5"))
|
||||
self.assertFalse(automaton.accepts("1"))
|
||||
self.assertFalse(automaton.accepts("3"))
|
||||
self.assertFalse(automaton.accepts("34"))
|
||||
self.assertFalse(automaton.accepts("1057"))
|
||||
self.assertFalse(automaton.accepts("4454"))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 216
|
||||
|
||||
Napisz funkcję `code_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
kody pocztowe (ciągi cyfra-cyfra-minus-cyfra-cyfr-cyfra).
|
||||
|
||||
NAME: code_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task216 import code_automaton
|
||||
|
||||
class Task216Test(unittest.TestCase):
|
||||
"""Testy do zadania 216"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = code_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("61-909"))
|
||||
self.assertTrue(automaton.accepts("22-340"))
|
||||
self.assertTrue(automaton.accepts("00-000"))
|
||||
self.assertTrue(automaton.accepts("99-999"))
|
||||
|
||||
self.assertFalse(automaton.accepts("61909"))
|
||||
self.assertFalse(automaton.accepts("61-90"))
|
||||
self.assertFalse(automaton.accepts("000-000"))
|
||||
self.assertFalse(automaton.accepts(""))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 217
|
||||
|
||||
Napisz funkcję `dna_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
niepuste ciągi złozone z liter "A", "C", "G" i "T"
|
||||
których długość jest wielokrotnością liczby 3.
|
||||
|
||||
NAME: dna_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task217 import dna_automaton
|
||||
|
||||
class Task217Test(unittest.TestCase):
|
||||
"""Testy do zadania 217"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = dna_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("AAACGT"))
|
||||
self.assertTrue(automaton.accepts("ACA"))
|
||||
self.assertTrue(automaton.accepts("ACAAAAGCAACAAAAGCA"))
|
||||
self.assertTrue(automaton.accepts("TTT"))
|
||||
|
||||
self.assertFalse(automaton.accepts("TT"))
|
||||
self.assertFalse(automaton.accepts("A"))
|
||||
self.assertFalse(automaton.accepts("AAACG"))
|
||||
self.assertFalse(automaton.accepts(""))
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,42 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 218
|
||||
|
||||
Napisz funkcję `binary_list_automaton()`, która
|
||||
tworzy i zwraca automat, który akceptuje
|
||||
napisy złożone z liczb zapisanych binarnie
|
||||
(bez zbędnych zer na początku) oddzielonych dwukropkami.
|
||||
Akceptowana powinna być także pojedyncza liczba.
|
||||
|
||||
NAME: binary_list_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task218 import binary_list_automaton
|
||||
|
||||
class Task218Test(unittest.TestCase):
|
||||
"""Testy do zadania 218"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = binary_list_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("100:11:11101"))
|
||||
self.assertTrue(automaton.accepts("1"))
|
||||
self.assertTrue(automaton.accepts("0:110"))
|
||||
|
||||
self.assertFalse(automaton.accepts(""))
|
||||
self.assertFalse(automaton.accepts("010:110"))
|
||||
self.assertFalse(automaton.accepts("2"))
|
||||
self.assertFalse(automaton.accepts("100::11:11101"))
|
||||
self.assertFalse(automaton.accepts("100:11:11101:"))
|
||||
self.assertFalse(automaton.accepts(":100:11:11101"))
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,45 +0,0 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Zadanie 219
|
||||
|
||||
Napisz funkcję `alt_automaton()`, która
|
||||
tworzy i zwraca automat, akceptujący
|
||||
napisy złożone z "abc" powielonego dowolną liczbę razy
|
||||
(w tym zero) oraz napisy złożone z "ab" powielonego
|
||||
dowolną liczbę razy.
|
||||
|
||||
NAME: alt_automaton
|
||||
PARAMS: -
|
||||
RETURN: DeterministicAutomaton
|
||||
POINTS: 8
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from Task219 import alt_automaton
|
||||
|
||||
class Task219Test(unittest.TestCase):
|
||||
"""Testy do zadania 219"""
|
||||
|
||||
def test_simple(self):
|
||||
"""Prosty test."""
|
||||
|
||||
automaton = alt_automaton()
|
||||
|
||||
self.assertTrue(automaton.accepts("abababab"))
|
||||
self.assertTrue(automaton.accepts("abcabc"))
|
||||
self.assertTrue(automaton.accepts("abc"))
|
||||
self.assertTrue(automaton.accepts("ab"))
|
||||
self.assertTrue(automaton.accepts(""))
|
||||
self.assertTrue(automaton.accepts("abab"))
|
||||
self.assertTrue(automaton.accepts("abcabcabcabcabcabcabcabc"))
|
||||
|
||||
self.assertFalse(automaton.accepts("ba"))
|
||||
self.assertFalse(automaton.accepts("abca"))
|
||||
self.assertFalse(automaton.accepts("aba"))
|
||||
self.assertFalse(automaton.accepts("ababc"))
|
||||
self.assertFalse(automaton.accepts("abcab"))
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@ -1,122 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Automat deterministyczny.
|
||||
"""
|
||||
|
||||
class DeterministicAutomaton:
|
||||
"""
|
||||
Klasa reprezentująca deterministyczny automat skończenie stanowy.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
"""
|
||||
Konstruktor.
|
||||
"""
|
||||
|
||||
# Liczba wszystkich stanów,
|
||||
# stany będą identyfikowane przez kolejne liczby:
|
||||
# 0, 1, ..., number_of_states - 1
|
||||
self.number_of_states = 0
|
||||
|
||||
# przejścia będą przechowywane w tablicy
|
||||
# haszującej indeksowanej parą stan-znak,
|
||||
# tj. transitions[(state_from, character)]
|
||||
# przechowuje stan docelowy przy
|
||||
# przejściu od stanu state_from przez znak
|
||||
# character
|
||||
self.transitions = { }
|
||||
|
||||
# stan początkowy
|
||||
self.initial_state = None
|
||||
|
||||
# zbiór stanów końcowych
|
||||
self.final_states = set()
|
||||
|
||||
# funkcje modyfikujące automat
|
||||
|
||||
def add_state(self):
|
||||
"""
|
||||
Dodaje nowy stan, zwraca numer utworzonego stanu
|
||||
"""
|
||||
self.number_of_states += 1
|
||||
return self.number_of_states - 1
|
||||
|
||||
def add_transition(self, state_from, symbol, state_to):
|
||||
"""
|
||||
Dodaje przejście od stanu state_from przez znak symbol
|
||||
do stanu state_to.
|
||||
"""
|
||||
self.transitions[(state_from, symbol)] = state_to
|
||||
|
||||
def mark_as_initial(self, state):
|
||||
"""
|
||||
Oznacza stan jako początkowy.
|
||||
"""
|
||||
self.initial_state = state
|
||||
|
||||
def mark_as_final(self, state):
|
||||
"""
|
||||
Oznacza stan jako końcowy.
|
||||
"""
|
||||
self.final_states.add(state)
|
||||
|
||||
# dostęp do automatu
|
||||
|
||||
def get_number_of_states(self):
|
||||
"""
|
||||
Zwraca liczbę stanów.
|
||||
"""
|
||||
return self.number_of_states
|
||||
|
||||
def get_initial_state(self):
|
||||
"""
|
||||
Zwraca stan początkowy.
|
||||
"""
|
||||
return self.initial_state
|
||||
|
||||
def is_final_state(self, state):
|
||||
"""
|
||||
Zwraca informacje, czy stan jest końcowy.
|
||||
"""
|
||||
return state in self.final_states
|
||||
|
||||
def get_target_state(self, state_from, symbol):
|
||||
"""
|
||||
Zwraca stan docelowy, przy przejściu od stanu state_from
|
||||
przez symbol bądź wartość None, jeśli nie
|
||||
ma takiego przejścia.
|
||||
"""
|
||||
return self.transitions.get((state_from, symbol))
|
||||
|
||||
def accepts(self, string):
|
||||
"""
|
||||
Sprawdza, czy automat akceptuje napis.
|
||||
"""
|
||||
current_state = self.get_initial_state()
|
||||
|
||||
for symbol in string:
|
||||
current_state = self.get_target_state(current_state, symbol)
|
||||
|
||||
if current_state is None:
|
||||
return False
|
||||
|
||||
return self.is_final_state(current_state)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
# budowanie automatu
|
||||
AUTOMATON = DeterministicAutomaton()
|
||||
|
||||
INITIAL_STATE = AUTOMATON.add_state()
|
||||
FINAL_STATE = AUTOMATON.add_state()
|
||||
AUTOMATON.add_transition(INITIAL_STATE, 'x', FINAL_STATE)
|
||||
|
||||
AUTOMATON.mark_as_initial(INITIAL_STATE)
|
||||
AUTOMATON.mark_as_final(FINAL_STATE)
|
||||
|
||||
# uruchamianie automatu
|
||||
print(AUTOMATON.accepts("x")) # wypisze True
|
||||
print(AUTOMATON.accepts("")) # wypisze False
|
||||
print(AUTOMATON.accepts("ab")) # wypisze False
|
||||
4
blend.sh
4
blend.sh
@ -14,8 +14,8 @@ mkdir arena
|
||||
cp -R $STUDENT_DIR/* arena/
|
||||
ln -s ../$STUDENT_DIR/.git arena/.git
|
||||
|
||||
mkdir -p arena/regexp
|
||||
mkdir -p arena/automata
|
||||
#mkdir -p arena/regexp
|
||||
#mkdir -p arena/automata
|
||||
|
||||
rm -rf arena/odp arena/$PREFIX
|
||||
|
||||
|
||||
@ -1,8 +0,0 @@
|
||||
448696 102 1
|
||||
448696 104 1
|
||||
448696 107 1
|
||||
448696 110 1
|
||||
448696 301 3
|
||||
448696 302 4
|
||||
448696 303 3
|
||||
448696 304 2
|
||||
@ -1,37 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,36 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,39 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,41 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,45 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,39 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,31 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,41 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,42 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,34 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,43 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,39 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,39 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,41 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,39 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,41 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,39 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,43 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,38 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,35 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,38 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,37 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,40 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,39 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,41 +0,0 @@
|
||||
#!/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()
|
||||
@ -1,38 +0,0 @@
|
||||
#!/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()
|
||||
12
vars
12
vars
@ -9,15 +9,15 @@ POINT_LIMIT=15
|
||||
|
||||
typeset -A TIME_LIMITS
|
||||
set -A TIME_LIMITS \
|
||||
"1" "2021-01-08 10:00:00 +0100" \
|
||||
"2" "2021-01-22 23:59:59 +0100" \
|
||||
"3" "2021-01-08 13:00:00 +0100"
|
||||
"1" "2020-11-27 10:00:00 +0100" \
|
||||
"2" "2020-01-31 23:59:59 +0100" \
|
||||
"3" "2020-01-25 13:00:00 +0100"
|
||||
|
||||
typeset -A HOME_TIME_LIMITS
|
||||
set -A HOME_TIME_LIMITS \
|
||||
"1" "2021-01-08 10:00:00 +0100" \
|
||||
"2" "2021-01-22 23:59:59 +0100" \
|
||||
"3" "2021-01-08 13:00:00 +0100"
|
||||
"1" "2020-11-27 10:45:00 +0100" \
|
||||
"2" "2020-01-31 23:59:59 +0100" \
|
||||
"3" "2020-01-25 13:00:00 +0100"
|
||||
|
||||
|
||||
typeset -A HOME_POINT_LIMITS
|
||||
|
||||
Loading…
Reference in New Issue
Block a user