remove bin

.gitignore

@@ -6,3 +6,4 @@
 */out
 .Rhistory
 main
+.Rproj.user

uczelnia/2_semestr/matematyka_stosowana/Prawdopodobieństwo.md

@@ -303,4 +303,14 @@ Zał:
 - Rozkład normalny
 
 Test rangowych znaków dla jednej populacji
-Rangowanie polega na nadawaniu rang wartościom. Przy identycznych wartościach nadajemy średnią artmetyczną rang, które przypadałaby na te wartości.
+Rangowanie polega na nadawaniu rang wartościom. Przy identycznych wartościach nadajemy średnią artmetyczną rang, które przypadałaby na te wartości.
+
+# Regresje I i II rodzaju
+## I rodzaj
+Funkcja regresji liniowej I rodzaju zmiennej Y względem zmiennej X jest zbiorem punktów $(x, g_2(x)) \in R^2$  
+
+__Zadanie 27.7 prezentacja wykład 12 na egzaminie__
+
+## Rodzaj II
+Funkcję, której przewidywaną postać wyznacza się metodą mniejszych kwadraatów minimalizując wyrażenie $E(Y - g(X))^2$, nazywamy funkcją regresji II rodzaju
+

uczelnia/2_semestr/matematyka_stosowana/laby/lab_10.R

@@ -0,0 +1,167 @@
+# zadanie 1
+
+# Próby niezależne
+
+# a)
+
+# założenie 1: normalność rozkładów
+
+# h0 – rozkład średnich ocen w populacji studentek jest normalny
+# h1 – ~h0
+
+# h0' – rozkład średnich ocen w populacji studentów jest normalny
+# h1' – ~h0'
+
+by(Ankieta$Średnia, Ankieta$Płeć, shapiro.test)
+
+# dla kobiet: W = 0.97625, p-value = 0.942
+# dla mężczyzn: W = 0.97148, p-value = 0.1578
+# aplha = 0.01
+
+# w obu przypadka alpha < p-value
+# brak podstaw do odrzucenia h0 i h0'
+
+# b)
+
+# h0 – jednorodność wariancji sigma.k^2 = sigma.m^2
+# h1 – ~h0
+
+var.test(Ankieta$Średnia ~ Ankieta$Płeć)
+# F = 0.40623, num df = 9, denom df = 61, p-value = 0.1459
+# alpha = 0.01
+
+# Wniosek: brak podstaw do odrzucenia h0
+# będziemy stosować test bez poprawki welcha
+
+# c)
+
+# h0 – m.kobiet = m.mężczyzn
+# h1 – m.kobiet > m.mężczyzn
+
+
+t.test(Ankieta$Średnia ~ Ankieta$Płeć, alternative = 'g', var.equal = TRUE)
+# t = -0.49177, df = 70, p-value = 0.6878
+# alpha = 0.01
+
+# Wniosek: Na poziomie istotności 0.01 nie ma podstaw do odrzucenia hipotezy h0, zatem wyniki próby nie potwierdzają przypuszczenia, że średnie oceny studentek są wyższe niż studentów studiujących na I roku WI na ZUT w Szczecinie w tym roku akademickim.
+
+
+
+# Zadanie 2
+# alpha = 0.05
+
+# Test dla dwóch wskaźników struktury
+
+# grupy:
+# 1 – grupa mieszkających z rodziną
+# 2 – grupa mieszkających poza domem rodzinnym
+
+# wyróżniona cecha: absolewnci TI
+
+# Hipotezy:
+# h0 – p1 = p2
+# h1 – p1 < p2
+
+table(Ankieta$M.zamieszkania, Ankieta$Sz.średnia)
+prop.test(c(15, 20), c(32, 40), alternative = 'l')
+# X-squared = 0.00069498, df = 1, p-value = 0.4895
+# aplha = 0.05
+
+# Wniosek: na poziomie istotności 0.05 nie można odrzucić hipotezy h0. Zatem odsetki osób, które ukończyły TI nie różnią się istotnie dla mieszkających podczas studiowania z rodziną oraz dla mieszkających poza domem rodzinnym.
+
+# Zadanie 3
+
+# próby zależne
+
+# alpha = 0.01
+
+# założenie: normalność różnicy zmiennych
+# h0 – rozkład różnicy zmiennych jest normalny
+# h1 – ~h0
+
+x1 = c(225, 236, 312, 238, 241, 196, 205, 259, 218)
+x2 = c(216, 195, 245, 235, 221, 170, 180, 265, 179)
+
+shapiro.test(x1 - x2)
+# W = 0.96898, p-value = 0.8858
+
+# Wniosek: brak podstaw do odrzucenia h0
+
+
+# test studenta dla dwóch średnich – próby zależne
+# h0 – m1 - m2 = 0
+# h1 – m1 - m2 > 0
+t.test(x1, x2, paired = T, alternative = 'g')
+# t = 3.3633, df = 8, p-value = 0.004942
+
+# Wniosek: na poziomie isotności 0.01 odrzucamy h0 i przyjmujemy h1, zatem leczenie statynami istotnie wpływa na obniżenie poziomu cholesterolu.
+
+# Zadanie 4
+# normalność rozkładów -> jednorodność wariancji -> właściwy test
+
+# aplha = 0.01
+
+# założenie 1: normalność rozkładów
+# h0 – średni wzrost w populacji studentek jest normalny
+# h1 – ~h0
+
+# h0' – średni wzrost w populacji studentów jest normalny
+# h1 – ~h0'
+by(Ankieta$Wzrost, Ankieta$Płeć, shapiro.test)
+# dla kobiet: W = 0.95432, p-value = 0.7197
+# dla mężczyzn: W = 0.9598, p-value = 0.04048
+
+# brak podstaw do odrzucenia h0 i h0'
+
+# założenie 2: jednorodność wariancji
+# h0 – jednorodność wariancji k.sigma^2 = m.sigma^2
+# h1 – ~h0
+var.test(Ankieta$Wzrost ~ Ankieta$Płeć)
+# F = 1.2842, num df = 9, denom df = 61, p-value = 0.528
+# brak podstaw do odrzucenia h0
+# będziemy stosować test bez poprawki welcha
+
+# h0 – m.kobiet = m.mężczyzn
+# h1 – m.kobiet ≠ m.mężczyzn
+t.test(Ankieta$Wzrost ~ Ankieta$Płeć, alternative = 'two.sided', var.equal = T)
+# t = -5.2844, df = 70, p-value = 1.36e-06
+
+# Na poziomie istotności 0.01 odrzucamy h0 i przyjmujemy h1.
+
+# zadanie 5
+# wskaźnik struktury, grupująca jest płeć
+
+# zadanie 7
+
+
+# zadanie 8
+# alpha = 0.02
+
+# założenie 1: normalność rozkładu
+# h0 – rozkład średnich ocen w grupie posiadającej rodzeństwo jest normalny
+# h1 – ~h0
+
+# h0' – rozkład średnich ocen w grupie nieposiadającej rodzeństwa jest normalny
+# h1' – ~h0'
+
+by(Ankieta$Średnia, Ankieta$Rodzeństwo, shapiro.test)
+# nieposiadający rodzeństwa: W = 0.93477, p-value = 0.3929
+# posiadający rodzeństwo: W = 0.97486, p-value = 0.26
+
+# brak podstaw do odrzucenia h0 i h0'
+
+# założenie 2: jednorodność wariancji
+# h0 – jednorodność wariancji n.sigma^2 = t.sigma^2
+# h1 – ~h0
+var.test(Ankieta$Średnia ~ Ankieta$Rodzeństwo)
+# F = 0.80082, num df = 12, denom df = 58, p-value = 0.704
+
+# brak podstaw do odrzucenia h0
+# test bez poprawki welcha
+
+# h0 – m.z_rodzeństwem = m.bez_rodzeństwa
+# h1 – m.z_rodzeństwem ≠ m.bez_rodzeństwa
+t.test(Ankieta$Średnia ~ Ankieta$Rodzeństwo, alternative = 'two.sided', var.equal = T)
+# t = -0.61915, df = 70, p-value = 0.5378
+
+# wniosek: na poziomie istotności 0.02 brak podstaw do odrzucenia h0, że średnia ocen osób posiadających rodzeństwo nie różni istotnie od średniej osób nieposiadających rodzieństwa w badanej grupie.

