F

 Conflicts:

	README.md

	TaskB00/run.py

	TaskC01/test.exp

.idea/.gitignore

@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml

.idea/DJFZ-2023.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

.idea/jpa-buddy.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JpaBuddyIdeaProjectConfig">
-    <option name="renamerInitialized" value="true" />
-  </component>
-</project>

.idea/misc.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_18" project-jdk-name="Python 3.11 (PythonTest)" project-jdk-type="Python SDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-  <component name="ProjectType">
-    <option name="id" value="jpab" />
-  </component>
-</project>

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/DJFZ-2023.iml" filepath="$PROJECT_DIR$/.idea/DJFZ-2023.iml" />
-    </modules>
-  </component>
-</project>

README.md

@@ -23,7 +23,7 @@ nie będzie wpływał na ocenę, ale bez zdanego kolowkium nie da się zaliczyć
 Proszę stworzyć prywatne repozytorium na https://git.wmi.amu.edu.pl/ o nazwie djfz-2023-sNRINDEKSU oraz dać 
 prawa do odczytu użytkownikowi bfijalkowski (prowadzący przedmiot). W NRINDEKSU proszę wpisać swój nr indeksu, np. djfz-2023-s123456.
 
-Następnie w swoim repozytorium proszę spullować niniejsze repozytorium: `git pull git@git.wmi.amu.edu.pl:bfijalkowski/DJFZ-2023.git`
+Następnie w swoim repozytorium proszę zforkować niniejsze repozytorium: `git pull git@git.wmi.amu.edu.pl:bfijalkowski/DJFZ-2023.git`
 W ten sposób będziemy aktualizować zadania co zajęcia.
 
 Proszę rozwiązać zadanie TASKX02 lub TASKX03 w zależności od numeru indeksu. W tym celu należy dodać plik `run.py`
@@ -48,3 +48,279 @@ B00 - zadanie wykonywane wspólnie na zajęciach
 B01-B04, B06-B09 - po jedno dla każdego
 B05 - jedno dla wszystkich
 
