def stevilo_ovir(ovire):
    return len(ovire)


def dolzina_ovir(ovire):
    dolzina = 0
    for x0, x1, _ in ovire:
        dolzina += x1 - x0 + 1
    return dolzina


def sirina(ovire):
    najx = 0
    for _, x1, _ in ovire:
        if x1 > najx:
            najx = x1
    return najx


def pretvori_vrstico(vrstica):
    vrstica = "." + vrstica + "."
    bloki = []
    for i, znak in enumerate(vrstica):
        if znak == "#":
            if vrstica[i - 1] == ".":
                zacetek = i
            if vrstica[i + 1] == ".":
                bloki.append((zacetek, i))
    return bloki


def pretvori_zemljevid(zemljevid):
    ovire = []
    for y, vrstica in enumerate(zemljevid, start=1):
        ovire += dodaj_vrstico(pretvori_vrstico(vrstica), y)
    return ovire


def globina(ovire, x):
    najy = None
    for x0, x1, y in ovire:
        if x0 <= x <= x1 and (najy == None or y < najy):
            najy = y
    return najy


def senca(ovire):
    zaprti = []
    for x in range(1, sirina(ovire) + 1):
        zaprti.append(globina(ovire, x) == None)
    return zaprti



import unittest
import ast

ovire1 = [(1, 3, 6), (2, 4, 3), (4, 6, 7),
          (3, 4, 9), (6, 9, 5), (9, 10, 2), (9, 10, 8)]

ovire2 = [(1, 3, 6), (2, 4, 3), (4, 6, 7),
          (3, 4, 9), (9, 10, 2), (9, 10, 8)]

ovire3 = [(1, 3, 6), (2, 4, 3),
          (3, 4, 9), (9, 10, 2), (9, 10, 8)]


class TestOneLineMixin:
    functions = {
        elm.name: elm
        for elm in ast.parse(open(__file__, "r", encoding="utf-8").read()).body
        if isinstance(elm, ast.FunctionDef)}

    def assert_is_one_line(self, func):
        body = self.functions[func.__code__.co_name].body
        self.assertEqual(len(body), 1, "\nFunkcija ni dolga le eno vrstico")
        self.assertIsInstance(body[0], ast.Return, "\nFunkcija naj bi vsebovala le return")

    def test_nedovoljene_funkcije(self):
        dovoljene_funkcije = {
            "stevilo_ovir", "dolzina_ovir", "sirina", "pretvori_vrstico",
            "pretvori_zemljevid", "globina", "senca", "indeksi"}
        for func in self.functions:
            self.assertIn(func, dovoljene_funkcije, f"\nFunkcija {func} ni dovoljena.")


class Test01Obvezna(unittest.TestCase, TestOneLineMixin):
    def test_01_stevilo_ovir(self):
        self.assertEqual(7, stevilo_ovir(ovire1))
        self.assertEqual(6, stevilo_ovir(ovire2))
        self.assertEqual(0, stevilo_ovir([]))

        self.assert_is_one_line(stevilo_ovir)

    def test_02_dolzina_ovir(self):
        self.assertEqual(19, dolzina_ovir(ovire1))
        self.assertEqual(15, dolzina_ovir(ovire2))
        self.assertEqual(0, dolzina_ovir([]))

        self.assert_is_one_line(dolzina_ovir)

    def test_03_sirina(self):
        self.assertEqual(10, sirina(ovire1))
        self.assertEqual(9, sirina(ovire1[:-2]))
        self.assertEqual(6, sirina(ovire1[:-3]))
        self.assertEqual(3, sirina(ovire1[:1]))

        self.assert_is_one_line(sirina)


    def test_05_globina(self):
        self.assertEqual(3, globina(ovire1, 3))
        self.assertEqual(5, globina(ovire1, 6))
        self.assertEqual(7, globina(ovire2, 6))
        self.assertIsNone(globina(ovire3, 6))

        self.assert_is_one_line(globina)

    def test_06_senca(self):
        self.assertEqual([False] * 10, senca(ovire1))
        self.assertEqual([False, False, False, False, False, False, True, True, False, False], senca(ovire2))
        self.assertEqual([False, False, False, False, True, True, True, True, False, False], senca(ovire3))
        self.assertEqual([False] * 6, senca(ovire2[:-3]))
        self.assertEqual([False] * 3, senca(ovire3[:1]))

        self.assert_is_one_line(senca)


class Test02Dodatna(unittest.TestCase, TestOneLineMixin):
    def test_01_indeksi(self):
        self.assertEqual([3, 10, 15, 17], indeksi("prepelica peče pepelko", "pe"))
        self.assertEqual([0, 2, 8, 16], indeksi("pepelka peče prepelico", "pe"))
        self.assertEqual([0, 2], indeksi("peperutka", "pe"))
        self.assertEqual([0], indeksi("peperutka", "pepe"))
        self.assertEqual([8], indeksi("peperutka", "a"))
        self.assertEqual([0, 3, 10, 15, 17], indeksi("prepelica peče pepelko", "p"))
        self.assertEqual([], indeksi("prepelica peče pepelko", "m"))

        self.assert_is_one_line(indeksi)

    def test_02_pretvori_vrstico(self):
        self.assertEqual([(3, 5)], pretvori_vrstico("..###."))
        self.assertEqual([(3, 5), (7, 7)], pretvori_vrstico("..###.#."))
        self.assertEqual([(1, 2), (5, 7), (9, 9)], pretvori_vrstico("##..###.#."))
        self.assertEqual([(1, 1), (4, 6), (8, 8)], pretvori_vrstico("#..###.#."))
        self.assertEqual([(1, 1), (4, 6), (8, 8)], pretvori_vrstico("#..###.#"))
        self.assertEqual([], pretvori_vrstico("..."))
        self.assertEqual([], pretvori_vrstico(".."))
        self.assertEqual([], pretvori_vrstico("."))

        self.assert_is_one_line(pretvori_vrstico)


if __name__ == "__main__":
    unittest.main()