uczelnia/2_semestr/matematyka_stosowana/laby/lab_11.R

@@ -0,0 +1,178 @@
+# zadanie 1
+
+# zmienna mierzalna
+plony = c(2.6, 2.4, 2, 1.8, 2.2, 1.5, 1.5, 1.4, 1.2, 1.5, 1.2, 1.5, 0.8, 1)
+# zmienna grupująca
+kombinacje = c(rep('1', 5), rep('2', 4), rep('3', 5))
+
+## Normalność rozkładów
+
+### (wariant skrócony)
+by(plony, kombinacje, shapiro.test)
+# kombinacja 1: W = 0.98676, p-value = 0.9672
+# kombinacja 2: W = 0.82743, p-value = 0.1612
+# kombinacja 3: W = 0.90345, p-value = 0.4292
+
+# Brak podstaw do odrzucenia hipotez zerowych
+
+## Jednorodność wariancji
+# h0: sigma^2 = (sigma.2)^2 = (sigma.3)^2
+# h1: ~h0
+bartlett.test(plony ~ kombinacje)
+# Bartlett's K-squared = 1.8396, df = 2, p-value= 0.3986
+
+# alpha < p-value – Brak podstaw do odrzucenia h0
+
+## Test anova
+# h0: m.1 = m.2 = m.3 (brak wpływu)
+# h1: ~h0 (istotny wpływ)
+
+anova(aov(plony ~ kombinacje))
+
+# Response: plony
+# Df Sum Sq Mean Sq F value    Pr(>F)    
+# kombinacje  2 2.7571 1.37857  18.053 0.0003356 ***
+#  Residuals  11 0.8400 0.07636                      
+
+# F: 18.053 p-value: 0.0003356
+
+# Odrzucamy h0, przyjmujemy h1, nawóz ma istotny wpływ
+
+# Wniosek: na poziomie istotności 0.05 odrzucamy h0 i przyjmujemy h1, zatem nawożenie istotnie wpływa na plony rzepaku jarego.
+
+
+# Zadanie 2
+
+# Jedna próba
+
+## Test normalności rozkładu
+
+# wariant skrócony
+
+shapiro.test(Ankieta.M$Waga)
+# W = 0.94653, p-value = 0.009113
+
+# Odrzucamy h0
+
+# Test nieparametryczny Wilcoxona
+# h0: mediana = 70
+# h1: mediana > 70
+wilcox.test(Ankieta.M$Waga, mu = 70, alternative = 'g')
+# V = 1129.5, p-value = 0.008091
+
+# Wniosek: na poziomie istotności 0.05 odrzucamy h0 i przyjmujemy h1. Zatem mediana wagi populacji mężczyzn studiujących na I roku WI ZUT w Szczecinie jest istotnie większa od 70kg.
+
+
+# Zadanie 3
+
+# Dwie niezależne próby
+
+utargi = c(7.6, 12.0, 7.3, 11.3, 7.0, 10.8, 6.5, 8.1, 3.2, 8.7, 8.8, 11.7, 12.7, 18.5, 3.3, 6.7, 8.6, 6.9, 3.8, 3.7) # zmienna mierzalna
+miasta = c(rep('A', 13), rep('B', 7)) # zmienna grupująca
+
+## Normalność rozkładu
+# wariant skrócony
+by(utargi, miasta, shapiro.test)
+# Miasto A:  W = 0.94565, p-value = 0.5341
+# Brak podstaw do odrzucenia h0
+
+# Miasto B:  W = 0.76886, p-value = 0.01989
+# Odrzucamy h0
+
+# Wniosek: odrzucamy hipotezę, że rozkład miesięcznego utargu w mieście B jest zgodny z rozkładem normalnym.
+
+## Test nieparametryczny wilcoxona
+# h0: mediana.A = mediana.B
+# h1: mediana.A > mediana.B
+
+wilcox.test(utargi ~ miasta, alternative = 'g')
+# W = 65, p-value = 0.0674
+# brak podstaw do odrzucenia h0
+
+# Wniosek: Na poziomie istotności 0.05 nie ma podstaw by odrzucić hipotezę h0. Mediany utargów w mieście A i B nie różnią się istotnie.
+
+# Zadanie 4
+
+# Dwie zależne próby
+x1 = c(85, 122, 162, 206, 121, 250, 200, 156)
+x2 = c(87, 82, 158, 96, 131, 121, 194, 130)
+
+## Normalność rozkładu różnicy zmiennych
+# wariant skrócony
+shapiro.test(x1 - x2)
+# W = 0.81838, p-value = 0.04487
+
+# Wniosek: odrzucamy h0
+
+## Test nieparametryczny Wilcoxona: próby zależne
+# h0: mediana1 - mediana2 = 0
+# h1: mediana1 - mediana2 > 0
+
+wilcox.test(x1, x2, paired = T, alternative = 'g')
+# V = 31, p-value = 0.03906
+
+# Odrzucamy h0 i przyjmujemy h1
+
+# Wniosek: na poziomie istotności 0.05 odrzucamy h0 i przyjmujemy h1, zatem trening istotnie wpływa na skrócenie czasu potrzebnego myszom na wyjście z labiryntu.
+
+
+# Zadanie 5
+frewkencja = c(32.5, 40.8, 41.7, 41.2, 37.9, 38.3, 42, 39.8, 43.1, 42.6, 38.9, 43.1, 40.4, 41.8, 42, 39, 43.7, 40, 39.7, 43, 43.1, 43.9, 44.2, 45.2, 44.6, 42.5, 43.4, 44.8, 42.8, 43.1, 44.8, 45)
+miasta = c(rep('Wroclaw', 10), rep('Warszawa', 11), rep('Krakow', 11))
+# alhpa = 0.05
+# 3 próby
+
+## Jednorodność wariancji
+# h0: sigma^2 = (sigma.2)^2 = (sigma.3)^2
+# h1: ~h0
+bartlett.test(frewkencja ~ miasta)
+# Bartlett's K-squared = 11.774, df = 2, p-value = 0.002775
+# aplha > p-value
+# odrzucamy h0, przyjmujemy h1
+
+# h0: mediana.1 = mediana.2 = mediana.3
+# h1: ~h0
+kruskal.test(frewkencja ~ miasta)
+
+# Kruskal-Wallis chi-squared = 16.791, df = 2, p-value = 0.0002259
+# alpha > p-value
+# odrzucamy h0 i przyjmujemy h1
+
+# Wniosek: na poziomie istotności 0.05 odrzucamy h0 i przyjmujemy h1, zatem frekwencja w wyborach prezydenckich dla wszystkich tych miast nie jest taka sama.
+
+
+# Zadanie 8
+# 3 próby
+
+# alpha = 0.01
+
+## Test normalności
+# wariant skrócony
+
+by(Ankieta$L.godzin, Ankieta$M.zamieszkania, shapiro.test)
+# akademik: W = 0.96227, p-value = 0.5107
+# mieszkanie z rodziną: W = 0.98145, p-value = 0.8405
+# stancja lub inne: W = 0.95429, p-value = 0.5278
+
+# W każdej próbce brak podstaw do odrzucenia h0
+
+## Test jednorodności wariancji
+# h0: sigma.0^2 = (sigma.1)^2 = (sigma.2)^2
+# h1: ~h0
+
+bartlett.test(Ankieta$L.godzin ~ Ankieta$M.zamieszkania)
+# Bartlett's K-squared = 0.47545, df = 2, p-value = 0.7884
+
+# alpha < p-value
+# brak podstaw do odrzucenia h0, zatem wariancje są jednorodne
+
+
+# h0: m0 = m1 = m2 (brak wpływu)
+# h1: ~h0 (istotny wpływ)
+
+anova(aov(Ankieta$L.godzin ~ Ankieta$M.zamieszkania))
+# F - 0.5896 p-value 0.5573
+# alpha < 0.5573
+# brak podstaw do odrzucenia h0
+
+# Wniosek: Na poziomie istotności 0.01 nie ma podstaw do odrzucenia h0, zatem liczba godzin spędzonych przed komputerem w ciągu doby w popuplacji studentów pierwszego roku WI ZUT w Szczecinie w tym roku akademickim nie zależy od miejsca zamieszkania.