+## Zajęcia 2 30.10.2023 Automaty niedeterministyczne skończone
+
+C00 - zadanie wykonywane wspólnie na zajęciach
+C01-C03, C04-C06 - po jedno dla każdego
+
+## Zajęcia 3 13.11.2023 Wyrażenia regularne
+
+D01 - D04 - do wykonania przez każdego
+
+Dokumentacja wyrażeń regularnych w python3: https://docs.python.org/3/library/re.html
+
+### Podstawowe funkcje
+
+search - zwraca pierwsze dopasowanie w napisie
+
+findall - zwraca listę wszystkich dopasowań (nienakładających się na siebie)
+
+match - zwraca dopasowanie od początku string
+
+To tylko podstawowe funkcje, z których będziemy korzystać. W dokumentacji opisane są wszystkie.
+
+### Obiekt match
+
+```
+import re
+answer = re.search('na','banan')
+print(answer)
+print(type(answer))
+print(answer.start())
+print(answer.end())
+print(answer.group())
+
+answer = re.search('na','kabanos')
+print(answer)
+
+if answer:
+    print(answer.group())
+else:
+    pass
+```
+
+### Metaznaki
+
+
+- [] -  zbiór znaków
+- . - jakikolwiek znak
+
+- ^ - początek napisu
+- $ - koniec napisu
+
+- ? - znak występuje lub nie występuje
+- \* - zero albo więcej pojawień się
+- \+ - jeden albo więcej pojawień się
+- {} - dokładnie tyle pojawień się
+
+- | - lub
+- () - grupa
+- \ -znak ucieczki
+
+- \d digit
+- \D nie digit
+- \s whitespace
+- \S niewhitespace
+
+
+### Flagi
+
+Można użyć specjalnych flag, np:
+`re.search('ma', 'AlA Ma KoTa', re.IGNORECASE)`.
+
+### Przykłady (objaśnienia na laboratoriach)
+
+```
+import re
+
+text = 'Ala ma kota i hamak, oraz 150 bananów.'
+
+re.search('ma',text)
+re.match('ma',text)
+re.match('Ala ma',text)
+re.findall('ma',text)
+
+re.findall('[mn]a',text)
+re.findall('[0-9]',text)
+re.findall('[0-9abc]',text)
+re.findall('[a-z][a-z]ma[a-z]',text)
+re.findall('[a-zA-Z][a-zA-Z]ma[a-zA-z0-9]',text)
+re.findall('\d',text)
+
+re.search('[0-9][0-9][0-9]',text)
+re.search('[\d][\d][\d]',text)
+
+re.search('\d{2}',text)
+re.search('\d{3}',text)
+
+re.search('\d+',text)
+
+re.search('\d+ bananów',text)
+re.search('\d* bananów','Ala ma dużo bananów')
+re.search('\d* bananów',text)
+re.search('ma \d? bananów','Ala ma 5 bananów')
+re.search('ma ?\d? bananów','Ala ma bananów')
+re.search('ma( \d)? bananów','Ala ma bananów') 
+
+re.search('\d+ bananów','Ala ma 10 bananów albo 20 bananów')
+re.search('\d+ bananów$','Ala ma 10 bananów albo 20 bananów')
+
+text = 'Ala ma kota i hamak, oraz 150	bananów.'
+
+re.search('\d+ bananów',text)
+
+re.search('\d+\sbananów',text)
+
+re.search('kota . hamak',text)
+
+re.search('kota . hamak','Ala ma kota z hamakiem')
+
+re.search('kota .* hamak','Ala ma kota lub hamak')
+
+re.search('\.',text)
+
+re.search('kota|psa','Ala ma kota lub hamak')
+
+re.findall('kota|psa','Ala ma kota lub psa')
+
+re.search('kota (i|lub) psa','Ala ma kota lub psa')
+
+re.search('mam (kota).*(kota|psa)','Ja mam kota. Ala ma psa.').group(0)
+
+re.search('mam (kota).*(kota|psa)','Ja mam kota. Ala ma psa.').group(1)
+
+re.search('mam (kota).*(kota|psa)','Ja mam kota. Ala ma psa.').group(2)
+```
+
+### Przykłady wyrażenia regularne 2 (objaśnienia na laboratoriach)
+
+####  ^
+```
+re.search('[0-9]+', '123-456-789')
+re.search('[^0-9][0-9]+[^0-9]', '123-456-789')
+```
+
+#### cudzysłów
+'' oraz "" - oznaczają to samo w pythonie
+
+' ala ma psa o imieniu "Burek"'
+
+" ala ma psa o imieniu 'Burek' "
+
+' ala ma psa o imieniu \'Burek\' '
+
+" ala ma psa o imieniu \"Burek\" "
+
+#### multiline string
+
+#### raw string
+
+przy raw string znaki \ traktowane są jako zwykłe znaki \
+
+chociaż nawet w raw string nadal są escapowane (ale wtedy \ pozostają również w stringu bez zmian)
+
+https://docs.python.org/3/reference/lexical_analysis.html
+
+dobra praktyka - wszędzie escapować
+
+```
+'\\'
+print('\\')
+
+r'\\'
+print(r'\\')
+
+
+print("abcd")
+print("ab\cd")
+print(r"ab\cd")
+
+print("ab\nd")
+print(r"ab\nd")
+
+
+print("\"")
+print(r"\"")
+
+print("\")
+print(r"\")
+
+re.search('\\', r'a\bc')
+re.search(r'\\', r'a\bc')
+re.search('\\\\', r'a\bc')
+```
+## Zajęcia 4 27.11.2023 Wyrażenia regularne 2
+
+E00 - E09 - po jedno dla każdego
+
+E10 - E36 - po jedno dla każdego
+
+E37 - E43 - po jedno dla każdego
+
+E44 - E48 - po jedno dla każdego
+
+## Zajęcia 5 11.12.2023 Wyrażenia regularne 3
+
+F00 - F05 - do wykonania przez każdego
+
+Proszę o przekopiowanie sobie pliku polish_wiki_excerpt.in z zadania F00 do katalogów z pozostałymi zadaniami
+
+#### RE SUB
+```
+re.sub(pattern, replacement, string)
+
+re.sub('a','b', 'ala ma kota')
+```
+
+#### backreferencje:
+
+```
+
+re.search(r' \d+ \d+', 'ala ma 41 41 kota')
+re.search(r' \d+ \d+', 'ala ma 41 123 kota')
+re.search(r' (\d+) \1', 'ala ma 41 41 kota')
+re.search(r' (\d+) \1', 'ala ma 41 123 kota')
+```
+
+#### lookahead ( to sa takie assercje):
+```
+re.search(r'ma kot', 'ala ma kot')
+re.search(r'ma kot(?=[ay])', 'ala ma kot')
+re.search(r'ma kot(?=[ay])', 'ala ma kotka')
+re.search(r'ma kot(?=[ay])', 'ala ma koty')
+re.search(r'ma kot(?=[ay])', 'ala ma kota')
+
+re.search(r'ma kot(?![ay])', 'ala ma kot')
+re.search(r'ma kot(?![ay])', 'ala ma kotka')
+re.search(r'ma kot(?![ay])', 'ala ma koty')
+re.search(r'ma kot(?![ay])', 'ala ma kota')
+```
+
+#### named groups
+```
+r = re.search(r'ma (?P<ilepsow>\d+) kotow i (?P<ilekotow>\d+) psow', 'ala ma 100 kotow i 200 psow')
+r.groups()
+r.groups('ilepsow')
+r.groups('ilekotow')
+```
+
+#### re.split
+```
+('a,b.c,d').split(',')
+('a,b.c,d').split(',')
+('a,b.c,d').split(',.')
+re.split(r',', 'a,b.c,d') 
+re.split(r'[.,]', 'a,b.c,d') 
+```
+#### \w word character
+```
+\w - matchuje Unicod word character , jeżeli flaga ASCII to [a-zA-Z0-9_]
+\w - odwrotne do \W, jezeli flaga ASCI to [^a-zA-Z0-9_]
+
+re.findall(r'\w+', 'ala ma 3 koty.')
+re.findall(r'\W+', 'ala ma 3 koty.')
+```
+#### początek albo koniec słowa | word boundary
+```
+re.search(r'\bkot\b', 'Ala ma kota')
+re.search(r'\bkot\b', 'Ala ma kot')
+re.search(r'\bkot\b', 'Ala ma kot.')
+re.search(r'\bkot\b', 'Ala ma kot ')
+
+re.search(r'\Bot\B', 'Ala ma kot ')
+re.search(r'\Bot\B', 'Ala ma kota ')
+```
+#### MULTILINE
+```
+re.findall(r'^Ma', 'Ma kota Ala\nMa psa Jacek') 
+re.findall(r'^Ma', 'Ma kota Ala\nMa psa Jacek', re.MULTILINE)

TaskB00/run.py

@@ -0,0 +1,63 @@
+import sys
+
+
+class FSA:
+
+    def __init__(self):
+        self.initial_state = '0'  # zakładamy dla uproszczenia, że initial state = 0
+        self.final_states = set()
+
+        self.transitions = dict()
+        self.alphabet = set()
+
+    def add_transition(self, state_from, state_to, symbol):
+
+        if state_from in self.transitions.keys():
+            self.transitions[state_from][symbol] = state_to
+        else:
+            self.transitions[state_from] = dict()
+            self.transitions[state_from][symbol] = state_to
+
+    def add_final_state(self, state):
+        self.final_states.add(state)
+
+    def get_final_state(self, string):
+
+        current_state = self.initial_state
+        for symbol in string:
+            current_state = self.transitions[current_state][symbol]
+        return current_state
+
+    def accepts(self, string):
+
+        if self.get_final_state(string) in self.final_states:
+            return True
+        else:
+            return False
+
+
+fsa = FSA()
+
+table = open(sys.argv[1])
+for line in table:
+    line = line.rstrip('\n')
+    if len(line.split('\t')) == 3:
+        a, b, c = line.split('\t')
+        fsa.add_transition(a, b, c)
+        fsa.alphabet.add(c)
+    elif len(line.split('\t')) == 1:
+        fsa.add_final_state(line)
+    else:
+        assert False
+
+for line in sys.stdin:
+
+    line = line.rstrip()
+    for symbol in line:
+        if symbol not in fsa.alphabet:
+            assert False
+
+    if fsa.accepts(line):
+        print('YES')
+    else:
+        print('NO')

TaskB00/test1.out

@@ -0,0 +1,9 @@
+NO
+YES
+NO
+NO
+NO
+NO
+NO
+NO
+NO

TaskB01/description.txt

@@ -9,5 +9,5 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 2
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59
 REMAINDER: 1/4

TaskB02/description.txt

@@ -9,5 +9,5 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 2
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59
 REMAINDER: 2/4

TaskB03/description.txt

@@ -10,5 +10,5 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 2
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59
 REMAINDER: 3/4

TaskB03/fsa_description.arg

@@ -0,0 +1,5 @@
+0	1	0
+0	0	1
+1	0	0
+1	1	1
+0

TaskB03/run.py

@@ -0,0 +1,59 @@
+import sys
+
+
+class FSA:
+
+    def __init__(self):
+        self.initial_state = '0'  # zakładamy dla uproszczenia, że initial state = 0
+        self.final_states = set()
+
+        self.transitions = dict()
+        self.alphabet = set()
+
+    def add_transition(self, state_from, state_to, symbol):
+
+        if state_from in self.transitions.keys():
+            self.transitions[state_from][symbol] = state_to
+        else:
+            self.transitions[state_from] = dict()
+            self.transitions[state_from][symbol] = state_to
+
+    def add_final_state(self, state):
+        self.final_states.add(state)
+
+    def get_final_state(self, string):
+
+        current_state = self.initial_state
+        for symbol in string:
+            current_state = self.transitions[current_state][symbol]
+        return current_state
+
+    def accepts(self, string):
+
+        if self.get_final_state(string) in self.final_states:
+            return True
+        else:
+            return False
+
+if __name__ == "__main__":
+    fsa = FSA()
+
+    table = open(sys.argv[1])
+    for line in table:
+        line = line.rstrip('\n')
+        if len(line.split('\t')) == 3:
+            a, b, c = line.split('\t')
+            fsa.add_transition(a, b, c)
+            fsa.alphabet.add(c)
+        elif len(line.split('\t')) == 1:
+            fsa.add_final_state(line)
+        else:
+            assert False
+
+
+    for line in sys.stdin:
+        stripped_line = line.strip()
+        if fsa.accepts(stripped_line):
+            print('YES')
+        else:
+            print('NO')

TaskB03/test.out

@@ -0,0 +1,14 @@
+NO
+NO
+YES
+YES
+YES
+NO
+YES
+NO
+YES
+NO
+YES
+YES
+NO
+YES

TaskB04/description.txt

@@ -10,5 +10,5 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 2
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59
 REMAINDER: 0/4

TaskB05/description.txt

@@ -9,4 +9,4 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 2
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59

TaskB05/fsa_description.arg

@@ -0,0 +1,56 @@
+0	0	0
+0	1	1
+0	0	2
+0	0	3
+0	0	4
+0	0	5
+0	0	6
+0	0	7
+0	0	8
+0	0	9
+0	0	x
+1	0	0
+1	1	1
+1	0	2
+1	0	3
+1	0	4
+1	0	5
+1	0	6
+1	0	7
+1	0	8
+1	2	9
+1	0	x
+2	3	0
+2	3	1
+2	3	2
+2	3	3
+2	3	4
+2	3	5
+2	3	6
+2	3	7
+2	3	8
+2	3	9
+2	0	x
+3	4	0
+3	4	1
+3	4	2
+3	4	3
+3	4	4
+3	4	5
+3	4	6
+3	4	7
+3	4	8
+3	4	9
+3	0	x
+4	4	0
+4	4	1
+4	4	2
+4	4	3
+4	4	4
+4	4	5
+4	4	6
+4	4	7
+4	4	8
+4	4	9
+4	4	x
+4

TaskB05/run.py

@@ -0,0 +1,59 @@
+import sys
+
+
+class FSA:
+
+    def __init__(self):
+        self.initial_state = '0'  # zakładamy dla uproszczenia, że initial state = 0
+        self.final_states = set()
+
+        self.transitions = dict()
+        self.alphabet = set()
+
+    def add_transition(self, state_from, state_to, symbol):
+
+        if state_from in self.transitions.keys():
+            self.transitions[state_from][symbol] = state_to
+        else:
+            self.transitions[state_from] = dict()
+            self.transitions[state_from][symbol] = state_to
+
+    def add_final_state(self, state):
+        self.final_states.add(state)
+
+    def get_final_state(self, string):
+
+        current_state = self.initial_state
+        for symbol in string:
+            current_state = self.transitions[current_state][symbol]
+        return current_state
+
+    def accepts(self, string):
+
+        if self.get_final_state(string) in self.final_states:
+            return True
+        else:
+            return False
+
+if __name__ == "__main__":
+    fsa = FSA()
+
+    table = open(sys.argv[1])
+    for line in table:
+        line = line.rstrip('\n')
+        if len(line.split('\t')) == 3:
+            a, b, c = line.split('\t')
+            fsa.add_transition(a, b, c)
+            fsa.alphabet.add(c)
+        elif len(line.split('\t')) == 1:
+            fsa.add_final_state(line)
+        else:
+            assert False
+
+
+    for line in sys.stdin:
+        stripped_line = line.strip()
+        if fsa.accepts(stripped_line):
+            print('YES')
+        else:
+            print('NO')

TaskB05/simple.out

@@ -0,0 +1,6 @@
+NO
+YES
+NO
+NO
+YES
+YES

TaskB06/description.txt

@@ -9,5 +9,5 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 3
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59
 REMAINDER: 0/4

TaskB07/description.txt

@@ -9,5 +9,5 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 3
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59
 REMAINDER: 1/4

TaskB08/description.txt

@@ -9,5 +9,5 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 3
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59
 REMAINDER: 2/4

TaskB09/description.txt

@@ -9,5 +9,5 @@ If a string is accepted by the
 automaton, write YES, otherwise- write NO.
 
 POINTS: 3
-DEADLINE: 2020-11-07 23:59:00
+DEADLINE: 2023-10-29 23:59:59
 REMAINDER: 3/4

TaskB09/fsa_description.arg

@@ -0,0 +1,217 @@
+0	0	a
+0	0	b
+0	0	c
+0	0	d
+0	0	e
+0	0	f
+0	0	g
+0	0	h
+0	0	i
+0	0	j
+0	0	k
+0	0	l
+0	1	m
+0	0	n
+0	0	o
+0	0	p
+0	0	q
+0	0	r
+0	0	s
+0	0	t
+0	0	u
+0	0	v
+0	0	w
+0	0	x
+0	0	y
+0	0	z
+0	0	
+1	2	a
+1	0	b
+1	0	c
+1	0	d
+1	0	e
+1	0	f
+1	0	g
+1	0	h
+1	0	i
+1	0	j
+1	0	k
+1	0	l
+1	0	m
+1	0	n
+1	0	o
+1	0	p
+1	0	q
+1	0	r
+1	0	s
+1	0	t
+1	0	u
+1	0	v
+1	0	w
+1	0	x
+1	0	y
+1	0	z
+1	0	
+2	0	a
+2	0	b
+2	3	c
+2	0	d
+2	0	e
+2	0	f
+2	0	g
+2	0	h
+2	0	i
+2	0	j
+2	0	k
+2	0	l
+2	0	m
+2	0	n
+2	0	o
+2	0	p
+2	0	q
+2	0	r
+2	0	s
+2	0	t
+2	0	u
+2	0	v
+2	0	w
+2	0	x
+2	0	y
+2	0	z
+2	0	
+3	0	a
+3	4	b
+3	0	c
+3	0	d
+3	0	e
+3	0	f
+3	0	g
+3	0	h
+3	0	i
+3	0	j
+3	0	k
+3	0	l
+3	0	m
+3	0	n
+3	0	o
+3	0	p
+3	0	q
+3	0	r
+3	0	s
+3	0	t
+3	0	u
+3	0	v
+3	0	w
+3	0	x
+3	0	y
+3	0	z
+3	0	
+4	0	a
+4	0	b
+4	0	c
+4	0	d
+4	5	e
+4	0	f
+4	0	g
+4	0	h
+4	0	i
+4	0	j
+4	0	k
+4	0	l
+4	0	m
+4	0	n
+4	0	o
+4	0	p
+4	0	q
+4	0	r
+4	0	s
+4	0	t
+4	0	u
+4	0	v
+4	0	w
+4	0	x
+4	0	y
+4	0	z
+4	0	
+5	0	a
+5	0	b
+5	0	c
+5	0	d
+5	0	e
+5	0	f
+5	0	g
+5	0	h
+5	0	i
+5	0	j
+5	0	k
+5	0	l
+5	0	m
+5	0	n
+5	0	o
+5	0	p
+5	0	q
+5	0	r
+5	0	s
+5	6	t
+5	0	u
+5	0	v
+5	0	w
+5	0	x
+5	0	y
+5	0	z
+5	0	
+6	0	a
+6	0	b
+6	0	c
+6	0	d
+6	0	e
+6	0	f
+6	0	g
+6	7	h
+6	0	i
+6	0	j
+6	0	k
+6	0	l
+6	0	m
+6	0	n
+6	0	o
+6	0	p
+6	0	q
+6	0	r
+6	0	s
+6	0	t
+6	0	u
+6	0	v
+6	0	w
+6	0	x
+6	0	y
+6	0	z
+6	0	
+7	7	a
+7	7	b
+7	7	c
+7	7	d
+7	7	e
+7	7	f
+7	7	g
+7	7	h
+7	7	i
+7	7	j
+7	7	k
+7	7	l
+7	7	m
+7	7	n
+7	7	o
+7	7	p
+7	7	q
+7	7	r
+7	7	s
+7	7	t
+7	7	u
+7	7	v
+7	7	w
+7	7	x
+7	7	y
+7	7	z
+7	7	
+7

TaskB09/run.py

@@ -0,0 +1,59 @@
+import sys
+
+
+class FSA:
+
+    def __init__(self):
+        self.initial_state = '0'  # zakładamy dla uproszczenia, że initial state = 0
+        self.final_states = set()
+
+        self.transitions = dict()
+        self.alphabet = set()
+
+    def add_transition(self, state_from, state_to, symbol):
+
+        if state_from in self.transitions.keys():
+            self.transitions[state_from][symbol] = state_to
+        else:
+            self.transitions[state_from] = dict()
+            self.transitions[state_from][symbol] = state_to
+
+    def add_final_state(self, state):
+        self.final_states.add(state)
+
+    def get_final_state(self, string):
+
+        current_state = self.initial_state
+        for symbol in string:
+            current_state = self.transitions[current_state][symbol]
+        return current_state
+
+    def accepts(self, string):
+
+        if self.get_final_state(string) in self.final_states:
+            return True
+        else:
+            return False
+
+if __name__ == "__main__":
+    fsa = FSA()
+
+    table = open(sys.argv[1])
+    for line in table:
+        line = line.rstrip('\n')
+        if len(line.split('\t')) == 3:
+            a, b, c = line.split('\t')
+            fsa.add_transition(a, b, c)
+            fsa.alphabet.add(c)
+        elif len(line.split('\t')) == 1:
+            fsa.add_final_state(line)
+        else:
+            assert False
+
+
+    for line in sys.stdin:
+        stripped_line = line.strip()
+        if fsa.accepts(stripped_line):
+            print('YES')
+        else:
+            print('NO')

TaskB09/simple.out

@@ -0,0 +1,3 @@
+NO
+YES
+YES

TaskC00/description.txt

@@ -0,0 +1,14 @@
+Read a description of a non-deterministic finite-state automaton in the AT&T format                                                                                                                                                                         
+(without weights) from the file in the first argument.
+
+Read strings from the standard input.
+If a string is accepted by the
+automaton, write YES, otherwise- write NO.
+
+The program is invoked like this: python run.py test1.arg < test1.in > test1.out
+
+Note that not all transitions must be included in description.
+If no transition is given for the given state and letter, write NO.
+
+POINTS: 3
+DEADLINE: 2023-11-12 23:59:59

TaskC00/run.py

@@ -0,0 +1,67 @@
+import sys
+
+
+class FSA:
+
+    def __init__(self,):
+        self.initial_state = '0'
+        self.final_states = set()
+
+        self.transitions = dict()
+        self.alphabet = set()
+
+    def add_transition(self, state_from, state_to, symbol):
+
+        if state_from in self.transitions.keys():
+            if symbol not in self.transitions[state_from].keys():
+                self.transitions[state_from][symbol] = {state_to}
+            else:
+                self.transitions[state_from][symbol] |= {state_to}
+        else:
+            self.transitions[state_from] = dict()
+            self.transitions[state_from][symbol] = {state_to}
+
+    def add_final_state(self, state):
+        self.final_states.add(state)
+    
+    def get_final_state(self, string):
+        current_state = self.initial_state
+        for symbol in string:
+            current_state = self.transitions[current_state][symbol]
+        return current_state
+
+    def accepts(self, string):
+        current_states = {self.initial_state}
+        for symbol in string:
+            next_states = set()
+            for state in current_states:
+                if state in self.transitions and symbol in self.transitions[state]:
+                    next_states |= self.transitions[state][symbol]
+            current_states = next_states
+
+        return bool(current_states.intersection(self.final_states))
+
+
+
+
+fsa = FSA()
+
+table = open(sys.argv[1])
+for line in table:
+    line = line.rstrip()
+
+    if len(line.split('\t')) == 3:
+        a, b, c = line.split('\t')
+        fsa.add_transition(a, b, c)
+        fsa.alphabet.add(c)
+    else:
+        fsa.add_final_state(line)
+
+
+for line in sys.stdin:
+    line = line.rstrip()
+
+    if fsa.accepts(line):
+        print('YES')
+    else:
+        print('NO')

TaskC00/testnfa.arg

@@ -0,0 +1,7 @@
+0	1	a
+1	0	a
+1	2	b
+2	4	c
+1	3	b
+3
+4

TaskC00/testnfa.exp

@@ -0,0 +1,8 @@
+YES
+YES
+NO
+NO
+NO
+YES
+NO
+YES

TaskC00/testnfa.in

@@ -0,0 +1,8 @@
+abc
+ab
+abcd
+aaaabc
+aaaaaaaabc
+aaaaaaabc
+zzz
+aaaaaaabc

TaskC00/testnfa.out

@@ -0,0 +1,8 @@
+YES
+YES
+NO
+NO
+NO
+YES
+NO
+YES

TaskC01/description.txt

@@ -0,0 +1,14 @@
+Use a non deterministic finite-state automaton (FSA) engine from the TaskC00.
+Create your own non deterministic FSA description to check whether the string second letter
+from right is 'b'.
+Don't use external files like in TaskF00 (description should be included in run file).
+
+The alphabet is "a", "b", "C"
+
+Read strings from the standard input.
+If a string is accepted by the 
+automaton, write YES, otherwise- write NO. 
+
+POINTS: 3
+DEADLINE: 2023-11-12 23:59:59
+REMAINDER: 0/3

TaskC01/test.exp

@@ -0,0 +1,6 @@
+YES
+YES
+NO
+NO
+NO
+YES

TaskC01/test.in

@@ -0,0 +1,6 @@
+abc
+abbc
+bca
+b
+abaa
+aaacbb

TaskC02/description.txt

@@ -0,0 +1,14 @@
+Use a non deterministic finite-state automaton (FSA) engine from the TaskC00.
+Create your own non deterministic FSA description to check whether the string
+ends with "ab"
+Don't use external files like in TaskF00 (description should be included in run file).
+
+The alphabet is "a", "b", "C"
+
+Read strings from the standard input.
+If a string is accepted by the 
+automaton, write YES, otherwise- write NO. 
+
+POINTS: 3
+DEADLINE: 2023-11-12 23:59:59
+REMAINDER: 1/3

TaskC02/run.py

@@ -0,0 +1,67 @@
+import sys
+
+
+class FSA:
+
+    def __init__(self,):
+        self.initial_state = '0'
+        self.final_states = set()
+
+        self.transitions = dict()
+        self.alphabet = set()
+
+    def add_transition(self, state_from, state_to, symbol):
+
+        if state_from in self.transitions.keys():
+            if symbol not in self.transitions[state_from].keys():
+                self.transitions[state_from][symbol] = {state_to}
+            else:
+                self.transitions[state_from][symbol] |= {state_to}
+        else:
+            self.transitions[state_from] = dict()
+            self.transitions[state_from][symbol] = {state_to}
+
+    def add_final_state(self, state):
+        self.final_states.add(state)
+    
+    def get_final_state(self, string):
+        current_state = self.initial_state
+        for symbol in string:
+            current_state = self.transitions[current_state][symbol]
+        return current_state
+
+    def accepts(self, string):
+        current_states = {self.initial_state}
+        for symbol in string:
+            next_states = set()
+            for state in current_states:
+                if state in self.transitions and symbol in self.transitions[state]:
+                    next_states |= self.transitions[state][symbol]
+            current_states = next_states
+
+        return bool(current_states.intersection(self.final_states))
+
+
+
+
+fsa = FSA()
+
+table = open(sys.argv[1])
+for line in table:
+    line = line.rstrip()
+
+    if len(line.split('\t')) == 3:
+        a, b, c = line.split('\t')
+        fsa.add_transition(a, b, c)
+        fsa.alphabet.add(c)
+    else:
+        fsa.add_final_state(line)
+
+
+for line in sys.stdin:
+    line = line.rstrip()
+
+    if fsa.accepts(line):
+        print('YES')
+    else:
+        print('NO')

TaskC02/test.arg

@@ -0,0 +1,11 @@
+0	0	a
+0	0	b
+0	0	c
+0	1	a
+1	1	a
+1	2	b
+1	0	c
+2	0	a
+2	0	b
+2	0	c
+2

TaskC02/test.exp

@@ -0,0 +1,6 @@
+YES
+NO
+YES
+NO
+YES
+NO

TaskC02/test.in

@@ -0,0 +1,6 @@
+ab
+a
+abbab
+bbbbb
+ababaab
+b

TaskC02/test.out

@@ -0,0 +1,6 @@
+YES
+NO
+YES
+NO
+YES
+NO

TaskC03/description.txt

@@ -0,0 +1,14 @@
+Use a non deterministic finite-state automaton (FSA) engine from the TaskC00.
+Create your own non deterministic FSA description to check whether the string
+contains "abc"
+Don't use external files like in TaskF00 (description should be included in run file).
+
+The alphabet is "a", "b", "c"
+
+Read strings from the standard input.
+If a string is accepted by the 
+automaton, write YES, otherwise- write NO. 
+
+POINTS: 3
+DEADLINE: 2023-11-12 23:59:59
+REMAINDER: 2/3

TaskC03/test.exp

@@ -0,0 +1,7 @@
+YES
+YES
+YES
+NO
+NO
+NO
+NO

TaskC03/test.in

@@ -0,0 +1,7 @@
+abc
+acabc
+acabccb
+abbab
+bbbbb
+ababaab
+bc

TaskC04/description.txt

@@ -0,0 +1,28 @@
+Deterministic automaton III
+===========================
+
+Read a description of a finite-state automaton in the AT&T format
+(without weights) from the file in the first argument. Then, read strings from the
+standard input. If a string is
+accepted by the automaton, write TRUE, a space and the string on the
+standard output, otherwise — write FALSE, a space and the string.
+
+If there is a non-determinism in the automaton, the first transition should be chosen.
+
+The automaton can contain epsilon transitions ("<eps>" instead of a
+character). They should be interpreted as follows: an epsilon
+transition can be used (without "eating" a character from the input),
+if there is no other transition applicable. You can assume that there
+is at most one epsilon transition from a given state and that there
+are no cycles with epsilon transition.
+
+Your program does not have to check whether the description is correct
+and whether the automaton is deterministic.
+
+long.arg - this automaton accepts two texts - "aaaa" and "a" replicated 4038 times.
+simple1.arg - simple automaton accepting only text "abc"
+simple2.arg - automaton accepting text "ab*c" (b replicated any number of times) and "kot"
+
+POINTS: 3
+DEADLINE: 2023-11-12 23:59:59
+REMAINDER: 0/3

TaskC04/eps.arg

@@ -0,0 +1,8 @@
+0	1	a
+1	0	a
+1	2	b
+2	4	c
+1	3	<eps>
+3	4	d
+3
+4

TaskC04/eps.exp

@@ -0,0 +1,10 @@
+TRUE a
+FALSE aa
+TRUE aaa
+TRUE abc
+TRUE aaabc
+FALSE aaabcd
+FALSE aabc
+FALSE abd
+TRUE ad
+FALSE aad

TaskC04/eps.in

@@ -0,0 +1,10 @@
+a
+aa
+aaa
+abc
+aaabc
+aaabcd
+aabc
+abd
+ad
+aad

TaskC04/long.exp

@@ -0,0 +1,7 @@
+FALSE aaa
+FALSE aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+TRUE aaaa
+TRUE aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+FALSE xyz
+FALSE aba
+FALSE a

TaskC04/long.in

@@ -0,0 +1,7 @@
+aaa
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+aaaa
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+xyz
+aba
+a

TaskC04/simple1.arg

@@ -0,0 +1,4 @@
+0	1	a
+1	2	b
+2	3	c
+3

TaskC04/simple1.exp

@@ -0,0 +1,8 @@
+FALSE a
+FALSE ab
+TRUE abc
+FALSE abcd
+FALSE aaaaab
+TRUE abc
+FALSE xyz
+FALSE 0

TaskC04/simple1.in

@@ -0,0 +1,8 @@
+a
+ab
+abc
+abcd
+aaaaab
+abc
+xyz
+0

TaskC04/simple2.arg

@@ -0,0 +1,8 @@
+0	1	a
+1	1	b
+1	2	c
+0	3	k
+3	4	o
+4	5	t
+2
+5

TaskC04/simple2.exp

@@ -0,0 +1,9 @@
+TRUE kot
+TRUE ac
+TRUE abc
+TRUE abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
+FALSE abcd
+FALSE abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccc
+FALSE kotek
+FALSE kotabc
+TRUE kot

TaskC04/simple2.in

@@ -0,0 +1,9 @@
+kot
+ac
+abc
+abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc
+abcd
+abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccc
+kotek
+kotabc
+kot

TaskC05/description.txt

@@ -0,0 +1,52 @@
+Dictionary
+==========
+
+Your program should read a finite-state automaton from file in the first argument.
+The automaton is deterministic, you can assume it does not contain
+cycles.
+
+Each automaton path is labeled with a symbol sequence of the following form:
+
+<input word>;<description>
+
+e.g.:
+
+biały;ADJ
+dom;N
+piła;N
+piła;V
+stali;N
+stali;V
+stali;ADJ
+
+Next you should read words from the standard input.
+For each word, you should all automaton
+paths that begin a given word, the following symbol is ';'
+(semicolon), e.g. for the word 'dom' we are looking for paths
+beginning with 'dom;'. If there is no such path, the following message
+should be printed:
+
+<input word>;OOV
+
+For instance, for the automaton given above and the input:
+
+budynek
+dom
+piła
+
+we should get:
+
+budynek;OOV
+dom;N
+piła;N
+piła;V
+
+If there is more than one path for a given word, they should be given in alphabetical order.
+
+The program does not have to check whether the automaton is correct
+and whether it is deterministic and does not contain cycles.
+
+
+POINTS: 3
+DEADLINE: 2023-11-12 23:59:59
+REMAINDER: 1/3

TaskC05/elem.arg

@@ -0,0 +1,31 @@
+0	1	b
+0	2	d
+0	3	p
+0	4	s
+1	5	i
+2	6	o
+3	7	i
+4	8	t
+5	9	a
+6	10	m
+7	11	ł
+8	12	a
+9	13	ł
+10	14	;
+11	15	a
+12	16	l
+13	17	y
+14	24	N
+15	18	;
+16	19	i
+17	20	;
+18	24	N
+18	24	V
+19	21	;
+20	22	A
+21	22	A
+21	24	N
+21	24	V
+22	23	D
+23	24	J
+24

TaskC05/elem.exp

@@ -0,0 +1 @@
+dom;N

TaskC05/elem.in

@@ -0,0 +1 @@
+dom

TaskC05/medium.exp

@@ -0,0 +1,7 @@
+arbuz;N
+arbuza;N
+arbuzowi;ADJ
+arbuzowi;N
+azylant;N
+azylanci;N
+azylantowie;OOV

TaskC05/medium.in

@@ -0,0 +1,6 @@
+arbuz
+arbuza
+arbuzowi
+azylant
+azylanci
+azylantowie

TaskC05/multi.arg

@@ -0,0 +1,31 @@
+0	1	b
+0	2	d
+0	3	p
+0	4	s
+1	5	i
+2	6	o
+3	7	i
+4	8	t
+5	9	a
+6	10	m
+7	11	ł
+8	12	a
+9	13	ł
+10	14	;
+11	15	a
+12	16	l
+13	17	y
+14	24	N
+15	18	;
+16	19	i
+17	20	;
+18	24	N
+18	24	V
+19	21	;
+20	22	A
+21	22	A
+21	24	N
+21	24	V
+22	23	D
+23	24	J
+24

TaskC05/multi.exp

@@ -0,0 +1,2 @@
+piła;N
+piła;V

TaskC05/multi.in

@@ -0,0 +1 @@
+piła

TaskC05/oov.arg

@@ -0,0 +1,31 @@
+0	1	b
+0	2	d
+0	3	p
+0	4	s
+1	5	i
+2	6	o
+3	7	i
+4	8	t
+5	9	a
+6	10	m
+7	11	ł
+8	12	a
+9	13	ł
+10	14	;
+11	15	a
+12	16	l
+13	17	y
+14	24	N
+15	18	;
+16	19	i
+17	20	;
+18	24	N
+18	24	V
+19	21	;
+20	22	A
+21	22	A
+21	24	N
+21	24	V
+22	23	D
+23	24	J
+24

TaskC05/oov.exp

@@ -0,0 +1 @@
+budynek;OOV

TaskC05/oov.in

@@ -0,0 +1 @@
+budynek

TaskC06/description.txt

@@ -0,0 +1,24 @@
+Paths
+======
+
+Your program should read a finite-state automaton from
+the standard input.
+The automaton is deterministic, you can assume it does not contain
+cycles. The automaton alphabet is the set of Polish lower-case letters
+(English letters plus: ą, ć, ę, ł, ń, ó, ś, ź and ż).
+
+Your program should print, on standard output, all the paths of the
+automaton in alphabetical order (to be precise: order induced by byte
+codes of strings, not according to the standard Polish order). "Print
+a path" means print a text line containing all subsequent characters.
+
+The program does not have to check whether the automaton is correct
+and whether it is deterministic and does not contain cycles.
+
+Weights (if any) should be disregarded.
+
+NOTE 1. You can add `LANG=C sort` to your Bash wrapper for the write sort.
+
+POINTS: 3
+DEADLINE: 2023-11-12 23:59:59
+REMAINDER: 2/3

TaskC06/small.exp

@@ -0,0 +1,4 @@
+biały
+dom
+piła
+stali

TaskC06/small.in

@@ -0,0 +1,18 @@
+0	1	b
+0	2	d
+0	3	p
+0	4	s
+1	5	i
+2	6	o
+3	7	i
+4	8	t
+5	9	a
+6	14	m
+7	10	ł
+8	11	a
+9	12	ł
+10	14	a
+11	13	l
+12	14	y
+13	14	i
+14

TaskC06/small2.exp

@@ -0,0 +1,3 @@
+biały
+piła
+stali

TaskC06/small2.in

@@ -0,0 +1,18 @@
+0	1	b
+0	2	d
+0	3	p
+0	4	s
+1	5	i
+2	6	o
+3	7	i
+4	8	t
+5	9	a
+6	15	m
+7	10	ł
+8	11	a
+9	12	ł
+10	14	a
+11	13	l
+12	14	y
+13	14	i
+14

TaskD01/description.txt

@@ -0,0 +1,5 @@
+Write a program to find lines containing the word "Hamlet".
+Do use regular expressions.
+
+POINTS: 1
+DEADLINE: 2023-11-26 23:59:59

TaskD01/run.py

@@ -0,0 +1,7 @@
+import re
+import sys
+
+for line in sys.stdin:
+	stripped_line = line.strip()
+	if re.search("Hamlet", stripped_line):
+		print(stripped_line)

TaskD01/simple.exp

@@ -0,0 +1,2 @@
+Here comes Hamlet
+Hamlet Hamlet again

TaskD01/simple.in

@@ -0,0 +1,3 @@
+Here comes Hamlet
+ABC
+Hamlet Hamlet again

TaskD01/simple.out

@@ -0,0 +1,2 @@
+Here comes Hamlet
+Hamlet Hamlet again

TaskD02/description.txt

@@ -0,0 +1,7 @@
+Write a program to find lines containing the word "pies" separated by spaces.
+The word does not need to have space on the left if it is the line beginning or space on the right if it is line ending.
+Return line no matter of word "pies" casing.
+Do use regular expressions.
+
+POINTS: 1
+DEADLINE: 2023-11-26 23:59:59

TaskD02/run.py

@@ -0,0 +1,7 @@
+import re
+import sys
+
+for line in sys.stdin:
+	stripped_line = line.strip()
+	if re.search(r"\bpies\b", stripped_line, re.IGNORECASE):
+		print(stripped_line)

TaskD02/simple.exp

@@ -0,0 +1,3 @@
+Pies ma Alę
+Kot i pies to zwierzęta
+pies

TaskD02/simple.in

@@ -0,0 +1,5 @@
+Pies ma Alę
+Ala ma psa
+tu nic nie ma
+Kot i pies to zwierzęta
+pies

TaskD02/simple.out

@@ -0,0 +1,3 @@
+Pies ma Alę
+Kot i pies to zwierzęta
+pies

TaskD03/description.txt

@@ -0,0 +1,6 @@
+Write a program to find lines containing date from 1900 to 1999 in format '19XX r.' no matter what on the left or right of the expression.
+Note that part ' r.' is obligatory.
+Do use regular expressions.
+
+POINTS: 1
+DEADLINE: 2023-11-26 23:59:59

TaskD03/run.py

@@ -0,0 +1,7 @@
+import re
+import sys
+
+for line in sys.stdin:
+	stripped_line = line.strip()
+	if re.search("19[0-9][0-9] r\.", stripped_line, re.IGNORECASE):
+		print(stripped_line)

TaskD03/simple.exp

@@ -0,0 +1,3 @@
+Kiedyś był 1934 r.
+Kiedyś był 1934 r.fsdfsdfsdf
+1934 r. to jakaś data