vd768er/usaa24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

a4

Browse Source
This commit is contained in:
Džubara 2024-11-18 14:32:10 +01:00
parent ed50e09388
commit a4f237c52b
3 changed files with 103 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
a4/program.c Normal file
View File

76
cv4/a_train.c
View File

@ -3,74 +3,74 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
// Pridá nový vozeň na koniec vlaku
struct car* add_car(struct car* first, const char* target) { struct car* add_car(struct car* first, const char* target) {
struct car* new_car = (struct car*)malloc(sizeof(struct car)); struct car* new_car = (struct car*)malloc(sizeof(struct car)); // Alokuje pamäť pre nový vozeň
if (new_car == NULL) { if (new_car == NULL) { // Skontroluje, či sa pamäť podarilo alokovať
printf("Chyba: Nepodarilo sa alokovať pamäť pre nový vozeň.\n"); printf("Chyba: Nepodarilo sa alokovať pamäť pre nový vozeň.\n");
return first; return first; // Ak nie, vráti pôvodný zoznam
} }
strncpy(new_car->value, target, SIZE); strncpy(new_car->value, target, SIZE); // Nastaví cieľovú stanicu vozňa
new_car->next = NULL; new_car->next = NULL; // Nový vozeň bude posledný v zozname
if (first == NULL) { if (first == NULL) { // Ak je vlak prázdny
return new_car; return new_car; // Nový vozeň sa stane prvým
} }
struct car* temp = first; struct car* temp = first; // Začne na začiatku vlaku
while (temp->next != NULL) { while (temp->next != NULL) { // Prejde na koniec zoznamu
temp = temp->next; temp = temp->next;
} }
temp->next = new_car; temp->next = new_car; // Pridá nový vozeň na koniec
return first; return first; // Vráti začiatok zoznamu
} }
// Vytlačí všetky vozne vo vlaku
void print_train(struct car* first) { void print_train(struct car* first) {
if (first == NULL) { if (first == NULL) { // Ak je vlak prázdny
printf("Vlak je prazdny.\n"); printf("Vlak je prazdny.\n");
return; return; // Ukončí funkciu
} }
struct car* temp = first; struct car* temp = first; // Začne na začiatku vlaku
while (temp != NULL) { while (temp != NULL) { // Prechádza cez všetky vozne
printf("Cielova stanica: %s\n", temp->value); printf("Cielova stanica: %s\n", temp->value); // Vytlačí cieľovú stanicu vozňa
temp = temp->next; temp = temp->next; // Prejde na ďalší vozeň
} }
} }
// Zruší všetky vozne vo vlaku
void cancel_train(struct car* first) { void cancel_train(struct car* first) {
struct car* temp; struct car* temp;
while (first != NULL) { while (first != NULL) { // Prechádza cez všetky vozne
temp = first; temp = first; // Dočasne uloží aktuálny vozeň
first = first->next; first = first->next; // Prejde na ďalší vozeň
free(temp); free(temp); // Uvoľní pamäť aktuálneho vozňa
} }
printf("Vsetky vozne boli zrusene.\n"); printf("Vsetky vozne boli zrusene.\n");
} }
// Odstráni všetky vozne s danou cieľovou stanicou
struct car* clear_train(struct car* first, const char* target) { struct car* clear_train(struct car* first, const char* target) {
struct car* current = first; struct car* current = first; // Začne na začiatku vlaku
struct car* previous = NULL; struct car* previous = NULL; // Uchováva predchádzajúci vozeň
while (current != NULL) { while (current != NULL) { // Prechádza cez všetky vozne
// Porovnanie hodnoty cielovej stanice if (strcmp(current->value, target) == 0) { // Ak sa cieľová stanica zhoduje
if (strcmp(current->value, target) == 0) { if (previous == NULL) { // Ak je to prvý vozeň
// Ak sa cielova stanica zhoduje, odstráni vozeň first = current->next; // Aktualizuje začiatok zoznamu
if (previous == NULL) {
// Ak je to prvý vozeň
first = current->next;
} else { } else {
previous->next = current->next; previous->next = current->next; // Preskočí aktuálny vozeň
} }
struct car* temp = current; struct car* temp = current; // Dočasne uloží aktuálny vozeň
current = current->next; current = current->next; // Prejde na ďalší vozeň
free(temp); free(temp); // Uvoľní pamäť aktuálneho vozňa
} else { } else {
// Ak sa nezhoduje, prejde na nasledujúci vozeň previous = current; // Aktualizuje predchádzajúci vozeň
previous = current; current = current->next; // Prejde na ďalší vozeň
current = current->next;
} }
} }
return first; return first; // Vráti začiatok zoznamu
} }

106
cv6/a_station.c
View File

