From 16b668dd27e76bab3380e03eb0d315ae121fecc3 Mon Sep 17 00:00:00 2001 From: Your Name Date: Sun, 25 Jan 2026 15:26:05 +0100 Subject: [PATCH] funguje --- sk2/Makefile | 22 ++++ sk2/README.md | 55 ++++++++ sk2/calculator | Bin 0 -> 21632 bytes sk2/calculator.c | 328 +++++++++++++++++++++++++++++++++++++++++++++++ sk2/calculator.h | 13 ++ sk2/calculator.o | Bin 0 -> 10320 bytes sk2/main.c | 41 ++++++ sk2/main.o | Bin 0 -> 3128 bytes 8 files changed, 459 insertions(+) create mode 100644 sk2/Makefile create mode 100644 sk2/README.md create mode 100755 sk2/calculator create mode 100644 sk2/calculator.c create mode 100644 sk2/calculator.h create mode 100644 sk2/calculator.o create mode 100644 sk2/main.c create mode 100644 sk2/main.o diff --git a/sk2/Makefile b/sk2/Makefile new file mode 100644 index 0000000..77b4f0b --- /dev/null +++ b/sk2/Makefile @@ -0,0 +1,22 @@ +CC = gcc +CFLAGS = -Wall -Wextra -std=c99 -pedantic -lm +TARGET = calculator + +all: $(TARGET) + +$(TARGET): main.o calculator.o + $(CC) $(CFLAGS) -o $(TARGET) main.o calculator.o -lm + +main.o: main.c calculator.h + $(CC) $(CFLAGS) -c main.c + +calculator.o: calculator.c calculator.h + $(CC) $(CFLAGS) -c calculator.c + +clean: + rm -f *.o $(TARGET) + +run: $(TARGET) + ./$(TARGET) + +.PHONY: all clean run diff --git a/sk2/README.md b/sk2/README.md new file mode 100644 index 0000000..b7d8b0d --- /dev/null +++ b/sk2/README.md @@ -0,0 +1,55 @@ +# Vedecká kalkulačka + +## Zadanie +Naprogramujte vedeckú kalkulačku, ktorá vyhodnocuje matematické výrazy v infixovej notácii s podporou základných operácií a matematických funkcií. + +## Požiadavky +- Načítanie a práca s číslami s presnosťou minimálne 2 desatinné miesta +- Podpora základných operácií: sčítanie (+), odčítanie (-), násobenie (*), delenie (/), zátvorky +- Podpora matematických funkcií: sinus (sin), kosínus (cos), druhá odmocnina (sqrt), druhá mocnina (^), dekadický logaritmus (log) + +## Funkcionalita +Kalkulačka: +1. Načíta matematický výraz z príkazového riadku +2. Prevedie infixový zápis na postfixový (RPN) +3. Vyhodnotí výraz pomocou zásobníkového algoritmu +4. Vypíše výsledok s presnosťou na 2 desatinné miesta +5. Podporuje interaktívny režim so zadaním "koniec" pre ukončenie + +## Opis riešenia +Riešenie využíva algoritmus shunting-yard (železničný zoraďovací algorimus) pre prevod infixovej notácie na postfixovú (RPN). Následne sa RPN výraz vyhodnotí pomocou zásobníka. + +### Hlavné kroky: +1. **Analýza vstupu**: Lexikálna analýza vstupného reťazca +2. **Konverzia na RPN**: + - Použitie dvoch zásobníkov: jeden pre operátory/funkcie, druhý pre výstup + - Respektovanie priorít operátorov a asociativity + - Spracovanie matematických funkcií +3. **Vyhodnotenie RPN**: + - Zásobníkový algoritmus pre vyhodnotenie + - Aplikácia operátorov a funkcií +4. **Výstup**: Formátovanie výsledku na 2 desatinné miesta + +### Podporované výrazy: +- Jednoduché aritmetické operácie: `2 + 3 * 4` +- Zátvorky: `(2 + 3) * 4` +- Matematické funkcie: `sin(0)`, `cos(0)`, `sqrt(25)`, `log(100)` +- Mocniny: `2^3`, `4^0.5` +- Komplexné výrazy: `sin(0) + cos(0) * 2` + +## Podmienky pre správne fungovanie +1. Program vyžaduje matematickú knižnicu (libm) +2. Vstupné výrazy musia byť matematicky korektné +3. Zátvorky musia byť správne párové +4. Delenie nulou spôsobí chybu +5. Logaritmus a odmocnina zo záporného čísla spôsobí chybu + +## Inštalácia a spustenie +```bash +# Kompilácia +make + +# Spustenie +make run +# alebo +./calculator diff --git a/sk2/calculator b/sk2/calculator new file mode 100755 index 0000000000000000000000000000000000000000..653970eba69269cdb6b2bdc64d550bfc5775a1da GIT binary patch literal 21632 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 xbQw50=h5&{zNM literal 0 HcmV?d00001 diff --git a/sk2/calculator.c b/sk2/calculator.c new file mode 100644 index 0000000..f7ccf32 --- /dev/null +++ b/sk2/calculator.c @@ -0,0 +1,328 @@ +#include "calculator.h" +#include +#include +#include +#include +#include + +#define MAX_STACK_SIZE 256 +#define MAX_TOKEN_LENGTH 100 + +typedef struct { + double data[MAX_STACK_SIZE]; + int top; +} Stack; + +typedef struct { + char data[MAX_STACK_SIZE][MAX_TOKEN_LENGTH]; + int top; +} StringStack; + +static void init_stack(Stack *s) { + s->top = -1; +} + +static bool is_stack_empty(Stack *s) { + return s->top == -1; +} + +static bool is_stack_full(Stack *s) { + return s->top == MAX_STACK_SIZE - 1; +} + +static void push(Stack *s, double value) { + if (!is_stack_full(s)) { + s->data[++s->top] = value; + } +} + +static double pop(Stack *s) { + if (!is_stack_empty(s)) { + return s->data[s->top--]; + } + return 0.0; +} + +static void init_string_stack(StringStack *s) { + s->top = -1; +} + +static bool is_string_stack_empty(StringStack *s) { + return s->top == -1; +} + +static bool is_string_stack_full(StringStack *s) { + return s->top == MAX_STACK_SIZE - 1; +} + +static void push_string(StringStack *s, const char *str) { + if (!is_string_stack_full(s) && strlen(str) < MAX_TOKEN_LENGTH) { + strcpy(s->data[++s->top], str); + } +} + +static char* pop_string(StringStack *s) { + if (!is_string_stack_empty(s)) { + return s->data[s->top--]; + } + return NULL; +} + +static char* peek_string(StringStack *s) { + if (!is_string_stack_empty(s)) { + return s->data[s->top]; + } + return NULL; +} + +bool is_operator(char c) { + return c == '+' || c == '-' || c == '*' || c == '/' || c == '^'; +} + +int get_priority(char op) { + switch (op) { + case '+': + case '-': + return 1; + case '*': + case '/': + return 2; + case '^': + return 3; + default: + return 0; + } +} + +bool is_function(const char *str, int *length) { + if (strncmp(str, "sin", 3) == 0) { + *length = 3; + return true; + } + if (strncmp(str, "cos", 3) == 0) { + *length = 3; + return true; + } + if (strncmp(str, "sqrt", 4) == 0) { + *length = 4; + return true; + } + if (strncmp(str, "log", 3) == 0) { + *length = 3; + return true; + } + return false; +} + +double apply_operator(double a, double b, char op) { + switch (op) { + case '+': return a + b; + case '-': return a - b; + case '*': return a * b; + case '/': + if (b == 0) { + return NAN; + } + return a / b; + case '^': return pow(a, b); + default: return NAN; + } +} + +double apply_function(const char *func, double value, bool *error) { + if (strcmp(func, "sin") == 0) { + return sin(value); + } + if (strcmp(func, "cos") == 0) { + return cos(value); + } + if (strcmp(func, "sqrt") == 0) { + if (value < 0) { + *error = true; + return NAN; + } + return sqrt(value); + } + if (strcmp(func, "log") == 0) { + if (value <= 0) { + *error = true; + return NAN; + } + return log10(value); + } + *error = true; + return NAN; +} + +static char** infix_to_postfix(const char *expression, int *token_count, bool *error) { + StringStack operator_stack; + init_string_stack(&operator_stack); + char **output = malloc(MAX_STACK_SIZE * sizeof(char*)); + for (int i = 0; i < MAX_STACK_SIZE; i++) { + output[i] = malloc(MAX_TOKEN_LENGTH * sizeof(char)); + } + *token_count = 0; + *error = false; + int i = 0; + int len = strlen(expression); + while (i < len) { + if (isspace(expression[i])) { + i++; + continue; + } + if (isdigit(expression[i]) || expression[i] == '.') { + int j = 0; + char num[MAX_TOKEN_LENGTH] = {0}; + while (i < len && (isdigit(expression[i]) || expression[i] == '.')) { + num[j++] = expression[i++]; + } + num[j] = '\0'; + strcpy(output[(*token_count)++], num); + continue; + } + int func_len; + if (is_function(expression + i, &func_len)) { + char func[10] = {0}; + strncpy(func, expression + i, func_len); + func[func_len] = '\0'; + i += func_len; + push_string(&operator_stack, func); + continue; + } + if (is_operator(expression[i])) { + while (!is_string_stack_empty(&operator_stack)) { + char *top = peek_string(&operator_stack); + if (strcmp(top, "(") != 0 && + get_priority(top[0]) >= get_priority(expression[i]) && + strlen(top) == 1) { + strcpy(output[(*token_count)++], pop_string(&operator_stack)); + } else { + break; + } + } + char op[2] = {expression[i++], '\0'}; + push_string(&operator_stack, op); + continue; + } + if (expression[i] == '(') { + char bracket[2] = {expression[i++], '\0'}; + push_string(&operator_stack, bracket); + continue; + } + if (expression[i] == ')') { + i++; + while (!is_string_stack_empty(&operator_stack) && + strcmp(peek_string(&operator_stack), "(") != 0) { + strcpy(output[(*token_count)++], pop_string(&operator_stack)); + } + if (is_string_stack_empty(&operator_stack)) { + *error = true; + break; + } + pop_string(&operator_stack); + if (!is_string_stack_empty(&operator_stack)) { + char *top = peek_string(&operator_stack); + if (is_function(top, &func_len)) { + strcpy(output[(*token_count)++], pop_string(&operator_stack)); + } + } + continue; + } + *error = true; + break; + } + while (!is_string_stack_empty(&operator_stack)) { + char *top = peek_string(&operator_stack); + if (strcmp(top, "(") == 0) { + *error = true; + break; + } + strcpy(output[(*token_count)++], pop_string(&operator_stack)); + } + if (*error) { + for (int j = 0; j < MAX_STACK_SIZE; j++) { + free(output[j]); + } + free(output); + return NULL; + } + return output; +} + +static double evaluate_postfix(char **tokens, int token_count, bool *error) { + Stack value_stack; + init_stack(&value_stack); + for (int i = 0; i < token_count; i++) { + char *token = tokens[i]; + if (isdigit(token[0]) || (token[0] == '.' && isdigit(token[1]))) { + push(&value_stack, atof(token)); + continue; + } + int func_len; + if (is_function(token, &func_len)) { + if (is_stack_empty(&value_stack)) { + *error = true; + return NAN; + } + double value = pop(&value_stack); + double result = apply_function(token, value, error); + if (*error) { + return NAN; + } + push(&value_stack, result); + continue; + } + if (is_operator(token[0]) && strlen(token) == 1) { + if (is_stack_empty(&value_stack)) { + *error = true; + return NAN; + } + double b = pop(&value_stack); + if (is_stack_empty(&value_stack)) { + *error = true; + return NAN; + } + double a = pop(&value_stack); + double result = apply_operator(a, b, token[0]); + if (isnan(result)) { + *error = true; + return NAN; + } + push(&value_stack, result); + continue; + } + *error = true; + return NAN; + } + if (is_stack_empty(&value_stack)) { + *error = true; + return NAN; + } + double result = pop(&value_stack); + if (!is_stack_empty(&value_stack)) { + *error = true; + return NAN; + } + return result; +} + +double evaluate_expression(const char *expression, bool *error) { + *error = false; + if (expression == NULL || strlen(expression) == 0) { + *error = true; + return NAN; + } + int token_count; + char **postfix_tokens = infix_to_postfix(expression, &token_count, error); + if (*error || postfix_tokens == NULL) { + *error = true; + return NAN; + } + double result = evaluate_postfix(postfix_tokens, token_count, error); + for (int i = 0; i < MAX_STACK_SIZE; i++) { + free(postfix_tokens[i]); + } + free(postfix_tokens); + + return result; +} diff --git a/sk2/calculator.h b/sk2/calculator.h new file mode 100644 index 0000000..f795e9e --- /dev/null +++ b/sk2/calculator.h @@ -0,0 +1,13 @@ +#ifndef CALCULATOR_H +#define CALCULATOR_H + +#include + +double evaluate_expression(const char *expression, bool *error); +bool is_operator(char c); +int get_priority(char op); +bool is_function(const char *str, int *length); +double apply_operator(double a, double b, char op); +double apply_function(const char *func, double value, bool *error); + +#endif diff --git a/sk2/calculator.o b/sk2/calculator.o new file mode 100644 index 0000000000000000000000000000000000000000..0b52d6ce791eec44b150a809843016d0efe0b418 GIT binary patch literal 10320 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 +#include +#include +#include + +#define MAX_INPUT_LENGTH 256 + +int main() { + char input[MAX_INPUT_LENGTH]; + printf("=== Vedecka kalkulacka ===\n"); + printf("Podporovane operacie: + - * / ( )\n"); + printf("Funkcie: sin(), cos(), sqrt(), log()\n"); + printf("Mocnina: ^ (napr. 2^3 = 8)\n"); + printf("Pre ukoncenie napiste 'koniec'\n\n"); + while (1) { + printf("Zadajte vyraz: "); + if (fgets(input, sizeof(input), stdin) == NULL) { + break; + } + input[strcspn(input, "\n")] = 0; + if (strcmp(input, "koniec") == 0 || + strcmp(input, "exit") == 0 || + strcmp(input, "quit") == 0) { + break; + } + if (strlen(input) == 0) { + continue; + } + bool error = false; + double result = evaluate_expression(input, &error); + if (error || isnan(result)) { + printf("Chyba: Neplatny vyraz!\n"); + } else { + printf("Vysledok: %.2f\n", result); + } + } + + printf("Kalkulacka ukoncena.\n"); + return 0; +} diff --git a/sk2/main.o b/sk2/main.o new file mode 100644 index 0000000000000000000000000000000000000000..e985718d58b6af82a3c3f65906181795f5be6a08 GIT binary patch literal 3128 zcmb_dU1(fI6h51zNsUc54J}wII(>-Uwaqmf1J*z^7}H#^hEhpT!7h{C+2nS2@7>;? zkgZS^6E%cD5PkPSpTwt12!gUyXc79*2hleXL~N*vKQBSVc+R~uo10-TLh-=tne(0R zoHH}$&g^TG=gzjJQlKOSPr;t0P=Kw2d-L&dIu5$awpd?*AEcaT)lZG)c=dQMX92EYe%EBE5H4-yZZ$#yjg0ckzPJZzmm5L~iSxEIX4u%?gf3%De3Pq$|#RCJWCy1>3UuD7(lqHm|t` z8@~8B8)Ij(aNZRxC_8pR*p^`Ev^-z1lZaTNaIza-=0$!9k;S^puZ%M2hR6kC$@1ZH zfIkxp^*PKvEov3++x3Wg0%q%8MHHR#C>t<_OWp9?-Y#W9ZU9V8OpLP3%v@mm0n6o# z5o2gD7ldZ+>hQ2JG-3>ArGvKIfuj!x-G`~^8E6A&5Y~=^#x2miki14|N^f zz@|NjI1Q3*YT{&X-&<`HJ)P~}r;rljt$v8w0l)9I^0l|T;k1_Uw(bj|3jHyDxCX>} zaL|5q=|`Xyek=ihH~}9>zy}lXkp$dKz@f@5+bDzzYJu-T&9!X51fE~CY$(kOggoCZ zcr`oJ)f$LJUJ1A_@?xpx3eU3~8}fP2#~Y9@ER^#lZdI^cC?}-GK8HR2dp8pG{ZsGh zv=u(2@m0^yNL=SXt?{3g_EZ9YTH{;No=xDtqVbodEfV-@<7&SjN?tw2@5H&<@9PpL zepd{CPvW#+`t}t6V~MN$pGtdEYU1CAL-B7(T=5m}+Zew)#{Wg*e=hBv1b#1FFcg*l zdSt>eiPL)G`Co|P_oGj(^Gz+!O_^sc#*cp|A87pVB>$5bKYq@iY5ZR$|9Xrc&;LUV zKNMRhlX0|P8ci|0de!H1VBlqm^n#kXqQVVdEcsv*xzE9v^E@zICo&37wJL1%*^Vy^ zd=m%5n*jG;_oAzyNNRegcY72MN=VH9nZ&MGeB(opZ5^2uXSCLG5Z z^?1CAM3WckFi~#HL!w?&ta_;*AScQrI0#qoKVc-wsh1m) zK$liftslcec@lq#qTa0t1$aU(2>&AYiAtyRGw4ul1`m_0daaa^z|>ucqZeN z(${|p9h6g#e@DivcQ+}XzQR`h&&Wcm&(wc