Upload

Nahrání páté lekce.

cviceni05/01_nasobeni_polynomu.py

@@ -0,0 +1,43 @@
+# Zadání:
+#########
+# 
+# Napište funkci polyMulti, která násobí dva polynomy (polynomy mohou mít různé
+# stupně).
+#
+# Příklad volání: polyMulti( [1, 1], [-2, 1] ) vrátí [-2, -1, 1] neboť 
+# (x+1)(x−2)=x^2−x−2
+###############################################################################
+
+def polyMulti( x, y ):
+    """
+    Provede vzájemné pronásobení dvou polynomů reprezentovaných jako pole.
+    Například [1, 1] značí polynom x + 1.
+    
+    Parametry:
+    ----------
+        x: list
+            První polynom
+        y: list
+            Druhý polynom
+    
+    Vrací:
+    ------
+        list
+            Výsledek násobení polynomů x a y.
+    """
+
+    # Vytvoří pole nul o délce (x + y)-1.
+    poly = [0]*(len(x)+len(y)-1)
+
+    # Vezme po řadě všechny prvky polynomu x
+    for a in range(len(x)):
+
+        # projde všechny prvky druhého polynomu
+        for b in range( len(y) ):
+
+            # Uloží výsledek
+            poly[a+b] += x[a]*y[b]
+
+    return poly
+
+print(polyMulti( [1, 1], [-2, 1] ))

cviceni05/02_permutace.py

@@ -0,0 +1,65 @@
+# Zadání:
+#########
+#
+# Pokud pole o délce N, obsahuje všechna čísla od 0..N-1 právě jednou, pak toto
+# pole kóduje permutaci tak, že první prvek se zobrazí na místo, kde se v poli 
+# nachází 0, druhý prvek na místo, kde se v poli nachází 1,…
+#
+# Pole [0, 1, 2, 3], kóduje identickou tzv. jednotkovou permutaci o čtyřech 
+# prvcích, pole [3, 2, 1, 0] kóduje otočení prvků v poli.
+#
+# Napište program, který načtěte z jednoho řádku standardního vstupu vektor 
+# reprezentující permutaci a najde a vytiskne inverzní permutaci, tj. 
+# permutaci, která převede zadanou permutaci na jednotkovou.
+#
+# Inverzní permutace k permutaci [2, 0, 1], je permutace [1, 2, 0], neboť první
+# permutace zobrazí 0→2 a druhá permutace 2→0, obdobně 1→0, druhá permutace 
+# 0→1; první 2→1 a druhá 1→2.
+###############################################################################
+
+# Pole čísel je zadáno jako uživatelský vstup. Jednotlivá čísla odděluje 
+# mezera. 
+array = list(map(int, input().split(" ")))
+
+def permutate( array ):
+    """
+    Najde permutaci k zadanému poli. Požadavkem je, aby pole o délce N 
+    obsahovalo všechny čísla od 0 do N-1. 
+    
+    Parametry:
+    ---------
+        array: list
+            Pole čísel splňující požadavky popsané výše.
+
+    Vrací:
+    ------
+        list
+            Permutace předaného pole.
+        
+        False
+            Pole nevyhovuje požadavkům nebo nebo má nulovou délku.
+    """
+
+    if len( array ) == 0:
+        return False
+
+    # Vytvoří pole nul o stejné délce jako má array
+    temp = [0]*( len( array ) )
+
+    # Projde všechny prvky v poli array
+    for i, item in enumerate( array ):
+
+        # V poli musí existovat prvek, jehož hodnota je stejná jako index 
+        # aktuálního
+        if i in array:
+
+            # Do temp uloží aktuální prvek na místo, kde se v array nachází
+            # prvek stejné hodnoty jako index aktuálního čísla. 
+            temp[ array.index(i) ] = item
+        else:
+            return False
+
+    return temp
+
+print(permutate( array ) )
+#print(permutate( [2, 0, 1, 4] ) ) # -> False

cviceni05/03_vypis_matice.py

@@ -0,0 +1,41 @@
+# Zadání:
+#########
+#
+# Napište funkci printMatrix, která vypíše matici zadanou 2D polem.
+#
+# Prvky budou odděleny mezerou a každý řádek bude vypsán na nový řádek.
+#
+# Kromě prvků matice nebude vypsán žádný jiný znak.
+###############################################################################
+
+def printMatrix( matrix ):
+    """
+    Vypíše 2D pole poněkud čielnějším způsobem.
+    
+    Parametry:
+    ----------
+        matrix: list
+            2D pole pro vypsání.
+    """
+
+    width = len(matrix[0])
+    height = len(matrix)
+
+    for x in range(width):
+        for y in range( height ):
+
+            # Parametr end určuje znak na konci každého volání funkce print.
+            # Bez něj by se každé číslo vypsalo na nový řádek.
+            print(matrix[x][y], end=" ")
+
+        # Nový řádek.
+        print()
+
+printMatrix(
+    [
+        [2, 4, 7, 8],
+        [8, 9, 9, 7],
+        [8, 9, 9, 7],
+        [8, 9, 9, 7]
+    ]
+)

