├── 1409 ├── task2.3.c ├── task2.2.c ├── task2.1.c ├── task4.c ├── task3.c └── task1.c ├── 2109 ├── task4.c ├── task3.c ├── task5.2.c ├── task5.1.c ├── task6.c ├── task1.c └── task2.c ├── 2311 ├── task_1.c ├── task_2.c ├── task_3.c └── task_4.c ├── 2610 ├── task_2.c └── task_1.c ├── 2809 ├── task_3.c ├── task_4.c ├── task_5.c ├── task_2.c ├── task_1.c ├── task_6.c └── task_7.c ├── 0211 ├── task_2.c ├── task_4.c ├── task_5.c ├── task_1.c ├── task_6.c ├── task_3.c └── task_7.c ├── 0510 ├── task_8.c ├── task_9.c ├── task_10.c ├── task_1.c ├── task_2.c ├── task_5.c ├── task_3.c ├── task_6.c ├── task_4.c └── task_7.c ├── README.md ├── 0911 ├── test.c ├── task_4.c ├── task_2.c ├── task_1.c ├── task_3.c └── task_5.c ├── tittactoe ├── utils.c ├── utils.h └── tiktaktoe.c ├── 0709 ├── task5.c ├── task4.c ├── task3.c ├── task7.c ├── something.c ├── helloworld.c └── task6.c ├── CMakeLists.txt ├── kr ├── var2 │ ├── task_1.c │ ├── task_2.c │ └── task_3.c └── var1 │ ├── task_2.c │ ├── task_1.c │ └── task_3.c ├── strange └── type_1.c ├── labs ├── lab2 │ ├── string_lab.h │ ├── test.c │ └── string_lab.c ├── lab1 │ └── task_1.c └── lab3 │ ├── lab3.h │ ├── main.c │ └── lab3.c ├── 0712 └── task1.c └── .gitignore /0211/task_2.c: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /0510/task_8.c: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /0510/task_9.c: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /2311/task_1.c: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /0510/task_10.c: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # KMBO-RPO 2 | 3 | Задачи и лабараторные в МИРЭА на РПО (1 курс 1 семестр) 4 | -------------------------------------------------------------------------------- /0911/test.c: -------------------------------------------------------------------------------- 1 | // examples for 2 | // 1) strcat 3 | 4 | #include 5 | #include 6 | 7 | 8 | int main () { 9 | 10 | } -------------------------------------------------------------------------------- /tittactoe/utils.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int x = 0; 5 | if (x == 0){ 6 | int x = 1; 7 | printf("%d ", x); 8 | } 9 | printf("%d\n", x); 10 | } -------------------------------------------------------------------------------- /tittactoe/utils.h: -------------------------------------------------------------------------------- 1 | #ifndef UTILS_H 2 | #define UTILS_H 3 | 4 | #include 5 | #include 6 | 7 | int check_winner(int matrix[3][3]); 8 | 9 | int output_matrix(int matrix[3][3]); 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /0709/task5.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | float kmh; 6 | float ms; 7 | 8 | printf("Please enter km/h value: "); 9 | scanf("%f", &kmh); 10 | 11 | ms = kmh / 3.6; 12 | 13 | printf("m/s value: %f\n", ms); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /2311/task_2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int gcd(int a, int b) { 4 | if (b == 0) { 5 | return a; 6 | } 7 | return gcd(b, a % b); 8 | } 9 | 10 | int main() { 11 | int a, b; 12 | scanf("%d %d", &a, &b); 13 | printf("%d\n", gcd(a, b)); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /0709/task4.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | float celsium; 5 | float fahrenheit; 6 | 7 | printf("Please enter celsium value: "); 8 | scanf("%f", &celsium); 9 | 10 | fahrenheit = celsium * 1.8 + 32; 11 | 12 | printf("Fahrenheit value: %f\n", fahrenheit); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /0709/task3.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int x; 5 | int y; 6 | 7 | printf("Please enter first num: "); 8 | scanf("%d", &x); 9 | printf("Please enter second num: "); 10 | scanf("%d", &y); 11 | 12 | printf("x // y = %d\nx %% y = %d\n", x / y, x % y); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /2109/task4.c: -------------------------------------------------------------------------------- 1 | // enter all mul table from 1 to 10 2 | 3 | 4 | #include 5 | 6 | 7 | int main() { 8 | for (int i = 1; i <= 9; i++) { 9 | for (int j = 1; j <= 9; j++) { 10 | printf("%d * %d = %2d ", i, j, i * j); 11 | } 12 | printf("\n"); 13 | } 14 | return 0; 15 | } -------------------------------------------------------------------------------- /2109/task3.c: -------------------------------------------------------------------------------- 1 | // are given natural numbers from 35 to 87 enter number % 7 == 1 or 2 or 5 2 | 3 | 4 | #include 5 | 6 | 7 | int main() { 8 | for (int i = 35; i <= 87; i++) { 9 | if (i % 7 == 1 || i % 7 == 2 || i % 7 == 5) { 10 | printf("%d\n", i); 11 | } 12 | } 13 | return 0; 14 | } -------------------------------------------------------------------------------- /2109/task5.2.c: -------------------------------------------------------------------------------- 1 | // print factorial of n 2 | 3 | 4 | #include 5 | 6 | 7 | int main() { 8 | int n; 9 | int fact = 1; 10 | 11 | printf("Please enter n: "); 12 | scanf("%d", &n); 13 | 14 | for (int i = 1; i <= n; i++) { 15 | fact *= i; 16 | } 17 | printf("%d\n", fact); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.23) 2 | project(lab3 C) 3 | 4 | set(CMAKE_C_STANDARD 99) 5 | 6 | set(SOURCE_EXE labs/lab3/main.c) 7 | set(SOURCE_LIB labs/lab3/lab3.c) 8 | 9 | 10 | add_library(lab3 STATIC ${SOURCE_LIB}) 11 | add_executable( 12 | main ${SOURCE_EXE} 13 | ) 14 | 15 | target_link_libraries(main lab3) 16 | -------------------------------------------------------------------------------- /2809/task_3.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | int n; 6 | int count = 0; 7 | 8 | printf("Please enter n: "); 9 | scanf("%d", &n); 10 | 11 | while (n > 0) { 12 | if (n % 2 == 1) { 13 | count++; 14 | } 15 | n /= 2; 16 | } 17 | printf("%d\n", count); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /kr/var2/task_1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int number; 5 | int reversed_number = 0; 6 | printf("Enter number: "); 7 | scanf("%d", &number); 8 | while (number != 0) { 9 | reversed_number = reversed_number * 10 + number % 10; 10 | number = number / 10; 11 | } 12 | printf("Reversed number: %d", reversed_number); 13 | } -------------------------------------------------------------------------------- /0709/task7.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | int x; 6 | int y; 7 | 8 | printf("Please enter x value: "); 9 | scanf("%d", &x); 10 | printf("Please enter y value: "); 11 | scanf("%d", &y); 12 | 13 | x += y; 14 | y = x - y; 15 | x -= y; 16 | 17 | printf("x value: %d\n", x); 18 | printf("y value: %d\n", y); 19 | return 0; 20 | } -------------------------------------------------------------------------------- /kr/var1/task_2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int number; 5 | printf("Enter number: "); 6 | scanf("%d", &number); 7 | int n_counts[10] = {0}; 8 | 9 | while (number != 0) { 10 | n_counts[number % 10] += 1; 11 | number = number / 10; 12 | } 13 | for (int i = 0; i < 10; i++) { 14 | printf("%d: %d\n", i, n_counts[i]); 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /2109/task5.1.c: -------------------------------------------------------------------------------- 1 | // print n element of fibonachi 2 | 3 | #include 4 | 5 | 6 | int main() { 7 | int n; 8 | long long a = 0; 9 | long long b = 1; 10 | long long c; 11 | 12 | printf("Please enter n: "); 13 | scanf("%d", &n); 14 | 15 | for (int i = 0; i < n; i++) { 16 | c = a + b; 17 | a = b; 18 | b = c; 19 | } 20 | printf("%lld\n", a); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /2109/task6.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | int n; 6 | 7 | printf("Please enter n: "); 8 | scanf("%d", &n); 9 | 10 | for (int i = 0; i < n; ++i) { 11 | for (int j = 0; j < n - i; ++j) { 12 | printf(" "); 13 | } 14 | for (int j = 0; j < 2 * i + 1; ++j) { 15 | printf("*"); 16 | } 17 | printf("\n"); 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /2809/task_4.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | int n; 6 | 7 | printf("Please enter n: "); 8 | scanf("%d", &n); 9 | 10 | for (int i = 0; i < n; ++i) { 11 | for (int j = 0; j < n - i; ++j) { 12 | printf(" "); 13 | } 14 | for (int j = 0; j < 2 * i + 1; ++j) { 15 | printf("*"); 16 | } 17 | printf("\n"); 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /0709/something.c: -------------------------------------------------------------------------------- 1 | // swap value of to variables 2 | 3 | #include 4 | 5 | 6 | int main() { 7 | int x; 8 | int y; 9 | 10 | printf("Please enter x value: "); 11 | scanf("%d", &x); 12 | printf("Please enter y value: "); 13 | scanf(" %d", &y); 14 | 15 | x += y; 16 | y = x - y; 17 | x -= y; 18 | 19 | printf("x value: %.2i\n", x); 20 | printf("y value: %i", y); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /1409/task2.3.c: -------------------------------------------------------------------------------- 1 | // calculate square and perimert of circle by radius 2 | 3 | 4 | #include 5 | 6 | 7 | int main() { 8 | float r; 9 | float p; 10 | float s; 11 | #define PI 3.14159 12 | 13 | printf("Please enter r value: "); 14 | scanf("%f", &r); 15 | 16 | p = 2.0 * PI * r; 17 | s = PI * r * r; 18 | 19 | printf("Square: %.4f\n", s); 20 | printf("Perimeter: %.4f\n", p); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /2809/task_5.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | int m; 6 | int h; 7 | 8 | printf("Please enter m: "); 9 | scanf("%d", &m); 10 | printf("Please enter h: "); 11 | scanf("%d", &h); 12 | 13 | int angle = 30 * h - 5.5 * m; 14 | if (angle < 0) { 15 | angle = -angle; 16 | } 17 | if (angle > 180) { 18 | angle = 360 - angle; 19 | } 20 | printf("%d\n", angle); 21 | 22 | } 23 | -------------------------------------------------------------------------------- /1409/task2.2.c: -------------------------------------------------------------------------------- 1 | // calculate square and perimert of rectangle by 2 side 2 | 3 | 4 | #include 5 | 6 | 7 | int main() { 8 | float a; 9 | float b; 10 | float p; 11 | float s; 12 | 13 | printf("Please enter a value: "); 14 | scanf("%f", &a); 15 | printf("Please enter b value: "); 16 | scanf("%f", &b); 17 | 18 | p = (a + b) * 2; 19 | s = a * b; 20 | 21 | printf("Square: %.4f\n", s); 22 | printf("Perimeter: %.4f\n", p); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /2809/task_2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int is_simple(int n) { 5 | for (int i = 2; i * i <= n; ++i) { 6 | if (n % i == 0) { 7 | return 0; 8 | } 9 | } 10 | return 1; 11 | } 12 | 13 | 14 | int main() { 15 | int n; 16 | 17 | printf("Please enter n: "); 18 | scanf("%d", &n); 19 | 20 | for (int i = 2; i <= n; ++i) { 21 | if (is_simple(i)) { 22 | printf("%d ", i); 23 | } 24 | } 25 | printf("\n"); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /0211/task_4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | int main() { 6 | char str[20]; 7 | memset(str, '\0', 20); 8 | printf("Enter string: "); 9 | scanf("%s", str); 10 | int len = strlen(str); 11 | 12 | for (int i = 0; i < len; i++) { 13 | if (str[i] >= 'a' && str[i] <= 'z') { 14 | str[i] -= 32; 15 | } else if (str[i] >= 'A' && str[i] <= 'Z') { 16 | str[i] += 32; 17 | } 18 | } 19 | printf("%s", str); 20 | return 0; 21 | } -------------------------------------------------------------------------------- /0211/task_5.c: -------------------------------------------------------------------------------- 1 | // func for reverse string 2 | #include 3 | #include 4 | 5 | 6 | int reverse(char *str) { 7 | int len = strlen(str); 8 | for (int i = 0; i < len / 2; i++) { 9 | char tmp = str[i]; 10 | str[i] = str[len - i - 1]; 11 | str[len - i - 1] = tmp; 12 | } 13 | return 0; 14 | } 15 | 16 | 17 | int main() { 18 | char str[20]; 19 | memset(str, '\0', 20); 20 | printf("Enter string: "); 21 | scanf("%s", str); 22 | reverse(str); 23 | printf("%s", str); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /2109/task1.c: -------------------------------------------------------------------------------- 1 | // get 2 numbers if first > second print first else print second if equal print 0 2 | 3 | // Language: c 4 | 5 | #include 6 | 7 | 8 | int main() { 9 | int x; 10 | int y; 11 | 12 | printf("Please enter first num: "); 13 | scanf("%d", &x); 14 | printf("Please enter second num: "); 15 | scanf("%d", &y); 16 | 17 | if (x > y) { 18 | printf("Больше\n"); 19 | } else if (x < y) { 20 | printf("Меньше\n"); 21 | } else { 22 | printf("Числа равны\n"); 23 | } 24 | return 0; 25 | } -------------------------------------------------------------------------------- /strange/type_1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int *a = calloc(10, sizeof(int)); 6 | int *b = calloc(10, sizeof(int)); 7 | 8 | for (int i = 0; i < 15; ++i) { 9 | a[i] = i; 10 | } 11 | printf("a: "); 12 | for (int i = 0; i < 10; ++i) { 13 | printf("%2i ", a[i]); 14 | } 15 | printf("\n"); 16 | printf("b: "); 17 | for (int i = 0; i < 10; ++i) { 18 | printf("%2i ", b[i]); 19 | } 20 | printf("\n"); 21 | free(a); 22 | free(b); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /2809/task_1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | int dublicate = 0; 6 | int b; 7 | 8 | printf("Please enter n: "); 9 | scanf("%d", &n); 10 | 11 | 12 | for (int i = 0; i < 10; i++) { 13 | b = n 14 | while (b > 0) { 15 | if (b % 10 == i) { 16 | dublicate++; 17 | } 18 | b /= 10; 19 | } 20 | if (dublicate > 1) { 21 | printf("Yes"); 22 | return 0; 23 | } 24 | } 25 | printf("No"); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /0709/helloworld.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | int x; 6 | float y; 7 | char z; 8 | 9 | printf("Please enter int value: "); 10 | scanf("%d", &x); 11 | printf("Please enter float value: "); 12 | scanf("%f", &y); 13 | printf("Please enter char value: "); 14 | scanf(" %c", &z); 15 | 16 | printf("x - int value: %d, size: %lu\n", x, sizeof(x) * 8); 17 | printf("y - float value: %f, size: %lu\n", y, sizeof(y) * 8); 18 | printf("z - char value: %c, size: %lu\n", z, sizeof(z) * 8); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /0211/task_1.c: -------------------------------------------------------------------------------- 1 | // get name and surname and out them 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | char name[20]; 8 | char surname[20]; 9 | memset(name, '\0', 20); 10 | memset(surname, '\0', 20); 11 | 12 | 13 | printf("Enter your name: "); 14 | scanf("%s", name); 15 | printf("Enter your surname: "); 16 | scanf("%s", surname); 17 | char full_name[40]; 18 | sprintf(full_name, "%sЯ%s", name, surname); 19 | printf("Your name is %s\n", full_name); 20 | printf("%i\n", strcmp(name, surname)); 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /0211/task_6.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | int main() { 6 | char input[100]; 7 | char output[100]; 8 | memset(input, '\0', 100); 9 | memset(output, '\0', 100); 10 | printf("Enter your text: "); 11 | scanf("%s", input); 12 | char prev_letter = '\0'; 13 | int counter = 0; 14 | for (int i = 0; i < 100; ++i) { 15 | if (input[i] == prev_letter) { 16 | continue; 17 | } 18 | prev_letter = input[i]; 19 | output[counter] = input[i]; 20 | counter++; 21 | } 22 | puts(output); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /0211/task_3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char str[20]; 6 | memset(str, '\0', 20); 7 | printf("Enter string: "); 8 | scanf("%s", str); 9 | int len = strlen(str); 10 | int is_palindrome = 1; 11 | for (int i = 0; i < len / 2; i++) { 12 | if (str[i] != str[len - i - 1]) { 13 | is_palindrome = 0; 14 | break; 15 | } 16 | } 17 | if (is_palindrome) { 18 | printf("String is palindrome"); 19 | } else { 20 | printf("String is not palindrome"); 21 | } 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /0510/task_1.c: -------------------------------------------------------------------------------- 1 | // input 2 vec out sum vec and len sum vec 2 | 3 | #include 4 | #include 5 | 6 | int main() { 7 | int vec1[3]; 8 | int vec2[3]; 9 | 10 | printf("Please enter vec1: "); 11 | scanf("%d %d %d", &vec1[0], &vec1[1], &vec1[2]); 12 | printf("Please enter vec2: "); 13 | scanf("%d %d %d", &vec2[0], &vec2[1], &vec2[2]); 14 | 15 | int sum[3] = {vec1[0] + vec2[0], vec1[1] + vec2[1], vec1[2] + vec2[2]}; 16 | 17 | printf("sum = (%d, %d, %d)\n", sum[0], sum[1], sum[2]); 18 | printf("len = %f\n", sqrt(sum[0] * sum[0] + sum[1] * sum[1] + sum[2] * sum[2])); 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /0510/task_2.c: -------------------------------------------------------------------------------- 1 | // input n and input n elem 2 | 3 | #include 4 | #include 5 | 6 | int main() { 7 | int n; 8 | 9 | printf("Please enter n: "); 10 | scanf("%d", &n); 11 | int vec[n]; 12 | 13 | for (int i = 0; i < n; ++i) { 14 | printf("Please enter vec[%d]: ", i); 15 | scanf("%d", &vec[i]); 16 | } 17 | 18 | int sum = 0; 19 | int el; 20 | for (int i = 0; i < n; ++i) { 21 | printf("Please enter point[%d]: ", i + 1); 22 | scanf("%d", &el); 23 | sum += pow(el, i + 1) * vec[i]; 24 | } 25 | printf("value = %d\n", sum); 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /kr/var2/task_2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int number; 6 | printf("Enter number: "); 7 | scanf("%d", &number); 8 | // get len of number 9 | int len = 0; 10 | int tmp = number; 11 | while (tmp != 0) { 12 | tmp = tmp / 10; 13 | len += 1; 14 | } 15 | tmp = number; 16 | int digit; 17 | int sum = 0; 18 | while (tmp != 0) { 19 | digit = tmp % 10; 20 | tmp = tmp / 10; 21 | sum += pow(digit, len); 22 | } 23 | if (sum == number) { 24 | printf("Yes"); 25 | } else { 26 | printf("No"); 27 | } 28 | } -------------------------------------------------------------------------------- /labs/lab2/string_lab.h: -------------------------------------------------------------------------------- 1 | #ifndef FIRST_SEM_STRING_LAB_H 2 | #define FIRST_SEM_STRING_LAB_H 3 | 4 | char *_strremove(char *str, const char ch); // + 5 | 6 | int _strcountchar(const char *str, const char ch); // + 7 | 8 | char *_strdelspaces(char *str); // + 9 | 10 | char *_strtolower(char *str); // + 11 | 12 | char *_strtoupper(char *str); // + 13 | 14 | int _strcmp(const char *str1, const char *str2); 15 | 16 | char *_strreverse(const char *str1); // + 17 | 18 | int _atoi(const char *str); // + 19 | 20 | char *_strchr(char *str, int ch); // + 21 | 22 | char *_strstr(const char *str, const char *substr); // + 23 | 24 | #endif //FIRST_SEM_STRING_LAB_H 25 | -------------------------------------------------------------------------------- /2809/task_6.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | int n, a, b, c; 8 | int guess = 0; 9 | int number = 0; 10 | 11 | srand(time(NULL)); 12 | number = rand() % 100 + 1; 13 | 14 | printf("Введите число: "); 15 | scanf("%d", &n); 16 | 17 | while (guess != number) { 18 | printf("Введите число: "); 19 | scanf("%d", &guess); 20 | if (guess > number) { 21 | printf("Слишком много\n"); 22 | } else if (guess < number) { 23 | printf("Слишком мало\n"); 24 | } 25 | } 26 | printf("Вы угадали число"); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /1409/task2.1.c: -------------------------------------------------------------------------------- 1 | // calculate square and perimert of triangle by 3 side 2 | 3 | 4 | #include 5 | #include 6 | 7 | 8 | int main() { 9 | float a; 10 | float b; 11 | float c; 12 | float p; 13 | float s; 14 | 15 | printf("Please enter a value: "); 16 | scanf("%f", &a); 17 | printf("Please enter b value: "); 18 | scanf("%f", &b); 19 | printf("Please enter c value: "); 20 | scanf("%f", &c); 21 | 22 | p = (a + b + c); 23 | s = (p / 2) * ((p / 2) - a) * ((p / 2) - b) * ((p / 2) - c); 24 | s = sqrt(s); 25 | 26 | printf("Square: %.4f\n", s); 27 | printf("Perimeter: %.4f\n", p); 28 | return 0; 29 | } -------------------------------------------------------------------------------- /1409/task4.c: -------------------------------------------------------------------------------- 1 | // calculate m = (n * p * (1 + p)^y) / (12 * ((1 + p)^y – 1)), 2 | 3 | #include 4 | #include 5 | 6 | 7 | int main() { 8 | float n; 9 | float p; 10 | float y; 11 | float m; 12 | float s; 13 | 14 | printf("Please enter n value: "); 15 | scanf("%f", &n); 16 | printf("Please enter p value: "); 17 | scanf("%f", &p); 18 | printf("Please enter y value: "); 19 | scanf("%f", &y); 20 | 21 | m = (n * p * pow((1 + p), y)) / (12 * (pow((1 + p), y) - 1)); 22 | s = m * 12 * y; 23 | 24 | printf("Mth payment value: %010.2f\n", m); 25 | printf("All payment value: %010.2f\n", s); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /0911/task_4.c: -------------------------------------------------------------------------------- 1 | // input string delete from string all not letter symbol 2 | #include 3 | #include 4 | #include 5 | 6 | int main() { 7 | char *str = NULL; 8 | char *output = NULL; 9 | size_t size; 10 | printf("Enter your text: "); 11 | getline(&str, &size, stdin); 12 | int len = strlen(str); 13 | output = (char *) malloc(len * sizeof(char)); 14 | memset(output, '\0', len); 15 | int j = 0; 16 | for (int i = 0; i < strlen(str); i++) { 17 | if ((str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) { 18 | output[j] = str[i]; 19 | j++; 20 | } 21 | } 22 | puts(output); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /0911/task_2.c: -------------------------------------------------------------------------------- 1 | // check string1 == string2 without using strcmp 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | char str1[100]; 8 | char str2[100]; 9 | printf("Enter string1: "); 10 | scanf("%s", str1); 11 | printf("Enter string2: "); 12 | scanf("%s", str2); 13 | int len1 = strlen(str1); 14 | int len2 = strlen(str2); 15 | if (len1 != len2) { 16 | printf("Strings are not equal"); 17 | return 0; 18 | } 19 | for (int i = 0; i < len1; i++) { 20 | if (str1[i] != str2[i]) { 21 | printf("Strings are not equal"); 22 | return 0; 23 | } 24 | } 25 | printf("Strings are equal"); 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /1409/task3.c: -------------------------------------------------------------------------------- 1 | // get number and calculate prod and sum of digits 2 | 3 | #include 4 | 5 | 6 | int main() { 7 | int n; 8 | int sum; 9 | int prod; 10 | int wide; 11 | 12 | printf("Please enter n value: "); 13 | scanf("%d", &n); 14 | 15 | printf("Please enter wide value: "); 16 | scanf("%d", &wide); 17 | 18 | printf("Number in hex format: %*x = %*X\n", wide, n, wide, n); 19 | printf("Number in oct format: %*o = %*O\n", wide, n, wide, n); 20 | 21 | sum = n % 10 + n / 10 % 10 + n / 100 % 10; 22 | prod = (n % 10) * (n / 10 % 10) * (n / 100 % 10); 23 | 24 | printf("Sum of digits: %*d\n", wide, sum); 25 | printf("Product of digits: %*d\n", wide, prod); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /2610/task_2.c: -------------------------------------------------------------------------------- 1 | // input n, create mass n x n, with random numbers from 0 to 100 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | int main() { 9 | int n; 10 | printf("Enter n: "); 11 | scanf("%d", &n); 12 | int matrix[n][n]; 13 | srand(time(NULL)); 14 | for (int i = 0; i < n; ++i) { 15 | for (int j = 0; j < n; ++j) { 16 | matrix[i][j] = rand() % 100; 17 | } 18 | } 19 | printf("Matrix:\n"); 20 | int* pointer = &matrix[0][0]; 21 | for (int i = 0; i < n; ++i) { 22 | for (int j = 0; j < n; ++j) { 23 | printf("%2d ", *pointer); 24 | pointer++; 25 | } 26 | printf("\n"); 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /0911/task_1.c: -------------------------------------------------------------------------------- 1 | // input string unknown length, output sorted string 2 | 3 | #include 4 | #include 5 | 6 | 7 | void sort(char *str, int len) { 8 | len--; 9 | char temp; 10 | for (int i = 0; i < len; i++) { 11 | for (int j = 0; j < len; j++) { 12 | if (str[i] < str[j]) { 13 | temp = str[i]; 14 | str[i] = str[j]; 15 | str[j] = temp; 16 | } 17 | } 18 | } 19 | } 20 | 21 | int main() { 22 | char *str; 23 | size_t size; 24 | 25 | printf("Enter string: "); 26 | getline(&str, &size, stdin); 27 | 28 | int len = strlen(str); 29 | sort(str, len); 30 | 31 | puts(str); 32 | return 0; 33 | } 34 | 35 | 36 | -------------------------------------------------------------------------------- /1409/task1.c: -------------------------------------------------------------------------------- 1 | // get two points and calculate equation 2 | 3 | 4 | #include 5 | 6 | 7 | int main() { 8 | float x1; 9 | float y1; 10 | float x2; 11 | float y2; 12 | float k; 13 | float b; 14 | 15 | printf("Please enter x1 value: "); 16 | scanf("%f", &x1); 17 | printf("Please enter y1 value: "); 18 | scanf("%f", &y1); 19 | printf("Please enter x2 value: "); 20 | scanf("%f", &x2); 21 | printf("Please enter y2 value: "); 22 | scanf("%f", &y2); 23 | 24 | k = (y2 - y1) / (x2 - x1); 25 | b = y1 - k * x1; 26 | 27 | printf("First point - (%.2f, %.2f)\n", x1, y1); 28 | printf("Second point - (%.2f, %.2f)\n", x2, y2); 29 | printf("Equation: %.2fx + %.2f = y\n", k, b); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /0712/task1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | void filePrint(FILE *file) { 7 | char *str = (char *) malloc(1 * sizeof(char)); 8 | while (!feof(file)) { 9 | fscanf(file, "%s", str); 10 | printf("%s ", str); 11 | } 12 | free(str); 13 | } 14 | 15 | void fileAppend(FILE *file, char *str) { 16 | fseek(file, 0, SEEK_END); 17 | fprintf(file, "%s", str); 18 | } 19 | 20 | void fileSearch(FILE *file, char *str) { 21 | // find str in line and print this line with UPPER CASE of str 22 | char *line = (char *) malloc(1 * sizeof(char)); 23 | while (!feof(file)) { 24 | fscanf(file, "%s", line); 25 | if (strstr(line, str) != NULL) { 26 | printf("%s ", line); 27 | } 28 | } 29 | } -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ### C++ template 2 | # Prerequisites 3 | *.d 4 | 5 | # Compiled Object files 6 | *.slo 7 | *.lo 8 | *.o 9 | *.obj 10 | 11 | # Precompiled Headers 12 | *.gch 13 | *.pch 14 | 15 | # Compiled Dynamic libraries 16 | *.so 17 | *.dylib 18 | *.dll 19 | 20 | # Fortran module files 21 | *.mod 22 | *.smod 23 | 24 | # Compiled Static libraries 25 | *.lai 26 | *.la 27 | *.a 28 | *.lib 29 | 30 | # Executables 31 | *.exe 32 | *.out 33 | *.app 34 | 35 | ### C template 36 | 37 | 38 | 39 | *.ko 40 | *.elf 41 | 42 | # Linker output 43 | *.ilk 44 | *.map 45 | *.exp 46 | 47 | *.so.* 48 | 49 | *.i*86 50 | *.x86_64 51 | *.hex 52 | 53 | # Debug files 54 | *.dSYM/ 55 | *.su 56 | *.idb 57 | *.pdb 58 | 59 | # Kernel Module Compile Results 60 | *.mod* 61 | *.cmd 62 | .tmp_versions/ 63 | modules.order 64 | Module.symvers 65 | Mkfile.old 66 | dkms.conf 67 | 68 | -------------------------------------------------------------------------------- /0709/task6.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int hour_1; 5 | int minute_1; 6 | int second_1; 7 | int hour_2; 8 | int minute_2; 9 | int second_2; 10 | 11 | printf("Hours of first day: "); 12 | scanf("%d", &hour_1); 13 | printf("Minutes of first day: "); 14 | scanf("%d", &minute_1); 15 | printf("Seconds of first day: "); 16 | scanf("%d", &second_1); 17 | printf("Hours of second day: "); 18 | scanf("%d", &hour_2); 19 | printf("Minutes of second day: "); 20 | scanf("%d", &minute_2); 21 | printf("Seconds of second day: "); 22 | scanf("%d", &second_2); 23 | 24 | int total_seconds_1 = hour_1 * 3600 + minute_1 * 60 + second_1; 25 | int total_seconds_2 = hour_2 * 3600 + minute_2 * 60 + second_2; 26 | 27 | printf("Answer: %d\n", total_seconds_2 - total_seconds_1); 28 | return 0; 29 | } -------------------------------------------------------------------------------- /kr/var1/task_1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | int number; 6 | int check_sum = 0; 7 | int first_div; 8 | int second_div; 9 | printf("Enter number: "); 10 | scanf("%d", &number); 11 | 12 | for (int i = 1; i * i <= number; i++) { 13 | if (number % i == 0) { 14 | first_div = i; 15 | second_div = number / i; 16 | if (first_div != second_div && first_div != 1) { 17 | printf("%d %d ", first_div, second_div); 18 | check_sum += first_div + second_div; 19 | } else { 20 | printf("%d ", first_div); 21 | check_sum += first_div; 22 | } 23 | } 24 | } 25 | printf("\n"); 26 | if (check_sum == number) { 27 | printf("Yes"); 28 | } else { 29 | printf("No"); 30 | } 31 | return 0; 32 | } -------------------------------------------------------------------------------- /0510/task_5.c: -------------------------------------------------------------------------------- 1 | // input n, a, gen mas len n 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | float get_float_number(int min, int max) { 8 | float number; 9 | int number_int = rand() % (max - min + 1) + min; 10 | number = (float) number_int; 11 | return number; 12 | } 13 | 14 | int main() { 15 | int n; 16 | int a; 17 | 18 | printf("Please enter n: "); 19 | scanf("%d", &n); 20 | printf("Please enter a: "); 21 | scanf("%d", &a); 22 | 23 | int vec[n]; 24 | srand(time(NULL)); 25 | for (int i = 0; i < n; ++i) { 26 | vec[i] = get_float_number(-a, a); 27 | printf("%d ", vec[i]); 28 | } 29 | printf("\n") 30 | 31 | int sign_changes = 0; 32 | for (int i = 0; i < n - 1; ++i) { 33 | if (vec[i] * vec[i + 1] < 0) { 34 | ++sign_changes; 35 | } 36 | } 37 | printf("%d\n", sign_changes); 38 | } -------------------------------------------------------------------------------- /0911/task_3.c: -------------------------------------------------------------------------------- 1 | // check count substring in string 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | char *str = NULL; 8 | char *substr = NULL; 9 | size_t size; 10 | printf("Enter string: "); 11 | getline(&str, &size, stdin); 12 | printf("Enter substring: "); 13 | getline(&substr, &size, stdin); 14 | 15 | int len_str = strlen(str); 16 | int len_substr = strlen(substr); 17 | len_str--; 18 | len_substr--; 19 | int count = 0; 20 | 21 | for (int i = 0; i < (len_str - len_substr); i++) { 22 | int is_substr = 1; 23 | for (int j = 0; j < len_substr; j++) { 24 | if (str[i + j] != substr[j]) { 25 | is_substr = 0; 26 | break; 27 | } 28 | } 29 | if (is_substr) { 30 | count++; 31 | } 32 | } 33 | printf("Count: %d", count); 34 | return 0; 35 | } -------------------------------------------------------------------------------- /0211/task_7.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char alphabet[26 * 2] = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; 6 | char Alphabet[26 * 2] = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"; 7 | char input[100]; 8 | char output[100]; 9 | memset(input, '\0', 100); 10 | memset(output, '\0', 100); 11 | printf("Enter your text: "); 12 | scanf("%s", input); 13 | int shift; 14 | printf("Enter shift: "); 15 | scanf("%i", &shift); 16 | shift %= 26; 17 | for (int i = 0; i < strlen(input); i++) { 18 | for (int j = 0; j < 26; j++) { 19 | if (input[i] == alphabet[j]) { 20 | output[i] = alphabet[j + shift]; 21 | break; 22 | } 23 | if (input[i] == Alphabet[j]) { 24 | output[i] = Alphabet[j + shift]; 25 | break; 26 | } 27 | } 28 | } 29 | puts(output); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /0510/task_3.c: -------------------------------------------------------------------------------- 1 | // input n and input n elem 2 | 3 | #include 4 | #include 5 | 6 | 7 | int main() { 8 | int n; 9 | 10 | printf("Please enter n: "); 11 | scanf("%d", &n); 12 | int vec[n]; 13 | 14 | for (int i = 0; i < n; ++i) { 15 | printf("Please enter vec[%d]: ", i); 16 | scanf("%d", &vec[i]); 17 | } 18 | 19 | int* output = calloc(n, sizeof(int)); 20 | int len = 0; 21 | int checker = 0; 22 | for (int i = 0; i < n; ++i) { 23 | for (int j = 0; j < len; ++j) { 24 | if (vec[i] == output[j]) { 25 | checker = 1; 26 | break; 27 | } 28 | } 29 | if (checker == 0) { 30 | output[len] = vec[i]; 31 | ++len; 32 | } 33 | checker = 0; 34 | } 35 | 36 | output = realloc(output, len * sizeof(int)); 37 | 38 | for (int i = 0; i < len; ++i) { 39 | printf("%d ", output[i]); 40 | } 41 | 42 | printf("\n"); 43 | free(output); 44 | 45 | return 0; 46 | } -------------------------------------------------------------------------------- /0510/task_6.c: -------------------------------------------------------------------------------- 1 | // input matrix 3x3 and output transposed matrix and determinant 2 | 3 | #include 4 | #include 5 | 6 | 7 | int main() { 8 | int matrix[3][3]; 9 | 10 | printf("Please enter matrix:\n"); 11 | for (int i = 0; i < 3; ++i) { 12 | for (int j = 0; j < 3; ++j) { 13 | printf("Please enter matrix[%d][%d]: ", i, j); 14 | scanf("%d", &matrix[i][j]); 15 | } 16 | } 17 | 18 | int det; 19 | det = matrix[0][0] * matrix[1][1] * matrix[2][2] 20 | + matrix[0][1] * matrix[1][2] * matrix[2][0] 21 | + matrix[0][2] * matrix[1][0] * matrix[2][1] 22 | - matrix[0][2] * matrix[1][1] * matrix[2][0] 23 | - matrix[0][1] * matrix[1][0] * matrix[2][2] 24 | - matrix[0][0] * matrix[1][2] * matrix[2][1]; 25 | 26 | printf("det = %d\n", det); 27 | 28 | for (int i = 0; i < 3; ++i) { 29 | for (int j = i + 1; j < 3; ++j) { 30 | int temp = matrix[i][j]; 31 | matrix[i][j] = matrix[j][i]; 32 | matrix[j][i] = temp; 33 | } 34 | } 35 | } -------------------------------------------------------------------------------- /kr/var2/task_3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | int n; 8 | int a; 9 | int b; 10 | printf("Введите количество элементов массива, нижнюю и верхнюю границы рандома через пробел\n"); 11 | scanf("%i %i %i", &n, &a, &b); 12 | int mass[n]; 13 | srand(time(NULL)); 14 | for (int i = 0; i < n; ++i) { 15 | mass[i] = rand() % (b - a + 1) + a; 16 | } 17 | for (int i = 0; i < n; ++i) { 18 | printf("%i ", mass[i]); 19 | } 20 | printf("\n"); 21 | int unique[n]; 22 | int i_unique = 0; 23 | int is_unique; 24 | for (int i = 0; i < n; ++i) { 25 | is_unique = 1; 26 | for (int j = 0; j < n; ++j) { 27 | if (mass[i] == mass[j] && i != j) { 28 | is_unique = 0; 29 | break; 30 | } 31 | } 32 | if (is_unique) { 33 | unique[i_unique] = mass[i]; 34 | i_unique++; 35 | } 36 | } 37 | for (int i = 0; i < i_unique; ++i) { 38 | printf("%i ", unique[i]); 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /2311/task_3.c: -------------------------------------------------------------------------------- 1 | // bin_search 2 | 3 | #include 4 | 5 | int bin_search(int *arr, int size, int value, int left, int right) { 6 | if (left > right) { 7 | return -1; 8 | } 9 | int mid = (left + right) / 2; 10 | if (arr[mid] == value) { 11 | return mid; 12 | } else if (arr[mid] > value) { 13 | return bin_search(arr, size, value, left, mid - 1); 14 | } else { 15 | return bin_search(arr, size, value, mid + 1, right); 16 | } 17 | } 18 | 19 | int sort(int *arr, int size) { 20 | for (int i = 0; i < size; i++) { 21 | for (int j = 0; j < size - i - 1; j++) { 22 | if (arr[j] > arr[j + 1]) { 23 | int tmp = arr[j]; 24 | arr[j] = arr[j + 1]; 25 | arr[j + 1] = tmp; 26 | } 27 | } 28 | } 29 | return 0; 30 | } 31 | 32 | int main() { 33 | int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 34 | sort(arr, 9); 35 | int size = sizeof(arr) / sizeof(arr[0]); 36 | int value; 37 | scanf("%d", &value); 38 | printf("%d\n", bin_search(arr, size, value, 0, size - 1)); 39 | return 0; 40 | } -------------------------------------------------------------------------------- /kr/var1/task_3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | int n; 8 | printf("Enter n: "); 9 | scanf("%d", &n); 10 | // generate matrix 11 | int matrix[n][n]; 12 | srand(time(NULL)); 13 | for (int i = 0; i < n; ++i) { 14 | for (int j = 0; j < n; ++j) { 15 | matrix[i][j] = rand() % 100; 16 | } 17 | } 18 | // out matrix 19 | printf("Matrix:\n"); 20 | for (int i = 0; i < n; ++i) { 21 | for (int j = 0; j < n; ++j) { 22 | printf("%2d ", matrix[i][j]); 23 | } 24 | printf("\n"); 25 | } 26 | // transpose matrix 27 | int tmp; 28 | for (int i = 0; i < n; ++i) { 29 | for (int j = i; j < n; ++j) { 30 | tmp = matrix[i][j]; 31 | matrix[i][j] = matrix[j][i]; 32 | matrix[j][i] = tmp; 33 | } 34 | } 35 | // out transposed matrix 36 | printf("Transposed matrix:\n"); 37 | for (int i = 0; i < n; ++i) { 38 | for (int j = 0; j < n; ++j) { 39 | printf("%2d ", matrix[i][j]); 40 | } 41 | printf("\n"); 42 | } 43 | return 0; 44 | } -------------------------------------------------------------------------------- /0510/task_4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | float get_float_number(int min, int max) { 6 | float number; 7 | int number_int = rand() % (max - min + 1) + min; 8 | number = (float) number_int; 9 | return number; 10 | } 11 | 12 | int main() { 13 | // input n, a, b gen mass len(n) elem get_float_number(a, b) 14 | int n; 15 | int a; 16 | int b; 17 | 18 | printf("Please enter n: "); 19 | scanf("%d", &n); 20 | printf("Please enter a: "); 21 | scanf("%d", &a); 22 | printf("Please enter b: "); 23 | scanf("%d", &b); 24 | 25 | int elem; 26 | int vec[n]; 27 | int len; 28 | for (int i = 0; i < n; ++i) { 29 | srand(time(NULL)); 30 | elem = get_float_number(a, b); 31 | int checker = 0; 32 | for (int j = 0; j < len; ++j) { 33 | if (elem == vec[j]) { 34 | checker = 1; 35 | break; 36 | } 37 | } 38 | if (checker == 0) { 39 | vec[len] = elem; 40 | printf("%d ", vec[len]); 41 | ++len 42 | } 43 | checker = 0; 44 | } 45 | printf("\n"); 46 | } -------------------------------------------------------------------------------- /2311/task_4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int check(char *str) { 5 | int *stack = (int *) malloc(sizeof(int) * 3); 6 | int cur_i = 1; 7 | for (int i = 0; str[i] != '\0'; i++) { 8 | if (str[i] == '(' || str[i] == '[' || str[i] == '{') { 9 | if (str[i] == '(') { 10 | stack[i] = 1; 11 | } else if (str[i] == '[') { 12 | stack[i] = 2; 13 | } else { 14 | stack[i] = 3; 15 | } 16 | int *tmp = (int *) realloc(stack, sizeof(int) * (cur_i + 1)); 17 | if (tmp == NULL) { 18 | return 0; 19 | } 20 | stack = tmp; 21 | cur_i++; 22 | } else if (str[i] == ')' || str[i] == ']' || str[i] == '}') { 23 | if (str[i] == ')') { 24 | if (stack[cur_i - 1] != 1) { 25 | return 0; 26 | } 27 | } else if (str[i] == ']') { 28 | if (stack[cur_i - 1] != 2) { 29 | return 0; 30 | } 31 | } else { 32 | if (stack[cur_i - 1] != 3) { 33 | return 0; 34 | } 35 | } 36 | cur_i--; 37 | } 38 | } 39 | return 1; 40 | } 41 | 42 | 43 | int main() { 44 | char str[100]; 45 | scanf("%s", str); 46 | printf("%d\n", check(str)); 47 | return 0; 48 | } -------------------------------------------------------------------------------- /2809/task_7.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | 7 | float get_float_number(int min, int max, int accuracy) { 8 | float number; 9 | accuracy = pow(10, accuracy) 10 | int min_int = min * accuracy; 11 | int max_int = max * accuracy; 12 | int number_int = rand() % (max_int - min_int + 1) + min_int; 13 | number = (float) number_int / accuracy; 14 | return number; 15 | } 16 | 17 | 18 | int main() { 19 | int n; 20 | int m; 21 | int a; 22 | int b; 23 | 24 | 25 | printf("Please enter n: "); 26 | scanf("%d", &n); 27 | printf("Please enter m: "); 28 | scanf("%d", &m); 29 | printf("Please enter a: "); 30 | scanf("%d", &a); 31 | printf("Please enter b: "); 32 | scanf("%d", &b); 33 | 34 | float max_number = a; 35 | float min_number = b; 36 | float sum_number = 0.0; 37 | float number; 38 | 39 | srand(time(NULL)); 40 | for (int i = 0; i < n; ++i) { 41 | number = get_float_number(a, b, m); 42 | printf("%f\n", number); 43 | if (number > max_number) { 44 | max_number = number; 45 | } 46 | if (number < min_number) { 47 | min_number = number; 48 | } 49 | sum_number += number; 50 | } 51 | printf("\n"); 52 | printf("Max number: %f\n", max_number); 53 | printf("Min number: %f\n", min_number); 54 | printf("Avg number: %f\n", sum_number / n); 55 | } -------------------------------------------------------------------------------- /2109/task2.c: -------------------------------------------------------------------------------- 1 | // get 2 numbers and operator and print result 2 | 3 | #include 4 | 5 | 6 | int main() { 7 | int x; 8 | int y; 9 | char op; 10 | 11 | // if (op == '+') { 12 | // printf("%d + %d = %d", x, y, x + y); 13 | // } else if (op == '-') { 14 | // printf("%d - %d = %d", x, y, x - y); 15 | // } else if (op == '*') { 16 | // printf("%d * %d = %d", x, y, x * y); 17 | // } else if (op == '/') { 18 | // if (y == 0) { 19 | // printf("Division by zero"); 20 | // } else { 21 | // printf("%d / %d = %d", x, y, x / y); 22 | // } 23 | // } else if (op == '%') { 24 | // printf("%d %% %d = %d", x, y, x % y); 25 | // } else { 26 | // printf("Unknown operator"); 27 | // } 28 | 29 | while (1) { 30 | printf("Please enter first num: "); 31 | scanf("%d", &x); 32 | printf("Please enter second num: "); 33 | scanf("%d", &y); 34 | printf("Please enter operator: "); 35 | scanf(" %c", &op); 36 | switch (op) { 37 | case '+': 38 | printf("%d + %d = %d", x, y, x + y); 39 | break; 40 | case '-': 41 | printf("%d - %d = %d", x, y, x - y); 42 | break; 43 | case '*': 44 | printf("%d * %d = %d", x, y, x * y); 45 | break; 46 | case '/': 47 | if (y == 0) { 48 | printf("Division by zero"); 49 | } else { 50 | printf("%d / %d = %d", x, y, x / y); 51 | } 52 | break; 53 | case '%': 54 | printf("%d %% %d = %d", x, y, x % y); 55 | break; 56 | case '0': 57 | return 0; 58 | default: 59 | printf("Unknown operator"); 60 | break; 61 | } 62 | printf("\n"); 63 | } 64 | return 0; 65 | } -------------------------------------------------------------------------------- /0911/task_5.c: -------------------------------------------------------------------------------- 1 | // input line output max and min (by length) word 2 | // string input by getline 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | int main() { 9 | char *str = NULL; 10 | size_t size; 11 | printf("Enter your text: "); 12 | getline(&str, &size, stdin); 13 | int len = strlen(str); 14 | char *max = NULL; 15 | char *min = NULL; 16 | char *tmp = NULL; 17 | tmp = (char *) malloc(len * sizeof(char)); 18 | max = (char *) malloc(len * sizeof(char)); 19 | min = (char *) malloc(len * sizeof(char)); 20 | memset(max, '\0', len); 21 | memset(min, '\0', len); 22 | memset(tmp, '\0', len); 23 | int j = 0; 24 | int k = 0; 25 | int max_len = 0; 26 | int min_len = 10000; 27 | for (int i = 0; i < len - 1; i++) { 28 | if (str[i] != ' ') { 29 | tmp[j] = str[i]; 30 | j++; 31 | } else { 32 | if (j > max_len) { 33 | max_len = j; 34 | memset(max, '\0', len); 35 | k = 0; 36 | while (tmp[k] != '\0') { 37 | max[k] = tmp[k]; 38 | k++; 39 | } 40 | } 41 | if (j < min_len) { 42 | min_len = j; 43 | memset(min, '\0', len); 44 | k = 0; 45 | while (tmp[k] != '\0') { 46 | min[k] = tmp[k]; 47 | k++; 48 | } 49 | } 50 | j = 0; 51 | memset(tmp, '\0', len); 52 | } 53 | } 54 | if (j > max_len) { 55 | memset(max, '\0', len); 56 | k = 0; 57 | while (tmp[k] != '\0') { 58 | max[k] = tmp[k]; 59 | k++; 60 | } 61 | } 62 | if (j < min_len) { 63 | memset(min, '\0', len); 64 | k = 0; 65 | while (tmp[k] != '\0') { 66 | min[k] = tmp[k]; 67 | k++; 68 | } 69 | } 70 | printf("Max: %s\n", max); 71 | printf("Min: %s", min); 72 | return 0; 73 | } -------------------------------------------------------------------------------- /labs/lab2/test.c: -------------------------------------------------------------------------------- 1 | #include "string_lab.h" 2 | #include 3 | #include 4 | 5 | 6 | int main() { 7 | char str1[100] = "123"; 8 | char str123[100] = " -432c"; 9 | printf("str1: %s\n", str1); 10 | printf("int1: %d\n", _atoi(str1)); 11 | printf("str123: %s\n", str123); 12 | printf("int123: %d\n", _atoi(str123)); 13 | // printf("str1_reverse: %s\n", _strreverse(str1)); 14 | // 15 | // char str2[100] = "abc"; 16 | // printf("str2: %s\n", str2); 17 | // printf("str2_upper: %s\n", _strtoupper(str2)); 18 | // 19 | // char str3[100] = "ABC"; 20 | // printf("str3: %s\n", str3); 21 | // printf("str3_lower: %s\n", _strtolower(str3)); 22 | // 23 | // char str4[100] = "Hello, world!"; 24 | // printf("str4: %s\n", str4); 25 | // printf("str4_remove: %s\n", _strremove(str4, 'l')); 26 | // 27 | // char str5[100] = "Hello, world!"; 28 | // printf("str5: %s\n", str5); 29 | // printf("str5_count: %d\n", _strcountchar(str5, 'l')); 30 | // 31 | // char str6[100] = "Hello, world!"; 32 | // printf("str6: %s\n", str6); 33 | // printf("str6_delspaces: %s\n", _strdelspaces(str6)); 34 | // 35 | // char str7[100] = "Hello, world!"; 36 | // char str8[100] = "Hello, world!"; 37 | // char str9[100] = "Hello, world?"; 38 | // char str12[100] = "Hello, world"; 39 | // char str13[100] = "Hello, world "; 40 | // printf("str7: %s\n", str7); 41 | // printf("str8: %s\n", str8); 42 | // printf("str7 == str8: %d\n", _strcmp(str7, str8)); 43 | // printf("str7 == str9: %d\n", _strcmp(str7, str9)); 44 | // printf("str7 == str12: %d\n", _strcmp(str7, str12)); 45 | // printf("str12 == str13: %d\n", _strcmp(str12, str13)); 46 | // 47 | // char str10[100] = "Hello, world!"; 48 | // printf("str10: %s\n", str10); 49 | // printf("str10_chr: %s\n", _strchr(str10, 'w')); 50 | // 51 | // char str11[100] = "this is a test"; 52 | // printf("str11: %s\n", str11); 53 | // printf("str11_strstr: %s\n", _strstr(str11, "is")); 54 | // 55 | // char str14[100] = "hello"; 56 | // char str15[100] = "olleh"; 57 | // printf("str14: %s\n", _strreverse(str14)); 58 | // char *res = _strreverse(str14); 59 | // printf("str15: %d\n", strcmp(res, str15)); 60 | 61 | return 0; 62 | } -------------------------------------------------------------------------------- /labs/lab1/task_1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | int get_rand_number(int min, int max) { 7 | int number_int = rand() % (max - min + 1) + min; 8 | return number_int; 9 | } 10 | 11 | void quick_sort(int *vec, int left, int right) { 12 | int i = left; 13 | int j = right; 14 | int pivot = vec[(left + right) / 2]; 15 | int temp; 16 | while (i <= j) { 17 | while (vec[i] < pivot) { 18 | ++i; 19 | } 20 | while (vec[j] > pivot) { 21 | --j; 22 | } 23 | if (i <= j) { 24 | temp = vec[i]; 25 | vec[i] = vec[j]; 26 | vec[j] = temp; 27 | ++i; 28 | --j; 29 | } 30 | } 31 | if (left < j) { 32 | quick_sort(vec, left, j); 33 | } 34 | if (i < right) { 35 | quick_sort(vec, i, right); 36 | } 37 | } 38 | 39 | int get_fashion(int *vec, int len) { 40 | int fashion = vec[0]; 41 | int fashion_count = 1; 42 | int current = vec[0]; 43 | int current_count = 1; 44 | for (int i = 1; i < len; ++i) { 45 | if (vec[i] == current) { 46 | ++current_count; 47 | } else { 48 | if (current_count > fashion_count) { 49 | fashion = current; 50 | fashion_count = current_count; 51 | } 52 | current = vec[i]; 53 | current_count = 1; 54 | } 55 | } 56 | if (current_count > fashion_count) { 57 | fashion = current; 58 | } 59 | return fashion; 60 | } 61 | 62 | 63 | int main() { 64 | int a; 65 | int b; 66 | 67 | printf("Please enter a: "); 68 | scanf("%d", &a); 69 | printf("Please enter b: "); 70 | scanf("%d", &b); 71 | 72 | int mass[100]; 73 | int sum = 0; 74 | int elem; 75 | 76 | srand(time(NULL)); 77 | for (int i = 0; i < 100; ++i) { 78 | elem = get_rand_number(a, b); 79 | mass[i] = elem; 80 | sum += elem; 81 | } 82 | 83 | quick_sort(mass, 0, 99); 84 | for (int i = 0; i < 10; ++i) { 85 | for (int j = 0; j < 10; ++j) { 86 | printf("%5d ", mass[i * 10 + j]); 87 | } 88 | printf("\n"); 89 | } 90 | printf("\n"); 91 | 92 | int min = mass[0]; 93 | int max = mass[99]; 94 | int scope = max - min; 95 | int fashion = get_fashion(mass, 100); 96 | float median = ((float) mass[49] + (float) mass[50]) / 2; 97 | float average = (float) sum / 100; 98 | 99 | printf("Min: %d\n", min); 100 | printf("Max: %d\n", max); 101 | printf("Scope: %d\n", scope); 102 | printf("Median: %.2f\n", median); 103 | printf("Average: %.2f\n", average); 104 | printf("Fashion: %d\n", fashion); 105 | return 0; 106 | } 107 | -------------------------------------------------------------------------------- /2610/task_1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | typedef struct array { 6 | int *mass; 7 | int size; 8 | int capacity; 9 | } array; 10 | 11 | void init(array *arr, int size) { 12 | arr->mass = malloc(size * sizeof(int)); 13 | arr->size = size; 14 | arr->capacity = 1; 15 | } 16 | 17 | void print(array *arr) { 18 | for (int i = 0; i < arr->size; ++i) { 19 | printf("%i ", arr->mass[i]); 20 | } 21 | printf("\n"); 22 | } 23 | 24 | void print_size(array *arr) { 25 | printf("%i\n", arr->size); 26 | } 27 | 28 | void add(array *arr, int value) { 29 | if (arr->size == arr->capacity) { 30 | printf("Размер массива изменился\n"); 31 | arr->capacity *= 2; 32 | arr->mass = realloc(arr->mass, arr->capacity * sizeof(int)); 33 | } 34 | arr->mass[arr->size] = value; 35 | arr->size++; 36 | } 37 | 38 | void delete(array *arr, int index) { 39 | arr->size--; 40 | for (int i = index; i < arr->size; ++i) { 41 | arr->mass[i] = arr->mass[i + 1]; 42 | } 43 | } 44 | 45 | void delete_last(array *arr) { 46 | arr->size--; 47 | } 48 | 49 | 50 | int find(array *arr, int value) { 51 | for (int i = 0; i < arr->size; ++i) { 52 | if (arr->mass[i] == value) { 53 | return i; 54 | } 55 | } 56 | return -1; 57 | } 58 | 59 | enum { 60 | INIT, 61 | PRINT, 62 | PRINT_SIZE, 63 | ADD, 64 | DELETE, 65 | DELETE_LAST, 66 | FIND, 67 | EXIT 68 | }; 69 | 70 | int main() { 71 | array arr; 72 | printf("Команды:\n"); 73 | printf("1 - вывести массив\n"); 74 | printf("2 - вывести размер массива\n"); 75 | printf("3 - добавить элемент в массив\n"); 76 | printf("4 - удалить элемент из массива\n"); 77 | printf("5 - удалить последний элемент массива\n"); 78 | printf("6 - найти элемент в массиве\n"); 79 | printf("7 - выйти\n"); 80 | int user_out = INIT; 81 | while (1) { 82 | if (user_out == INIT) { 83 | init(&arr, 0); 84 | } 85 | if (user_out == PRINT) { 86 | print(&arr); 87 | } 88 | if (user_out == PRINT_SIZE) { 89 | print_size(&arr); 90 | } 91 | if (user_out == ADD) { 92 | int value; 93 | printf("Введите элемент для добавления: "); 94 | scanf("%i", &value); 95 | add(&arr, value); 96 | } 97 | if (user_out == DELETE) { 98 | int index; 99 | printf("Введите индекс элемента для удаления: "); 100 | scanf("%i", &index); 101 | delete(&arr, index); 102 | } 103 | if (user_out == DELETE_LAST) { 104 | delete_last(&arr); 105 | } 106 | if (user_out == FIND) { 107 | int value; 108 | printf("Введите элемент для поиска: "); 109 | scanf("%i", &value); 110 | printf("%i\n", find(&arr, value)); 111 | } 112 | if (user_out == EXIT) { 113 | break; 114 | } 115 | printf("Введите номер команды:\n"); 116 | scanf("%i", &user_out); 117 | } 118 | return 0; 119 | } -------------------------------------------------------------------------------- /0510/task_7.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void clrscr() 6 | { 7 | system("@cls||clear"); 8 | } 9 | 10 | int check_winner(int matrix[3][3]) { 11 | if (matrix[0][0] == matrix[1][1] && matrix[1][1] == matrix[2][2] && (matrix[1][1] == 1 || matrix[1][1] == 2)) { 12 | return matrix[1][1]; 13 | } else if (matrix[0][2] == matrix[1][1] && matrix[1][1] == matrix[2][0] && 14 | (matrix[1][1] == 1 || matrix[1][1] == 2)) { 15 | return matrix[1][1]; 16 | } 17 | for (int i = 0; i < 3; ++i) { 18 | if (matrix[0][i] && matrix[1][i] && matrix[2][i]) { 19 | int sum = matrix[0][i] + matrix[1][i] + matrix[2][i]; 20 | if (sum == 3 || sum == 6) { 21 | return sum / 3; 22 | } 23 | } 24 | 25 | } 26 | for (int i = 0; i < 3; ++i) { 27 | if (matrix[i][0] && matrix[i][1] && matrix[i][2]) { 28 | int sum = matrix[i][0] + matrix[i][1] + matrix[i][2]; 29 | if (sum == 3 || sum == 6) { 30 | return sum / 3; 31 | } 32 | } 33 | 34 | } 35 | if (matrix[0][0] && matrix[0][1] && matrix[0][2] && matrix[1][0] && matrix[1][1] && matrix[1][2] && matrix[2][0] && 36 | matrix[2][1] && matrix[2][2]) { 37 | return 3; 38 | } 39 | return 0; 40 | 41 | } 42 | 43 | int output_matrix(int matrix[3][3]) { 44 | for (int i = 0; i < 3; ++i) { 45 | for (int j = 0; j < 3; ++j) { 46 | if (matrix[i][j] == 0) { 47 | printf(" "); 48 | } else if (matrix[i][j] == 1) { 49 | printf("X"); 50 | } else if (matrix[i][j] == 2) { 51 | printf("O"); 52 | } 53 | if (j != 2) { 54 | printf("|"); 55 | } 56 | } 57 | printf("\n"); 58 | } 59 | return 0; 60 | } 61 | 62 | int main() { 63 | int matrix[3][3]; 64 | int winner = 0; 65 | int turn = 1; 66 | int x, y; 67 | // set null matrix 68 | for (int i = 0; i < 3; ++i) { 69 | for (int j = 0; j < 3; ++j) { 70 | matrix[i][j] = 0; 71 | } 72 | } 73 | 74 | int error = 0; 75 | while (winner == 0) { 76 | 77 | if (turn == 1) { 78 | clrscr(); 79 | if (error) { 80 | printf("Error! Please enter correct coordinates!\n"); 81 | error = 0; 82 | } 83 | output_matrix(matrix); 84 | 85 | printf("Please enter x and y: "); 86 | scanf("%d %d", &x, &y); 87 | if (matrix[x][y] == 0) { 88 | matrix[x][y] = 1; 89 | turn = 2; 90 | } else { 91 | error = 1; 92 | } 93 | } else if (turn == 2) { 94 | srand(time(NULL)); 95 | x = rand() % 3; 96 | y = rand() % 3; 97 | if (matrix[x][y] == 0) { 98 | matrix[x][y] = 2; 99 | turn = 1; 100 | } 101 | } 102 | winner = check_winner(matrix); 103 | } 104 | if (winner == 1) { 105 | printf("You won!\n"); 106 | } else if (winner == 2) { 107 | printf("Computer won!\n"); 108 | } else if (winner == 3) { 109 | printf("Draw!\n"); 110 | } 111 | } -------------------------------------------------------------------------------- /labs/lab2/string_lab.c: -------------------------------------------------------------------------------- 1 | #include "string_lab.h" 2 | #include 3 | #include 4 | #include 5 | 6 | char *_strremove(char *str, const char ch) { 7 | if (str == NULL) { 8 | return NULL; 9 | } 10 | char *p = str; 11 | while (*p) { 12 | if (*p == ch) { 13 | memmove(p, p + 1, strlen(p)); 14 | } else { 15 | p++; 16 | } 17 | } 18 | return str; 19 | } 20 | 21 | int _strcountchar(const char *str, const char ch) { 22 | if (str == NULL || ch == '\0') { 23 | return -1; 24 | } 25 | int count = 0; 26 | int str_len = strlen(str); 27 | int cur_index = strchr(str, ch) - &str[0]; 28 | while (cur_index < str_len && cur_index >= 0) { 29 | count++; 30 | cur_index = strchr(&str[cur_index + 1], ch) - &str[0]; 31 | } 32 | if (count == 0) { 33 | return -1; 34 | } 35 | return count; 36 | } 37 | 38 | char *_strdelspaces(char *str) { 39 | if (str == NULL) { 40 | return NULL; 41 | } 42 | int str_len = strlen(str); 43 | for (int i = 0; i < str_len; i++) { 44 | if (str[i] == ' ' && str[i + 1] == ' ') { 45 | memmove(&str[i], &str[i + 1], str_len - i); 46 | i--; 47 | str_len--; 48 | } 49 | } 50 | 51 | return str; 52 | } 53 | 54 | char *_strtolower(char *str) { 55 | if (str == NULL) { 56 | return NULL; 57 | } 58 | int str_len = strlen(str); 59 | for (int i = 0; i < str_len; i++) { 60 | if (str[i] >= 'A' && str[i] <= 'Z') { 61 | str[i] += 32; 62 | } 63 | } 64 | return str; 65 | } 66 | 67 | char *_strtoupper(char *str) { 68 | if (str == NULL) { 69 | return NULL; 70 | } 71 | int str_len = strlen(str); 72 | for (int i = 0; i < str_len; i++) { 73 | if (str[i] >= 'a' && str[i] <= 'z') { 74 | str[i] -= 32; 75 | } 76 | } 77 | return str; 78 | } 79 | 80 | int _strcmp(const char *str1, const char *str2) { 81 | int len = strlen(str1) > strlen(str2) ? strlen(str1) : strlen(str2); 82 | for (int i = 0; i < len; i++) { 83 | if (str1[i] != str2[i]) { 84 | return str1[i] - str2[i]; 85 | } 86 | } 87 | return 0; 88 | } 89 | 90 | char *_strreverse(const char *str1) { 91 | if (str1 == NULL) { 92 | return NULL; 93 | } 94 | int str1_len = strlen(str1); 95 | char *str2 = (char *) malloc((str1_len + 1) * sizeof(char)); 96 | for (int i = 0; i < str1_len; i++) { 97 | str2[i] = str1[str1_len - i - 1]; 98 | } 99 | str2[str1_len] = '\0'; 100 | return str2; 101 | } 102 | 103 | 104 | int _atoi(const char *str) { 105 | int str_len = strlen(str); 106 | int i = 0; 107 | while (str[i] == ' ' || str[i] == '\t') { 108 | printf("%c", str[i]); 109 | i++; 110 | } 111 | int flag = 1; 112 | if (str[i] == '-') { 113 | i++; 114 | flag = -1; 115 | } 116 | int result = 0; 117 | for (; i < str_len; i++) { 118 | if (str[i] >= '0' && str[i] <= '9') { 119 | result = result * 10 + (str[i] - '0'); 120 | } else { 121 | return result * flag; 122 | } 123 | } 124 | return result * flag; 125 | } 126 | 127 | char *_strchr(char *str, int ch) { 128 | if (str == NULL) { 129 | return NULL; 130 | } 131 | int str_len = strlen(str); 132 | for (int i = 0; i < str_len; i++) { 133 | if (str[i] == ch) { 134 | return &str[i]; 135 | } 136 | } 137 | return NULL; 138 | } 139 | 140 | char *_strstr(const char *str, const char *substr) { 141 | if (str == NULL) { 142 | return NULL; 143 | } 144 | int str_len = strlen(str); 145 | int substr_len = strlen(substr); 146 | for (int i = 0; i < str_len; i++) { 147 | if (str[i] == substr[0]) { 148 | int j = 0; 149 | while (j < substr_len && str[i + j] == substr[j]) { 150 | j++; 151 | } 152 | if (j == substr_len) { 153 | return (char *) &str[i]; 154 | } 155 | } 156 | } 157 | return NULL; 158 | } 159 | -------------------------------------------------------------------------------- /labs/lab3/lab3.h: -------------------------------------------------------------------------------- 1 | #ifndef LAB3_H 2 | #define LAB3_H 3 | 4 | #include 5 | #include 6 | 7 | #define SIZE 128 // переменная, присваиваемая каждому новому студенту, после чего инкрементируемая 8 | // то есть у каждого нового будет уникальный id 9 | // после вызова initUniversity(..) необходимо присвоить значению максимальный Id среди всех считанных студентов 10 | 11 | // Структура описывающая студента 12 | typedef struct { 13 | unsigned long id; // Уникальный id, получаемый из g_Id 14 | char name[SIZE]; // Имя 15 | char surname[SIZE]; // Фамилия 16 | char groupName[SIZE]; // Название группы 17 | unsigned birthYear; // Год рождения 18 | } Student; 19 | 20 | // Структура описывающая группу 21 | // Cоздается при чтении, если getGroup() вернула NULL; название группы берется из структуры студента 22 | typedef struct { 23 | char name[SIZE]; // Название группы 24 | unsigned studentsCount; // Количество студентов в группе (размер динамического массива) 25 | Student *students; // Динамический массив со студентами 26 | } Group; 27 | 28 | // Структура описывающая университет 29 | typedef struct { 30 | unsigned groupsCount; // Количество групп в университете (размер динамического массива) 31 | Group *groups; // Динамический массив с группами 32 | } University; 33 | 34 | /* 35 | - Функция, инициализирующаяя структуру университета 36 | - Читаем бинарный файл с последовательно записанными студентами, и заполняем университет 37 | группами (взятыми из поля groupName студента) и самими студентами 38 | - При любых ошибках чтения файла, все равно возвращается указатель на структуру университета 39 | - При добавлении студентов, должна меняться глобальная переменная, отвечающая за Id (максимальный id + 1), 40 | чтобы не было пересечений при добавлении новых студентов 41 | */ 42 | University *initUniversity(const char *fileName); 43 | 44 | /* 45 | - Функция, добавляющая новую группу в университет 46 | - Перераспределяет память по указателю groups, инкрементирует счетчик 47 | - Возвращает признак успешного добавления 48 | */ 49 | bool addNewGroup(University *university, const Group group); 50 | 51 | /* 52 | - Функция, добавляющая нового студента в массив студентов, отсортировав по фамилии 53 | - Работает аналогично addNewGroup 54 | - Должна назначать Id переданному студенту если он не задан (id == 0) 55 | - Возвращает признак успешного добавления 56 | */ 57 | bool addNewStudent(Group *group, Student student); 58 | 59 | /* 60 | - Функция, удаляющая группу из университета по заданному имени 61 | - Возвращает признак успешного удаления 62 | */ 63 | bool removeGroup(University *university, const char *name); 64 | 65 | /* 66 | - Функция, удаляющая студента из университета по заданному Id 67 | - Возвращает признак успешного удаления 68 | */ 69 | bool removeStudent(University *university, const unsigned long id); 70 | 71 | /* 72 | - Функция, возвращающая указатель на группу по заданному имени 73 | - Если такой группы нет в университете, возвращается NULL 74 | */ 75 | Group *getGroup(const University *university, const char *name); 76 | 77 | /* 78 | - Функция, возвращающая указатель на студента по заданному Id 79 | - Если такого студента нет в университете, возвращается NULL 80 | */ 81 | Student *getStudent(const University *university, const unsigned long id); 82 | 83 | /* 84 | - Функция, печатающая информацию об университете в следующем формате: 85 | ------------------------------------------------------------------------------- 86 | НАЗВАНИЕ ГРУППЫ 87 | Id 88 | Фамилия Имя 89 | Дата рождения 90 | Id 91 | ... 92 | ------------------------------------------------------------------------------- 93 | НАЗВАНИЕ ГРУППЫ 94 | Id 95 | ... 96 | ------------------------------------------------------------------------------- 97 | - Если в университете нет ни групп, ни студентов выводить сообщение об этом 98 | */ 99 | void printUniversity(const University *university); // + 100 | 101 | /* 102 | - Функция, печатающая информацию о группе в следующем формате: 103 | НАЗВАНИЕ ГРУППЫ 104 | Id 105 | Фамилия Имя 106 | Дата рождения 107 | Id 108 | ... 109 | - Если в группе нет студентов, выводить сообщение об этом 110 | */ 111 | void printGroup(const Group group); // + 112 | 113 | /* 114 | - Функция, печатающая информацию о студенте в следующем формате: 115 | Id 116 | Фамилия Имя 117 | Дата рождения 118 | */ 119 | void printStudent(const Student student); // + 120 | 121 | /* 122 | - Функция, освобождающая всю выделенную память для университета 123 | */ 124 | void freeUniversity(University *university); 125 | 126 | /* 127 | - Функция, сохраняющая информацию о студентах университа в бинарный файл 128 | - Студенты записываются в файл последовательно 129 | - Файл полностью перезаписывается 130 | - Возвращает признак успешного сохранения 131 | */ 132 | bool saveToFile(const char *fileName, const University *university); 133 | 134 | #endif -------------------------------------------------------------------------------- /labs/lab3/main.c: -------------------------------------------------------------------------------- 1 | #include "lab3.h" 2 | #include 3 | #include 4 | 5 | 6 | typedef enum { 7 | E_INVALID = 0, 8 | E_ADD_GROUP, 9 | E_ADD_STUDENT, 10 | E_DEL_GROUP, 11 | E_DEL_STUDENT, 12 | E_PRINT_UNI, 13 | E_PRINT_GROUP, 14 | E_PRINT_STUDENT, 15 | E_END 16 | } EAction; 17 | 18 | const char *Enum2Str(EAction eAct) { 19 | switch (eAct) { 20 | case E_INVALID: 21 | return "- Невалидная команда"; 22 | case E_ADD_GROUP: 23 | return "- Добавить группу"; 24 | case E_ADD_STUDENT: 25 | return "- Добавить студента"; 26 | case E_DEL_GROUP: 27 | return "- Удалить группу"; 28 | case E_DEL_STUDENT: 29 | return "- Удалить студента"; 30 | case E_PRINT_UNI: 31 | return "- Напечатать информацию об университете"; 32 | case E_PRINT_GROUP: 33 | return "- Напечатать информацию о группе"; 34 | case E_PRINT_STUDENT: 35 | return "- Напечатать информацию о студенте"; 36 | case E_END: 37 | return "- Окончание работы"; 38 | default: 39 | return "? - Невалидная команда"; 40 | } 41 | } 42 | 43 | Group *add_group_task(University *university) { 44 | Group *group = NULL; 45 | char groupName[SIZE]; 46 | 47 | printf("Введите название группы:\n"); 48 | scanf("%s", groupName); 49 | group = (Group *) malloc(sizeof(Group)); 50 | strcpy(group->name, groupName); 51 | addNewGroup(university, *group); 52 | return group; 53 | } 54 | 55 | void add_student_task(University *university) { 56 | Student *student = NULL; 57 | int studentGroupId = 0; 58 | int flag = 0; 59 | Group *group = NULL; 60 | student = (Student *) malloc(sizeof(Student)); 61 | 62 | 63 | printf("Введите имя студента:\n"); 64 | scanf("%s", student->name); 65 | 66 | printf("Введите фамилию студента:\n"); 67 | scanf("%s", student->surname); 68 | 69 | printf("Введите год рождения студента\n"); 70 | scanf("%d", &student->birthYear); 71 | 72 | printf("Выберете группу студента:\n"); 73 | for (int i = 0; i < university->groupsCount; i++) { 74 | printf("%d %s\n", i + 1, university->groups[i].name); 75 | } 76 | printf("%d %s\n", university->groupsCount + 1, "Новая группа"); 77 | scanf("%d", &studentGroupId); 78 | 79 | if (studentGroupId == university->groupsCount + 1) { 80 | group = add_group_task(university); 81 | flag = 1; 82 | } else { 83 | group = &university->groups[studentGroupId - 1]; 84 | } 85 | addNewStudent(group, *student); 86 | free(student); 87 | if (flag) { 88 | free(group); 89 | } 90 | } 91 | 92 | void del_group_task(University *university) { 93 | char groupName[SIZE]; 94 | memset(groupName, 0, SIZE); 95 | 96 | printf("Введите название группы которую нужно удалить:\n"); 97 | scanf("%s", groupName); 98 | if (removeGroup(university, groupName)) { 99 | printf("Группа %s успешно удалена\n", groupName); 100 | } else { 101 | printf("Группа %s не найдена\n", groupName); 102 | } 103 | } 104 | 105 | void del_student_task(University *university) { 106 | int studentId = 0; 107 | 108 | printf("Введите id студента которого нужно удалить: \n"); 109 | scanf("%d", &studentId); 110 | if (removeStudent(university, studentId)) { 111 | printf("Студент с id %d удален\n", studentId); 112 | } else { 113 | printf("Студент с id %d не найден\n", studentId); 114 | } 115 | } 116 | 117 | 118 | void print_university_task(University *university) { 119 | printUniversity(university); 120 | } 121 | 122 | void print_group_task(University *university) { 123 | char groupName[SIZE]; 124 | memset(groupName, 0, SIZE); 125 | Group *group = NULL; 126 | 127 | 128 | printf("Введите название группы:\n"); 129 | scanf("%s", groupName); 130 | group = getGroup(university, groupName); 131 | if (group == NULL) { 132 | printf("Группа не найдена\n"); 133 | } else { 134 | printGroup(*group); 135 | } 136 | } 137 | 138 | void print_student_task(University *university) { 139 | int studentId = 0; 140 | Student *student = NULL; 141 | 142 | printf("Введите id студента:\n"); 143 | scanf("%d", &studentId); 144 | student = getStudent(university, studentId); 145 | if (student == NULL) { 146 | printf("Студент не найден\n"); 147 | } else { 148 | printStudent(*student); 149 | } 150 | } 151 | 152 | EAction get_action() { 153 | int beforeEAction = 0; 154 | EAction eAction; 155 | 156 | printf("Выберите действие:\n"); 157 | for (int i = 1; i <= E_END; i++) { 158 | printf("%d %s\n", i, Enum2Str((EAction) i)); 159 | } 160 | scanf("%d", &beforeEAction); 161 | if (beforeEAction < 1 || beforeEAction > E_END) { 162 | eAction = E_INVALID; 163 | } else { 164 | eAction = (EAction) beforeEAction; 165 | } 166 | return eAction; 167 | } 168 | 169 | 170 | int main(int argc, char *argv[]) { 171 | char *fileName = NULL; 172 | size_t fileNameSize = 0; 173 | if (argc < 2) { 174 | printf("Имя файла не задано\n"); 175 | printf("Введите имя файла:\n"); 176 | getline(&fileName, &fileNameSize, stdin); 177 | fileName[strlen(fileName) - 1] = '\0'; 178 | } else { 179 | fileName = argv[1]; 180 | } 181 | 182 | University *university = initUniversity(fileName); 183 | Group *group = NULL; 184 | EAction eAction = E_INVALID; 185 | 186 | while (eAction != E_END) { 187 | eAction = get_action(); 188 | switch (eAction) { 189 | case E_ADD_GROUP: 190 | group = add_group_task(university); 191 | free(group); 192 | continue; 193 | case E_ADD_STUDENT: 194 | add_student_task(university); 195 | continue; 196 | case E_DEL_GROUP: 197 | del_group_task(university); 198 | continue; 199 | case E_DEL_STUDENT: 200 | del_student_task(university); 201 | continue; 202 | case E_PRINT_UNI: 203 | print_university_task(university); 204 | continue; 205 | case E_PRINT_GROUP: 206 | print_group_task(university); 207 | continue; 208 | case E_PRINT_STUDENT: 209 | print_student_task(university); 210 | continue; 211 | case E_INVALID: 212 | printf("Невалидная команда\n"); 213 | continue; 214 | case E_END: 215 | break; 216 | } 217 | } 218 | 219 | printf("Работа завершена\n"); 220 | printf("Введите имя файла для сохранения:\n"); 221 | fflush(stdin); 222 | fflush(stdout); 223 | getline(&fileName, &fileNameSize, stdin); 224 | printf("Сохранение в файл %s\n", fileName); 225 | saveToFile("out.dat", university); 226 | freeUniversity(university); 227 | free(fileName); 228 | 229 | return 0; 230 | } 231 | -------------------------------------------------------------------------------- /tittactoe/tiktaktoe.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void clear_console() { 6 | system("@cls||clear"); 7 | } 8 | 9 | int check_winner(int matrix[3][3]) { 10 | if (matrix[0][0] == matrix[1][1] && matrix[1][1] == matrix[2][2] && (matrix[1][1] == 1 || matrix[1][1] == 2)) { 11 | return matrix[0][0]; 12 | } 13 | if (matrix[0][2] == matrix[1][1] && matrix[1][1] == matrix[2][0] && (matrix[1][1] == 1 || matrix[1][1] == 2)) { 14 | return matrix[0][2]; 15 | } 16 | if (matrix[0][0] == matrix[0][1] && matrix[0][1] == matrix[0][2] && (matrix[0][0] == 1 || matrix[0][0] == 2)) { 17 | return matrix[0][0]; 18 | } 19 | if (matrix[1][0] == matrix[1][1] && matrix[1][1] == matrix[1][2] && (matrix[1][0] == 1 || matrix[1][0] == 2)) { 20 | return matrix[1][0]; 21 | } 22 | if (matrix[2][0] == matrix[2][1] && matrix[2][1] == matrix[2][2] && (matrix[2][0] == 1 || matrix[2][0] == 2)) { 23 | return matrix[2][0]; 24 | } 25 | if (matrix[0][0] == matrix[1][0] && matrix[1][0] == matrix[2][0] && (matrix[0][0] == 1 || matrix[0][0] == 2)) { 26 | return matrix[0][0]; 27 | } 28 | if (matrix[0][1] == matrix[1][1] && matrix[1][1] == matrix[2][1] && (matrix[0][1] == 1 || matrix[0][1] == 2)) { 29 | return matrix[0][1]; 30 | } 31 | if (matrix[0][2] == matrix[1][2] && matrix[1][2] == matrix[2][2] && (matrix[0][2] == 1 || matrix[0][2] == 2)) { 32 | return matrix[0][2]; 33 | } 34 | 35 | return 0; 36 | 37 | } 38 | 39 | int print_line_x(int line[3]) { 40 | printf(" +----+----+----+\n"); 41 | for (int i = 0; i < 4; ++i) { 42 | printf(" "); 43 | printf("|"); 44 | if (i == 0 || i == 3) { 45 | if (line[0] == 0) { 46 | printf(" "); 47 | } else if (line[0] == 1) { 48 | printf("X X"); 49 | } else if (line[0] == 2) { 50 | printf(" OO "); 51 | } 52 | printf("|"); 53 | if (line[1] == 0) { 54 | printf(" "); 55 | } else if (line[1] == 1) { 56 | printf("X X"); 57 | } else if (line[1] == 2) { 58 | printf(" OO "); 59 | } 60 | printf("|"); 61 | if (line[2] == 0) { 62 | printf(" "); 63 | } else if (line[2] == 1) { 64 | printf("X X"); 65 | } else if (line[2] == 2) { 66 | printf(" OO "); 67 | } 68 | } else { 69 | if (line[0] == 0) { 70 | printf(" "); 71 | } else if (line[0] == 1) { 72 | printf(" XX "); 73 | } else if (line[0] == 2) { 74 | printf("O O"); 75 | } 76 | printf("|"); 77 | if (line[1] == 0) { 78 | printf(" "); 79 | } else if (line[1] == 1) { 80 | printf(" XX "); 81 | } else if (line[1] == 2) { 82 | printf("O O"); 83 | } 84 | printf("|"); 85 | if (line[2] == 0) { 86 | printf(" "); 87 | } else if (line[2] == 1) { 88 | printf(" XX "); 89 | } else if (line[2] == 2) { 90 | printf("O O"); 91 | } 92 | } 93 | printf("|"); 94 | if (i != 3) { 95 | printf("\n"); 96 | } 97 | } 98 | printf("\n"); 99 | return 0; 100 | } 101 | 102 | int output_matrix(int matrix[3][3]) { 103 | clear_console(); 104 | printf("\n\n\n"); 105 | for (int i = 0; i < 3; ++i) { 106 | print_line_x(matrix[i]); 107 | 108 | } 109 | printf(" +----+----+----+\n"); 110 | return 0; 111 | } 112 | 113 | 114 | int get_computer_move(int matrix[9]) { 115 | int x, y; 116 | do { 117 | x = rand() % 3; 118 | y = rand() % 3; 119 | } while (matrix[3 * x + y] != 0); 120 | 121 | matrix[3 * x + y] = 2; 122 | return 0; 123 | } 124 | 125 | //int get_computer_move_2(int matrix[3][3]) { 126 | // int x, y; 127 | // for (int i; i < 3, ++i) { 128 | // for (int j; j < 3, ++j) { 129 | // if (matrix[i][j] == 0) { 130 | // matrix[i][j] = 2; 131 | // return 0; 132 | // } 133 | // } 134 | // } 135 | // return 0; 136 | //} 137 | 138 | int check_move(int matrix[3][3], int x, int y, int turn) { 139 | // if turn == 1 -> computer 140 | // if turn == 2 -> player 141 | int ans = 0; 142 | if (turn == 1) { 143 | matrix[x][y] = 2; 144 | if (check_winner(matrix) == 2) { 145 | return 2; 146 | } 147 | 148 | for (int i; i < 3; ++i) { 149 | for (int j; j < 3; ++j) { 150 | if (matrix[i][j] == 0) { 151 | 152 | if (check_move(matrix, i, j, 2) == 0) { 153 | return 0; 154 | } 155 | } 156 | 157 | } 158 | } 159 | return 1; 160 | } 161 | if (turn == 2) { 162 | matrix[x][y] = 1; 163 | if (check_winner(matrix) == 1) { 164 | return 0; 165 | } 166 | for (int i; i < 3; ++i) { 167 | for (int j; j < 3; ++j) { 168 | if (matrix[i][j] == 0) { 169 | if (check_move(matrix, i, j, 1) == 0) { 170 | return 0; 171 | } 172 | } 173 | } 174 | } 175 | return 1; 176 | } 177 | return 1; 178 | } 179 | 180 | int get_player_move(int matrix[3][3], int error) { 181 | int x, y; 182 | if (error) { 183 | printf("Error! Please enter correct coordinates!\n"); 184 | } 185 | output_matrix(matrix); 186 | printf("Please enter x and y: "); 187 | scanf("%d %d", &x, &y); 188 | if (matrix[x][y] == 0) { 189 | matrix[x][y] = 1; 190 | } else { 191 | return 1; 192 | } 193 | return 0; 194 | } 195 | 196 | int game(int matrix[3][3]) { 197 | int error = 0; 198 | int turn = 1; 199 | int winner = 0; 200 | 201 | while (winner == 0) { 202 | 203 | if (turn == 1) { 204 | if (!get_player_move(matrix, error)) { 205 | turn = 2; 206 | error = 0; 207 | } else { 208 | error = 1; 209 | } 210 | } else if (turn == 2) { 211 | get_computer_move(matrix); 212 | turn = 1; 213 | 214 | } 215 | winner = check_winner(matrix); 216 | } 217 | output_matrix(matrix); 218 | if (winner == 1) { 219 | printf("You won!\n"); 220 | } else if (winner == 2) { 221 | printf("Computer won!\n"); 222 | } else if (winner == 3) { 223 | printf("Draw!\n"); 224 | } 225 | return 0; 226 | } 227 | 228 | int main() { 229 | int matrix[3][3]; 230 | 231 | 232 | for (int i = 0; i < 3; ++i) { 233 | for (int j = 0; j < 3; ++j) { 234 | matrix[i][j] = 0; 235 | } 236 | } 237 | 238 | srand(time(NULL)); 239 | game(matrix); 240 | } 241 | 242 | -------------------------------------------------------------------------------- /labs/lab3/lab3.c: -------------------------------------------------------------------------------- 1 | #include "lab3.h" 2 | #include 3 | #include 4 | #include 5 | 6 | unsigned long int g_Id = 1; 7 | 8 | int max_id(University *university) { 9 | int max = 0; 10 | for (int i = 0; i < university->groupsCount; i++) { 11 | for (int j = 0; j < university->groups[i].studentsCount; j++) { 12 | if (university->groups[i].students[j].id > max) { 13 | max = university->groups[i].students[j].id; 14 | } 15 | } 16 | } 17 | return max; 18 | } 19 | 20 | University *initUniversity(const char *fileName) { 21 | University *university = (University *) malloc(sizeof(University)); 22 | if (university == NULL) { 23 | return NULL; 24 | } 25 | university->groups = NULL; 26 | university->groupsCount = 0; 27 | 28 | FILE *file = fopen(fileName, "rb"); 29 | if (file == NULL) { 30 | return university; 31 | } 32 | 33 | Group *group = NULL; 34 | Student *student = NULL; 35 | Group *group_tmp = NULL; 36 | 37 | while (!feof(file)) { 38 | student = (Student *) malloc(sizeof(Student)); 39 | fread(student, sizeof(Student), 1, file); 40 | 41 | if (feof(file)) { 42 | free(student); 43 | break; 44 | } 45 | 46 | group = getGroup(university, student->groupName); 47 | if (group == NULL) { 48 | group_tmp = (Group *) malloc(sizeof(Group)); 49 | 50 | strcpy(group_tmp->name, student->groupName); 51 | group_tmp->students = NULL; 52 | group_tmp->studentsCount = 0; 53 | 54 | if (!addNewGroup(university, *group_tmp)) { 55 | continue; 56 | } 57 | free(group_tmp); 58 | 59 | group = &university->groups[university->groupsCount - 1]; 60 | } 61 | if (!addNewStudent(group, *student)) { 62 | continue; 63 | } 64 | free(student); 65 | } 66 | fclose(file); 67 | g_Id = max_id(university) + 1; 68 | return university; 69 | } 70 | 71 | 72 | void sort_students_by_surname(Group *group) { 73 | for (int i = (int) group->studentsCount - 1; i > 0; i--) { 74 | if (strcasecmp(group->students[i].surname, group->students[i - 1].surname) < 0) { 75 | Student tmp = group->students[i]; 76 | group->students[i] = group->students[i - 1]; 77 | group->students[i - 1] = tmp; 78 | } else { 79 | break; 80 | } 81 | } 82 | } 83 | 84 | bool addNewGroup(University *university, const Group group) { 85 | if (university == NULL) { 86 | return false; 87 | } 88 | 89 | Group *group_tmp = NULL; 90 | if (university->groupsCount == 0) { 91 | group_tmp = (Group *) malloc(sizeof(Group)); 92 | } else { 93 | group_tmp = (Group *) realloc(university->groups, (university->groupsCount + 1) * sizeof(Group)); 94 | } 95 | 96 | if (group_tmp == NULL) { 97 | return false; 98 | } 99 | 100 | university->groups = group_tmp; 101 | university->groups[university->groupsCount] = group; 102 | university->groupsCount++; 103 | 104 | return true; 105 | } 106 | 107 | bool addNewStudent(Group *group, Student student) { 108 | if (group == NULL) { 109 | return false; 110 | } 111 | 112 | if (strcmp(group->name, student.groupName) != 0) { 113 | return false; 114 | } 115 | 116 | Student *student_tmp = NULL; 117 | if (group->studentsCount == 0) { 118 | student_tmp = (Student *) malloc(sizeof(Student)); 119 | } else { 120 | student_tmp = (Student *) realloc(group->students, sizeof(Student) * (group->studentsCount + 1)); 121 | } 122 | if (student_tmp == NULL) { 123 | return false; 124 | } 125 | 126 | group->students = student_tmp; 127 | 128 | if (student.id == 0) { 129 | student.id = g_Id; 130 | } 131 | group->students[group->studentsCount] = student; 132 | group->studentsCount++; 133 | 134 | sort_students_by_surname(group); 135 | 136 | g_Id = student.id > g_Id ? student.id + 1 : g_Id + 1; 137 | 138 | return true; 139 | } 140 | 141 | 142 | bool removeGroup(University *university, const char *name) { 143 | if (university == NULL || name == NULL) { 144 | return false; 145 | } 146 | 147 | for (int i = 0; i < university->groupsCount; i++) { 148 | if (strcmp(university->groups[i].name, name) == 0) { 149 | free(university->groups[i].students); 150 | memmove( 151 | &university->groups[i], 152 | &university->groups[i + 1], 153 | (university->groupsCount - i - 1) * sizeof(Group) 154 | ); 155 | university->groupsCount--; 156 | return true; 157 | } 158 | } 159 | return false; 160 | } 161 | 162 | bool removeStudent(University *university, const unsigned long id) { 163 | if (university == NULL) { 164 | return false; 165 | } 166 | for (int i = 0; i < university->groupsCount; i++) { 167 | for (int j = 0; j < university->groups[i].studentsCount; j++) { 168 | if (university->groups[i].students[j].id == id) { 169 | memmove( 170 | &university->groups[i].students[j], 171 | &university->groups[i].students[j + 1], 172 | (university->groups[i].studentsCount - j - 1) * sizeof(Student) 173 | ); 174 | university->groups[i].studentsCount--; 175 | return true; 176 | } 177 | } 178 | } 179 | return false; 180 | } 181 | 182 | 183 | Group *getGroup(const University *university, const char *name) { 184 | if (university == NULL || name == NULL) { 185 | return NULL; 186 | } 187 | 188 | for (int i = 0; i < university->groupsCount; i++) { 189 | if (strcmp(university->groups[i].name, name) == 0) { 190 | return &university->groups[i]; 191 | } 192 | } 193 | return NULL; 194 | } 195 | 196 | 197 | Student *getStudent(const University *university, const unsigned long id) { 198 | if (university == NULL) { 199 | return NULL; 200 | } 201 | 202 | for (int i = 0; i < university->groupsCount; i++) { 203 | for (int j = 0; j < university->groups[i].studentsCount; j++) { 204 | if (university->groups[i].students[j].id == id) { 205 | return &university->groups[i].students[j]; 206 | } 207 | } 208 | } 209 | return NULL; 210 | } 211 | 212 | void printUniversity(const University *university) { 213 | if (university == NULL) { 214 | return; 215 | } 216 | for (int i = 0; i < university->groupsCount; i++) { 217 | printf("%s\n", university->groups[i].name); 218 | printGroup(university->groups[i]); 219 | printf("------------------------------------------------------------------------------\n"); 220 | } 221 | if (university->groupsCount == 0) { 222 | printf("University is empty\n"); 223 | } 224 | } 225 | 226 | 227 | void printGroup(const Group group) { 228 | for (int i = 0; i < group.studentsCount; i++) { 229 | printStudent(group.students[i]); 230 | } 231 | if (group.studentsCount == 0) { 232 | printf("Group is empty\n"); 233 | } 234 | } 235 | 236 | void printStudent(const Student student) { 237 | printf("\t%lu\n", student.id); 238 | printf("\t\t%s %s\n", student.surname, student.name); 239 | printf("\t\t%d\n", student.birthYear); 240 | } 241 | 242 | 243 | void freeUniversity(University *university) { 244 | if (university == NULL) { 245 | return; 246 | } 247 | for (int i = 0; i < university->groupsCount; i++) { 248 | free(university->groups[i].students); 249 | } 250 | free(university->groups); 251 | free(university); 252 | } 253 | 254 | bool saveToFile(const char *fileName, const University *university) { 255 | FILE *file = fopen(fileName, "w+b"); 256 | 257 | if (file == NULL) { 258 | return false; 259 | } 260 | 261 | for (int i = 0; i < university->groupsCount; i++) { 262 | for (int j = 0; j < university->groups[i].studentsCount; j++) { 263 | fwrite(&university->groups[i].students[j], sizeof(Student), 1, file); 264 | } 265 | } 266 | 267 | fclose(file); 268 | return true; 269 | } --------------------------------------------------------------------------------