TRIPSÁNSZKY ÁKOS OKTATÁSI OLDALA
Objektum-orientált programozás alap információk
Cél:
A további tanulmányokat támogató informatikai ismeretek és készségek bővítése, valamint az objektum-orientált technológiák alkalmazásának elsajátítása C++ nyelven.
Főtémák:
  • OOP alapelvek és C++ nyelvi eszközök (osztály, kapszulázás, öröklődés, polimorfizmus, absztrakció)
  • Összetett adattárolási elvek és adatstruktúrák
  • Operációs rendszerek
  • Hálózatok
  • Adatbázisok
Laborok szerepe:
Objektumok készítésének és felhasználásának begyakorlása, összetett adattárolási elvek alkalmazása, a problémamegoldó készség fejlesztése.
Előadások szerepe:
Áttekintést adnak az informatika további területeiről (operációs rendszerek, hálózatok, adatbázisok), és tárgyalják az objektum-orientált programozás alapelveit a laborok megértésének támogatására.
Várható kimenet:
Szilárd OOP-alapismeretek C++-ban; moduláris, jól karbantartható kód készítése; OO technikák és adatstruktúrák magabiztos alkalmazása mérnöki feladatokban.
ZH SZABÁLYOK
Engedélyezett segédeszközök
1. A tanszéki oldalra feltöltött laborok
2. Saját USB-n hozott gyakorló kódok: ezek lehetnek akár a gyakorló feladatok AI-jal promptolt megoldásai is, azonban a számonkérés során nem használható közvetlen semmilyen LLM.
Becsületesség garanciák
1. A számonkérés során telefonokat kikapcsolva a táskába helyezni
2. Internet elérés kikapcsolva
3. Laptop tálca elrejtés azonnali bukás
FELKÉSZÜLÉS ZH-KRA
1. szint: A mintaZH feladatok legyenek elkészítve akár LLM-mel, akár kézzel. ! EZT MINDENKÉPPEN TARTSUK BE
2. szint: A laborok gyakorlófeladatainak megoldása otthon
3. szint: A laborok gyakorlófeladatainak megoldása laboron időre
Ezért összesen akár 10 pluszpont is szerezhető a félév során, laboronként max 2 pont
OOP Labor 2 – Függvények, Sablonok, Makrók, Preprocesszor – Dinamikus tömbkezelés, Színezés
#include <iostream> #include "fgv.h" #include "szinek.h" static double negyzet(double x) inline static ostream& dendl(ostream& os) extern int laborszam; int main() {   csere_referencia(a, b);   csere_sablon(sz1, sz2);   matematikai_fgv* f = negyzet; }
main.cpp
#pragma once #ifndef FGV_H #define FGV_H #include <string> void csere(int* elso, int* masodik); void csere_referencia(...); template <typename Tipus> void csere_sablon(Tipus& elso, ... ); double tomb_atlag(const double* tomb, ... ); double tomb_atlag(const int* tomb, ... ); double tomb_atlag(double mennyiLegyen = 0); typedef double matematikai_fgv(double); namespace korszeru {   ... } #endif
fgv.hpp
#include "fgv.hpp" #include <limits> void csere_referencia(int& elso, ... ) {   int tmp = elso;     elso = masodik;   masodik = tmp; } template <typename Tipus> void csere_sablon(Tipus& elso, ... ) {   Tipus tmp = elso;     elso = masodik;   masodik = tmp; }
fgv.cpp
#pragma once #define ALAP       "\033[0m" #define FELKOVER   "\033[1m" #define ALAHUZOTT "\033[4m" #define FEKETE     "\033[30m" #define PIROS      "\033[31m" #define ZOLD      "\033[32m" #define H_FEKETE   "\033[40m" #define H_PIROS    "\033[41m" #define H_ZOLD     "\033[42m" #define KIEMELT(FOCIM, UZENET) \   cout << H_SARGA << FEKETE << " " << FOCIM        << " " << ALAP << " " << UZENET << endl;
szinek.hpp
l2_gyakorlok.pdf
OOP Labor 3 – Összetett osztályok és asszociáció – "Étel" és "Alapanyag" példaprojekt
#include <vector> #include "alapanyag.hpp" #include "etel.hpp" int main() {   Alapanyag zab("Zabpehely", 62, 13, ... );   Etel zabkasa("Zabkása");   zabkasa.alapanyag_hozzaad(tej, 150);   cout << zabkasa << endl;   tej.ar_set(55); }
main.cpp
class Alapanyag { private:   string nev;   double szenhidrat_100g,          feherje_100g, ...   double ar_100g; public:   Alapanyag(const string& nev,             double ch, double feh, ...             double ar);   string nev_get() const;   double ch_get() const, ...   void   ar_set(double uj_ar);   friend ostream& operator<<(ostream& os,                           const Alapanyag& a); };
alapanyag.hpp
#include "alapanyag.hpp" Alapanyag::Alapanyag(const string& nev,                     double ch, ...)                     : nev(nev),                     szenhidrat_100g(ch), ...                     ar_100g(ar)                     {} string Alapanyag::nev_get()   const { return nev; } double Alapanyag::ch_get()   const { return szenhidrat_100g; } … ostream& operator<<(ostream& os, ... ) {   os << a.nev << " (100g): "   ... }
alapanyag.cpp
#include "alapanyag.hpp" #include <vector> #include <utility> class Etel {   private:     string nev;     vector<pair<Alapanyag, double> > alpk;   //vector<pair<Alapanyag*, double> > alpk;   public:     Etel(const string& nev); // konstruktor     ~Etel();                 // destruktor     void alapanyag_hozzaad(...);     double ossz_ch() const, ...     void osszes_alapanyag_kiir() const;     friend ostream& operator<<(..., ...); };
etel.hpp
#include "etel.hpp" void Etel::alapanyag_mennyiseg_novel(...) {   for (auto& par : alapanyagok) {     if (par.first.nev_get() == alapanyag_nev) {  //if (par.first->nev_get() == alapanyag_nev) {       par.second += gramm;       return;     }   } } ostream& operator<<(...) {   os << "Étel: " << e.nev << endl;   e.osszes_alapanyag_kiir();   os << "Tápérték összesen:" ...   return os; }
etel.cpp
l3_gyakorlok.pdf
OOP Labor 4 – Szövegfeldolgozás és konzol formázás: Tördélő osztály, színezett kimenet
#include <string> #include <vector> #include "tordelo.h" #include "szinek.h" ostream& tab(ostream& os) { return os.put('\t'); } int main() {   string bemenet; getline(cin, bemenet);   Tordelo t(bemenet);   int n = t.darab(); vector<string> szavak;   string s1 = szavak.empty() ? "" : szavak[0];   string_view view = modern; }
main.cpp
#ifndef TORDELO_H #define TORDELO_H using namespace std; #include <string> class Tordelo {   string s;   mutable int allapot;   mutable bool szokar; public:   static string elvalasztok;   Tordelo(const string& input);   int darab() const;   string szo(int hanyadik) const; }; #endif
tordelo.hpp
#include "tordelo.hpp" using namespace std; string Tordelo::elvalasztok = " ,.?!-"; Tordelo::Tordelo(const string& input)   : s(input),     allapot(0),     szokar(false)   {} int Tordelo::darab() const {   ... } string Tordelo::szo(int hanyadik) const {   ... }
tordelo.cpp
#pragma once #define ALAP       "\033[0m" #define FELKOVER   "\033[1m" #define ALAHUZOTT "\033[4m" #define FEKETE     "\033[30m" #define PIROS      "\033[31m" #define ZOLD      "\033[32m" #define H_FEKETE   "\033[40m" #define H_PIROS    "\033[41m" #define H_ZOLD     "\033[42m" #define KIEMELT(FOCIM, UZENET) \   cout << H_SARGA << FEKETE << " " << FOCIM        << " " << ALAP << " " << UZENET << endl;
szinek.hpp
l4_gyakorlok.pdf
OOP Labor 5 – Formátum-ellenőrzés, Kivételkezelés, Fájlbeolvasás, Szűrés osztályokkal
#include <regex> #include "CsvFeldolgozo.hpp" #include "DatumKezeles.hpp" #define BEMENTEI_FAJL "BME_2034.csv" constexpr char bemeneti_fajl[] = "..."; int main() {   string bekert_datum;   for (int i = 0; i < 10; ++i) {     ...     if (regex_match(bekert_datum, ...)) {...}     ...     if (i == 9) { ... }   } }
main.cpp
#pragma once #include <string> #include <tuple> #include <regex> using namespace std; extern const regex datum_minta; class DatumKezeles { public:   // "YYYY.MM.DD" formátumú-e   static bool ervenyes_datum(const string& s);   // A "YYYY.MM.DD" formátumból(év, hónap, nap)   static tuple<int, int, int> bont_dat(const                                     string& s); }; 
DatumKezeles.hpp
#include "DatumKezeles.hpp" #include <regex> #include <sstream> using namespace std; // regex a "YYYY.MM.DD" formátumra const regex datum_minta(R"..."); bool DatumKezeles::ervenyes_datum(...) {   return regex_match(s, datum_minta); } tuple<int, int, int> DatumKezeles::bont_dat(const string& s) {   int ev = 0, honap = 0, nap = 0;   char pont1, pont2;   istringstream ss(s);   ss >> ev >> pont1 >> honap >> ... ; }
DatumKezeles.cpp
#include <fstream> class CsvFeldolgozo {   public:   CsvFeldolgozo(const string& bemeneti_fajl,                 ...);   bool datum_utani_feldolgozas(...);   private:   string bemeneti_fajl, ...   ifstream be_fajl;   ofstream szoveges_fajl;   fstream binaris_fajl;   void fajl_megnyitas();   void fajl_bezaras();   static string vagas(const string& s);   void sor_feldolgozas(const string& sor, ...); };
CSVFeldolgozo.hpp
#include "CsvFeldolgozo.hpp" #include "DatumKezeles.hpp" #include <tuple> void CsvFeldolgozo::fajl_megnyitas() {   be_fajl.open(bemeneti_fajl, ios::in);   if (!be_fajl.is_open())     throw runtime_error("..." + ...);     ... } void CsvFeldolgozo::fajl_bezaras() {   ... }
CSVFeldolgozo.cpp
Tárgykód;Tárgynév;Kurzus;Oktató; CMEFKTVTRGY;Promptolástechnika;25o_L01;Harcos József; CMEMSLPJIX;Mesterséges Intelligencia alkalmazásai;25_L1;Vincze József; CME00004741;Komplex hiperbolikus analízis;l1_25;Dr. Catherine Petit; CME00008033;Számelmélet 2;L0_25;Dr. Nagy Sándor; CME00005422;Sztochasztikus differenciálegyenletek;L1-25;Dr. rer. math. Martin Groß; CME00006321;Kvaternikus-többváltozós Mértékfunkcionálanalízis;25_l1;Dr. Ovilovits Zsüliett; CMEQXBN982;Neurokognitív Fluktuációelmélet;L1_25;Kiszelyvári Bence;
2034.csv
l5_gyakorlok.pdf
OOP Labor 6 – 1. Zárthelyi gyakorló labor
zh1_gyakorlok.pdf
OOP Labor 8 – 1. Zárthelyi dolgozat
OOP Labor 9 – Öröklés, Dinamikus memória osztályon belül és Bináris fájlkezelés
#include <iostream> #include "orokles.cpp" #include "destruktor_this.cpp" #include "binaris.cpp" using namespace std; int main() {   AltalanosEszkoz kalapacs("Kalapács", 1.2,                            "KAL123", "GY-KAL");   kalapacs.mutat();   kalapacs.kiirPublic();   u.setName("Példa Elemér").setAge(23).print();   auto msWB = binaris_iras("adatok.bin", v); }
main.cpp
class Eszkoz {   private:     string szeriaszam;     protected:     string gyartoKod;       public:     string nev;             double suly;             Eszkoz(...)       : szeriaszam(sz), gyartoKod(gy), ... {}     void kiirPublic() const {       cout << "[Eszkoz] Nev: " << nev << endl;     }     string getSzeriaszam() const { return ... ; }   protected:     string getGyartoKod() const { return ... ; } };
orokles.cpp
class DinTomb {   int* tomb; ...   public:     DinTomb(int m) : meret(m) {       tomb = new int[meret];       for (int i = 0; i < meret; ++i)     ~DinTomb() { delete[] tomb; } }; class User { ...   public:     User& setName(const string& name) {       this->name = name;       return *this;     } };
destruktor_this.cpp
#include <chrono> #include <cstdint> #include <sys/stat.h> using namespace chrono; struct Adat {   int id;   double ertek; }; static long long fajlmeret(const string& fajlnev) {   struct stat st {};   if (stat(fajlnev.c_str(), &st) == 0)     return (long long)st.st_size;   return -1; }
binaris.cpp
l9_gyakorlok.pdf
OOP Labor 10 – Egyedi, natív adatstruktúrák STL nélkül
#include <cstddef> #include <cassert> int main() {   Adat a(1), b(2), c(3), d(4);   lista.vegere_beszuras(&a.hook1);   lista.vegere_beszuras(&b.hook1);   lista.print_all();   Buffer<int, 3> cb;   cb.push(1); cb.push(2); cb.push(3);   cout << "Kezdet: "; cb.print();   IndexeltBKF bkf;   for (int v : {5, 2, 8, 1, 4, 7, 9})     bkf.beszur(v); }
main.cpp
#include <cassert> template<typename T, size_t N> class Buffer {   T buffer[N];   size_t head = 0;   size_t tail = 0;   size_t size_ = 0;   public:     void push(const T& value) {...}     T pop() {...}     size_t size() const { return size_; }     void print() const {...} };
korkoros_buffer.cpp
#include <cstddef>  // offsetof struct IntruzivCsomo {   IntruzivCsomo* kovetkezo = nullptr;   IntruzivCsomo* elozo = nullptr; }; struct Adat {   IntruzivCsomo hook1; // első lista láncolása   IntruzivCsomo hook2; // második lista láncolása   int ertek;   Adat(int ertek) : ertek(ertek) {} };
indexelt_bkf.cpp
#include <stdexcept> struct Node {   int ertek;   int meret;   Node* bal;   Node* jobb;   Node(int v) : ertek(v), meret(1),       bal(nullptr), jobb(nullptr) {} }; struct IndexeltBKF {   Node* gyoker = nullptr;   void meret_frissites(Node* csomo) {...}   Node* beszur(Node* csomo, int ertek) {...}   void beszur(int ertek) {...}   Node* k_adik_legkisebb(...) const {...} ... };
intruziv_lista.cpp
l10_gyakorlok.pdf
OOP Labor 11 – Konténerek és algoritmusok az STL-ben
#include "utils.hpp" void demo_vector(); void demo_list(); void demo_deque(); void demo_set(); void demo_unordered_set(); void demo_map(); void demo_unordered_map(); int main() {   run_demo("VECTOR", demo_vector);   run_demo("LIST", demo_list);   run_demo("DEQUE", demo_deque);   run_demo("SET", demo_set);   run_demo("MAP", demo_map); }
main.cpp
#include <vector> #include <algorithm> vector<int> szamok; void demo_vector() {   szamok.assign({ 3, 5, 1, 4, 2, 2, 5 });   sort(szamok.begin(), szamok.end());   print_container(szamok, "rendezett vektor");   cout << "a 2-esek száma: " <<    count(szamok.begin(), szamok.end(), 2) << "\n";   erase(szamok, 5);   print_container(szamok, "..."); }
vector.cpp
#include <list> #include <algorithm> void demo_list() {   list<string> nevek = { "Anna", "Bela", "..." };   nevek.push_front("David");   nevek.push_back("Edit");   print_container(nevek, "Lista kezdeti ...");   auto it = find(nevek.begin(), nevek.end(),                  "Cecil");   if (it != nevek.end())       nevek.insert(it, "Gabor");   print_container(nevek, "Gabor beszúrva ..."); }
list.cpp
#include <deque> #include <algorithm> // reverse, max_element vector<int> szamok; void demo_deque() {   deque<int> d = { 10, 20, 30 };   d.push_front(5);   d.push_back(40);   print_container(d, "Deque tartalma");   reverse(d.begin(), d.end());   print_container(d, "Fordított deque");   auto max_it = max_element(d.begin(), d.end());   cout << "Legnagyobb elem: " << *max_it << "\n"; }
deque.cpp
#include "utils.hpp" #include <set> void demo_set() {   set<int> halmaz = { 7, 3, 4, 4, 1, 6 };   print_container(halmaz, "Set tartalma");   cout << (halmaz.find(3) != halmaz.end() ?     "3 benne van\n" : "3 nincs benne\n");   auto lb = halmaz.lower_bound(5);   if (lb != halmaz.end())       cout << "Első >= 5: " << *lb << "\n";   halmaz.erase(6);   print_container(halmaz, "6 törlése után"); }
set.cpp
#include "utils.hpp" #include <unordered_set> void demo_unordered_set() {   unordered_set<string> s = { "kutya", "macska" };   s.insert("madar");   print_container(s, "Unordered_set tartalma");   cout << (s.find("hal") != s.end() ?     "hal benne van\n" : "hal nincs benne\n");   s.erase("macska");   print_container(s, "macska törlése után");   cout << "A halmaz üres? " << (s.empty() ?     "Igen" : "Nem") << "\n"; }
unordered_set.cpp
#include "utils.hpp" #include <map> void demo_map() {   map<string, int> pontok = { {"Anna", ... };   pontok.emplace("David", 88);   for (auto& [nev, pont] : pontok)     cout << nev << " pontszáma: " << pont << "\n";   cout << "Cecil benne van? " << (pontok.count("Cecil") ?     "Igen" : "Nem") << "\n";   pontok.erase("Bela");   print_container(pontok | views::keys,     "Kulcsok Bela törlése után");   cout << "Aktuális elemszám: " << pontok.size() << "\n"; }
map.cpp
#include "utils.hpp" #include <unordered_map> void demo_unordered_map() {   unordered_map<string, int> szotar = {                 {"zold", 2}, {"kek", 3} };   szotar["fekete"] = 0;   for (auto& [szin, kod] : szotar)     cout << szin << " -> " << kod << "\n";   cout << "kek kulcs benne van? " << (szotar.count("kek")     ? "Igen" : "Nem") << "\n";   szotar.erase("zold"); }
unordered_map.cpp
#ifndef UTILS_H #define UTILS_H #include <ranges> template <typename Container> void print_container(const Container& c,         const string& label = "") {   if (!label.empty()) cout << label << ": ";   for (const auto& elem : c) cout << elem << " ";   cout << "\n"; } void run_demo(const string& title, void (*func)()); #endif
utils.hpp
#include "utils.hpp" #include <string> using namespace std; void run_demo(const string& title, void (*func)()) {   cout << "==== " << title << " ====\n";   func();   cout << "\n"; }
utils.cpp
l11_gyakorlok.pdf
OOP Labor 12 – Állapottal rendelkező objektumok: Funktorok, Predikátumok, Lambdák és Függvénypointerek
// funktorok.cpp int osszead_funktor_hivas(int a, int b); double skalar_szorzo_hivas(double c, double x); // predikatumok_alg.cpp int db_hosszabb_mint(const std::vector<std::string>& v, size_t n); int db_kisbetu(const std::string& s); // lambdak.cpp int lambdas_osszeadas(int a, int b); int hozza_k_ertek_szerint(int x, int k); void ref_capture_novel(int& a, int b); // hivas_tipusok.cpp int duplaz_fvptr(int x); int lambda_pluszegy(int x);
main.cpp
// 2) ÁLLAPOTOS funktor: konstruktorban kapott // skálázó tényezőt ELMENTI, és használja. struct SkalarSzorzo {   double c;   explicit SkalarSzorzo(double c_) : c(c_) {}   double operator()(double x) const {     return c * x;   } };
funktorok.cpp
#include <cctype> // islower // "HosszabbMint" — állapotos predikátum: // eltároljuk a küszöböt, és az alapján döntünk. struct HosszabbMint {   size_t n;   explicit HosszabbMint(size_t n_) : n(n_) {}   bool operator()(const string& s) const {     return s.size() > n;   } };
predikatumok.cpp
int lambdas_osszeadas(int a, int b) {   int res = ([](int x, int y)     { return x + y; })(a, b);   return res; } int hozza_k_ertek_szerint(int x, int k) {   // [k] => k érték szerint kerül be (MÁSOLAT).   // A k későbbi külső módosítása itt nem látszik.   int res = ([k](int v) { return v + k; })(x);   return res; } void ref_capture_novel(int& a, int b) {   ([&a, b]() { a += b; })(); }
lambdak.cpp
int std_function_valtas(int x, int mode) {   // std::function-be tetszőleges "int(int)" hívható betehető   std::function<int(int)> f;   if (mode == 0) {     // lambda     f = [](int v) { return v + 1; };   }   else {     // függvénymutató     f = &duplaz_impl;   }   return f(x); }
hivas_tipusok.cpp
l12_gyakorlok.pdf
OOP Labor 13 – 2. Zárthelyi gyakorló labor
zh2_gyakorlok.pdf
OOP Labor 14 – 2. Zárthelyi dolgozat
Programozás Python nyelven alap információk
Cél:
A további tanulmányokat támogató alapvető informatikai ismeretek és készségek elsajátítása.
Főtémák:
  • Algoritmusok
  • Programozás alapelemei
  • Adatstruktúrák
  • Objektum-orientált programozás alapjai
  • Python mérnöki számításokra
Laborok szerepe:
Programozási gyakorlottság és problémamegoldó készség fejlesztése feladatokon keresztül.
Előadások szerepe:
Áttekintést adnak az informatika alapterületeiről és segítik a gyakorlaton használt eszközök megértését.
Várható kimenet:
Biztos alapfokú Python-tudás a további informatikai/programozási kompetenciák hatékony fejlesztéséhez.
ZH SZABÁLYOK
Engedélyezett segédeszközök
1. A tanszéki oldalra feltöltött laborok
2. Saját USB-n hozott gyakorló kódok: ezek lehetnek akár a gyakorló feladatok AI-jal promptolt megoldásai is, azonban a számonkérés során nem használható közvetlen semmilyen LLM.
Becsületesség garanciák
1. A számonkérés során telefonokat kikapcsolva a táskába helyezni
2. Internet elérés kikapcsolva
3. Laptop tálca elrejtés azonnali bukás
FELKÉSZÜLÉS ZH-KRA
1. szint: A mintaZH feladatok legyenek elkészítve akár LLM-mel, akár kézzel. ! EZT MINDENKÉPPEN TARTSUK BE
2. szint: A laborok gyakorlófeladatainak megoldása otthon
3. szint: A laborok gyakorlófeladatainak megoldása laboron időre
Ezért összesen akár 20 pluszpont is szerezhető a félév során, laboronként max 2 pont
PYTHON Labor 6 – 1. Zárthelyi gyakorló labor
zh1_gyakorlok.pdf
PYTHON Labor 8 – 1. Zárthelyi dolgozat
PYTHON Labor 14 – 2. Zárthelyi dolgozat
Matematika A1 villamosmérnököknek alap információk
Cél:
A további tanulmányokat támogató alapvető matematikai ismeretek és készségek elsajátítása villamosmérnöki alkalmazásokhoz.
Főtémák:
  • Matematikai logika és halmazelmélet
  • Vektoralgebra és analitikus geometria
  • Valós és komplex számok tulajdonságai
  • Függvények jellemzése és folytonossága
  • Differenciál- és integrálszámítás alapjai és alkalmazásai
Gyakorlatok szerepe:
A gyakorlaton résztvevők átfogó képet kapnak az analízis eszköztáráról és annak villamosmérnöki relevanciájáról, a számonkérések eredményes teljesítésére fókuszálva.
Előadások szerepe:
Az előadások elméleti hátteret biztosítanak a matematikai fogalmak és tételek megalapozásához.
Várható kimenet:
Szilárd matematikai alapismeretek a villamosmérnöki képzés további tantárgyaihoz és a szakmai problémák megoldásához.
FÉLÉVKÖZI SZÁMONKÉRÉSEK
Általános információk
Két darab 90 perces évközi zárthelyit íratunk, melyeken segédeszköz (zsebszámológép, stb.) nem használható.
Zárthelyi időpontok és témák
1. zárthelyi: EGYEZTETÉS ALATT
Témája: Matematikai logika és halmazelmélet. Vektoralgebra és analitikus térgeometria. Komplex számok. Valós sorozatok és határértékszámítások.
2. zárthelyi: EGYEZTETÉS ALATT
Témája: Valós függvények határértéke, folytonossága. Differenciálszámítás alkalmazásokkal.
Pót/javítózárthelyi: EGYEZTETÉS ALATT
Témája: az 1., illetve a 2. zárthelyivel megegyező.
Pót-pótzárthelyi
Időpont: EGYEZTETÉS ALATT
Anyaga, időtartama az 1. vagy a 2. zárthelyivel azonos.
Itt javítani már nem lehet.

Jelentkezés: A pót-pótzárthelyire a Neptunban jelentkezni kell, és a zárthelyi megírása különeljárási díj kifizetésével jár.
A tárgy teljesítésének feltétele
Aláírást az kap, aki a gyakorlaton a jelenléti követelményt teljesítette, és mindkét zárthelyit külön-külön legalább 40%-ra megírta.
Pótlási és javítási lehetőség
A meg nem írt, vagy 40% alatti eredménnyel megírt zárthelyi(ke)t pótolni kell, a legalább 40%-os eredménnyel megírt zárthelyiket javítani lehet. Ugyanaz a dolgozat szolgál javításra és pótlásra is pótlás/javítás idején, és az egész hétvégén együttes átlaga a pót-pótzárthelyiń.
Vizsgajegy
Csak a jelenlétű követelményeket teljesítő hallgatók kapnak aláírást. Ha a két zárthelyi bármelyikének eredménye (pótlás után) nem éri el a 40%-ot, akkor az aláírást megtagadjuk.
Aláírást elnyert hallgató sikeres (legalább 50%-os) vizsga után kaphat jegyet, amit a két zárthelyin elért eredmények átlaga határoz meg.
p = p₁ + p₂ + 2v 4
átlaga határoz meg a következő táblázat szerint:
0% ≤ p < 40% esetén elégtelen (1)
40% ≤ p < 55% esetén elégséges (2)
55% ≤ p < 70% esetén közepes (3)
70% ≤ p < 85% esetén jó (4)
85% ≤ p ≤ 100% esetén jeles (5)
Az írásbeli alapján megajánlott jegy szóbeli vizsgával javítható.
ANALÍZIS Gyakorlat 2 – Halmazalgebra, Számossággal kapcsolatos feladatok, Relációk, függvények, Korlátos számhalmazok
Hamarosan...
ANALÍZIS Gyakorlat 3 – Komplex számok, Vektoralgebra
Hamarosan...
ANALÍZIS Gyakorlat 4 – Analitikus térgeometria, egyenesek és síkok megadása, Távolságok és szögek, Numerikus sorozatok I.
Hamarosan...
ANALÍZIS Gyakorlat 5 – Numerikus sorozatok II.
Hamarosan...
ANALÍZIS Gyakorlat 6 – Numerikus sorozatok III.
Hamarosan...
ANALÍZIS Gyakorlat 8 – Függvény határértéke
Hamarosan...
ANALÍZIS Gyakorlat 9 – Korlátos zárt halmazon folytonos függvények, Trigonometrikus, hiperbolikus függvények és inverzeik
Hamarosan...
ANALÍZIS Gyakorlat 10 – Deriválás, Érintőegyenessel kapcsolatos feladatok, Deriválás gyakorlása, logaritmikus deriválás, Magasabbrendű deriváltak
Hamarosan...
ANALÍZIS Gyakorlat 11 – Középérték tételek, l’Hospital-szabály
Hamarosan...
ANALÍZIS Gyakorlat 12 – Teljes függvényvizsgálat, Szélsőértékek meghatározása, Taylor-formula, Egyszerűbb határozatlan integrálok
Hamarosan...
ANALÍZIS Gyakorlat 13 – Parciális integrálás, Helyettesítési integrálás, Racionális törtfüggvények, illetve arra vezető helyettesítések
Hamarosan...
ANALÍZIS Gyakorlat 14 – Határozott integrál
Hamarosan...
IPA Labor 7 – 1. Zárthelyi dolgozat
IPA Labor 8 – Függvények, Paraméterátadás, Rekurzió, Struktúrák, Saját Fejlécek
#include "fuggvenyek.h" #include "strukturak.h" int main(void) {   köszönés();   lehessenek_ekezetek();   srand((unsigned int)time(NULL));   int tomb10[10];   int tomb25[25];   int_tomb_random_feltoltes   (tomb10, 10, -50, 50);   int_tomb_random_feltoltes2   (tomb25, 25, -50, 50);   int_tomb_kiiratas(tomb10, 10); }
main.c
#pragma once void köszönés() {   printf("Hello!\n\n"); } void puffer_torles() {   int clear;   while ((clear = getchar()) != '\n'); } unsigned long long faktorialis_sima(int n) {   … } unsigned long long faktorialis_rekurziv(int n) {   ... }
fuggvenyek.h
#pragma once struct civil {   int igazolvanyszam,     eletkor;   double karizma,     ero,     intelligencia; };
strukturak.h
📄
1. Feladat: Statisztika függvény tömbre
Írj egy statisztika függvényt, ami egy double tömbre kiszámítja és kiírja: átlag, szórás, medián, minimum, maximum...
...
2. Feladat: Véletlen mátrix generálása paraméterekkel
Írj függvényt, amely két egész paramétert kap (rows, cols) és létrehoz egy rows × cols méretű mátrixot...
...
3. Feladat: Binomiális együttható iteratív és rekurzív
Írj két függvényt a binomiális együtthatóra: egy iteratív és egy rekurzív megoldást...
...
4. Feladat: Anyagi pont mozgása (struktúrákkal)
Hozz létre struct Vec2 { double x,y; }; és struct Pont { Vec2 p, v; }; típusokat...
...
5. Feladat: Numerikus integrálás (trapéz, & függvénymutató)
Írj egy double integrate(double (*f)(double), double a, double b, int n) függvényt...
...
l8_gyakorlok.pdf
IPA Labor 10 – Fájlkezelés, Stringműveletek, Memóriakezelés
#define bemenetnev "minta.csv" #define kimenetnev "kimenet.csv" #define inputnev "input.txt" #define outputnev "output.txt" FILE *be, *ki; int main(void) {   char* buffer = (char*)malloc(100),         *mutato, *kovetkezo;   if (buffer == NULL) {     printf("Memória foglalási hiba!\n");     return -1;   }   ... }
main.c
0,01;0;0 0,02;0;0 0,03;0;0 0,04;0,23;0,000003386 0,05;0,14;0,00000245 0,06;0,08;0,000001382 0,07;0,06;0,000001235 0,08;0,04;0,000000819 0,09;0,01;0,000000073 0,1;0;0 0,11;0;0 0,12;0;0 0,13;0,15;0,000049433 0,14;0,12;0,000039514 0,15;0,11;0,000040838 0,16;0,1;0,00004096 0,17;0,11;0,000059447 0,18;0,13;0,000098561 0,19;0,2;0,00027436 0,2;0,25;0,0005
minta.csv
Szerda délután szeretek programozni laboron. 13523 9832 821 8942 83 1 0 0 0 1232 #&&@@[]]ˇ^°˘°~ˇ˘˘`˘°˛˘^˘^ˇ.,.-.,<># G4DT8N HLKR3B BFF21A SZTM4P FZS631 JOE123 $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ szép.
input.txt
📄
1. Feladat: Egészek feldolgozása szövegfájlban
Adott egy .txt fájl, amelyben soronként tetszőleges darab egész szám szerepel szóközzel elválasztva...
...
2. Feladat: Tördeld a szöveget megadott szélességre
Egy nagyon hosszú, egyetlen soros fájlt tördelj új sorokra 20 karakterenként...
...
3. Feladat: Egyszerű szóelválasztó
Írj primitív szóelválasztó programot magyar szavakhoz. Szabályok: két egymást követő mássalhangzó között választható el...
...
4. Feladat: Hangrend meghatározása
Írj programot, amely eldönti egy beírt szóról, hogy magas, mély vagy vegyes hangrendű...
...
5. Feladat: Szó kiemelése mondatban
Kérj be egy mondatot és külön egy szót. Ellenőrizd, hogy a szó teljes szóként (szóhatárok között) előfordul-e a mondatban...
...
l10_gyakorlok.pdf
IPA Labor 14 – 2.Zárthelyi dolgozat