@ -2,80 +2,86 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
struct station* create_station(){ // Vytvorí štruktúru stanice
struct station* station = (struct station*)calloc(1,sizeof(struct station)); struct station* create_station() {
station->tracks = (struct car**)calloc(STATION_SIZE, sizeof(struct car*)); struct station* station = (struct station*)calloc(1, sizeof(struct station)); // Alokuje pamäť pre stanicu
station->track_count = STATION_SIZE; station->tracks = (struct car**)calloc(STATION_SIZE, sizeof(struct car*)); // Alokuje pamäť pre pole koľají
return station; station->track_count = STATION_SIZE; // Nastaví počet koľají
return station; // Vráti ukazovateľ na stanicu
} }
void destroy_station(struct station* station){ // Zničí štruktúru stanice (zatiaľ prázdna implementácia)
void destroy_station(struct station* station) {
// Tu by malo byť uvoľnenie pamäte pre všetky objekty a pole
} }
int select_track(struct station* station, const char* target){ // Vypočíta index koľaje pre daný cieľ pomocou hashovacej funkcie
unsigned long hash = 5381; int select_track(struct station* station, const char* target) {
unsigned long hash = 5381; // Inicializuje hash hodnotu
int c; int c;
while ((c = *target++)) { while ((c = *target++)) { // Prechádza každým znakom reťazca
hash = ((hash << 5) + hash) + c; // hash * 33 + c hash = ((hash << 5) + hash) + c; // hash * 33 + c
} }
return hash % station->track_count; return hash % station->track_count; // Vráti index v rozsahu počtu koľají
} }
// Pridá kapacitu cieľu alebo vytvorí nový cieľ
void add_target_capacity(struct station* station, const char* target, int capacity) {
int index = select_track(station, target); // Získa index koľaje pre cieľ
struct car* current = station->tracks[index]; // Získa zoznam cieľov na danej koľaji
void add_target_capacity(struct station* station,const char* target, int capacity){ while (current) { // Prechádza zoznam cieľov
int index = select_track(station, target); if (strcmp(current->value, target) == 0) { // Ak cieľ už existuje
struct car* current = station->tracks[index]; current->capacity += capacity; // Zvýši jeho kapacitu
return; // Ukončí funkciu
while (current) {
if (strcmp(current->value, target) == 0) {
current->capacity += capacity; // Pridá kapacitu
return;
} }
current = current->next; current = current->next; // Pokračuje na ďalší prvok v zozname
} }
struct car* new_car = (struct car*)malloc(sizeof(struct car)); // Alokuje pamäť pre nový cieľ
struct car* new_car = (struct car*)malloc(sizeof(struct car)); strncpy(new_car->value, target, TARGET_SIZE - 1); // Nastaví názov cieľa
strncpy(new_car->value, target, TARGET_SIZE - 1); new_car->value[TARGET_SIZE - 1] = '\0'; // Ukončí reťazec nulou
new_car->value[TARGET_SIZE - 1] = '\0'; new_car->capacity = capacity; // Nastaví kapacitu cieľa
new_car->capacity = capacity; new_car->next = station->tracks[index]; // Pridá cieľ na začiatok zoznamu
new_car->next = station->tracks[index]; station->tracks[index] = new_car; // Uloží nový cieľ do koľaje
station->tracks[index] = new_car;
} }
int get_target_capacity(struct station* station,const char* target){ // Vráti kapacitu cieľa podľa názvu
int index = select_track(station, target); int get_target_capacity(struct station* station, const char* target) {
struct car* current = station->tracks[index]; int index = select_track(station, target); // Získa index koľaje pre cieľ
struct car* current = station->tracks[index]; // Získa zoznam cieľov na danej koľaji
while (current) { while (current) { // Prechádza zoznam cieľov
if (strcmp(current->value, target) == 0) { if (strcmp(current->value, target) == 0) { // Ak nájde cieľ
return current->capacity; return current->capacity; // Vráti jeho kapacitu
} }
current = current->next; current = current->next; // Pokračuje na ďalší prvok
} }
return 0; return 0; // Ak cieľ neexistuje, vráti 0
} }
int count_targets(struct station* station){ // Počíta počet cieľov vo všetkých koľajach
int count = 0; int count_targets(struct station* station) {
for (int i = 0; i < station->track_count; ++i) { int count = 0; // Inicializuje počet na 0
struct car* current = station->tracks[i]; for (int i = 0; i < station->track_count; ++i) { // Prechádza všetky koľaje
while (current) { struct car* current = station->tracks[i]; // Získa zoznam cieľov na koľaji
++count; while (current) { // Prechádza každý cieľ
current = current->next; ++count; // Zvyšuje počet
current = current->next; // Pokračuje na ďalší prvok
} }
} }
return count; return count; // Vráti celkový počet cieľov
} }
int count_capacity(struct station* station){ // Počíta celkovú kapacitu vo všetkých koľajach
int total_capacity = 0; int count_capacity(struct station* station) {
for (int i = 0; i < station->track_count; ++i) { int total_capacity = 0; // Inicializuje celkovú kapacitu na 0
struct car* current = station->tracks[i]; for (int i = 0; i < station->track_count; ++i) { // Prechádza všetky koľaje
while (current) { struct car* current = station->tracks[i]; // Získa zoznam cieľov na koľaji
total_capacity += current->capacity; while (current) { // Prechádza každý cieľ
current = current->next; total_capacity += current->capacity; // Pridá jeho kapacitu
current = current->next; // Pokračuje na ďalší prvok
} }
} }
return total_capacity; return total_capacity; // Vráti celkovú kapacitu
} }