cviceni05/04_nasobeni_vektoru_matice.py

@@ -0,0 +1,52 @@
+# Zadání:
+#########
+#
+# Napište funkci multiVecMat(v,m), která vypočte součin vektoru v a matice m.
+#
+# Pokud nesouhlasí rozměry matice a vektoru, pak funkce vrací None.
+#
+# Otestujte Váš program na těchto datech:
+#
+#    m=[[0,0,1],[0,1,0],[1,0,0]]
+#    v=[2, 4, 6]
+#
+###############################################################################
+
+def multiVecMat( vector, matrix ):
+    """
+    Pronásobí matici vektorem zprava.
+
+    Parametry:
+    ----------
+        vector: list
+            Vektor
+        matrix: list
+            Pronásobená matice. Její dimenze se musí shodovat s dimenzí
+            vektoru.
+
+    Vrací:
+        list
+            Pole velikosti vektoru.
+    """
+
+    # Vytvoří pole o velikosti vektoru
+    result = [0] * len( matrix[0] )
+
+    # Projde matici po řádcích
+    for r, row in enumerate( matrix ):
+
+        # Pokud nesedí rozměry, končíme
+        if len(row) != len(vector):
+            return None
+
+        # Projde každý prvek v řádku
+        for i, elem in enumerate( row ):
+
+            # K poli s výsledkem přičte na index aktuálního řádku výsledek
+            # násobení aktuálního prvku v řádku a jemu odpovídajícího 
+            # prvku z vektoru.
+            result[r] += elem * vector[i]
+
+    return result
+
+print( multiVecMat( [2, 4, 6], [[0,0,1],[0,1,0],[1,0,0]] ) )

cviceni05/05_prohozeni_radku_matice.py

@@ -0,0 +1,55 @@
+# Zadání:
+#########
+#
+# Napište program, který načte matici a následně permutaci, která definuje 
+# prohození řádků zadané matice. Na výstup program vytiskne matici s řádky 
+# prohozenými podle zadané permutace.
+###############################################################################
+
+matrix_input = input("Matice (čísla odděluj mezerou, řádky čárkou):").split(",")
+permutation = list( map( int, input("Permutace (čísla odděluj mezerou):").split(" ") ) )
+
+# Pouze zpracuje zadanou matici tak, aby s ní mohl python pracovat
+matrix = []
+for m in matrix_input:
+    matrix.append( list(map(int, m.split(" ") ) ) )
+
+def swap( perm, matrix ):
+    """
+    Prohodí řádky matice podle zadané permutace.
+
+    Parametry:
+    ----------
+        perm: list
+            Pole délky N obsahující čísla od 0 do N. Určuje permutaci,
+            se kterou se prohodí řádky matice.
+
+        matrix: list
+            Pole, ve kterém se prohodí řádky.
+    """
+
+    if len(perm) != len(matrix):
+        return None
+
+    # Vytvoří pole stejné velikosti jako předaná matice
+    result = [0] * len(matrix)
+
+    # Projde matici
+    for i in range( len( matrix ) ):
+
+        # Pokud v poli permutací není aktuální index,
+        # nevíme kam řádek umístit
+        if not i in perm:
+            return None
+
+        # Prohodí řádek na správné místo
+        result[ perm.index(i) ] = matrix[i]
+
+    return result
+
+print( swap( permutation, matrix ) )
+
+
+
+
+

cviceni05/data/matrix.txt

@@ -0,0 +1,5 @@
+ 1  1  2  5  6  1
+ 5  6  8  5  6  7
+10 12 10 12 11 11
+ 8 10  5  6  8  9
+ 6  5 10 12 15 19

cviceni05/data/tictactoe.txt

@@ -0,0 +1,10 @@
+0 0 0 0 0 2 0 0 0 0
+0 0 0 0 2 2 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 2 2 2 2 2 0 0 0 0
+1 2 1 2 1 2 1 1 1 1
+0 0 0 0 2 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0

cviceni05/domaci_priprava.py

@@ -0,0 +1,31 @@
+# Zadání:
+#########
+# Implementujte následující úlohy:
+# 
+# * Najděte v matici (2D poli) všechny záporné hodnoty, vraťte seznam jejich 
+#   indexů.
+# * Implementujte násobení dvou matic
+###############################################################################
+
+def findAllNegative( matrix ):
+    """
+    Najde všechny záporné hodnoty v matici a vrátí jejich indexy.
+
+    Parametry:
+    ----------
+        matrix: list
+            2D pole reprezentující matici
+
+    Vrací:
+        list
+            2D pole s indexy záporných hodnot z matice.
+    """
+    indexes = []
+
+    for x in matrix:
+        for y in matrix[x]:
+
+            if matrix[x][y] < 0:
+                indexes.append( [x,y] )
+
+    return indexes