Python, malo pomoči.

Torej, pri programiranju imamo nalogo ki jo moramo rešit. Ogrevalno sem naredu, nikakor pa ne morem za oceno 6. Bi mi lahko kdo pomagal prosim.

Programirali bomo Dots. Če je ne boste preskusili sami (ne priporočam, včasih malo zasvoji).
Naša različica bo brez grafike, ampak bistvo bomo zadeli. ;) Morda pa v kaki prihodnji nalogi naredimo še grafični del.

Različne barve bodo predstavljene s številkami od 1 do 5. Stanje igralne plošče bo shranjeno v seznamu seznamov. Imeli bomo torej spremenljivko (navadno jo bomo imenovali polje), ki bo imela toliko elementov, kolikor je stolpcev, in vsak element bo vseboval toliko števil, kolikor je vrstic. Elemente stolpcev bomo pisali od spodaj navzgor (tako vam bo iz nekega razloga lažje). Če bi torej radi tretji element druge vrstice (od spodaj), bomo rekli polje[3][2] (pri čemer številčenje seveda začnemo z 0, kot vedno).

Za razliko od prave igre, v kateri je polje vedno dimenzij 6x6, je naše polje lahko poljubno veliko ali pa celo nekoliko dolgočasno; imamo lahko tudi le eno samo vrstico ali en sam stolpec.

V nekaterih funkcijah bomo govorili tudi o poti: pot je seznam koordinat, na primer [(3, 1), (3, 2), (4, 2), (4, 3)]. Koordinate, ki jih vsebuje imajo lahko poljuben vrstni red.

Ogrevanje

Napiši funkcijo dopolni(polje, visina). Argument polje je seznam seznamov števil. Funkcija mora dopolniti vse (pod)sezname tako, da bodo imeli visina elementov. Dopolniti ga mora z naključnimi števili med 1 in 5.

Funkcija ne vrača rezultata, temveč spreminja poslano polje.

Če imamo, recimo, polje = [[2, 4], [], [1, 2, 3]], mora dopolni(polje, 3) dodati en element v prvi podseznam, tri v drugega in nobenega v tretjega.

Za oceno 6: Izpis

Napiši funkcijo izpisi(polje), ki vrne niz z vsebino polja - če bi ta niz izpisali, bi dobili polje, kot ga vidi igralec. Upoštevati mora torej, da seznam polje vsebuje stolpcev, zapisane od spodaj navzgor. Tako mora

polje = [[1, 2, 4, 4], [4, 1, 4, 2], [2, 1, 4, 3], [2, 4, 2, 3], [1, 2, 3, 4]]
vrniti niz

42334
44423
21142
14221

Za oceno 7: Brisanje

Napiši funkcijo pobrisi_pot(pot, polje), ki pobriše pike na poljih, ki se nahajajo na poti. Pike nad njimi naj "padejo" en element nižje. Nekateri seznami bodo zaradi tega torej nekoliko krajši.

Poleg tega napiši funkcijo pobrisi_barvo(barva, polje), ki odstrani vse pike določene barve.

Funkciji ne vračata ničesar, temveč spreminjata polje, ki sta ga dobili kot argument.

Testi in moj program:

import unittest
from random import *
from functools import reduce
from operator import iadd
from copy import deepcopy
import operator

def dopolni(polje, visina):
    for list in polje:
        while len(list) < visina:
            list.append(randint(1, 5))
    return(polje)

def izpisi(polje):
    for niz in reversed(list(zip(*polje))):
        niz = ''.join(str(i) for i in niz)
        print(niz)
    return(niz)


