Added files for 4th lab

README.md

@@ -25,15 +25,57 @@ python main.py
 ```
 
 ***
+Iндiана Джонс i останнiй прямокутний обхiд Код задачi: IJONES 
+В пошуках Святого Грааля Iндiана Джонс зiткнувся з небезпечним випробуванням. Йому потрiбно пройти крiзь прямокутний коридор, який складається з крихких плит (пригадайте сцену з фiльму «Iндiана Джонс i останнiй хрестовий похiд»). На кожнiй плитi написана одна лiтера: 
+a a a 
+c a b 
+d e f 
+Можна починати з будь-якої плити в найлiвiшому стовпцi. Виходом iз коридору є верхня права та нижня права плити (для прикладу вище — a та f). 
+Iндiана спритний, i може переходити не лише на сусiдню плиту, а й перестрибувати через кiлька плит. Проте, щоб не провалитися крiзь пiдлогу, вiн повинен дотримуватися таких правил: 
+1. Пiсля кожного кроку Iндiана повинен опинятися правiше, нiж був перед цим. a a a 
+c a b 
+d e f 
+2. Завжди можна переходити на одну плиту праворуч. 
+a a a 
+c a b 
+d e f 
+3. Крiм руху на одну плиту праворуч, можна перестрибувати, проте лише на ту саму лiтеру. Наприклад, з лiтери a можна перестрибнути на будь-яку iншу лiтеру a за умови, що ми цим ходом просунемося правiше. 
+a a a 
+c a b 
+d e f 
 
-this program shows you the results of insertion and merge sorts for each algorithm, it also shows some additional information, such as:
-* time,
-* swap counter,
-* comparison counter.
+Для заданого коридору, пiдрахуйте, скiльки всього iснує способiв пройти його успiшно. 
+Вхiднi данi 
+Вхiдний файл ijones .in складається з H + 1 рядкiв. 
+• Перший рядок мiстить два числа W i H, роздiленi пробiлом: W — ширина коридору, H — висота коридору, 1  W, H  2000. 
+• Кожен з наступних H рядкiв мiстить слово довжиною W символiв, яке складається з малих латинських лiтер вiд a до z. 
+Вихiднi данi 
+Вихiдний файл ijones .out повинен мiстити одне цiле число — кiлькiсть рiзних шляхiв для виходу з коридору. 
+# Див. приклади нижче # 
 
-counters represent the numbers of corresponding operations that occurred during the sorting process.
-
-the list of objects is taken from *basin.csv* file. Each row there represents a new object as a sequence of its properties' values separated by commas. The order is:
-```
-address, volume_of_water, max_number_of_visitors
-```
+Приклад 1 
+ijones .in 
+3 3 
+aaa 
+cab 
+def 
+ijones .out 
+5 
+Пояснення: Iснує 3 варiанти обходу, якщо починати з лiтери a, i по одному варiанту, якщо починати з лiтери c або d. 
+Приклад 2 
+ijones .in 
+10 1 
+abcdefaghi 
+ijones .out 
+2 
+Приклад 3 
+ijones .in 
+7 6 
+aaaaaaa 
+aaaaaaa 
+aaaaaaa 
+aaaaaaa 
+aaaaaaa 
+aaaaaaa 
+ijones .out 
+201684 

ijones_algo.py

@@ -0,0 +1,60 @@
+from collections import defaultdict
+from typing import List
+
+INPUT_FILE_NAME = "test.in"
+OUTPUT_FILE_NAME = "test.out"
+
+
+def read_input_data():
+    with open(INPUT_FILE_NAME, "r") as input_file:
+        width, height = [int(number) for number in input_file.readline().split()]
+        corridor = [[letter for letter in row] for row in input_file.readlines()]
+    return corridor, width, height
+
+
+def write_output_data(ways: int):
+    with open(OUTPUT_FILE_NAME, "w") as output_file:
+        output_file.write(str(ways))
+
+
+def find_ways(corridor: List[List[int]], width: int, height: int) -> int:
+
+    ways_number_for_tile = []
+    for tile in range(height):
+        list_ways_number_for_tile = []
+        for row in range(width):
+            list_ways_number_for_tile.append(0)
+        ways_number_for_tile.append(list_ways_number_for_tile)
+
+    ways_number_for_letter = defaultdict(int)
+    for row in range(height): #ітеруємося по плиточках першого стовпця
+        tile_letter = corridor[row][0]
+        ways_number_for_tile[row][0] = 1 # 1 шлях
+        ways_number_for_letter[tile_letter] += 1 #якщо букви повторяються
+
+    for col in range(1, width): # в двох вкладених форах, ітеруємося по стовпцях починаючи з першого
+        letter_ways_number_for_current_column = defaultdict(int)
+        previous_column = col - 1 # зберігаємо значення індексу попередньої колонки
+        for row in range(height): # дивимося на кожну клітинку окремо
+            tile_letter = corridor[row][col] # зберіг зн поточної клітинки
+            ways = ways_number_for_letter[tile_letter] # глобальний словник: дивимось, скіьки в нас на даному етапі є шляхів до букви на якій ми стоїмо
+            if tile_letter != corridor[row][previous_column]:# порівлюємо, що tile_letter(поточна буква) така ж як (буква, яка лівіше) в тому ж рядку
+                ways += ways_number_for_tile[row][previous_column]# додаємо, якщо виконується умова, (дивимося на клітинку)
+            ways_number_for_tile[row][col] = ways # сетаємо к-сть способів дістатися до клітинки
+            letter_ways_number_for_current_column[tile_letter] += ways # способи потрапити в букву, з поточної колонки
+        update_letter_ways(letter_ways_number_for_current_column, ways_number_for_letter)
+    if height == 1: # 1 рядок
+        return ways_number_for_tile[0][width - 1] # значеняя шляхів в певну клітинку
+    else:
+        return ways_number_for_tile[0][width - 1] + ways_number_for_tile[height - 1][width - 1]
+
+
+def update_letter_ways(letter_ways_number_for_current_column: defaultdict, ways_number_for_letter: defaultdict) -> None:
+    for tile_letter in letter_ways_number_for_current_column:
+        ways_number_for_letter[tile_letter] += letter_ways_number_for_current_column[tile_letter]
+
+
+if __name__ == "__main__":
+    corridor, width, height = read_input_data()
+    successful_ways_number = find_ways(corridor, width, height)
+    write_output_data(successful_ways_number)

jonestest.py

@@ -0,0 +1,32 @@
+import unittest
+
+from ijones_algo import find_ways
+
+
+class SuccessfulWaysTest(unittest.TestCase):
+    def \
+            test_find_successful_ways_1(self):
+        corridor = [["a", "a", "a"], ["c", "a", "b"], ["d", "e", "f"]]
+        successful_ways_number = find_ways(corridor, 3, 3)
+        self.assertEqual(5, successful_ways_number)
+
+    def test_find_successful_ways_2(self):
+        corridor = [["a", "b", "c", "d", "e", "f", "a", "g", "h", "i"]]
+        successful_ways_number = find_ways(corridor, 10, 1)
+        self.assertEqual(2, successful_ways_number)
+
+    def test_find_successful_ways_3(self):
+        corridor = [["a", "a", "a", "a", "a", "a", "a"], ["a", "a", "a", "a", "a", "a", "a"],
+                    ["a", "a", "a", "a", "a", "a", "a"], ["a", "a", "a", "a", "a", "a", "a"],
+                    ["a", "a", "a", "a", "a", "a", "a"], ["a", "a", "a", "a", "a", "a", "a"]]
+        successful_ways_number = find_ways(corridor, 7, 6)
+        self.assertEqual(201684, successful_ways_number)
+
+    def test_find_successful_ways_4(self):
+        corridor = [["a"]]
+        successful_ways_number = find_ways(corridor, 1, 1)
+        self.assertEqual(1, successful_ways_number)
+
+
+if __name__ == '__main__':
+    unittest.main()

test.in

@@ -0,0 +1,4 @@
+3 3
+aaa
+cab
+def

test.out

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