From 3908ac94e6e4784a406455ff0c7c9450a066fd18 Mon Sep 17 00:00:00 2001 From: Wojtek Date: Sat, 9 Dec 2023 21:52:30 +0100 Subject: [PATCH] task C00-D04 \ C05,C06 --- TaskC00/long.out | 7 ++++ TaskC00/run.py | 52 ++++++++++++++++++++++++++++++ TaskC00/test1.out | 9 ++++++ TaskC00/testnfa.out | 8 +++++ TaskC01/run.py | 50 +++++++++++++++++++++++++++++ TaskC01/test.arg | 8 +++++ TaskC01/test.out | 6 ++++ TaskC02/run.py | 50 +++++++++++++++++++++++++++++ TaskC02/test.arg | 6 ++++ TaskC02/test.out | 6 ++++ TaskC03/run.py | 50 +++++++++++++++++++++++++++++ TaskC03/test.arg | 10 ++++++ TaskC03/test.out | 7 ++++ TaskC04/eps.out | 10 ++++++ TaskC04/long.out | 7 ++++ TaskC04/run.py | 78 +++++++++++++++++++++++++++++++++++++++++++++ TaskC04/simple1.out | 8 +++++ TaskC04/simple2.out | 9 ++++++ TaskD01/run.py | 12 +++++++ TaskD02/run.py | 13 ++++++++ TaskD03/run.py | 18 +++++++++++ TaskD04/run.py | 19 +++++++++++ 22 files changed, 443 insertions(+) create mode 100644 TaskC00/long.out create mode 100644 TaskC00/run.py create mode 100644 TaskC00/test1.out create mode 100644 TaskC00/testnfa.out create mode 100644 TaskC01/run.py create mode 100644 TaskC01/test.arg create mode 100644 TaskC01/test.out create mode 100644 TaskC02/run.py create mode 100644 TaskC02/test.arg create mode 100644 TaskC02/test.out create mode 100644 TaskC03/run.py create mode 100644 TaskC03/test.arg create mode 100644 TaskC03/test.out create mode 100644 TaskC04/eps.out create mode 100644 TaskC04/long.out create mode 100644 TaskC04/run.py create mode 100644 TaskC04/simple1.out create mode 100644 TaskC04/simple2.out create mode 100644 TaskD01/run.py create mode 100644 TaskD02/run.py create mode 100644 TaskD03/run.py create mode 100644 TaskD04/run.py diff --git a/TaskC00/long.out b/TaskC00/long.out new file mode 100644 index 0000000..7724ddd --- /dev/null +++ b/TaskC00/long.out @@ -0,0 +1,7 @@ +NO +NO +YES +YES +NO +NO +NO diff --git a/TaskC00/run.py b/TaskC00/run.py new file mode 100644 index 0000000..e60e5dd --- /dev/null +++ b/TaskC00/run.py @@ -0,0 +1,52 @@ +import sys + +def read_aut_nfa(nfsa_path): + with open(nfsa_path, "r", encoding="utf8") as file: + transisions = {} + accepting_states = set() + for line in file: + if line.startswith("#"): + continue + parts = line.strip().split() + if len(parts) == 1: + accepting_states.add(int(parts[0])) + else: + state_from = int(parts[0]) + state_to = int(parts[1]) + symbol = ' ' if len(parts) == 2 else parts[2] + if(state_from, symbol) not in transisions: + transisions[(state_from, symbol)] = [] + transisions[(state_from, symbol)].append(state_to) + #print(transisions) + return transisions, accepting_states + + +def is_accepted_byNFA(transisions, accepting_states, line): + current_states = set([0]) + for symbol in line.strip(): + next_states = set() + for state in current_states: + if (state, symbol) in transisions: + next_states.update(transisions[(state,symbol)]) + current_states = next_states + if len(current_states) == 0: + return "NO" + if any(state in accepting_states for state in current_states): + return "YES" + else: + return "NO" + +def process_input(transisions, accepting_states, input_file, output_file): + with open(input_file, "r") as input, open(output_file, "w") as output: + for line in input: + result = is_accepted_byNFA(transisions, accepting_states, line) + output.write(result + '\n') + + + + + +nfa_file, input_file, output_file = sys.argv[1], sys.argv[2], sys.argv[3] +transisions, accepting_states = read_aut_nfa(nfa_file) + +process_input(transisions, accepting_states, input_file, output_file) \ No newline at end of file diff --git a/TaskC00/test1.out b/TaskC00/test1.out new file mode 100644 index 0000000..4c1a9bc --- /dev/null +++ b/TaskC00/test1.out @@ -0,0 +1,9 @@ +NO +YES +NO +NO +NO +NO +NO +NO +NO diff --git a/TaskC00/testnfa.out b/TaskC00/testnfa.out new file mode 100644 index 0000000..c98399b --- /dev/null +++ b/TaskC00/testnfa.out @@ -0,0 +1,8 @@ +YES +YES +NO +NO +NO +YES +NO +YES diff --git a/TaskC01/run.py b/TaskC01/run.py new file mode 100644 index 0000000..4585c71 --- /dev/null +++ b/TaskC01/run.py @@ -0,0 +1,50 @@ +import sys + +def read_aut_nfa(nfsa_path): + with open(nfsa_path, "r", encoding="utf8") as file: + transisions = {} + accepting_states = set() + for line in file: + parts = line.strip().split() + if len(parts) == 1: + accepting_states.add(int(parts[0])) + else: + state_from = int(parts[0]) + state_to = int(parts[1]) + symbol = ' ' if len(parts) == 2 else parts[2] + if(state_from, symbol) not in transisions: + transisions[(state_from, symbol)] = [] + transisions[(state_from, symbol)].append(state_to) + #print(transisions) + return transisions, accepting_states + + +def is_accepted_byNFA(transisions, accepting_states, line): + current_states = set([0]) + for symbol in line.strip(): + next_states = set() + for state in current_states: + if (state, symbol) in transisions: + next_states.update(transisions[(state,symbol)]) + current_states = next_states + if len(current_states) == 0: + return "NO" + if any(state in accepting_states for state in current_states): + return "YES" + else: + return "NO" + +def process_input(transisions, accepting_states, input_file, output_file): + with open(input_file, "r") as input, open(output_file, "w") as output: + for line in input: + result = is_accepted_byNFA(transisions, accepting_states, line) + output.write(result + '\n') + + + + + +nfa_file, input_file, output_file = sys.argv[1], sys.argv[2], sys.argv[3] +transisions, accepting_states = read_aut_nfa(nfa_file) + +process_input(transisions, accepting_states, input_file, output_file) \ No newline at end of file diff --git a/TaskC01/test.arg b/TaskC01/test.arg new file mode 100644 index 0000000..dd969f3 --- /dev/null +++ b/TaskC01/test.arg @@ -0,0 +1,8 @@ +0 0 a +0 0 b +0 0 c +0 1 b +1 2 a +1 2 b +1 2 c +2 \ No newline at end of file diff --git a/TaskC01/test.out b/TaskC01/test.out new file mode 100644 index 0000000..fffc02c --- /dev/null +++ b/TaskC01/test.out @@ -0,0 +1,6 @@ +YES +YES +NO +NO +NO +YES diff --git a/TaskC02/run.py b/TaskC02/run.py new file mode 100644 index 0000000..4585c71 --- /dev/null +++ b/TaskC02/run.py @@ -0,0 +1,50 @@ +import sys + +def read_aut_nfa(nfsa_path): + with open(nfsa_path, "r", encoding="utf8") as file: + transisions = {} + accepting_states = set() + for line in file: + parts = line.strip().split() + if len(parts) == 1: + accepting_states.add(int(parts[0])) + else: + state_from = int(parts[0]) + state_to = int(parts[1]) + symbol = ' ' if len(parts) == 2 else parts[2] + if(state_from, symbol) not in transisions: + transisions[(state_from, symbol)] = [] + transisions[(state_from, symbol)].append(state_to) + #print(transisions) + return transisions, accepting_states + + +def is_accepted_byNFA(transisions, accepting_states, line): + current_states = set([0]) + for symbol in line.strip(): + next_states = set() + for state in current_states: + if (state, symbol) in transisions: + next_states.update(transisions[(state,symbol)]) + current_states = next_states + if len(current_states) == 0: + return "NO" + if any(state in accepting_states for state in current_states): + return "YES" + else: + return "NO" + +def process_input(transisions, accepting_states, input_file, output_file): + with open(input_file, "r") as input, open(output_file, "w") as output: + for line in input: + result = is_accepted_byNFA(transisions, accepting_states, line) + output.write(result + '\n') + + + + + +nfa_file, input_file, output_file = sys.argv[1], sys.argv[2], sys.argv[3] +transisions, accepting_states = read_aut_nfa(nfa_file) + +process_input(transisions, accepting_states, input_file, output_file) \ No newline at end of file diff --git a/TaskC02/test.arg b/TaskC02/test.arg new file mode 100644 index 0000000..50c7790 --- /dev/null +++ b/TaskC02/test.arg @@ -0,0 +1,6 @@ +0 0 a +0 0 b +0 0 c +0 1 a +1 2 b +2 \ No newline at end of file diff --git a/TaskC02/test.out b/TaskC02/test.out new file mode 100644 index 0000000..e09bb02 --- /dev/null +++ b/TaskC02/test.out @@ -0,0 +1,6 @@ +YES +NO +YES +NO +YES +NO diff --git a/TaskC03/run.py b/TaskC03/run.py new file mode 100644 index 0000000..4585c71 --- /dev/null +++ b/TaskC03/run.py @@ -0,0 +1,50 @@ +import sys + +def read_aut_nfa(nfsa_path): + with open(nfsa_path, "r", encoding="utf8") as file: + transisions = {} + accepting_states = set() + for line in file: + parts = line.strip().split() + if len(parts) == 1: + accepting_states.add(int(parts[0])) + else: + state_from = int(parts[0]) + state_to = int(parts[1]) + symbol = ' ' if len(parts) == 2 else parts[2] + if(state_from, symbol) not in transisions: + transisions[(state_from, symbol)] = [] + transisions[(state_from, symbol)].append(state_to) + #print(transisions) + return transisions, accepting_states + + +def is_accepted_byNFA(transisions, accepting_states, line): + current_states = set([0]) + for symbol in line.strip(): + next_states = set() + for state in current_states: + if (state, symbol) in transisions: + next_states.update(transisions[(state,symbol)]) + current_states = next_states + if len(current_states) == 0: + return "NO" + if any(state in accepting_states for state in current_states): + return "YES" + else: + return "NO" + +def process_input(transisions, accepting_states, input_file, output_file): + with open(input_file, "r") as input, open(output_file, "w") as output: + for line in input: + result = is_accepted_byNFA(transisions, accepting_states, line) + output.write(result + '\n') + + + + + +nfa_file, input_file, output_file = sys.argv[1], sys.argv[2], sys.argv[3] +transisions, accepting_states = read_aut_nfa(nfa_file) + +process_input(transisions, accepting_states, input_file, output_file) \ No newline at end of file diff --git a/TaskC03/test.arg b/TaskC03/test.arg new file mode 100644 index 0000000..aebecdf --- /dev/null +++ b/TaskC03/test.arg @@ -0,0 +1,10 @@ +0 0 a +0 0 b +0 0 c +0 1 a +1 2 b +2 3 c +3 3 a +3 3 b +3 3 c +3 \ No newline at end of file diff --git a/TaskC03/test.out b/TaskC03/test.out new file mode 100644 index 0000000..29c072b --- /dev/null +++ b/TaskC03/test.out @@ -0,0 +1,7 @@ +YES +YES +YES +NO +NO +NO +NO diff --git a/TaskC04/eps.out b/TaskC04/eps.out new file mode 100644 index 0000000..77e460b --- /dev/null +++ b/TaskC04/eps.out @@ -0,0 +1,10 @@ +TRUE a +FALSE aa +TRUE aaa +TRUE abc +TRUE aaabc +FALSE aaabcd +FALSE aabc +FALSE abd +TRUE ad +FALSE aad diff --git a/TaskC04/long.out b/TaskC04/long.out new file mode 100644 index 0000000..a767f3e --- /dev/null +++ b/TaskC04/long.out @@ -0,0 +1,7 @@ +FALSE aaa +FALSE aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +TRUE aaaa +TRUE aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +FALSE xyz +FALSE aba +FALSE a diff --git a/TaskC04/run.py b/TaskC04/run.py new file mode 100644 index 0000000..5cc732e --- /dev/null +++ b/TaskC04/run.py @@ -0,0 +1,78 @@ +import sys + +def read_aut_nfa(nfsa_path): + with open(nfsa_path, "r", encoding="utf8") as file: + transisions = {} + accepting_states = set() + for line in file: + if line.startswith("#"): + continue + parts = line.strip().split() + if len(parts) == 1: + accepting_states.add(int(parts[0])) + else: + state_from = int(parts[0]) + state_to = int(parts[1]) + #symbol = ' ' if len(parts) == 2 else parts[2] + symbol = parts[2] if len(parts) == 3 else "" + if(state_from, symbol) not in transisions: + transisions[(state_from, symbol)] = [] + transisions[(state_from, symbol)].append(state_to) + #print(transisions) + return transisions, accepting_states + + +def is_accepted_byNFA(transisions, accepting_states, line): + current_states = set([0]) + for symbol in line.strip(): + #print(f"Obecny symbol: {symbol}") + next_states = set() + for state in current_states: + if (state, symbol) in transisions: + next_states.update(transisions[(state,symbol)]) + #print(next_states) + #print(f"Przejście przez '{symbol}' ze stanu {state}: {transisions[(state, symbol)]}") + if len(next_states) == 0: + for state in current_states: + if (state, "") in transisions: + next_states.update(transisions[(state, "")]) + #print(next_states) + #print(f"Epsilonowe przejście ze stanu {state}: {transisions[(state, '')]}") + + if len(next_states) == 0: + #print("Brak dostępnych przejść") + return "FALSE" + current_states = next_states + #print(f"Obecny stan po przejsciu petli ------------------------------------------------ '{symbol}': {current_states}") + + #print(current_states) + #kod powyżej nie uwzględni epsilonowych przejść na końcu słowa. Tutaj to uwzględniam + flaga = True + while flaga: + flaga = False + next_states = set() + for state in current_states: + if(state, "") in transisions: + next_states.update(transisions[(state, "")]) + flaga = True + current_states = next_states + + if any(state in accepting_states for state in current_states): + return "TRUE" + else: + return "FALSE" + +def process_input(transisions, accepting_states, input_file, output_file): + with open(input_file, "r") as input, open(output_file, "w") as output: + for line in input: + result = is_accepted_byNFA(transisions, accepting_states, line) + output.write(result + ' ' + line) + + + + + +nfa_file, input_file, output_file = sys.argv[1], sys.argv[2], sys.argv[3] +transisions, accepting_states = read_aut_nfa(nfa_file) + +process_input(transisions, accepting_states, input_file, output_file) \ No newline at end of file diff --git a/TaskC04/simple1.out b/TaskC04/simple1.out new file mode 100644 index 0000000..f44ec1c --- /dev/null +++ b/TaskC04/simple1.out @@ -0,0 +1,8 @@ +FALSE a +FALSE ab +TRUE abc +FALSE abcd +FALSE aaaaab +TRUE abc +FALSE xyz +FALSE 0 diff --git a/TaskC04/simple2.out b/TaskC04/simple2.out new file mode 100644 index 0000000..0b6f0da --- /dev/null +++ b/TaskC04/simple2.out @@ -0,0 +1,9 @@ +TRUE kot +TRUE ac +TRUE abc +TRUE abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc +FALSE abcd +FALSE abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccc +FALSE kotek +FALSE kotabc +TRUE kot diff --git a/TaskD01/run.py b/TaskD01/run.py new file mode 100644 index 0000000..dcdff5a --- /dev/null +++ b/TaskD01/run.py @@ -0,0 +1,12 @@ +import re + +def hamlet_reg(file_path): + licznik = 0 + with open(file_path, 'r', encoding='utf-8') as file: + for line in file: + licznik += 1 + if (re.search("'.*Hamlet.*", line)): + print(f"{licznik}: {line.strip()}") + +file_path = 'TaskD01\simple.in' +hamlet_reg(file_path) \ No newline at end of file diff --git a/TaskD02/run.py b/TaskD02/run.py new file mode 100644 index 0000000..81a7766 --- /dev/null +++ b/TaskD02/run.py @@ -0,0 +1,13 @@ +import re + +def pies_reg(file_path): + licznik = 0 + with open(file_path, 'r', encoding='utf-8') as file: + for line in file: + licznik += 1 + if (re.search("(^|\s)pies($|\s)", line, re.IGNORECASE)): + print(f"{licznik}: {line.strip()}") + + +file_path = 'TaskD02\simple.in' +pies_reg(file_path) \ No newline at end of file diff --git a/TaskD03/run.py b/TaskD03/run.py new file mode 100644 index 0000000..caddc75 --- /dev/null +++ b/TaskD03/run.py @@ -0,0 +1,18 @@ +import re + +#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. + + +def data_reg(file_path): + licznik = 0 + with open(file_path, 'r', encoding='utf-8') as file: + for line in file: + licznik += 1 + if (re.search(".*19\d{2} r\..*", line)): + print(f"{licznik}: {line.strip()}") + + +file_path = 'TaskD03\simple.in' +data_reg(file_path) \ No newline at end of file diff --git a/TaskD04/run.py b/TaskD04/run.py new file mode 100644 index 0000000..c4f3756 --- /dev/null +++ b/TaskD04/run.py @@ -0,0 +1,19 @@ +import re + +#Write a program to find all maximum substrings of digits. +#Return only these substrings separated by spaces in their order. +#Do use regular expressions. + + +def liczby_reg(file_path): + licznik = 0 + with open(file_path, 'r', encoding='utf-8') as file: + for line in file: + licznik += 1 + number = (re.findall(r'\d+', line)) + if number: + print(f"{licznik}: {' '.join(number)}") + + +file_path = 'TaskD04\simple.in' +liczby_reg(file_path) \ No newline at end of file