uczelnia/2_semestr/matematyka_stosowana/laby/laby.Rproj

@@ -0,0 +1,13 @@
+Version: 1.0
+
+RestoreWorkspace: Default
+SaveWorkspace: Default
+AlwaysSaveHistory: Default
+
+EnableCodeIndexing: Yes
+UseSpacesForTab: Yes
+NumSpacesForTab: 2
+Encoding: UTF-8
+
+RnwWeave: Sweave
+LaTeX: pdfLaTeX

uczelnia/2_semestr/programowanie/laby/lab11/zad1.cpp

@@ -0,0 +1,64 @@
+#include <cmath>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+class Ksztalt {
+public:
+  virtual ~Ksztalt() = default;
+  virtual double pole() = 0;
+  virtual std::string opis() = 0;
+};
+
+class Kolo : public Ksztalt {
+  int r;
+
+public:
+  Kolo(int r) : r(r) {}
+
+  double pole() override { return r * r * M_PI; }
+  std::string opis() override { return "To jest koło";}  
+
+  ~Kolo() override {}
+};
+
+class Trojkat : public Ksztalt {
+  int a, h;
+
+public:
+  Trojkat(int a, int h) : a(a), h(h) {}
+
+  double pole() override { return a * h * 0.5; }
+  std::string opis() override { return "To jest trójkąt";}   
+
+  ~Trojkat() override {}
+};
+
+class Kwadrat : public Ksztalt {
+  int a;
+
+public:
+  Kwadrat(int a) : a(a) {}
+
+  double pole() override { return a * a; }
+  std::string opis() override { return " To jest kwadrat"; }
+
+  ~Kwadrat() override {}
+};
+
+double sum_pole(std::vector<std::unique_ptr<Ksztalt>> &vec) {
+  double sum = 0;
+  for (auto &ksztalt : vec) {
+    sum += ksztalt->pole();
+  }
+  return sum;
+}
+
+int main() {
+  std::vector<std::unique_ptr<Ksztalt>> vec;
+  vec.push_back(std::make_unique<Trojkat>(2, 4));
+  vec.push_back(std::make_unique<Kolo>(2));
+  vec.push_back(std::make_unique<Kwadrat>(4));
+  std::cout << "Suma pól wszystkich figur to: " << sum_pole(vec) << std::endl;
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad10.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <memory>
+
+class StrategiaPodatkowa {
+public:
+  virtual double oblicz(double kwota) const = 0;
+  virtual ~StrategiaPodatkowa() = default;
+};
+
+class PodatekLiniowy : public StrategiaPodatkowa {
+  const double procent = 0.19;
+
+public:
+  double oblicz(double kwota) const override { return kwota * procent; }
+};
+
+class PodatekProgresywny : public StrategiaPodatkowa {
+  const double prog_1 = 0.19;
+  const double prog_2 = 0.8;
+
+public:
+  double oblicz(double kwota) const override {
+    return (kwota < 4000) ? (kwota * prog_1) : (kwota * prog_2);
+  }
+};
+
+class BrakPodatku : public StrategiaPodatkowa {
+public:
+  double oblicz(double) const override { return 0.0; }
+};
+
+class Faktura {
+  std::unique_ptr<StrategiaPodatkowa> strategia;
+  double kwota;
+
+public:
+  Faktura(std::unique_ptr<StrategiaPodatkowa> s, double kwota)
+      : strategia(std::move(s)), kwota(kwota) {}
+
+  double kwotaDoZaplaty() const { return strategia->oblicz(kwota) + kwota; }
+};
+
+int main() {
+  Faktura faktura_socjalistyczna(std::make_unique<PodatekProgresywny>(), 5000);
+  Faktura faktura_wolnorynkowa(std::make_unique<PodatekLiniowy>(), 5000);
+  Faktura faktura_libertalinistyczna(std::make_unique<BrakPodatku>(), 5000);
+
+  std::cout << faktura_socjalistyczna.kwotaDoZaplaty() << std::endl;
+  std::cout << faktura_wolnorynkowa.kwotaDoZaplaty() << std::endl;
+  std::cout << faktura_libertalinistyczna.kwotaDoZaplaty() << std::endl;
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad11.cpp

@@ -0,0 +1,111 @@
+#include <iostream>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <vector>
+
+class Zwierze {
+public:
+  virtual std::string odglos() = 0;
+  virtual std::string jedzenie() = 0;
+  virtual double ileKalorii() = 0;
+  virtual ~Zwierze() = default;
+
+  friend std::ostream &operator<<(std::ostream &os, Zwierze &z) {
+    os << "To zwierze wydaje dźwięk: " << z.odglos() << ".\nJe " << z.jedzenie()
+       << " i potrzebuje " << z.ileKalorii() << " kalorii dziennie\n";
+    return os;
+  }
+};
+
+class Lew : public Zwierze {
+public:
+  std::string odglos() override { return "Odgłos lwa"; }
+  std::string jedzenie() override { return "Mięso";}  
+  double ileKalorii() override { return 2348; }
+};
+
+class Slon : public Zwierze {
+public:
+  std::string odglos() override { return "Odgłos słonia"; }
+  std::string jedzenie() override { return "Liście";}  
+  double ileKalorii() override { return 23; }
+};
+
+class Papuga : public Zwierze {
+public:
+  std::string odglos() override { return "Odgłos papugii"; }
+  std::string jedzenie() override { return "Ziarna"; }
+  double ileKalorii() override { return 2; }
+};
+
+class Waz : public Zwierze {
+public:
+  std::string odglos() override { return "Odgłos węża"; }
+  std::string jedzenie() override { return "Mięso"; }
+  double ileKalorii() override { return 387; }
+};
+
+class Opiekun {
+public:
+  void nakarm() { std::cout << "Nakarmione" << std::endl; }
+};
+
+class Wybieg {
+  Opiekun opiekun_wybiegu;
+
+public:
+  std::vector<std::unique_ptr<Zwierze>> zwierzeta;
+
+public:
+  Wybieg(std::vector<std::unique_ptr<Zwierze>> zwierzeta,
+         Opiekun opiekun_wybiegu)
+      : zwierzeta(std::move(zwierzeta)), opiekun_wybiegu(opiekun_wybiegu) {}
+};
+
+class Zoo {
+  std::vector<std::unique_ptr<Wybieg>> wybiegi;
+
+public:
+  Zoo(std::vector<std::unique_ptr<Wybieg>> wybiegi)
+      : wybiegi(std::move(wybiegi)) {}
+
+  double dziennaPorcjaKalorii() {
+    double sum = 0;
+    for (auto &wybieg : wybiegi) {
+      for (const auto &zwierze : wybieg->zwierzeta) {
+        sum += zwierze->ileKalorii();
+      }
+    }
+    return sum;
+  }
+
+  friend std::ostream &operator<<(std::ostream &os, Zoo &z) {
+    os << '[';
+    for (auto &wybieg : z.wybiegi) {
+      for (const auto &zwierze : wybieg->zwierzeta) {
+        os << *zwierze << ',';
+      }
+    }
+    os << ']';
+    return os;
+  }
+};
+
+int main() {
+  std::vector<std::unique_ptr<Zwierze>> zwierzeta;
+  zwierzeta.push_back(std::make_unique<Waz>());
+  zwierzeta.push_back(std::make_unique<Slon>());
+  zwierzeta.push_back(std::make_unique<Lew>());
+
+  Opiekun opiekun;
+  std::vector<std::unique_ptr<Wybieg>> wybiegi;
+
+  wybiegi.push_back(std::make_unique<Wybieg>(std::move(zwierzeta), opiekun));
+
+  Zoo zoo = Zoo(std::move(wybiegi));
+  std::cout << "Dzienna porcja kalorii: " << zoo.dziennaPorcjaKalorii()
+            << std::endl;
+
+  std::cout << zoo;
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad12.cpp

@@ -0,0 +1,179 @@
+#include <iostream>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <vector>
+
+class StrategiaZywienia {
+public:
+  virtual std::string pobierzOpisStrategii() const = 0;
+  virtual ~StrategiaZywienia() = default;
+};
+
+class Drapieznik : public StrategiaZywienia {
+public:
+  std::string pobierzOpisStrategii() const override {
+    return "Drapieznik (wymaga miesa)";
+  }
+};
+
+class Roslinozerca : public StrategiaZywienia {
+public:
+  std::string pobierzOpisStrategii() const override {
+    return "Roslinozerca (wymaga roslin)";
+  }
+};
+
+class Wszystkozerca : public StrategiaZywienia {
+public:
+  std::string pobierzOpisStrategii() const override {
+    return "Wszystkozerca (je wszystko)";
+  }
+};
+
+class Zwierze {
+protected:
+  std::unique_ptr<StrategiaZywienia> strategia;
+
+public:
+  Zwierze(std::unique_ptr<StrategiaZywienia> strat)
+      : strategia(std::move(strat)) {}
+
+  virtual std::string odglos() = 0;
+  virtual std::string jedzenie() = 0;
+  virtual double ileKalorii() = 0;
+  virtual ~Zwierze() = default;
+
+  void ustawStrategie(std::unique_ptr<StrategiaZywienia> nowaStrategia) {
+    strategia = std::move(nowaStrategia);
+  }
+
+  std::string pokazJakJe() const {
+    return strategia ? strategia->pobierzOpisStrategii() : "Brak strategii";
+  }
+
+  friend std::ostream &operator<<(std::ostream &os, Zwierze &z) {
+    os << "To zwierze wydaje dzwiek: " << z.odglos() << ".\nJe " << z.jedzenie()
+       << ", potrzebuje " << z.ileKalorii()
+       << " kcal. Styl zycia: " << z.pokazJakJe() << "\n";
+    return os;
+  }
+};
+
+class Lew : public Zwierze {
+public:
+  Lew() : Zwierze(std::make_unique<Drapieznik>()) {}
+  std::string odglos() override { return "Odgłos lwa"; }
+  std::string jedzenie() override { return "Mięso";}  
+  double ileKalorii() override { return 2348; }
+};
+
+class Slon : public Zwierze {
+public:
+  Slon() : Zwierze(std::make_unique<Roslinozerca>()) {}
+  std::string odglos() override { return "Odgłos słonia"; }
+  std::string jedzenie() override { return "Liście";}  
+  double ileKalorii() override { return 20000; }
+};
+
+class Papuga : public Zwierze {
+public:
+  Papuga() : Zwierze(std::make_unique<Roslinozerca>()) {}
+  std::string odglos() override { return "Odgłos papugii"; }
+  std::string jedzenie() override { return "Ziarna"; }
+  double ileKalorii() override { return 2; }
+};
+
+class Waz : public Zwierze {
+public:
+  Waz() : Zwierze(std::make_unique<Drapieznik>()) {}
+  std::string odglos() override { return "Odgłos węża"; }
+  std::string jedzenie() override { return "Mięso"; }
+  double ileKalorii() override { return 387; }
+};
+
+std::unique_ptr<Zwierze> stworzZwierze(const std::string &gatunek) {
+  if (gatunek == "Lew" || gatunek == "lew") {
+    return std::make_unique<Lew>();
+  } else if (gatunek == "Slon" || gatunek == "slon") {
+    return std::make_unique<Slon>();
+  } else if (gatunek == "Papuga" || gatunek == "papuga") {
+    return std::make_unique<Papuga>();
+  } else if (gatunek == "Waz" || gatunek == "waz") {
+    return std::make_unique<Waz>();
+  }
+  return nullptr;
+}
+
+class Opiekun {
+public:
+  void nakarm() { std::cout << "Nakarmione" << std::endl; }
+};
+
+class Wybieg {
+  Opiekun opiekun_wybiegu;
+
+public:
+  std::vector<std::unique_ptr<Zwierze>> zwierzeta;
+  Wybieg(std::vector<std::unique_ptr<Zwierze>> zwierzeta,
+         Opiekun opiekun_wybiegu)
+      : zwierzeta(std::move(zwierzeta)), opiekun_wybiegu(opiekun_wybiegu) {}
+};
+
+class Zoo {
+  std::vector<std::unique_ptr<Wybieg>> wybiegi;
+
+public:
+  Zoo(std::vector<std::unique_ptr<Wybieg>> wybiegi)
+      : wybiegi(std::move(wybiegi)) {}
+
+  double dziennaPorcjaKalorii() {
+    double sum = 0;
+    for (auto &wybieg : wybiegi) {
+      for (const auto &zwierze : wybieg->zwierzeta) {
+        sum += zwierze->ileKalorii();
+      }
+    }
+    return sum;
+  }
+
+  friend std::ostream &operator<<(std::ostream &os, Zoo &z) {
+    os << "[\n";
+    for (auto &wybieg : z.wybiegi) {
+      for (const auto &zwierze : wybieg->zwierzeta) {
+        os << "  " << *zwierze;
+      }
+    }
+    os << ']';
+    return os;
+  }
+};
+
+int main() {
+  std::vector<std::unique_ptr<Zwierze>> zwierzeta;
+
+  zwierzeta.push_back(stworzZwierze("Waz"));
+  zwierzeta.push_back(stworzZwierze("Slon"));
+  zwierzeta.push_back(stworzZwierze("Lew"));
+
+  std::cout << "Przed zmianą strategii" << std::endl;
+  std::cout << *zwierzeta[2];
+
+  std::cout << "\n Dynamiczna podmiana strategii dla Lwa..." << std::endl;
+  zwierzeta[2]->ustawStrategie(std::make_unique<Wszystkozerca>());
+
+  std::cout << *zwierzeta[2];
+  std::cout << "-------------------------------------------\n" << std::endl;
+
+  Opiekun opiekun;
+  std::vector<std::unique_ptr<Wybieg>> wybiegi;
+  wybiegi.push_back(std::make_unique<Wybieg>(std::move(zwierzeta), opiekun));
+
+  Zoo zoo = Zoo(std::move(wybiegi));
+  std::cout << "Dzienna porcja kalorii w calym zoo: "
+            << zoo.dziennaPorcjaKalorii() << " kcal\n"
+            << std::endl;
+  std::cout << zoo << std::endl;
+
+  return 0;
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad2.cpp

@@ -0,0 +1,21 @@
+class A {
+public:
+  virtual void f() = 0;
+  virtual void g() = 0;
+  virtual void h() = 0;
+  virtual ~A() = default;
+};
+
+class B : public A {
+public:
+  void f() override { return; }
+  void g() override final { return; }
+  void h() override { return; }
+  ~B() { return; }
+};
+
+class C final : public B {
+  void f() override final { return; }
+  void g() override final { return; } // błąd
+  void h() override final { return; }
+};

uczelnia/2_semestr/programowanie/laby/lab11/zad3.cpp

@@ -0,0 +1,34 @@
+#include <iostream>
+#include <memory>
+#include <vector>
+
+class Czlowiek {
+public:
+  virtual void mowa() const { std::cout << "..." << std::endl; }
+  virtual ~Czlowiek() = default;
+};
+
+class Polak : public Czlowiek {
+public:
+  void mowa() const override { std::cout << "Czesc!" << std::endl; }
+};
+
+class Anglik : public Czlowiek {
+public:
+  void mowa() const override { std::cout << "Hello!" << std::endl; }
+};
+
+int main() {
+  std::vector<std::unique_ptr<Czlowiek>> ludzie;
+  ludzie.push_back(std::make_unique<Polak>());
+  ludzie.push_back(std::make_unique<Anglik>());
+  ludzie.push_back(std::make_unique<Czlowiek>());
+  for (const auto &c : ludzie)
+    c->mowa();
+  // Cześć!
+  // Hello!
+  // ...
+
+  // Przy metodzie niewirtualnej pojawi się błąd kompilacji – nadpisujemy meto
+  // dę, która nie jest wirtualna
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad4.cpp

@@ -0,0 +1,45 @@
+#include <iostream>
+
+class Pojazd {
+public:
+  virtual ~Pojazd() = default;
+  virtual void wydajDzwiekWirtualnie() {} // metoda wirtualna
+};
+
+class Samochod : public Pojazd {
+public:
+  void sygnal() { std::cout << "Sygnał!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Sygnał!"; }
+};
+
+class Rower : public Pojazd {
+public:
+  void Dzwonek() { std::cout << "Dzyń dzyń!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Dzyń dzyń!"; }
+};
+
+class Motocykl : public Pojazd {
+public:
+  void Warkot() { std::cout << "Wrum wrum!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Wrum wrum!"; }
+};
+
+void wydajDzwiek(Pojazd *p) {
+  if (Samochod *s = dynamic_cast<Samochod *>(p)) {
+    s->sygnal();
+  } else if (Rower *r = dynamic_cast<Rower *>(p)) {
+    r->Dzwonek();
+  } else if (Motocykl *m = dynamic_cast<Motocykl *>(p)) {
+    m->Warkot();
+  }
+}
+
+void wydajDzwiek2(Pojazd &p) { p.wydajDzwiekWirtualnie(); }
+
+int main() {
+  Rower r2;
+  Pojazd *r = &r2;
+
+  wydajDzwiek(r);
+  wydajDzwiek2(r2);
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad5.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+#include <typeinfo>
+
+class Pojazd {
+public:
+  virtual ~Pojazd() = default;
+  virtual void wydajDzwiekWirtualnie() {} // metoda wirtualna
+};
+
+class Samochod : public Pojazd {
+public:
+  void sygnal() { std::cout << "Sygnał!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Sygnał!"; }
+};
+
+class Rower : public Pojazd {
+public:
+  void Dzwonek() { std::cout << "Dzyń dzyń!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Dzyń dzyń!"; }
+};
+
+class Motocykl : public Pojazd {
+public:
+  void Warkot() { std::cout << "Wrum wrum!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Wrum wrum!"; }
+};
+
+class NiepolimorficznyTyp {};
+class NiepolimorficznyTyp2 : public NiepolimorficznyTyp {};
+
+void pokazTyp(const Pojazd *p) {
+  const std::type_info &ti = typeid(*p);
+  std::cout << "Rzeczywisty typ: " << ti.name() << std::endl;
+}
+
+void pokazTyp2(const NiepolimorficznyTyp *n) {
+  const std::type_info &ti = typeid(*n);
+  std::cout << "Rzeczywisty typ: " << ti.name() << std::endl;
+}
+
+int main() {
+  Pojazd p;
+  Samochod s;
+  NiepolimorficznyTyp2 npol;
+  pokazTyp(&p);
+  pokazTyp(&s);
+  pokazTyp2(&npol);
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad6.cpp

@@ -0,0 +1,42 @@
+#include <iostream>
+#include <typeinfo>
+
+class Pojazd {
+public:
+  virtual ~Pojazd() = default;
+  virtual void wydajDzwiekWirtualnie() {} // metoda wirtualna
+};
+
+class Samochod : public Pojazd {
+public:
+  void sygnal() { std::cout << "Sygnał!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Sygnał!"; }
+};
+
+class Rower : public Pojazd {
+public:
+  void Dzwonek() { std::cout << "Dzyń dzyń!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Dzyń dzyń!"; }
+};
+
+class Motocykl : public Pojazd {
+public:
+  void Warkot() { std::cout << "Wrum wrum!"; }
+  void wydajDzwiekWirtualnie() override { std::cout << "Wrum wrum!"; }
+};
+
+int main() {
+  Rower r;
+  Pojazd *p = &r;
+
+  Samochod *s_static = static_cast<Samochod *>(p);
+
+  std::cout
+      << "Wynik static_cast:  " << s_static
+      << "\n"; // miejsce w pamięci. dowolne wywołanie metody zwróci teraz błąd
+
+  Samochod *s_dynamic = dynamic_cast<Samochod *>(p);
+
+  std::cout << "Wynik dynamic_cast: " << s_dynamic
+            << "\n"; // nullptr, bo sprawdził w runtime, że typ się nie zgadza
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad7.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+template <typename T>
+std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
+  os << "[";
+  for (size_t i = 0; i < v.size(); ++i) {
+    os << v[i];
+    if (i != v.size() - 1)
+      os << ", ";
+  }
+  os << "]";
+  return os;
+}
+
+template <typename T1, typename T2> class Para {
+  T1 pierwszy;
+  T2 drugi;
+
+public:
+  Para(const T1 &p, const T2 &d) : pierwszy(p), drugi(d) {}
+
+  const T1 &pobierzPierwszy() const { return pierwszy; }
+  const T2 &pobierzDrugi() const { return drugi; }
+
+  friend std::ostream &operator<<(std::ostream &os, const Para<T1, T2> &para) {
+    os << "(" << para.pierwszy << ", " << para.drugi << ")";
+    return os;
+  }
+};
+
+int main() {
+  Para<int, std::string> p1(42, "Tralala");
+  std::cout << "Para 1: " << p1 << "\n";
+  std::cout << "Pierwszy element p1: " << p1.pobierzPierwszy() << "\n\n";
+
+  Para<double, double> p2(3.1415, 2.7182);
+  std::cout << "Para 2: " << p2 << "\n";
+  std::cout << "Drugi element p2: " << p2.pobierzDrugi() << "\n\n";
+
+  std::vector<int> liczby = {1, 1, 2, 3, 5, 8};
+  Para<std::string, std::vector<int>> p3("Fibonacci", liczby);
+
+  std::cout << "Para 3: " << p3 << "\n";
+
+  return 0;
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad8.cpp

@@ -0,0 +1,33 @@
+#include <bitset>
+#include <iostream>
+
+template <typename T> class Liczalna {
+public:
+  void zliczDoN(int n) {
+    for (int i = 0; i < n; i++) {
+      static_cast<T *>(this)->wypisz(i);
+    }
+  }
+};
+
+class Dziesietna : public Liczalna<Dziesietna> {
+public:
+  void wypisz(int liczba) { std::cout << "Dziesietnie: " << liczba << "\n"; }
+};
+
+class Binarna : public Liczalna<Binarna> {
+public:
+  void wypisz(int liczba) {
+    std::cout << "Binarnie: " << std::bitset<8>(liczba) << "\n";
+  }
+};
+
+int main() {
+  Dziesietna d;
+  d.zliczDoN(4);
+
+  Binarna b;
+  b.zliczDoN(4);
+
+  return 0;
+}

uczelnia/2_semestr/programowanie/laby/lab11/zad9.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <string>
+
+class Pracownik {
+  std::string imie;
+
+public:
+  Pracownik(const std::string &i) : imie(i) {}
+  virtual double pensja() const { return 0; }
+  virtual void wypisz() const {
+    std::cout << imie << ", pensja: " << pensja() << std::endl;
+  }
+  virtual ~Pracownik() {}
+};
+
+class Etatowy : public Pracownik {
+  double stawka;
+
+public:
+  Etatowy(const std::string &i, double s) : Pracownik(i), stawka(s) {}
+  double pensja() const override { return stawka; }
+};
+
+void przetworz(Pracownik &p) { p.wypisz(); }
+
+int main() {
+  Pracownik *tab[] = {new Etatowy("Ala", 5000)};
+  przetworz(*tab[0]);
+  delete tab[0];
+}

uczelnia/2_semestr/programowanie/laby/lab12/narzedzia.hpp

@@ -0,0 +1,27 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+template <typename T> T wiekszy(T a, T b) { return a > b ? a : b; }
+
+template <typename T> void zamien(T &a, T &b) {
+  T c = a;
+  a = b;
+  b = c;
+}
+
+template <typename T> void wypisz(T *tab, int n) {
+  for (int i = 0; i < n; i++) {
+    std::cout << *(tab + i);
+  }
+  std::cout << std::endl;
+}
+
+template <typename T> void sortuj3(T a, T b, T c) {
+  std::vector<T> vec{a, b, c};
+  std::sort(vec.begin(), vec.end());
+
+  for (const auto &symbol : vec) {
+    std::cout << symbol;
+  }
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad1.cpp

@@ -0,0 +1,9 @@
+#include <iostream>
+
+template <typename T> T potroj(T x) { return x * 3; }
+
+int main() {
+  std::cout << potroj(7) << '\n';
+  std::cout << potroj(2.5) << '\n';
+  std::cout << potroj('A') << '\n';
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad10.cpp

@@ -0,0 +1,13 @@
+#include "narzedzia.hpp"
+
+int main() {
+  int a = 2, b = 1, c = 4;
+  sortuj3(a, b, c);
+  std::cout << std::endl;
+  double i = 1.5, j = 0, k = 14.234;
+  sortuj3(i, j, k);
+  std::cout << std::endl;
+  std::string x = "abc", y = "cde", z = "gde";
+  sortuj3(x, y, z);
+  std::cout << std::endl;
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad2.cpp

@@ -0,0 +1,10 @@
+template <typename T> T wiekszy(T a, T b) { return a > b ? a : b; }
+
+int main() {
+  wiekszy(2, 5);     // int int
+  wiekszy(2.0, 5.0); // double double
+  // wiekszy(2, 5.0); // nie uruchomi się, bowiem zadeklarowalilśmy dwa 
+  // argumenty tego samego typu, a podajemy dwa różne
+  wiekszy<double>(2, 5.0); // double
+  wiekszy('A', 'Z');       // char
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad3.cpp

@@ -0,0 +1,9 @@
+#include <iostream>
+
+template <typename T> T srednia(T a, T b) { return (a + b) / 2; }
+
+int main() {
+  std::cout << srednia(3, 4) << std::endl;           // co się wypisze? 3
+  std::cout << srednia(3.0, 4.0) << std::endl;       // co się wypisze? 3.5
+  std::cout << srednia<double>(3, 4.0) << std::endl; // 3.5
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad4.cpp

@@ -0,0 +1,21 @@
+#include <iostream>
+
+template <typename T> void zamien(T &a, T &b) {
+  T c = a;
+  a = b;
+  b = c;
+}
+
+template <typename T> void zamiana_i_wyswietlenie(T &x, T &y) {
+  zamien(x, y); // teraz x == 2, y == 1
+  std::cout << x << ',' << y << std::endl;
+}
+
+int main() {
+  int x = 2, y = 4;
+  zamiana_i_wyswietlenie(x, y);
+  double i = 2.5, j = 3.5;
+  zamiana_i_wyswietlenie(i, j);
+  std::string a = "hej", b = "ho";
+  zamiana_i_wyswietlenie(a, b);
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad5.cpp

@@ -0,0 +1,14 @@
+#include <iostream>
+
+template <typename T> T minZ3(T a, T b, T c) {
+  return a < b ? (a < c ? a : c) : (b < c ? b : c);
+}
+
+int main() {
+  if (minZ3(7, 2, 5) == 2) {
+    std::cout << "1 ok\n";
+  }
+  if (minZ3(3.5, 1.2, 4.8) == 1.2) {
+    std::cout << "2 ok\n";
+  }
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad6.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+
+template <typename T> int policz(const T *tab, int n, T wartosc) {
+  int count = 0;
+  for (int i = 0; i < n; i++) {
+    if (*(tab + i) == wartosc)
+      count++;
+  }
+  return count;
+}
+
+int main() {
+  int dane[] = {1, 2, 3, 2, 2, 5};
+  if (policz(dane, 6, 2) == 3) {
+    std::cout << "Zgadza się :D\n";
+  }
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad7.cpp

@@ -0,0 +1,13 @@
+#include <iostream>
+
+template <typename T, int N> void powtorz(const T &wartosc) {
+  for (int i = 0; i < N; i++) {
+    std::cout << wartosc;
+  }
+  std::cout << '\n';
+}
+
+int main() {
+  powtorz<char, 5>('*'); // *****
+  powtorz<int, 3>(7);    // 7 7 7
+}

uczelnia/2_semestr/programowanie/laby/lab12/zad8.cpp

@@ -0,0 +1,11 @@
+// Fragment A
+template <typename T> T podwoj(T x) { return x + x; }
+podwoj(2, 3); // funkcja przyjmuje jeden argument a jest wywołana z dwoma
+
+// Fragment B
+template <typename T> T iloczyn(T a, T b);
+// definicja w innym pliku .cpp - kod się nie linkuje
+
+// Fragment C
+template <typename T> T wiekszy(T a, T b) { return a > b ? a : b; }
+wiekszy("abc", 5); // musi być dwa razy ten sam typ danych, a nie dwa różne

uczelnia/2_semestr/programowanie/laby/lab12/zad9.cpp

@@ -0,0 +1,21 @@
+#include "narzedzia.hpp"
+
+int main() {
+  std::cout << wiekszy(2, 4) << std::endl;
+  std::cout << wiekszy(2.2, 4.3) << std::endl;
+  std::cout << wiekszy("abc", "cdf") << std::endl;
+
+  std::cout << "\n===\n";
+
+  int x = 2, y = 4;
+  zamien(x, y);
+  std::cout << x << ',' << y;
+
+  double i = 2.5, j = 3.5;
+  zamien(i, j);
+  std::cout << i << ',' << j;
+
+  std::string a = "abc", b = "cde";
+  zamien(a, b);
+  std::cout << a << ',' << b;
+}

uczelnia/2_semestr/python/laby/11/zad1.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+
+def zad1(n: int) -> None:
+    a: np.ndarray = np.ones((n, n))
+    exp = np.arange(0, n)
+
+    for i in range(1, n):
+        a[i, :] = i + 1
+        a[i, :] **= exp
+    return a
+
+
+if __name__ == "__main__":
+    a = zad1(5)
+    print(a)

uczelnia/2_semestr/python/laby/11/zad2.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+
+def zad2(n: int) -> np.ndarray:
+    n_2 = n**2
+    a: np.ndarray = np.arange(1, n_2 + 1)
+    a = a.reshape(n, n)
+
+    for i in range(1, n + 1):
+        if i % 2 != 0:
+            a[i, :] = np.flip(a[i, :])
+    return a
+
+
+if __name__ == "__main__":
+    a = zad2(4)
+    print(a)

uczelnia/2_semestr/python/laby/11/zad3.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+
+def zad2(n: int) -> np.ndarray:
+    n_2 = n**2
+    a: np.ndarray = np.arange(1, n_2 + 1)
+    a = a.reshape(n, n)
+
+    for i in range(1, n + 1):
+        if i % 2 != 0:
+            a[i, :] = np.flip(a[i, :])
+    return a
+
+
+def zad3(a: np.ndarray):
+    mask = a % 5 == 0
+    a[mask] = 0
+    mask = a % 3 == 0
+    a[mask] = 0
+    return a
+
+
+if __name__ == "__main__":
+    a = zad2(4)
+    a = zad3(a)
+    print(a)

uczelnia/2_semestr/python/laby/11/zad4.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+a = np.arange(1, 21)
+a = a.reshape(4, 5)
+print(a.T)

uczelnia/2_semestr/python/laby/11/zad5.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+
+def policz_wyznaczniki(wspolczynniki: np.ndarray, wolne: np.ndarray):
+    for i in range(0, wspolczynniki.shape[1]):
+        j = wspolczynniki.copy()
+        j = j[:, i] = wolne.copy()
+        yield np.linalg.det(j)
+
+
+def zad5(wspolczynniki: np.ndarray, wolne: np.ndarray):
+    glowny = np.linalg.det(wspolczynniki)
+    wyniki = []
+
+    for wyznacznik in policz_wyznaczniki(wspolczynniki, wolne):
+        wyniki.append(wyznacznik / glowny)
+
+    print(wyniki)
+
+
+a = np.array([8, 1, 2, 5, -3, -7, 0, -5, 7])
+a = a.reshape(3, 3)
+b = np.array([16, -22, 11]).T
+zad5(a, b)

uczelnia/2_semestr/python/wykład.md

@@ -9,4 +9,11 @@ W czasie tego wykładu pisałem program [zut-calenadar](https://github.com/szymo
 Nawet o wyjątkach Pan powiedział.
 
 
-Teraz o deklaracji zmiennych?????????????????????????????????????
+Teraz o deklaracji zmiennych?????????????????????????????????????
+
+
+Byte array to array który trzyma byte :OOO
+
+Operacje na plikach, nudy
+
+`r'string'` – wyłącza ucieczkę znaczków