class TestStevilcnica(unittest.TestCase):
    def test_5_dopolni(self):
        polje = [[] for i in range(5)]
        dopolni(polje, 10)
        self.assertEqual(len(polje), 5)
        self.assertTrue(all(len(stolpec) == 10 for stolpec in polje))
        vse_stevilke = reduce(iadd, polje, [])
        for i in range(1, 6):
            self.assertGreaterEqual(
                vse_stevilke.count(i), 2,
                "Med 50 številkami bi pričakoval vsaj dve številki {}".format(i)
            )

        zacetek = [[1], [4, 1], [2, 1, 4], [], [1, 2, 3, 4]]
        polje = zacetek.copy()
        dopolni(polje, 4)
        for stolpec, zstolpec in zip(polje, zacetek):
            self.assertEqual(stolpec[:len(zstolpec)], zstolpec,
                             "'dopolni' ne sme spreminjati obstoječih številk")
            self.assertEqual(len(zstolpec), 4)

    def test_6_izpis(self):
        polje = [[1, 2, 4, 4],
                 [4, 1, 4, 2],
                 [2, 1, 4, 3],
                 [2, 4, 2, 3],
                 [1, 2, 3, 4]]
        self.assertEqual(izpisi(polje).strip(), "42334\n44423\n21142\n14221")

        polje = [[1], [4], [2], [2], [1]]
        self.assertEqual(izpisi(polje).strip(), "14221")

        polje = [[1, 4, 2, 2, 1]]
        self.assertEqual(izpisi(polje).strip(), "1\n2\n2\n4\n1")

    def test_7_pobrisi_pot(self):
        polje = [[1, 2, 4, 4],
                 [4, 1, 4, 2],
                 [2, 1, 4, 3],
                 [2, 4, 2, 3],
                 [1, 2, 3, 4]]

        pobrisi_pot([(0, 1), (1, 1), (2, 1)], polje)
        self.assertEqual(polje, [[1, 4, 4],
                                 [4, 4, 2],
                                 [2, 4, 3],
                                 [2, 4, 2, 3],
                                 [1, 2, 3, 4]])

        polje = [[0, 1, 2, 3, 4],
                 [4, 4, 2, 2, 2]]
        pobrisi_pot([(0, 1), (0, 2)], polje)
        self.assertEqual(polje, [[0, 3, 4],
                                 [4, 4, 2, 2, 2]])

        polje = [[0, 1, 2, 3, 4],
                 [4, 4, 2, 2, 2]]
        pobrisi_pot([(0, 2), (0, 1)], polje)
        self.assertEqual(polje, [[0, 3, 4],
                                 [4, 4, 2, 2, 2]])

        polje = [[0, 1, 2, 3, 4],
                 [4, 4, 2, 2, 2]]
        pobrisi_pot([(0, 2), (0, 4), (0, 0), (0, 3), (0, 1)], polje)
        self.assertEqual(polje, [[],
                                 [4, 4, 2, 2, 2]])


    def test_7_pobrisi_barvo(self):
        polje = [[1, 2, 4, 4],
                 [4, 1, 4, 2],
                 [2, 1, 4, 3],
                 [2, 4, 2, 3],
                 [1, 2, 3, 4]]

        polje2 = deepcopy(polje)
        pobrisi_barvo(1, polje2)
        self.assertEqual(polje2, [[2, 4, 4],
                                  [4, 4, 2],
                                  [2, 4, 3],
                                  [2, 4, 2, 3],
                                  [2, 3, 4]])

        polje2 = deepcopy(polje)
        pobrisi_barvo(2, polje2)
        self.assertEqual(polje2, [[1, 4, 4],
                                  [4, 1, 4],
                                  [1, 4, 3],
                                  [4, 3],
                                  [1, 3, 4]])

        polje2 = deepcopy(polje)
        pobrisi_barvo(3, polje2)
        self.assertEqual(polje2, [[1, 2, 4, 4],
                                  [4, 1, 4, 2],
                                  [2, 1, 4],
                                  [2, 4, 2],
                                  [1, 2, 4]])

        polje2 = deepcopy(polje)
        pobrisi_barvo(4, polje2)
        self.assertEqual(polje2, [[1, 2],
                                  [1, 2],
                                  [2, 1, 3],
                                  [2, 2, 3],
                                  [1, 2, 3]])

        polje2 = deepcopy(polje)
        pobrisi_barvo(5, polje2)
        self.assertEqual(polje2, [[1, 2, 4, 4],
                                  [4, 1, 4, 2],
                                  [2, 1, 4, 3],
                                  [2, 4, 2, 3],
                                  [1, 2, 3, 4]])

    def test_8_preveri_pot(self):
        polje = [[1, 2, 4, 4],
                 [4, 1, 4, 2],
                 [2, 1, 4, 3],
                 [2, 4, 2, 3],
                 [1, 2, 3, 4]]

        polje4 = [[4] * 4] * 5

        self.assertTrue(preveri_pot([(1, 1), (2, 1)], polje))
        self.assertTrue(preveri_pot([(0, 2), (0, 3)], polje))
        self.assertTrue(preveri_pot([(0, 2), (1, 2), (2, 2)], polje))
        self.assertTrue(preveri_pot([(2, 2), (1, 2), (0, 2), (0, 3)], polje))

        self.assertTrue(preveri_pot([(2, 2), (1, 2), (1, 1), (2, 1), (2, 2)],
                                    polje4))
        self.assertTrue(preveri_pot([(1, 1), (1, 2), (1, 3), (2, 3), (3, 3),
                                     (3, 2), (2, 2), (2, 1), (1, 1)],
                                    polje4))

        self.assertFalse(preveri_pot([(1, 1)], polje))
        self.assertFalse(preveri_pot([(1, 1), (2, 2)], polje4),
                         "Diagonale so prepovedane")
        self.assertFalse(preveri_pot([(0, 2), (2, 2)], polje4),
                         "Dovoljeni so le premiki za eno polje")
        self.assertFalse(preveri_pot([(1, 2), (0, 2), (2, 2)], polje4),
                         "Dovoljeni so le premiki za eno polje")
        self.assertFalse(preveri_pot([(0, 2), (2, 2), (1, 2)], polje4),
                         "Dovoljeni so le premiki za eno polje")
        self.assertFalse(preveri_pot([(2, 2), (0, 2)], polje4),
                         "Dovoljeni so le premiki za eno polje")
        self.assertFalse(preveri_pot([(1, 0), (1, 2)], polje4),
                         "Dovoljeni so le premiki za eno polje")
        self.assertFalse(preveri_pot([(1, 2), (1, 0)], polje4),
                         "Dovoljeni so le premiki za eno polje")
        self.assertFalse(preveri_pot([(1, 0), (4, 3)], polje4),
                         "Dovoljeni so le premiki za eno polje")
        self.assertFalse(preveri_pot([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1),
                                      (3, 2), (5, 2), (5, 3), (5, 4)], polje4),
                         "Dovoljeni so le premiki za eno polje")

        self.assertFalse(preveri_pot([(1, 3), (1, 2), (2, 2), (1, 2)], polje4),
                         "Polja se ne smejo ponavljati")
        self.assertFalse(preveri_pot([(2, 2), (2, 1), (2, 0), (2, 1), (2, 2)],
                                     polje4),
                         "Polja se ne smejo ponavljati")

        self.assertFalse(preveri_pot([(0, 2), (1, 2), (2, 2), (2, 3)], polje),
                         "Vsa polja na poti morajo biti enake barve")
        self.assertFalse(preveri_pot([(0, 2), (1, 2), (2, 2), (2, 3), (3, 3)],
                                     polje),
                         "Vsa polja na poti morajo biti enake barve")
        self.assertFalse(preveri_pot([(1, 2), (2, 2), (2, 3), (3, 3)], polje),
                         "Vsa polja na poti morajo biti enake barve")
        self.assertFalse(preveri_pot([(2, 2), (2, 3), (3, 3)], polje),
                         "Vsa polja na poti morajo biti enake barve")
        self.assertFalse(preveri_pot([(2, 2), (2, 3), (2, 2)], polje),
                         "Vsa polja na poti morajo biti enake barve")

        self.assertFalse(preveri_pot([(0, 0), (-1, 0), (-1, 1)], polje4),
                         "Pot ne sme zapustiti polja")
        self.assertFalse(preveri_pot([(-1, 0), (-1, 1)], polje4),
                         "Pot ne sme zapustiti polja")
        self.assertFalse(preveri_pot([(-1, 0)], polje4),
                         "Pot ne sme zapustiti polja")
        self.assertFalse(preveri_pot([(0, 0), (0, -1), (1, -1)], polje4),
                         "Pot ne sme zapustiti polja")
        self.assertFalse(preveri_pot([(0, 2), (0, 3), (0, 4)], polje4),
                         "Pot ne sme zapustiti polja")
        self.assertFalse(preveri_pot([(4, 2), (4, 3), (5, 3)], polje4),
                         "Pot ne sme zapustiti polja")
        self.assertFalse(preveri_pot([(5, 3), (4, 3)], polje4),
                         "Pot ne sme zapustiti polja")
        self.assertFalse(preveri_pot([(5, 3), (4, 3), (5, 3)], polje4),
                         "Pot ne sme zapustiti polja")
        self.assertFalse(preveri_pot([(1, 2), (1, 1), (1, 0), (1, -1),
                                      (1, 0), (1, 1), (1, 2)], polje4),
                         "Pot ne sme zapustiti polja")

    def test_9_pot_iz_koordinat(self):
        self.assertEqual(pot_iz_koordinat("53"), [(5, 3)])
        self.assertEqual(pot_iz_koordinat("53R"), [(5, 3), (6, 3)])
        self.assertEqual(pot_iz_koordinat("53UDLR"),
                         [(5, 3), (5, 4), (5, 3), (4, 3), (5, 3)])
        self.assertEqual(pot_iz_koordinat("53DDDDD"),
                         [(5, 3), (5, 2), (5, 1), (5, 0), (5, -1), (5, -2)])

    def test_A_ni_sosednjih(self):
        self.assertFalse(ni_sosednjih([[1, 2, 3], [4, 4, 6], [7, 8, 9]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3], [4, 5, 5], [7, 8, 9]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3], [4, 5, 6], [7, 8, 6]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3], [4, 5, 3], [7, 8, 9]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3], [4, 5, 6], [4, 8, 9]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3], [4, 5, 6], [7, 5, 9]]))
        self.assertFalse(ni_sosednjih([[1, 5, 3], [4, 5, 6], [7, 8, 9]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3], [1, 5, 6], [7, 8, 9]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3], [4, 5, 3], [7, 8, 9]]))

        self.assertTrue(ni_sosednjih([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))

        self.assertTrue(ni_sosednjih([[1, 2, 3, 4, 5, 6]]))
        self.assertFalse(ni_sosednjih([[2, 2, 3, 4, 5, 6]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3, 3, 5, 6]]))
        self.assertFalse(ni_sosednjih([[1, 2, 3, 4, 5, 5]]))

        self.assertTrue(ni_sosednjih([[1, 2, 3], [4, 5, 6], [7, 8, 7]]))
        self.assertTrue(ni_sosednjih([[1, 2, 3], [4, 5, 4], [7, 8, 9]]))
        self.assertTrue(ni_sosednjih([[1, 2, 3], [4, 5, 6], [1, 8, 9]]))
        self.assertTrue(ni_sosednjih([[1, 2, 3], [4, 5, 6], [7, 8, 3]]))

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

mislim da mi izpise le 14221... namesto vseh številk...
ce print-am zadevo mi ipise vse po vrstnem redu, ko pa jo return-am, pa ne dela...