kod

uczelnia/2_semestr/2 semestr.md

@@ -0,0 +1,7 @@
+[Matematyka dyskretna](matematyka_dyskretna/Matematyka%20dyskretna.md)
+[Matematyka stosowana](matematyka_stosowana/Matematyka%20stosowana.md)
+[Metody numeryczne](metody_numeryczne/Metody%20numeryczne.md)
+[Prawo podatkowe](prawo_podatkowe/Prawo%20podatkowe.md)
+[Programowanie](programowanie/Programowanie.md)
+[Python](python/Python.md)
+[Technika cyfrowa](techniki_cyfrowe/Technika%20cyfrowa.md)

uczelnia/2_semestr/matematyka_stosowana/Matematyka stosowana.md

@@ -1 +1,2 @@
 [[Prawdopodobieństwo]]
+[[Standaryzacja]]

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

@@ -53,5 +53,65 @@ Funkcja prawostronnie ciągła.
 
 W -∞ jest zerem, a w +∞ jest 1.
 
+# Wariancja
+Wariancja X to liczba. (czemu te definicje są takie nieludzkie)
+
+Odchylanie standardowe to pierwiastek z wariancji. Oznaczana małą literką sigma $\sigma$.
+
+Współczynnik zmienności mierzy odchylenie standardowe względem morbiusa.
+
+Kwantyl rzędu p to jakaś liczba pomiędzy granicą funkcji a jej wartością (?)
+
+Jak podaje [wikipedia](https://pl.wikipedia.org/wiki/Kwantyl):
+> Kwantyle to punkty odcięcia dzielące zakres rozkładu prawdopodobieństwa na ciągłe przedziały o równych prawdopodobieństwach lub dzielące obserwacje w próbie w ten sam sposób.
+
+## Mediana
+Wartość najbardziej po środku
+
+## Kwartyle
+To kwantyl rzędu $0.25, 0.5, 0.75$.
+Kwantyl $0.5$ to mediana.
+
+## Centyle setyle dupyle
+itp można tak dzielić
+
+### Długość dziecka
+Kwantylami można zmierzyć długość dziecka, bo dzięki temu można zapobiec różnym problemom.
+
+# Inne charakterystyki zmiennej losowej
+Miary mierzące asymetrię rozkładu.
+
+Mamy wydłużony ogon po lewej stronie.
+
+## Rozkład płac
+Większość ludzie zarabia średnią, a nieliczone jednostki zarabiają dużo.
+
+Przy robieniu pomiaru należy odrzucić jednostki skrajne.
+
+## Dominanta
+Moda, czyli coś co ma duże prawdopodobieństwo.
+
+# Rozkład
+
+## 0-1
+| $x_1$<br> | 0   | 1   |
+| --------- | --- | --- |
+| $p_1$     | q   | p   |
+Nie wiem o co chodzi.
 
 
+## Rozkład dwumianowy
+Kombinacje tworzą trójkąt pascala chyba czy coś?
+
+## Rozkład geometryczny
+Mamy tylko parametr P, zmienna losowa X przyjmuje K.
+Sumujemy ciąg geometryczny o ilorazie q.
+
+## Rozkład poissona
+Trujący chyba
+
+### Zmienne typu ciągłego
+Wartość dystrybuanty w punkcie x to jest całka, bo to pole pod wykresem.
+
+## Rozkład wykladniczy
+Funkcja gaussa.

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

@@ -0,0 +1,111 @@
+# zadanie 1, kwantyle | kolokwium
+
+# a)
+
+# kwantyl rozkładu normalnego standaryzowanego N(0,1)
+qnorm(0.97, 0, 1) # 1.880794
+qnorm(0.97) # 1.880794 | wartości 0,1 są domyślne, więc wynik jest taki sam
+
+# b)
+qchisq(0.975, 9) # 19.02277
+
+# c)
+qt(0.95, 9) # 1.833113
+
+# d)
+qf(0.995, 10, 23) # 3.642008
+
+# zadanie 2
+
+# a)
+pnorm(2.5, 1.5, 2) # 0.6914625
+round(pnorm(2.5, 1.5, 2), 4) # zaokrąglony wynik do 4 miejsc po przecinku: 0.6915
+
+# b)
+round(pnorm(-0.5, 1.5, 2, F), 4) # 0.8413
+
+# c)
+round(pnorm(2, 1.5, 2) - pnorm(0.5, 1.5, 2), 4) # 0.2902
+
+# d) na kolokwium będzie z abs
+round(pnorm(5, 1.5, 2) - pnorm(-1, 1.5, 2),4) # 0.8543
+
+# e)
+round(pnorm(-0.5, 1.5, 2) + pnorm(0.5,1.5,2, F),4) # 0.8501
+
+# f)
+# |2x - 1| < 1
+# -1 < 2x - 1 < 1
+# 0 < 2x < 2
+# 0 < x < 1
+round(pnorm(1, 1.5, 2) - pnorm(0, 1.5 ,2),4) # 0.1747
+
+# g)
+# |3x - 1| > 2
+# 3x - 1 < -2 && 3x -1 > 2
+# 3x < -1 && 3x > 3
+# x < -1/3 && x > 1
+round(pnorm(-1/3, 1.5, 2) + pnorm(1, 1.5, 2, F), 4) # 0.7784
+
+# zadanie 3
+# na kolokwium będzie b) i d)
+
+# a)
+# 2x > -4.5
+# 2 > -2.25
+round(pnorm(-2.25, -4, 3.5, F), 4) # 0.3085
+
+# b)
+# |5x - 1| > 2.5
+# 5x - 1 < -2.5 || 5x - 1 > 2.5
+# 5x < -1.5 || 5x > 3.5
+# -0.3 < -0.75 || x > 0.7
+round(pnorm(-0.3, -4, 3.5) + pnorm(0.7, -4, 3.5, F), 4) # 0.9444
+
+# c)
+# -8 < 3x + 1 < 2
+# -9 < 3x < 1
+# -3 < x < 1/3
+round(pnorm(1/3, -4, 3.5) - pnorm(-3, -4, 3.5), 4) # 0.2797
+
+# d)
+pnorm(7.5/4, -4, 3.5) - pnorm(-3.5/4, -4, 3.5) #0.139349
+
+# zadanie 4 | N(1000, 50)
+
+# a)
+round(pnorm(900, 1000, 50) * 4000) # 91
+
+# b)
+qnorm(0.13, 1000, 50, F) # 1056.32
+
+# zadanie 5 | N(6.8, 0.3)
+
+# a)
+round(pnorm(7.1, 6.8, 0.3) * 30) # 25
+
+# b)
+qnorm(0.15, 6.8, 0.3) # 6.48907
+
+# zadanie 6 | N(15, 13)
+
+# a) 22,05 < x < 22,10
+(pnorm(10,15,13)-pnorm(5,15,13)) # 0.129383
+
+# b)
+pnorm(20,15,13,F) # 0.3502612
+
+# zadanie 7 | N(20,5)
+#a) p = 0.8849  X < k1
+qnorm(0.8849, 20, 5)
+#25.99922
+
+#b) p =0.6554  X > k2
+qnorm(0.6554, 20, 5, F)
+#18.0003
+
+# c)
+20 - qnorm((1 - 0.6554) / 2, 20, 5) # 4.725577
+
+# d)
+20 - qnorm(0.00511/2, 20, 5) #14.00008

uczelnia/2_semestr/metody_numeryczne/Metody numeryczne.md

@@ -19,3 +19,24 @@ Liczb niemaszynowych __nie da się__ zapisać na skończonej liczbie bitów. Ope
 
 Zbiór liczb maszynowych jest skończony i ograniczony architekturą procesora.
 
+---
+
+Liczby całkowite, zmiennoprzecinkowe, precyzja
+
+Dlaczego Pani pokazuje nam kod w wordzie? A nie, to jednak mathlab.
+
+Macierze, macierz diagonalna. górno/dolno trójkątna.
+
+Normy wierszowe, normy kolumnowe.
+
+Jakieś macierze, nwm o co chodzi za bardzo.
+
+Metoda Doolittle'a, metoda podobna do eliminacji Gaussa.
+
+Jeśli macierz jest rzeczywista, symetryczna, dodatnio określona, to ma ona jeden jedyny rozkład na czynniki $A =LL^T$ gdzie $L$ jest macierzą trójkątną dolną o elementach dodatnich na głównej przekątnej.
+
+Rozkład LU: bierzemy macierz, przyrównujemy ją do macierzy $L * U$, a potem patrzymy z mnożenia co wychodzi i rozwiązujemy równania. 
+
+Rozkład QR.
+
+Układy równoważne: układ równań wynika z innego układu przez skończony ciąg operacji elementarnych.

uczelnia/2_semestr/prawo_podatkowe/Prawo podatkowe.md

@@ -0,0 +1,8 @@
+Forma zdawania zależy od frekwencji, cokolwiek miałoby to znaczyć.
+
+Zajęcia co dwa tygodnie, ale za dwa tygodnie go nie ma xdddd.
+
+Będzie praca jakaś o prawie intelektualnym coś tam.
+
+Zaczynamy o 12:30
+

uczelnia/2_semestr/programowanie/Programowanie.md

@@ -1 +1,9 @@
-[Programowanie](Programowanie.md)
+[Programowanie obiektowe cpp](Programowanie%20obiektowe%20cpp.md)
+
+Struktury metody itp.
+
+Klasa od struktury w cpp różni się tym, że klasa ma domyślnie wszystkie pola prywatne, a struktura publiczne.
+
+```cpp
+int* const* p; // stały wskaźnik na stałą int
+```

uczelnia/2_semestr/programowanie/laby/.envrc

@@ -0,0 +1 @@
+use flake

uczelnia/2_semestr/programowanie/laby/flake.lock

@@ -0,0 +1,60 @@
+{
+  "nodes": {
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1772408722,
+        "narHash": "sha256-rHuJtdcOjK7rAHpHphUb1iCvgkU3GpfvicLMwwnfMT0=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "f20dc5d9b8027381c474144ecabc9034d6a839a3",
+        "type": "github"
+      },
+      "original": {
+        "id": "flake-parts",
+        "type": "indirect"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1772433332,
+        "narHash": "sha256-izhTDFKsg6KeVBxJS9EblGeQ8y+O8eCa6RcW874vxEc=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "cf59864ef8aa2e178cccedbe2c178185b0365705",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1772328832,
+        "narHash": "sha256-e+/T/pmEkLP6BHhYjx6GmwP5ivonQQn0bJdH9YrRB+Q=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "c185c7a5e5dd8f9add5b2f8ebeff00888b070742",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-parts": "flake-parts",
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

uczelnia/2_semestr/programowanie/laby/flake.nix

@@ -0,0 +1,34 @@
+{
+  description = "Programowanie 2";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  };
+
+  outputs =
+    inputs@{ flake-parts, ... }:
+    flake-parts.lib.mkFlake { inherit inputs; } {
+      systems = [
+        "x86_64-linux"
+      ];
+      perSystem =
+        {
+          config,
+          self',
+          inputs',
+          pkgs,
+          system,
+          ...
+        }:
+        {
+
+          devShells.default = pkgs.mkShell {
+            packages = with pkgs; [
+              boost
+              catch2
+              gnumake
+            ];
+          };
+        };
+    };
+}

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

@@ -0,0 +1,14 @@
+#include <iostream>
+
+class Student {
+private:
+  std::string imie; // pole prywatne
+  int nrAlbumu;     // pole prywatne
+
+public:
+  Student(std::string imie, int nrAlbumu) // konstruktor
+      : imie(imie), nrAlbumu(nrAlbumu) {}
+  void pokaz() { // publiczna metoda
+    std::cout << imie << " " << nrAlbumu << std::endl;
+  }
+};

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

@@ -0,0 +1,17 @@
+#include <iostream>
+
+class Punkt {
+  int x, y;
+
+public:
+  Punkt(int x, int y) : x(x), y(y) {}
+  Punkt() : Punkt(0, 0) {}
+  void pokaz() { std::cout << '(' << x << ',' << y << ')' << std::endl; }
+};
+
+int main() {
+  Punkt p;
+  p.pokaz();
+  Punkt p2(2, 2);
+  p2.pokaz();
+}

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

@@ -0,0 +1,23 @@
+#include <iostream>
+
+class Punkt {
+  int x, y;
+
+public:
+  void ustaw(int x, int y) {
+    this->x = x;
+    this->y = y;
+  }
+
+  void pokaz() { std::cout << '(' << x << ',' << y << ')' << std::endl; }
+};
+
+int main() {
+  int x, y;
+  std::cout << "Podaj x i y: ";
+  std::cin >> x;
+  std::cin >> y;
+  Punkt p;
+  p.ustaw(x, y);
+  p.pokaz();
+}

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

@@ -0,0 +1,32 @@
+#include <iostream>
+
+class Punkt {
+  int x, y;
+
+public:
+  Punkt() {
+    x = 0;
+    y = 0;
+  }
+
+  Punkt(int x, int y) {
+    this->x = x;
+    this->y = y;
+  }
+
+  void pokaz() { std::cout << '(' << x << ',' << y << ')' << std::endl; }
+};
+
+int main() {
+  int x, y;
+  std::cout << "Podaj x i y: ";
+  std::cin >> x;
+  std::cin >> y;
+  Punkt p;
+  std::cout << "Domyślny punkt: ";
+  p.pokaz();
+  std::cout << std::endl;
+  std::cout << "Punkt z twoimi danymi: ";
+  Punkt p2(x, y);
+  p2.pokaz();
+}

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

@@ -0,0 +1,16 @@
+class Prostokat {
+private:
+  int a;
+  int b;
+
+public:
+  Prostokat() {} // dodany pusty konstruktor, by kod się skompilował
+  Prostokat(int x, int y) : a(x), b(y) {}
+};
+
+Prostokat p1; // w aktualnej formie się nie skompiluje, ponieważ nie istnieje 
+              // konstruktor bezargumentowy
+Prostokat p2(2, 3);
+Prostokat p3{4, 5};
+
+int main() {}

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

@@ -0,0 +1,12 @@
+#include <string>
+
+class Samochod {
+private:
+  std::string marka;
+  int rok;
+
+public:
+  Samochod(std::string m, int r) : marka(m), rok(r) {}
+};
+
+int main() {}

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

@@ -0,0 +1,21 @@
+#include <iostream>
+#include <string>
+
+class Produkt {
+  std::string nazwa;
+  float cena;
+
+public:
+  void ustawNazwe(std::string nazwa) { this->nazwa = nazwa; }
+  void ustawCene(float cena) { this->cena = cena; }
+  void pokaz() {
+    std::cout << "Produkt " << nazwa << " kosztuje " << cena << " zł."; 
+  }
+};
+
+int main() {
+  Produkt p;
+  p.ustawNazwe("Marchewka");
+  p.ustawCene(234.342);
+  p.pokaz();
+}

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

@@ -0,0 +1,18 @@
+#include <iostream>
+
+class Test {
+public:
+  Test() { std::cout << "Konstruktor" << std::endl; }
+  ~Test() { std::cout << "Destruktor" << std::endl; }
+};
+
+int main() {
+  std::cout << "Start" << std::endl;
+  Test a; // konstruktor 1
+  {
+    Test b; // konstruktor 2
+    std::cout << "Wewnatrz bloku" << std::endl;
+  } // destruktor 2
+  std::cout << "Koniec" << std::endl;
+  // destruktor 1
+}

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

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <string>
+
+class Ksiazka {
+  std::string tytul, autor;
+  int rokWydania;
+
+public:
+  Ksiazka() {}
+
+  Ksiazka(std::string tytul, std::string autor, int rokWydania)
+      : tytul(tytul), autor(autor), rokWydania(rokWydania) {}
+  ~Ksiazka() {
+      std::cout << "Likwiduję książkę..." << std::endl;
+  }
+
+  void pokaz() {
+    std::cout << "Ksiażka " << tytul << " została napisana przez " << autor << " w " << rokWydania << " roku." << std::endl;
+  }
+};
+
+int main() {
+    Ksiazka pusta_ksiazka;
+    pusta_ksiazka.pokaz();
+    Ksiazka niepusta_ksiazka("Ksiazka", "Stefan", 2026);
+    niepusta_ksiazka.pokaz();
+}
+
+

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

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <string>
+
+class KontoBankowe {
+  std::string wlasciciel;
+  float saldo;
+
+public:
+  KontoBankowe(std::string wlasciciel, float saldo = 0.0)
+      : wlasciciel(wlasciciel), saldo(saldo) {}
+  ~KontoBankowe() { std::cout << "Zamykam konto bankowe" << std::endl; }
+
+  void wplata(float pieniadze) { saldo += pieniadze; }
+  void wyplata(float pieniadze) { saldo -= pieniadze; }
+  void pokaz() { std::cout << wlasciciel << " ma " << saldo << " zł."; }
+};
+
+int main() {
+  KontoBankowe konto("bogdan");
+  konto.pokaz();
+  konto.wplata(23.3);
+  konto.pokaz();
+  konto.wyplata(2);
+  konto.pokaz();
+}

uczelnia/2_semestr/python/laby/drugi_lab.py

@@ -0,0 +1,125 @@
+import random
+
+# zadanie 1
+
+def zad1():
+    lista = [0, -2, 1, 7, 3, 4]
+    print(lista[::-1])
+
+    losowa_lista = [random.randint(1,100) for i in range(100)]
+    print(f"Cała lista: {losowa_lista}")
+    print(f"Odwrócona lista: {losowa_lista[::-1]}")
+
+# zadanie 2
+def zad2():
+    import math
+    x = float(input("Podaj x: "))
+    y = float(input("Podaj y: "))
+
+    result = math.e + math.log10(x**2 + 1) * (x-1)/(math.cos(y**3 - 1) + 6)
+    print(f"Wynikiem skomplikowanych obliczeń jest: {result}")
+
+# dla 2, 4 = 2.8183362733213935
+# dla -9.5, 6.4 = -1.3367487551407415
+
+def obliczenia_zad3():
+    x = int(input("Podaj x: "))
+    y = int(input("Podaj y: "))
+    z = int(input("Podaj z: "))
+    c = int(input("Podaj c: "))
+
+    match c:
+        case 1: # suma
+            return x + y + z
+        case 2: # różnica
+            return x - y - z
+        case 3: # iloczyn
+            return x * y * z
+        case _:
+            if y == 0:
+                raise ValueError("Nie dzielimy przez zero!")
+            return x / y / z
+
+def zad3():
+    try:
+        print(obliczenia_zad3())
+    except ValueError as e:
+        print(e)
+
+def zad4():
+    waga = float(input("Podaj wagę w kg: "))
+    wzrost = float(input("Podaj wzrost w m: "))
+    bmi = waga/wzrost**2
+    if bmi < 16:
+        print("Jesteś wygłodzony!")
+    elif bmi >= 16 and bmi < 17:
+        print("Jesteś wychudzony!")
+    elif bmi >= 17 and bmi < 18.5:
+        print("Masz niedowagę!")
+    elif bmi >= 18.5 and bmi < 25:
+        print("Jesteś w normie!")
+    elif bmi >= 25 and bmi < 30:
+        print("Masz nadwagę!")
+    elif bmi >= 30 and bmi < 35:
+        print("Otyłość I stopnia")
+    elif bmi >= 35 and bmi < 40:
+        print("Otyłość II stopnia")
+    elif bmi >= 40:
+        print("Otyłość III stopnia")
+
+def zad5():
+    for i in range(1, 5):
+        print("*" * i)
+
+def zad6():
+    macierz =[[i for i in range(1, 8, 3)]] * 3
+    print(macierz)
+
+def zad7():
+    n = int(input("Podaj zakres do którego szukamy liczb pierwszych: "))
+    prime_numbers = []
+    if n == 3:
+        prime_numbers.append(n)
+        print(f"Liczby pierwsze do {n} to: {prime_numbers}")
+        return
+
+    for i in range(2, n):
+        is_prime = True
+        for j in range(2, i - 1):
+            if i % j == 0:
+                print(f"{i} dzieli się przez {j}")
+                is_prime = False
+                continue
+        if is_prime:
+            prime_numbers.append(i)
+
+    print(f"Liczby pierwsze do {n} to: {prime_numbers}")
+    print(len(prime_numbers))
+
+def zad8():
+    n = int(input("Podaj n: "))
+    numbers = []
+    for i in range(1, n + 1):
+        if i % 10 == 3 or i % 100 == 14:
+            numbers.append(i)
+    print(f"Suma liczb naturalnych do {n} zakończonych na 3 lub 14 to {sum(numbers)}")
+
+def wyswietl(list):
+    print(' '.join([str(item) for item in list]).center(30))
+
+def zad9():
+    n = int(input("Podaj n: "))
+    rzad = [1]
+    wyswietl(rzad)
+
+    for _ in range(n - 1):
+        kolejny_rzad = [1]
+        for j in range(len(rzad) - 1):
+            kolejny_rzad.append(rzad[j] + rzad[j + 1])
+        kolejny_rzad.append(1)
+        rzad = kolejny_rzad
+        wyswietl(rzad)
+
+
+if __name__ == "__main__":
+    zad9()

uczelnia/2_semestr/techniki_cyfrowe/Tablica Graya.md

@@ -0,0 +1,2 @@
+Nie wiem o co chodzi, ale wykładowca mówi, że nie jest to takie proste, więc chyba faktycznie nie jest…
+

uczelnia/2_semestr/techniki_cyfrowe/Technika cyfrowa.md

@@ -6,3 +6,4 @@ Postać standardowa funkcji boolowskiej może być sumacyjna lub iloczynowa, mog
 
 [[Minimalizacja funkcji logicznych]]
 
+[[Tablica Graya]]

uczelnia/ZUT.md

@@ -1 +1,2 @@
 [1 semestr](/uczelnia/1_semestr/1%20semestr.md)
+[2 semestr](2_semestr/2%20semestr.md)