├── arrays.md
├── src
    ├── .gitkeep
    ├── db_structs.h
    ├── input_functions.h
    ├── database.h
    ├── db_master_tables
    │   ├── db_master_levels.h
    │   ├── db_master_modules.h
    │   ├── db_master_status_events.h
    │   ├── db_master_levels.c
    │   ├── db_master_modules.c
    │   └── db_master_status_events.c
    ├── indices.h
    ├── db_master_levels.h
    ├── Makefile
    ├── db_logs.txt
    ├── db_master_modules.h
    ├── db_master_status_events.h
    ├── shared.h
    ├── definitions.h
    ├── modules_db.c
    ├── database.c
    ├── input_functions.c
    ├── indices.c
    ├── db_master_levels.c
    ├── db_master_modules.c
    ├── db_master_status_events.c
    └── shared.c
├── .DS_Store
├── Violin concerto No. 1, Op. 26 - Max Bruch
    ├── Exam_02
    │   ├── 02_05.c
    │   ├── 02_04.c
    │   ├── 02_03.c
    │   ├── 02_01.c
    │   ├── 02_02.c
    │   └── README.md
    ├── Exam_01
    │   ├── 01_01.c
    │   ├── 01_02.c
    │   ├── 01_04.c
    │   ├── 01_05.c
    │   ├── 01_03.c
    │   ├── 01_06.c
    │   └── README.md
    ├── Exam_03
    │   ├── 03_04.c
    │   ├── 03_02.c
    │   ├── 03_01.c
    │   ├── 03_05.c
    │   ├── 03_03.c
    │   └── README.md
    ├── Exam_04
    │   ├── 04_02.c
    │   ├── 04_04.c
    │   ├── 04_01.c
    │   ├── 04_05.c
    │   └── README.md
    ├── Exam_06-08
    │   ├── palindrom.c
    │   ├── struct_1.c
    │   └── struct_2.c
    └── Exam_05
    │   ├── 05_03.c
    │   ├── 05_05.c
    │   ├── 05_04.c
    │   ├── 05_01.c
    │   └── README.md
├── exam_tasks.md
├── how_to_check_input.md
├── exam_info.md
├── algotitm_check.md
└── exam_taks.c


/arrays.md:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Kimbyakov/uwu_summer/HEAD/.DS_Store


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_02/02_05.c:
--------------------------------------------------------------------------------
 1 | // Задача 02_05 (205):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main (void)
 6 | {
 7 |     int x = 205;
 8 |     printf("%d", x);
 9 | 
10 |     return 0;
11 | }
12 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_02/02_04.c:
--------------------------------------------------------------------------------
 1 | // Задача 02_04 (Путь к Блокноту):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main (void) {
 6 | 
 7 |     printf("C:\\Windows\\System32\\notepad.exe");
 8 | 
 9 |     return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_02/02_03.c:
--------------------------------------------------------------------------------
 1 | // Задача 02_03 (Некоректная работа программы №3):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main (void) {
 6 | 
 7 |     printf("\"I'm Groot\" (c) Groot");
 8 | 
 9 |     return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_01/01_01.c:
--------------------------------------------------------------------------------
 1 | // Задача 01_01 (Исправление ошибок №1):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void)
 6 | {
 7 |     int a, b;
 8 | 
 9 |     scanf("%d %d", &a, &b);
10 |     printf("%d", a * b);
11 | 
12 |     return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_01/01_02.c:
--------------------------------------------------------------------------------
 1 | // Задача 01_02 (Исправление ошибок №2):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void)
 6 | {
 7 |     int x1, x2;
 8 |     scanf("%d %d", &x1, &x2);
 9 |     printf("%d", x1 * x2);
10 | 
11 |     return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_02/02_01.c:
--------------------------------------------------------------------------------
 1 | // Задача 02_01 (Некоректная работа программы №1):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main (void)
 6 | {
 7 |     int x = 0;
 8 | 
 9 |     scanf ("%d", &x);
10 |     printf("%05d", x);
11 |     return 0;
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_02/02_02.c:
--------------------------------------------------------------------------------
 1 | // Задача 02_02 (Некоректная работа программы №2):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main (void)
 6 | {
 7 |     int x;
 8 | 
 9 |     scanf ("%d", &x);
10 |     printf("%05d", x);
11 |     
12 |     return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_01/01_04.c:
--------------------------------------------------------------------------------
 1 | // Задача 01_04 (Исправление ошибок №4):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void)
 6 | {
 7 |     int left, right;
 8 |     
 9 |     scanf("%d %d", &left, &right);
10 |     printf("%d", left * right);
11 | 
12 |     return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_01/01_05.c:
--------------------------------------------------------------------------------
 1 | // Задача 01_05 (Исправление ошибок №5):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void)
 6 | {
 7 |     int x;
 8 |     double pi = 3.141;
 9 | 
10 |     scanf("%d", &x);
11 |     printf("%.2lf", pi * x);
12 | 
13 |     return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_01/01_03.c:
--------------------------------------------------------------------------------
 1 | // Задача 01_03 (Исправление ошибок №3):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void)
 6 | {
 7 |     int first, second;
 8 | 
 9 |     scanf("%d %d", &first, &second);
10 |     printf("%d", first * second);
11 | 
12 |     return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_01/01_06.c:
--------------------------------------------------------------------------------
 1 | // Задача 01_06 (Исправление ошибок №6):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void)
 6 | {
 7 |     int value;
 8 |     double pi = 3.141;
 9 | 
10 |     scanf("%d", &value);
11 |     printf("%.2lf", value * pi);
12 | 
13 |     return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_03/03_04.c:
--------------------------------------------------------------------------------
 1 | // Задача 03_04 (Inside the interval):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main (void) {
 6 | 
 7 |     int a, b, c;
 8 |     int result;
 9 | 
10 |     if (scanf("%d %d %d", &a, &b, &c) == 3) {
11 |         result = a < c && c < b;
12 |         printf("%d", result);
13 |     } else {
14 |         printf("n/a");
15 |     }
16 |     
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_03/03_02.c:
--------------------------------------------------------------------------------
 1 | // Задача 03_02 (Перевод в градусную меру):
 2 | 
 3 | #include <stdio.h>
 4 | #include <math.h>
 5 | 
 6 | int main (void) {
 7 | 
 8 |     double radian, degree;
 9 | 
10 |     if (scanf("%lf", &radian) == 1) {
11 |         degree = 57.29 * radian;
12 |         printf("%.0lf", roundf(degree));
13 |     } else {
14 |         printf("n/a");
15 |     }
16 |     
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_03/03_01.c:
--------------------------------------------------------------------------------
 1 | // Задача 03_01 (Платиновый шар):
 2 | 
 3 | #include <stdio.h>
 4 | #include <math.h>
 5 | 
 6 | int main (void) {
 7 | 
 8 |     double R, m, result;
 9 | 
10 |     if (scanf("%lf", &R) == 1) {
11 |         m = 21500 * (4.0 / 3.0) * M_PI * pow(R, 3);
12 |         result = round(m);
13 |         printf("%.0lf", result);
14 |     } else {
15 |         printf("n/a");
16 |     }
17 |     
18 |     return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_03/03_05.c:
--------------------------------------------------------------------------------
 1 | // Задача 03_05 (логическое выражение):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main (void) {
 6 | 
 7 |     int x, y, z, result;
 8 | 
 9 |     if ((scanf("%d %d %d", &x, &y, &z) == 3) && (x == 0 || x == 1) && (y == 0 || y == 1) && (z == 0 || z == 1)) {
10 |         result = x && (y || z);
11 |         printf("%d", result);
12 |     } else {
13 |         printf("n/a");
14 |     }
15 | 
16 |     return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/db_structs.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DB_STRUCTS_H_
 2 | #define SRC_DB_STRUCTS_H_
 3 | 
 4 | typedef struct ai_module {
 5 |   int id;
 6 |   char name[30];
 7 |   int module_level;
 8 |   int cell;
 9 |   int deletion_flag;
10 | } ai_module;
11 | 
12 | typedef struct level {
13 |   int id;
14 |   int cells_amount;
15 |   int protection_flag;
16 | } level;
17 | 
18 | typedef struct status_event {
19 |   int id;
20 |   int module_id;
21 |   int new_status;
22 |   char date[11];
23 |   char time[8];
24 | } status_event;
25 | 
26 | #endif  // SRC_DB_STRUCTS_H_
27 | 


--------------------------------------------------------------------------------
/src/input_functions.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_INPUT_FUNCTIONS_H_
 2 | #define SRC_INPUT_FUNCTIONS_H_
 3 | #include <stdio.h>
 4 | #include "definitions.h"
 5 | #include "indices.h"
 6 | 
 7 | int clean_stdin(void);
 8 | int get_option(int limit, int *state);
 9 | int choose_table(int *state);
10 | int input(int *option);
11 | void all_files_initialization(int *state);
12 | void close_files(FILE *modules_db, FILE *levels_db, FILE *status_db,
13 |                    FILE *modules_indices, FILE *levels_indices, FILE *status_indices);
14 | 
15 | #endif  // SRC_INPUT_FUNCTIONS_H_
16 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_04/04_02.c:
--------------------------------------------------------------------------------
 1 | // Задача 04_02 (Поиск наибольшего):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void) {
 6 | 
 7 |     int n, maximum = 0, flag = 1;
 8 | 
 9 |     while (n != -1) {
10 |         if (scanf("%d", &n) == 1 && n >= -1) {
11 | 	        if (n > maximum) {
12 | 	            maximum = n;
13 | 	        }
14 | 	    } else {
15 | 	    	flag = 0; // False
16 | 	    	break;
17 | 	    }
18 | 	}
19 | 
20 | 	if (flag == 1) {
21 | 		printf("%d", maximum);
22 | 	} else {
23 | 		printf("n/a");
24 | 	}
25 | 	
26 |     return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/database.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DATABASE_H_
 2 | #define SRC_DATABASE_H_
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | #include "indices.h"
 6 | 
 7 | 
 8 | //////////////////////////////////////////////////////
 9 | void *select(FILE *db, FILE *indices, int id, size_t struct_size);
10 | int delete(FILE *db, FILE *indices, int id, size_t struct_size);
11 | int insert(FILE *db, FILE *indices, void *entity, size_t struct_size);
12 | int update(FILE *db, FILE *indices, int id, void *entity, size_t struct_size);
13 | //////////////////////////////////////////////////////
14 | 
15 | #endif  // SRC_DATABASE_H_
16 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_04/04_04.c:
--------------------------------------------------------------------------------
 1 | // Задача 04_04 (Наибольшая цифра):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void) {
 6 | 
 7 |     int n, maximum = 0;
 8 |     char end;
 9 | 
10 |     if (scanf("%d%c", &n, &end) == 2 && (end == '\n' || end == EOF)) {
11 |     	
12 |     	if (n < 0) {
13 |     		n = -n;
14 |     	}
15 | 
16 | 	    while (n > 0) {
17 | 	        if (n % 10 > maximum) {
18 | 	        	maximum = n % 10;
19 | 	        }
20 | 	        n = n / 10;
21 | 	    }
22 | 
23 | 	    printf("%d", maximum);
24 | 
25 |     } else {
26 | 		printf("n/a");
27 | 	}
28 | 	
29 |     return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_04/04_01.c:
--------------------------------------------------------------------------------
 1 | // Задача 04_01 (Биномиальные коэффициенты):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int factorial(int n);
 6 | 
 7 | int main(void) {
 8 | 
 9 |     int n;
10 |     scanf("%d", &n);
11 | 
12 |     for (int k = 0; k <= n; k++) {
13 | 
14 |         printf("%d", factorial(n) / (factorial(k) * factorial(n - k)));
15 | 
16 |         if (k != n) {
17 |         	printf(" ");
18 |         }
19 |     }
20 | 
21 |     return 0;
22 | }
23 | 
24 | int factorial(int n) {
25 | 
26 |     int s = 1;
27 | 
28 |     for (int i = 1; i <= n; i++) {
29 |         s *= i;
30 |     }
31 | 
32 |     return s;
33 | }
34 | 


--------------------------------------------------------------------------------
/src/db_master_tables/db_master_levels.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DB_MASTER_LEVELS_H_
 2 | #define SRC_DB_MASTER_LEVELS_H_
 3 | #include "../db_structs.h"
 4 | #include "../database.h"
 5 | #include "../definitions.h"
 6 | #include "../input_functions.h"
 7 | 
 8 | level *levels_select(int id, int *state);
 9 | int levels_delete(int id, int *state);
10 | int levels_insert(level *new_level, int *state);
11 | int levels_update(int id, level *updated_level, int *state);
12 | void levels_select_query(int *state);
13 | void levels_insert_query(int *state);
14 | void levels_update_query(int *state);
15 | void levels_delete_query(int *state);
16 | void print_level(level printed_level);
17 | level input_level(int *state);
18 | 
19 | #endif  // SRC_DB_MASTER_LEVELS_H_
20 | 
21 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_06-08/palindrom.c:
--------------------------------------------------------------------------------
 1 | // определить является ли введенное слово палиндромом
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(){
 6 | 
 7 |     char word[200];
 8 |     int len = 0;
 9 |     int flag = 0;
10 | 
11 |     while (scanf("%c", &word[len]) == 1 && word[len] != '\n') {
12 |         if (word[len] >= 'a' && word[len] <= 'z')
13 |             word[len] -= 32;
14 |         len++;
15 |     }
16 | 
17 |     
18 |     for (int i = 0; i < len; i++){
19 |         if (word[i] != word[len-i-1]){
20 |             flag = 1;
21 |             break;
22 |            }
23 |         }
24 |     
25 |     if (flag) {
26 |         printf("NO");
27 |     }    
28 |     else {
29 |         printf("YES");
30 |     }
31 | 
32 |     return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/src/indices.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_INDICES_H_
 2 | #define SRC_INDICES_H_
 3 | #include <stdio.h>
 4 | #include "db_structs.h"
 5 | #include "input_functions.h"
 6 | 
 7 | 
 8 | typedef struct id_index {
 9 |   int id;
10 |   int db_pos;
11 | } id_index;
12 | 
13 | void init_indices(FILE *db, size_t struct_size, FILE *index_file);
14 | void index_initial_sort(int begin, int end, FILE *index_file);
15 | void swap_indices(int left, int right, id_index *left_index, id_index *right_index, FILE *index_file);
16 | id_index index_binary_search(int id, int *shift, FILE *index_file);
17 | void insert_into_index(int id, int pos, FILE *index_file);
18 | void delete_from_index(int id, FILE *index_file);
19 | void update_index(int id, int pos, FILE *index);
20 | 
21 | 
22 | #endif  // SRC_INDICES_H_
23 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_04/04_05.c:
--------------------------------------------------------------------------------
 1 | // Задача 04_05 (Product of odd digits):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void) {
 6 | 
 7 |  	int n, product = 1, counter = 0;
 8 |     char end;
 9 | 
10 |     if (scanf("%d%c", &n, &end) == 2 && (end == '\n' || end == EOF)) {
11 |     	
12 |     	if (n < 0) {
13 |     		n = -n;
14 |     	}
15 | 
16 | 	    while (n > 0) {
17 | 	        
18 | 	        if (n % 10 % 2 != 0) {
19 | 	            product *= n % 10;
20 | 	            counter++;
21 | 	        }
22 | 
23 | 	        n = n / 10;        
24 | 	    }
25 | 
26 | 	    if (counter > 0) {
27 | 	    	printf("%d", product);
28 | 	    } else {
29 | 	    	printf("0");
30 | 	    }
31 | 
32 |     } else {
33 | 		printf("n/a");
34 | 	}
35 | 	
36 |     return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/src/db_master_levels.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DB_MASTER_LEVELS_H_
 2 | #define SRC_DB_MASTER_LEVELS_H_
 3 | #include "db_structs.h"
 4 | #include "database.h"
 5 | #include "definitions.h"
 6 | #include "input_functions.h"
 7 | #include "indices.h"
 8 | 
 9 | level *levels_select(int id, int *state);
10 | int levels_delete(int id, int *state);
11 | int levels_insert(level *new_level, int *state);
12 | int levels_update(int id, level *updated_level, int *state);
13 | void levels_select_query(int *state);
14 | void levels_insert_query(int *state);
15 | void levels_update_query(int *state);
16 | void levels_delete_query(int *state);
17 | void levels_all_query(int *state);
18 | void print_level(level printed_level);
19 | level input_level(int *state);
20 | 
21 | #endif  // SRC_DB_MASTER_LEVELS_H_
22 | 
23 | 


--------------------------------------------------------------------------------
/src/Makefile:
--------------------------------------------------------------------------------
 1 | COMP=gcc
 2 | CFLAGS=-c -Wall -Wextra -Werror
 3 | SOURCES=database.c indices.c db_master_modules.c db_master_levels.c db_master_status_events.c input_functions.c shared.c modules_db.c 
 4 | OBJECTS=$(SOURCES:.c=.o)
 5 | EXECUTABLE=./dbms
 6 | 
 7 | all: create_dbms
 8 | 
 9 | create_dbms: $(SOURCES) db_structs.h definitions.h $(EXECUTABLE)
10 | 
11 | $(EXECUTABLE): $(OBJECTS)
12 | 	$(COMP) $^ -o $@
13 | 
14 | .c.a: database.o
15 | 	ar rcs $@ $^
16 | 
17 | .c.o:
18 | 	$(COMP) $(CFLAGS) $< -o $@
19 | 
20 | clean:
21 | 	rm -rf $(OBJECTS) $(EXECUTABLE)
22 | 
23 | 
24 | rebuild: clean all
25 | 
26 | stylecheck:
27 | 	cp ../materials/linters/CPPLINT.cfg .
28 | 	python3 ../materials/linters/cpplint.py --extensions=c $(SOURCES) *.h
29 | 
30 | cppcheck:
31 | 	cppcheck --enable=all --suppress=missingIncludeSystem ./


--------------------------------------------------------------------------------
/src/db_logs.txt:
--------------------------------------------------------------------------------
 1 | Check tables.....
 2 | 
 3 | ============================
 4 | MODULES
 5 | ============================
 6 | 0 Main module 4 3 0
 7 | 1 Text module 2 3 0
 8 | 2 Audio module 3 4 0
 9 | 3 Speech module 1 2 0
10 | 4 Fuzzy module 4 3 0
11 | 5 Neural module 1 1 0
12 | 6 Door management module 1 4 0
13 | 7 Simple logic module 2 2 0
14 | ...
15 | 
16 | ===========================
17 | LEVELS
18 | ===========================
19 | 1 4 0
20 | 2 4 0
21 | 3 4 0
22 | 4 4 0
23 | 
24 | ===========================
25 | STATUSES
26 | ===========================
27 | 0 0 1 05.11.2020 08:43:59
28 | 1 1 1 08.07.2020 02:07:10
29 | 2 2 1 28.11.2020 06:03:02
30 | 3 3 1 15.01.2020 15:36:22
31 | 4 4 1 05.01.2020 08:14:24
32 | 5 5 1 11.06.2020 17:48:49
33 | 6 6 1 25.03.2020 16:26:42
34 | 7 7 1 24.09.2020 13:16:23
35 | ...
36 | 


--------------------------------------------------------------------------------
/src/db_master_tables/db_master_modules.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DB_MASTER_MODULES_H_
 2 | #define SRC_DB_MASTER_MODULES_H_
 3 | #include "../db_structs.h"
 4 | #include <string.h>
 5 | #include "../database.h"
 6 | #include "../definitions.h"
 7 | #include "../input_functions.h"
 8 | 
 9 | ai_module *ai_modules_select(int id, int *state);
10 | int ai_modules_delete(int id, int *state);
11 | int ai_modules_update(int id, ai_module *updated_ai_module, int *state);
12 | int ai_modules_insert(ai_module *new_ai_module, int *state);
13 | void ai_modules_select_query(int *state);
14 | void ai_modules_insert_query(int *state);
15 | void ai_modules_update_query(int *state);
16 | void ai_modules_delete_query(int *state);
17 | void print_ai_module(ai_module printed_module);
18 | ai_module input_ai_module(int *state);
19 | 
20 | 
21 | 
22 | #endif  // SRC_DB_MASTER_MODULES_H_
23 | 
24 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_03/03_03.c:
--------------------------------------------------------------------------------
 1 | // Задача 03_03 (Перестановка крайних цифр):
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | int main(void) {
 6 | 
 7 |     int x, first, second, third;
 8 |     int flag = 1; // True (т.е. число положительное)
 9 | 
10 |     if (scanf("%d", &x) == 1) {  // 159
11 |         
12 |         if (x < 0) {
13 |             flag = 0; // False (т.е. число отрицательное)
14 |             x = -x;
15 |         }
16 | 
17 |         third = x % 10;   // 9
18 |         x = x / 10;       // 15
19 |         second = x % 10;  // 5
20 |         first = x / 10;   // 1
21 | 
22 |         if (flag == 1) {
23 |             printf("%d%d%d", third, second, first);
24 |         } else {
25 |             printf("-%d%d%d", third, second, first);
26 |         }
27 |         
28 |     } else {
29 |         printf("n/a");
30 |     }
31 | 
32 |     return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/src/db_master_modules.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DB_MASTER_MODULES_H_
 2 | #define SRC_DB_MASTER_MODULES_H_
 3 | #include "db_structs.h"
 4 | #include <string.h>
 5 | #include "database.h"
 6 | #include "definitions.h"
 7 | #include "input_functions.h"
 8 | #include "indices.h"
 9 | 
10 | ai_module *ai_modules_select(int id, int *state);
11 | int ai_modules_delete(int id, int *state);
12 | int ai_modules_update(int id, ai_module *updated_ai_module, int *state);
13 | int ai_modules_insert(ai_module *new_ai_module, int *state);
14 | void ai_modules_select_query(int *state);
15 | void ai_modules_insert_query(int *state);
16 | void ai_modules_update_query(int *state);
17 | void ai_modules_delete_query(int *state);
18 | void ai_modules_all_query(int *state);
19 | void print_ai_module(ai_module printed_module);
20 | ai_module input_ai_module(int *state);
21 | 
22 | 
23 | 
24 | #endif  // SRC_DB_MASTER_MODULES_H_
25 | 
26 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_06-08/struct_1.c:
--------------------------------------------------------------------------------
 1 | // Вывести имена и фамилии студентов, чей рост выше заданного
 2 | 
 3 | #include <stdio.h>
 4 | 
 5 | struct students {
 6 |     char name[100];
 7 |     char surname[100];
 8 |     int height; // рост студента
 9 | };
10 | 
11 | int main() {
12 |     int n; // количество студентов
13 |     scanf("%d", &n);
14 | 
15 |     struct students student[n];
16 |     
17 |     for (int i = 0; i < n; i++) {
18 |         scanf("%s", student[i].name);
19 |         scanf("%s", student[i].surname);
20 |         scanf("%d", &student[i].height);
21 |     }
22 | 
23 |     int limit;  // заданный рост
24 |     scanf("%d", &limit);
25 | 
26 |     for (int i = 0; i < n; i++) {
27 |         if (student[i].height > limit) {
28 |             printf("%s, %s\n", student[i].name, student[i].surname);
29 |         }
30 |     }
31 | 
32 |     return 0;
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/src/db_master_tables/db_master_status_events.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DB_MASTER_STATUS_EVENTS_H_
 2 | #define SRC_DB_MASTER_STATUS_EVENTS_H_
 3 | #include "../db_structs.h"
 4 | #include <time.h>
 5 | #include "../database.h"
 6 | #include "../definitions.h"
 7 | #include "../input_functions.h"
 8 | 
 9 | status_event *status_events_select(int id, int *state);
10 | int status_events_delete(int id, int *state);
11 | int status_events_insert(status_event *new_status_event, int *state);
12 | int status_events_update(int id, status_event *updated_status_event, int *state);
13 | void status_events_select_query(int *state);
14 | void status_events_insert_query(int *state);
15 | void status_events_update_query(int *state);
16 | void status_events_delete_query(int *state);
17 | void print_status_event(status_event printed_event);
18 | status_event input_status_event(int *state);
19 | 
20 | #endif  // SRC_DB_MASTER_STATUS_EVENTS_H_
21 | 
22 | 


--------------------------------------------------------------------------------
/src/db_master_status_events.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DB_MASTER_STATUS_EVENTS_H_
 2 | #define SRC_DB_MASTER_STATUS_EVENTS_H_
 3 | #include "db_structs.h"
 4 | #include <time.h>
 5 | #include "database.h"
 6 | #include "definitions.h"
 7 | #include "input_functions.h"
 8 | #include "indices.h"
 9 | 
10 | status_event *status_events_select(int id, int *state);
11 | int status_events_delete(int id, int *state);
12 | int status_events_insert(status_event *new_status_event, int *state);
13 | int status_events_update(int id, status_event *updated_status_event, int *state);
14 | void status_events_select_query(int *state);
15 | void status_events_insert_query(int *state);
16 | void status_events_update_query(int *state);
17 | void status_events_delete_query(int *state);
18 | void status_events_all_query(int *state);
19 | void print_status_event(status_event printed_event);
20 | status_event input_status_event(int *state);
21 | 
22 | #endif  // SRC_DB_MASTER_STATUS_EVENTS_H_
23 | 
24 | 


--------------------------------------------------------------------------------
/exam_tasks.md:
--------------------------------------------------------------------------------
 1 | 5 - вывести матрицу с числами от 1 до н^2 по змейке из левого верхнего угла в центр (как на степике)
 2 | 4 - повернуть матрицу на 90 градусов по часовой стрелке 
 3 | 3 - вывести массив неопределенной длины (ввод заканчивается на -1) задом наперед 
 4 | 2 - перевести радианы (действительное число) в градусы (целое число)
 5 | 1 - вывести строчку, где внутри есть " и '
 6 | 
 7 | 
 8 | 3 - поменять Макс и мин в массиве, заканчивающемся на -1
 9 | 
10 | 1. Исправить программу, там чёт простое, типа int pi = 3.14 было
11 | 2. Перевести из радианов в градусы (проверка на то, что радианы >=0 НЕ НУЖНА, проверено мистейком)
12 | 3. Дано целое число, вывести максимальную его цифру
13 | 4. Есть матрица, надо поменять местам строки, содержащие первые вхождения максимального и минимального элементов матрицы
14 | 5. На вход подаётся положительное число, надо вывести матрицу, заполненную числами от 1 до n^2 по спирали, типа
15 | 1 2 3
16 | 8 9 4
17 | 7 6 5
18 | 
19 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_06-08/struct_2.c:
--------------------------------------------------------------------------------
 1 | // Вывести имена студентов, чья оценка выше средней
 2 | 
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | 
 6 | struct students {
 7 |     char name[100];
 8 |     int mark;  // оценка
 9 | };
10 | 
11 | 
12 | int main() {
13 | 
14 |     int n;
15 |     scanf("%d", &n);
16 |     
17 |     struct students student[n];
18 | 
19 |     for (int i = 0; i < n; i++) {
20 |         scanf("%s", student[i].name);
21 |         scanf("%d", &student[i].mark);
22 |     }
23 | 
24 |     int summa = 0;
25 | 
26 |     for (int i = 0; i < n; i++) {
27 |         summa += student[i].mark;
28 |     }
29 | 
30 |     int average;
31 |     average = summa / n;
32 | 
33 |     int counter = 0;
34 | 
35 |     for (int i = 0; i < n; i++) {
36 |         if (student[i].mark > average) {
37 |             if (counter == 0) {
38 |                 printf("%s", student[i].name);
39 |             } else {
40 |                 printf(", %s", student[i].name);
41 |             }
42 |             counter++;
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/shared.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_SHARED_H_
 2 | #define SRC_SHARED_H_
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | #include <string.h>
 6 | #include "db_master_modules.h"
 7 | #include "db_master_levels.h"
 8 | #include "db_master_status_events.h"
 9 | #include "definitions.h"
10 | #include "input_functions.h"
11 | 
12 | void non_aggregative_query(int *state, void (*ai_modules_query)(int*),
13 |                     void (*levels_query)(int*), void (*status_events_query)(int*));
14 | void active_modules_query(int *state);
15 | void memlevel_modules_query(int *state);
16 | void set_protected_module_query(int *state);
17 | void move_module_query(int *state);
18 | void set_protected_level_query(int *state);
19 | void to_protected_mode_events(int module_id, FILE *status_db);
20 | int find_module_status(ai_module cur_module, FILE *status_db);
21 | int find_max_status_id(int size, FILE *status_db);
22 | void save_the_world(int *state);
23 | void turn_off_additional_modules(FILE *module_db, FILE *status_db);
24 | void set_deletion_flags(FILE *module_db);
25 | int move_main_module(FILE *module_db, FILE *level_db);
26 | 
27 | #endif  // SRC_SHARED_H_
28 | 


--------------------------------------------------------------------------------
/how_to_check_input.md:
--------------------------------------------------------------------------------
 1 | # Проверка вводимых данных, как это делать и зочем
 2 | ## Шаблонный вариат проверки ввода 
 3 | 
 4 | Задание: найдите максимальное число из трех введеных целочисленных величин. 
 5 | Функцию поиска большего числа оформите отдельной функцией. 
 6 | 
 7 | ```
 8 | #include <stdio.h>
 9 | 
10 | void search_max(int, int, int, int*); 
11 | 
12 | /* void search_max - это прототип функции. В прототипе функции можно указывать тип передаваемых аргументов, комилятор ссыт на имена типов данных, ибо ему пофиг и вообще эти имена дофига памяти занимают */
13 | 
14 | int main() {
15 |     int number1, number2, number3, max_number; /*  инициализируем переменные */
16 |     if (scanf("%d %d %d", &number1, &number2, &number3) != 3) { /* смотри ниже пункт 1 */
17 |         printf("n/a\n");
18 |     } else {
19 |         search_max(number1, number2, number3, &max_number);
20 |         printf("%d", max_number);
21 |     }
22 |   return 0;  
23 |   }
24 | 
25 |   void search_max(int number1, int number2, int number3, int *max_number){
26 |       *max_number = number1
27 |       if(number2 > *max_number){
28 |           *max_number = number2;
29 |       } else if(number3 > *max_number){
30 |           
31 |       }
32 |   }
33 |   ```
34 |   


--------------------------------------------------------------------------------
/src/definitions.h:
--------------------------------------------------------------------------------
 1 | #ifndef SRC_DEFINITIONS_H_
 2 | #define SRC_DEFINITIONS_H_
 3 | 
 4 | #define MODULES_TABLE 1
 5 | #define LEVELS_TABLE 2
 6 | #define STATUS_EVENTS_TABLE 3
 7 | 
 8 | #define RUNNING 0
 9 | #define OFF 1
10 | #define ERROR 2
11 | 
12 | #define INSTRUCTION_MESSAGE "Please choose one operation:\n"\
13 |                             "\t1. SELECT\n"\
14 |                             "\t2. INSERT\n"\
15 |                             "\t3. UPDATE\n"\
16 |                             "\t4. DELETE\n"\
17 |                             "\t5. SELECT ALL\n"\
18 |                             "\t6. Get all active additional modules\n"\
19 |                             "\t7. Get all modules at certain memory level\n"\
20 |                             "\t8. Set protected mode for module by id\n"\
21 |                             "\t9. Move module by id to specified memory "\
22 |                             "level and cell\n"\
23 |                             "\t10. Set protection flag of the specified"\
24 |                             " memory level and cell\n"\
25 |                             "\t11. Save the world!\n"\
26 |                             "\t0. Exit the program\n> "
27 | 
28 | #define TABLE_CHOOSE_MESSAGE "Please choose a table:\n"\
29 |                              "\t1. Modules\n"\
30 |                              "\t2. Levels\n"\
31 |                              "\t3. Status events\n> "
32 | 
33 | 
34 | #endif  // SRC_DEFINITIONS_H_
35 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_05/05_03.c:
--------------------------------------------------------------------------------
 1 | // Задача 05_03 (Вывод последовательности):
 2 | 
 3 | #include <stdio.h>
 4 | #define NMAX 1000 
 5 | 
 6 | int main() {
 7 | 
 8 |     int data[NMAX];                        // пойдем через статический массив
 9 |     int counter = 0;
10 |     int flag = 1;                          // предполагаем верный ввод
11 |     
12 |     for (int i = 0; i < NMAX; i++) {
13 |     	if (scanf("%d", &data[i]) == 1) {
14 |     		if (data[i] == -1) {
15 |     			break;
16 |     		} else {
17 |             	counter++;
18 |     		}
19 |     	} else {
20 |     		flag = 0;                      // False - ошибка ввода
21 |             break;
22 |     	}
23 |     }
24 | 
25 |     if (flag == 1) {
26 |     	if (counter % 2 == 0) {                           // если четное количество элементов
27 | 	        for (int j = 0; j < counter / 2; j++) {
28 | 	        	if (j != 0) {
29 | 	        		printf(" ");
30 | 	            }
31 | 	            printf("%d ", data[j]);
32 | 	            printf("%d", data[counter - 1 - j]);
33 | 	        }
34 | 	    } else {                                          // если нечетное количество элементов
35 | 	        for (int j = 0; j < counter / 2 ; j++) {
36 | 	            printf("%d ", data[j]);
37 | 	            printf("%d ", data[counter - 1 - j]);
38 | 	    	}
39 | 	        printf("%d", data[counter/2]);
40 | 	    }
41 | 
42 |     } else {
43 |     	printf("n/a");
44 |     }
45 | 
46 | 	return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_05/05_05.c:
--------------------------------------------------------------------------------
 1 | // Задача 05_05 (Реверс последовательности):
 2 | 
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | 
 6 | int main() {
 7 | 
 8 |     int number = 0;
 9 |     int index = 0;
10 |     int number_of_elements = 1;
11 |     int *data = (int*)malloc(number_of_elements * sizeof(int));
12 | 
13 |     if (data != NULL) {  // если память выделилась
14 | 
15 |         int flag = 1;  // True - предполагаем верный ввод
16 |         
17 |         while (number != -1) {  // пока не конец последовательности
18 | 
19 |             if (scanf("%d", &number) == 1 && number >= -1) {  // если ввод верный
20 | 
21 |                 if (number != -1) {
22 |                     number_of_elements++;
23 |                     data = (int*)realloc(data, number_of_elements * sizeof(int));
24 |                     data[index] = number;
25 |                     index++;
26 |                 }
27 | 
28 |             } else {
29 |                 flag = 0;  // False
30 |                 break;
31 |             }
32 | 
33 |         }
34 | 
35 |         if (flag) {
36 | 
37 |             for (int i = index - 1; i >= 0; i--) {
38 |                 printf("%d", data[i]);
39 |                 if (i != 0) {
40 |                     printf(" ");
41 |                 }
42 |             }
43 | 
44 |         } else {
45 |             printf("n/a");
46 |         }
47 | 
48 |         free(data);
49 |     
50 |     } else {
51 |         printf("Error - memory wasn't allocated");
52 |     }
53 |     
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_05/05_04.c:
--------------------------------------------------------------------------------
 1 | // Задача 05_04 (Removing repetitions):
 2 | 
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | 
 6 | int main(void) {
 7 | 
 8 |     int number = 0, index = 0, counter = 0, number_of_elements = 1;
 9 |     int *data = (int*)malloc(number_of_elements * sizeof(int));
10 | 
11 |     while (number != -1) {                // пока не конец последовательности
12 | 
13 |         if (scanf("%d", &number) == 1) {  // если ввод верный
14 |             if (number != -1) {
15 | 
16 |                 if (counter >= number_of_elements) {
17 |                     number_of_elements++;
18 |                     data = (int*)realloc(data, number_of_elements * sizeof(int));
19 |                 }
20 | 
21 |                 data[index] = number;
22 |                 index++;
23 |                 counter++;
24 | 
25 |             }
26 | 
27 |         } else {
28 |             printf("n/a");
29 |             break;
30 |         }
31 | 
32 |     }
33 | 
34 |     int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
35 | 
36 |     counter = 0;
37 | 
38 |     for (int i = 0; i < number_of_elements; i++) {
39 |         for (int k = 0; k < 10; k++) {
40 |             if (data[i] == arr[k]) {
41 |                 arr[k] = -1;
42 |                 if (counter == 0) {
43 |                     printf("%d", data[i]);
44 |                 } else {
45 |                     printf(" %d", data[i]);
46 |                 }
47 |                 counter++;
48 |             }
49 |         }
50 |     }
51 | 
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/exam_info.md:
--------------------------------------------------------------------------------
 1 | # ЧТО НУЖНО ЗАПОМНИТЬ НАИЗУСТЬ ПЕРЕД ЭКЗАМЕНОМ 
 2 | 
 3 |  ## :pencil2: Алгоритм входа в систему :pencil2:
 4 | 
 5 | В сам компуктер вводим следующее:
 6 | > Login: exam 
 7 | >
 8 | > Password: exam 
 9 | 
10 | - (1) Открываем терминал (если значка терминала нет на рабочем столе, то можно его найти вот так:
11 |     * Жмакаем комманд + пробел 
12 |     * Вводим в строку поиска "терминал"
13 | 
14 | - (2) Открываем Сафари или Хром
15 | (команда для открытия сафари с терминала 
16 | `open -a Safari`) 
17 |     * Если понадобится что-то ввести, то жмем Always allow, если ничего не получается, то введите в поле password слово exam
18 | 
19 | * (3) Заходим на сайт http://exam-msk.21-school.ru
20 | **ЭТОТ САЙТ НАДО ЗАПОМНИТЬ НАИЗУСТЬ**
21 | 
22 | * (4) Вводим в логин и пароль с платформы в формате:
23 | > логин@student.21-school.ru
24 | >
25 | > пароль 
26 | >
27 | **СВОЙ МЭЙЛ И ПАРОЛЬ НАДО ЗАПОМНИТЬ НАИЗУСТЬ**
28 | 
29 |   (5) Откроется сайтик и в поле где необходимо ввести ssh ключ - вводим ssh ключ
30 | >Где взять этот  ssh ключ? 
31 | >- (1) Открываем новое окно терминала. В терминале прописываем команду ssh-keygen 
32 | >- (2) Жмакаем энтер
33 | >- (3) Жмакаем еще **2 раза** энтер 
34 | >- (4) Выводим ключ в теминал через команду: `cat .ssh/id_rsa.pub`
35 | >- (5) Копируем его и вставляем в поле куда надо ввести ssh-ключ 
36 | 
37 | 
38 | ## Как открыть среду разработки (на примере VS Code)
39 | 
40 | - (1) Заходим в терминал
41 | - (2) Поднимаемся в директорию повыше командой  `cd ..`
42 | - (3) Еще раз поднимаемся в директорию повыше командой  `cd ..`
43 | - (4) Выводим список директорий через команду  `ls`
44 | - (5) Ищем папку Applications и переходим в нее через команду cd Applications
45 | - (6) Запускаем VS Code командой `open "Visual Studio Code.app"`
46 | 
47 | :octocat::octocat::octocat: #ямыавгуст :octocat::octocat::octocat:


--------------------------------------------------------------------------------
/src/modules_db.c:
--------------------------------------------------------------------------------
 1 | #include "db_master_modules.h"
 2 | #include "db_master_levels.h"
 3 | #include "db_master_status_events.h"
 4 | #include "shared.h"
 5 | #include "definitions.h"
 6 | 
 7 | void execute_query(int option, int *state);
 8 | 
 9 | int main(void) {
10 |   int state = RUNNING;
11 |   int option = 0;
12 |   all_files_initialization(&state);
13 |   while (OFF != state) {
14 |     if (RUNNING == state) {
15 |       state = input(&option);
16 |       execute_query(option, &state);
17 |     }
18 |     if (ERROR == state) {
19 |       printf("An error occured! Continuing...\n");
20 |       state = RUNNING;
21 |     }
22 |   }
23 |   return 0;
24 | }
25 | 
26 | void execute_query(int option, int *state) {
27 |   if (1 == option) {
28 |     non_aggregative_query(state, ai_modules_select_query, levels_select_query, status_events_select_query);
29 |   } else if (2 == option) {
30 |     non_aggregative_query(state, ai_modules_insert_query, levels_insert_query, status_events_insert_query);
31 |   } else if (3 == option) {
32 |     non_aggregative_query(state, ai_modules_update_query, levels_update_query, status_events_update_query);
33 |   } else if (4 == option) {
34 |     non_aggregative_query(state, ai_modules_delete_query, levels_delete_query, status_events_delete_query);
35 |   } else if (5 == option) {
36 |     non_aggregative_query(state, ai_modules_all_query, levels_all_query, status_events_all_query);
37 |   } else if (6 == option) {
38 |     active_modules_query(state);
39 |   } else if (7 == option) {
40 |     memlevel_modules_query(state);
41 |   } else if (8 == option) {
42 |     set_protected_module_query(state);
43 |   } else if (9 == option) {
44 |     move_module_query(state);
45 |   } else if (10 == option) {
46 |     set_protected_level_query(state);
47 |   } else if (11 == option) {
48 |     save_the_world(state);
49 |   }
50 | }
51 | 
52 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_05/05_01.c:
--------------------------------------------------------------------------------
 1 | // Задача 05_01 (Скалярное произведение):
 2 | 
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | 
 6 | int getNumbers(int *number, int n);
 7 | 
 8 | int main() {
 9 | 	
10 |    	int n;
11 |   	scanf("%d", &n);
12 |                            
13 |   	int *A = (int*)malloc(n * sizeof(int));            // создаем первый динамический массив
14 |   	int *B = (int*)malloc(n * sizeof(int));            // создаем второй динамический массив
15 | 
16 |   	if (A != NULL && B != NULL) {                      // если память выделилась:
17 | 
18 |   		if (getNumbers(A, n) && getNumbers(B, n)) {    // если ввод верный
19 | 
20 | 		  	int result = 0;
21 | 
22 | 		    for (int i = 0; i < n; i++) {
23 | 		      	result += A[i] * B[i];
24 | 		    }
25 | 
26 | 		  	printf("%d", result);
27 | 	
28 | 	 	} else {                                       // если ввод неверный
29 |   			printf("n/a");
30 |   		}
31 | 
32 |   		free(A);
33 | 	  	free(B);
34 |     	
35 |   	} else {                                           // если память не выделилась
36 |   		printf("n/a");
37 |   	}
38 | 
39 |   	return 0;
40 | }
41 | 
42 | int getNumbers(int *number, int n) {
43 |   	char end;
44 |   	int flag = 1;   
45 |   	                                 // ожидаем адекватный вход
46 |   	for (int i = 0; i < n; i++) {
47 |     	if (scanf("%d%c", &number[i], &end) == 2) {
48 |     		if (i != n - 1) {
49 |     			if (end != ' ') {
50 |     				flag = 0;                        // False - ошибка ввода
51 |     				break;
52 |     			}
53 |     		} else {
54 | 				if (end != '\n' && end != EOF) {
55 |     				flag = 0;                        // False - ошибка ввода
56 |     				break;
57 |     			}
58 |     		}
59 |     	} else {
60 |     		flag = 0;                                // False - ошибка ввода
61 |     		break;
62 |     	}
63 |   	}
64 | 
65 |   	return flag;
66 | }
67 | 


--------------------------------------------------------------------------------
/src/database.c:
--------------------------------------------------------------------------------
 1 | #include "database.h"
 2 | 
 3 | void *select(FILE *db, FILE *indices, int id, size_t struct_size) {
 4 |   void *result = malloc(struct_size);
 5 |   int shift = 0; id_index select_index = index_binary_search(id, &shift, indices);
 6 |   if (-1 == select_index.db_pos) {
 7 |     free(result);
 8 |     result = NULL;
 9 |   } else {
10 |     fseek(db, shift * struct_size, SEEK_SET);
11 |     fread(result, struct_size, 1, db);
12 |   }
13 |   return result;
14 | }
15 | 
16 | int delete(FILE *db, FILE *indices, int id, size_t struct_size) {
17 |   fseek(db, 0, SEEK_END);
18 |   int size = ftell(db) / struct_size;
19 |   void *cur_entity = malloc(struct_size);
20 |   int found_target = 0;
21 |   FILE *temp = fopen("tempusfrempus.tmp", "w+b");
22 |   for (int i = 0; i < size; i++) {
23 |     fseek(db, i * struct_size, SEEK_SET);
24 |     fseek(temp, (i - found_target) * struct_size, SEEK_SET);
25 |     fread(cur_entity, struct_size, 1, db);
26 |     if (*(int*)(cur_entity) == id) {
27 |       found_target = 1;
28 |     } else {
29 |       fwrite(cur_entity, struct_size, 1, temp);
30 |     }
31 |   }
32 |   if (found_target) {
33 |     db = freopen(NULL, "wb", db);
34 |     rewind(db);
35 |     rewind(temp);
36 |     for (int i = 0; i < size - 1; i++) {
37 |       fseek(db, i * struct_size, SEEK_SET);
38 |       fseek(temp, i * struct_size, SEEK_SET);
39 |       fread(cur_entity, struct_size, 1, temp);
40 |       fwrite(cur_entity, struct_size, 1, db);
41 |     }
42 |     db = freopen(NULL, "r+b", db);
43 |     rewind(db);
44 |     delete_from_index(id, indices);
45 |   }
46 |   fclose(temp);
47 |   free(cur_entity);
48 |   remove("tempusfrempus.tmp");
49 |   return found_target;
50 | }
51 | 
52 | int insert(FILE *db, FILE *indices, void *entity, size_t struct_size) {
53 |   int desired_id = *(int*)entity;
54 |   id_index found_index = index_binary_search(desired_id, NULL, indices);
55 |   if (-1 == found_index.db_pos) {
56 |     fseek(db, 0, SEEK_END);
57 |     fwrite(entity, struct_size, 1, db);
58 |     insert_into_index(desired_id, ftell(db) / struct_size - 1, indices);
59 |   }
60 |   return -1 == found_index.db_pos;
61 | }
62 | 
63 | int update(FILE *db, FILE *indices, int id, void *entity, size_t struct_size) {
64 |   int new_id = *(int*)entity;
65 |   int shift = 0;
66 |   id_index new_id_index = index_binary_search(new_id, NULL, indices);
67 |   id_index updated_index = index_binary_search(id, &shift, indices);
68 |   if (-1 == new_id_index.db_pos || (new_id == id && -1 != updated_index.db_pos)) {
69 |     fseek(db, shift * struct_size, SEEK_SET);
70 |     fwrite(entity, struct_size, 1, db);
71 |     update_index(updated_index.id, updated_index.db_pos, indices);
72 |   }
73 |   return (2 * (-1 == updated_index.id)) |\
74 |        (-1 != new_id_index.id && new_id_index.id != updated_index.id);
75 | }
76 | 


--------------------------------------------------------------------------------
/src/input_functions.c:
--------------------------------------------------------------------------------
 1 | #include "input_functions.h"
 2 | 
 3 | int clean_stdin(void) {
 4 |   while (getchar() != '\n') {}
 5 |   return 1;
 6 | }
 7 | 
 8 | int get_option(int limit, int *state) {
 9 |   int option = -1;
10 |   if (RUNNING == *state) {
11 |     if (1 != scanf("%d", &option) || option <= 0 || option > limit) {
12 |       *state = ERROR;
13 |     }
14 |   }
15 |   clean_stdin();
16 |   return option;
17 | }
18 | 
19 | int choose_table(int *state) {
20 |   printf(TABLE_CHOOSE_MESSAGE);
21 |   int table_number = get_option(3, state);
22 |   return table_number;
23 | }
24 | 
25 | int input(int *option) {
26 |   int state = RUNNING;
27 |   printf(INSTRUCTION_MESSAGE);
28 |   *option = get_option(11, &state);
29 |   if (0 == *option) {
30 |     state = OFF;
31 |   }
32 |   return state;
33 | }
34 | 
35 | void all_files_initialization(int *state) {
36 |   FILE *modules_db = NULL;
37 |   FILE *levels_db = NULL;
38 |   FILE *status_db = NULL;
39 |   FILE *modules_indices = NULL;
40 |   FILE *levels_indices = NULL;
41 |   FILE *status_indices = NULL;
42 |   if (NULL == (modules_db = fopen("../materials/master_modules.db", "r+b"))) {
43 |     *state = OFF;
44 |   } else if (NULL == (levels_db = fopen("../materials/master_levels.db", "r+b"))) {
45 |     *state = OFF;
46 |   } else if (NULL == (status_db = fopen("../materials/master_status_events.db", "r+b"))) {
47 |     *state = OFF;
48 |   } else if (NULL == (modules_indices = fopen("../materials/modules_indices.db", "w+b"))) {
49 |     *state = OFF;
50 |   } else if (NULL == (levels_indices = fopen("../materials/levels_indices.db", "w+b"))) {
51 |     *state = OFF;
52 |   } else if (NULL == (status_indices = fopen("../materials/status_events_indices.db", "w+b"))) {
53 |     *state = OFF;
54 |   } else {
55 |     init_indices(modules_db, sizeof(ai_module), modules_indices);
56 |     init_indices(levels_db, sizeof(level), levels_indices);
57 |     init_indices(status_db, sizeof(status_event), status_indices);
58 |   }
59 |   if (RUNNING != *state) {
60 |     printf("CRITICAL ERROR! CANNOT OPEN DATABASE FILE! CLOSING!!!\n");
61 |   }
62 |   close_files(modules_db, levels_db, status_db, modules_indices, levels_indices, status_indices);
63 | }
64 | 
65 | void close_files(FILE *modules_db, FILE *levels_db, FILE *status_db,
66 |                  FILE *modules_indices, FILE *levels_indices, FILE *status_indices) {
67 |   if (NULL != modules_db) {
68 |     fclose(modules_db);
69 |   }
70 |   if (NULL != levels_db) {
71 |     fclose(levels_db);
72 |   }
73 |   if (NULL != status_db) {
74 |     fclose(status_db);
75 |   }
76 |   if (NULL != modules_indices) {
77 |     fclose(modules_indices);
78 |   }
79 |   if (NULL != levels_indices) {
80 |     fclose(levels_indices);
81 |   }
82 |   if (NULL != status_indices) {
83 |     fclose(status_indices);
84 |   }
85 | }
86 | 
87 | 
88 | 
89 | 
90 | 
91 | 


--------------------------------------------------------------------------------
/algotitm_check.md:
--------------------------------------------------------------------------------
 1 | # Как по стайлу вылизать свой код 
 2 | 
 3 | 1) `clang-format -i name.c` 
 4 | 
 5 | Если вы хотите привести в порядок все файлы в папке, то можно воспользоваться регуляркой 
 6 |     `clang-format -i *.c`  будут вылизаны все файлы с расширением .с
 7 | 
 8 | 2) Если в вашем коде есть однострочные комментарии, то лучше их убрать, так как линтер будет ругаться. Можно их заменить на /* */ на вот такие. 
 9 | 
10 | В стандарте языка СИ однострочные комментарии появились относительно недавно, вероятно поэтому линтер ругается на одного строные комментарии 
11 | 
12 | 3) `gcc -Wall -Wextra -Werror name.c `
13 | 
14 | Тут думаю пояснения не нужны, если комплиятор ругается, то исправляем согласно сообщению из компилятора
15 | 
16 | 4) Не забываем про проверку на линтер
17 |  > Помимо тестов на корректные выходные данные система автотестирования будет
18 | >проверять вашу программу и ее исходный код по следующим пунктам:
19 | >
20 |  >* **Стилевые тесты.** Чтобы проверить, насколько красота вашего кода >соответствует
21 | >стандартам, вы можете протестировать ваш код с помощью скрипта ```materials/linters/cpplint.py```. В папке ```materials/linters``` также лежит файл ```CPPLINT.cfg```, который содержит необходимые фильтры-настройки для стилевого теста. Скрипт работает таким образом, что данный конфигурационный файл распространяет свое действие на все файлы, которые лежат с ним в директории или в директориях ниже. Поэтому, чтобы данные настройки применились к вашим файлам с исходным кодом, скопируйте ```CPPLINT.cfg``` в папку src (при отправке финального решения этот файл будет игнорироваться, его присутствие не обязательно). \
22 |  >  \
23 | Чтобы запустить скрипт, выполните следующую команду: \
24 |    ```python3 materials/linters/cpplint.py --extensions=c src/sourcefile_name.c``` \
25 |    \
26 |    Важно! Для запуска вам необходим python версии 3. Проверить установленную на
27 |    компьютере версию можно с помощью команды ```python3 --version```  
28 |    Чтобы скачать python3, введите в терминал одну из следующих команд: \
29 |    ```brew install python3``` \
30 |    или, если у вас есть root-права (для Ubuntu / Linux Mint / Debian) \
31 |    ```sudo apt install python3```
32 | 
33 | >
34 |  >* **Статический анализ кода.** Иногда (или не совсем иногда) встречается такое, >что 
35 | корректно компилирующаяся C-программа работает совершенно неправильно или завершается
36 |    с ошибкой попытки доступа не к своей области памяти. Чтобы предотвратить подобные
37 |    ошибки на этапе написания программы, используют специальные утилиты, которые анализируют
38 |    ваш исходный код на предмет потенциальных ошибок. Наша система автотестов использует
39 |    для этого ```cppcheck```. Чтобы установить эту утилиту, введите в терминал одну из следующих команд: \
40 |    ```brew install cppcheck``` \
41 |    или, если у вас есть root-права (для Ubuntu / Linux Mint / Debian) \
42 |    ```sudo apt install cppcheck``` \
43 |    \
44 |    Установив cppcheck, вы можете протестировать ваш исходный код: \
45 |    ```cppcheck --enable=all --suppress=missingIncludeSystem src/soursefile_name.c``` \
46 |    Также можно проверить сразу все файлы с исходным кодом в директории: \
47 |  >  ```cppcheck --enable=all --suppress=missingIncludeSystem src/```
48 | 
49 | 5)  Проверяем на учетки (дополняется) 


--------------------------------------------------------------------------------
/src/db_master_tables/db_master_levels.c:
--------------------------------------------------------------------------------
  1 | #include "db_master_levels.h"
  2 | 
  3 | level *levels_select(int id, int *state) {
  4 |   FILE *db = NULL;
  5 |   level *selected = NULL;
  6 |   if (NULL == (db = fopen("../materials/master_levels.db", "r+b"))) {
  7 |     *state = ERROR;
  8 |   } else {
  9 |     selected = select(db, id, sizeof(level));
 10 |     fclose(db);
 11 |   }
 12 |   return selected;
 13 | }
 14 | 
 15 | int levels_delete(int id, int *state) {
 16 |   FILE *db = NULL;
 17 |   int result = 0;
 18 |   if (NULL == (db = fopen("../materials/master_levels.db", "r+b"))) {
 19 |     *state = ERROR;
 20 |   } else {
 21 |     result = delete(db, id, sizeof(level));
 22 |     fclose(db);
 23 |   }
 24 |   return result;
 25 | }
 26 | 
 27 | int levels_insert(level *new_level, int *state) {
 28 |   FILE *db = NULL;
 29 |   int result = 0;
 30 |   if (NULL == (db = fopen("../materials/master_levels.db", "r+b"))) {
 31 |     *state = ERROR;
 32 |   } else {
 33 |     result = insert(db, new_level, sizeof(level));
 34 |     fclose(db);
 35 |   }
 36 |   return result;
 37 | }
 38 | 
 39 | int levels_update(int id, level *updated_level, int *state) {
 40 |   FILE *db = NULL;
 41 |   int result = 0;
 42 |   if (NULL == (db = fopen("../materials/master_levels.db", "r+b"))) {
 43 |     *state = ERROR;
 44 |   } else {
 45 |     result = update(db, id, updated_level, sizeof(level));
 46 |     fclose(db);
 47 |   }
 48 |   return result;
 49 | }
 50 | 
 51 | void levels_select_query(int *state) {
 52 |   int target_id = 0;
 53 |   printf("Insert number of the selected memory level:\n> ");
 54 |   if (1 != scanf("%d", &target_id)) {
 55 |     *state = ERROR;
 56 |   } else {
 57 |     level *result = levels_select(target_id, state);
 58 |     if (RUNNING == *state) {
 59 |       if (NULL == result) {
 60 |         printf("Level with inserted number doesn't appear in the database.\n");
 61 |       } else {
 62 |         print_level(*result);
 63 |       }
 64 |     }
 65 |     free(result);
 66 |   }
 67 | }
 68 | 
 69 | void levels_insert_query(int *state) {
 70 |   level new_level = input_level(state);
 71 |   int result = levels_insert(&new_level, state);
 72 |   if (RUNNING == *state) {
 73 |     if (0 == result) {
 74 |       printf("Database already has a memory level with that number.\n");
 75 |     } else {
 76 |       printf("New memory level was successfully inserted into database!\n");
 77 |     }
 78 |   }
 79 | }
 80 | 
 81 | void levels_update_query(int *state) {
 82 |   int target_id = 0;
 83 |   level updated_level = input_level(state);
 84 |   if (RUNNING != *state || !printf("Insert number of the updated memory level:\n> ")\
 85 |         ||  1 != scanf("%d", &target_id)) {
 86 |     *state = ERROR;
 87 |   } else {
 88 |     int result = levels_update(target_id, &updated_level, state);
 89 |     if (RUNNING == *state) {
 90 |       if (0 == result) {
 91 |         printf("Memory level with inserted number doesn't appear in the database.\n");
 92 |       } else {
 93 |         printf("The memory level was successfully updated!\n");
 94 |       }
 95 |     }
 96 |   }
 97 | }
 98 | 
 99 | void levels_delete_query(int *state) {
100 |   int target_id = 0;
101 |   printf("Insert number of the deleted memory level:\n> ");
102 |   if (1 != scanf("%d", &target_id)) {
103 |     *state = ERROR;
104 |   } else {
105 |     int result = levels_delete(target_id, state);
106 |     if (RUNNING == *state) {
107 |       if (0 == result) {
108 |         printf("Memory level with inserted ID doesn't appear in the database.\n");
109 |       } else {
110 |         printf("The memory level was successfully deleted!\n");
111 |       }
112 |     }
113 |   }
114 | }
115 | 
116 | void print_level(level printed_level) {
117 |   printf("  %d %d %d\n", printed_level.id, printed_level.cells_amount, printed_level.protection_flag);
118 | }
119 | 
120 | level input_level(int *state) {
121 |   level new_level = {0};
122 |   printf("Insert new memory level number:\n> ");
123 |   if (1 != scanf("%d", &(new_level.id))) {
124 |     *state = ERROR;
125 |   } else if (!printf("Insert new memory level cells amount:\n> ") || !clean_stdin()\
126 |                   || 1 != scanf("%d", &(new_level.cells_amount))) {
127 |     *state = ERROR;
128 |   } else if (!printf("Insert new memory level protection flag:\n> ") || !clean_stdin()\
129 |                   || 1 != scanf("%d", &(new_level.protection_flag)) || !clean_stdin()) {
130 |     *state = ERROR;
131 |   }
132 |   return new_level;
133 | }
134 | 
135 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_04/README.md:
--------------------------------------------------------------------------------
 1 | # Exam_04_01. Биномиальные коэффициенты.
 2 | 
 3 | ## Задание
 4 | 
 5 | **Уровень:** 3  
 6 | **Темы:** Базовые управляющие структуры (следование, ветвление, повторение).  
 7 | **Директория для решения:** src/  
 8 | **Файлы решения:** main.c  
 9 | **Входные данные:** стандартный поток ввода (stdin)  
10 | **Выходные данные:** стандартный поток вывода (stdout)  
11 | 
12 | Написать программу, осуществляющую вывод на стандартный поток stdout строки состоящей из биномиальных коэффициентов для `k=0..n` разделенных пробелами. `!` - операция взятия факториала, факториал числа n вычисляется как `n! = 1*2*3*...*n`, параметр n задается в виде неотрицательного целого числа через стандартный поток ввода stdin. В конце ответа не должно быть переноса на новую строку.
13 | 
14 | **Примечание:** за последним выведенным коэффициентом не должно следовать пробела.
15 | 
16 | ## Примеры
17 | 
18 | | Входные данные | Результат работы |  
19 | | 0 | 1 |  
20 | | 1 | 1 1 |  
21 | | 2 | 1 2 1 |  
22 | | 3 | 1 3 3 1 |  
23 | 
24 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
25 | 
26 | ________________________________
27 | 
28 | # Exam_04_02. Поиск наибольшего.
29 | 
30 | ## Задание
31 | 
32 | **Уровень:** 2  
33 | **Темы:** Базовые управляющие структуры (следование, ветвление, повторение).  
34 | **Директория для решения:** src/  
35 | **Файлы решения:** main.c  
36 | **Входные данные:** стандартный поток ввода (stdin)  
37 | **Выходные данные:** стандартный поток вывода (stdout)  
38 | 
39 | Написать программу, осуществляющую поиск наибольшего числа в последовательности, состоящей из неотрицательных целых чисел. Последовательность задается на стандартный поток ввода stdin, элементы последовательности разделены между собой пробелами, концом последовательности, является число -1, которое обозначает конец последовательности и не является ее злементом. Найденное наибольшее значение необходимо вывести на стандартный поток вывода. Гарантируется, что в последоватальности всегда есть хоть один элемент. В конце ответа не должно быть переноса ка новую строку.
40 | 
41 | ## Примеры
42 | 
43 | | Входные данные | Результат работы |  
44 | | 1000 -1 | 1000 |  
45 | | 1 2 3 4 3 2 1 -1 | 4 |  
46 | 
47 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
48 | 
49 | ________________________________
50 | 
51 | # Exam_04_04. Наибольшая цифра.
52 | 
53 | ## Задание
54 | 
55 | **Уровень:** 3  
56 | **Темы:** Базовые управляющие структуры (следование, ветвление, повторение).  
57 | **Директория для решения:** src/  
58 | **Файлы решения:** main.c  
59 | **Входные данные:** стандартный поток ввода (stdin)  
60 | **Выходные данные:** стандартный поток вывода (stdout)  
61 | 
62 | Написать программу, осуществляющую вывод на стандартный поток stdout наибольшей цифры целого числа, которое задается на стандартном потоке ввода stdin. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
63 | 
64 | ## Примеры
65 | 
66 | | Входные данные | Результат работы |  
67 | | 123 | 3 |  
68 | | 10 | 1 |  
69 | | 111111 | 1 |  
70 | | 0 | 0 |  
71 | 
72 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
73 | 
74 | ________________________________
75 | 
76 | # Exam_04_05. Произведение нечетных чисел.
77 | 
78 | ## Задание
79 | 
80 | **Уровень:** 3  
81 | **Темы:** Базовые управляющие структуры (следование, ветвление, повторение).  
82 | **Директория для решения:** src/  
83 | **Файлы решения:** main.c  
84 | **Входные данные:** стандартный поток ввода (stdin)  
85 | **Выходные данные:** стандартный поток вывода (stdout)  
86 | 
87 | Написать программу, осуществляющую вывод на стандартный поток stdout произведение нечетных цифр целого числа, подаваемого через стандартный поток ввода stdin. Если нечетных цифр в числе нет, вывести в качестве результата 0. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
88 | 
89 | ## Примеры
90 | 
91 | | Входные данные | Результат работы |  
92 | | 1234 | 3 |  
93 | | 24 | 0 |  
94 | | -3 | 3 |  
95 | 
96 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
97 | 


--------------------------------------------------------------------------------
/src/db_master_tables/db_master_modules.c:
--------------------------------------------------------------------------------
  1 | #include "db_master_modules.h"
  2 | 
  3 | ai_module *ai_modules_select(int id, int *state) {
  4 |   FILE *db = NULL;
  5 |   ai_module *selected = NULL;
  6 |   if (NULL == (db = fopen("../materials/master_modules.db", "r+b"))) {
  7 |     *state = ERROR;
  8 |   } else {
  9 |     selected = select(db, id, sizeof(ai_module));
 10 |     fclose(db);
 11 |   }
 12 |   return selected;
 13 | }
 14 | 
 15 | int ai_modules_delete(int id, int *state) {
 16 |   FILE *db = NULL;
 17 |   int result = 0;
 18 |   if (NULL == (db = fopen("../materials/master_modules.db", "r+b"))) {
 19 |     *state = ERROR;
 20 |   } else {
 21 |     result = delete(db, id, sizeof(ai_module));
 22 |     fclose(db);
 23 |   }
 24 |   return result;
 25 | }
 26 | 
 27 | int ai_modules_insert(ai_module *new_ai_module, int *state) {
 28 |   FILE *db = NULL;
 29 |   int result = 0;
 30 |   if (NULL == (db = fopen("../materials/master_modules.db", "r+b"))) {
 31 |     *state = ERROR;
 32 |   } else {
 33 |     result = insert(db, new_ai_module, sizeof(ai_module));
 34 |     fclose(db);
 35 |   }
 36 |   return result;
 37 | }
 38 | 
 39 | int ai_modules_update(int id, ai_module *updated_ai_module, int *state) {
 40 |   FILE *db = NULL;
 41 |   int result = 0;
 42 |   if (NULL == (db = fopen("../materials/master_modules.db", "r+b"))) {
 43 |     *state = ERROR;
 44 |   } else {
 45 |     result = update(db, id, updated_ai_module, sizeof(ai_module));
 46 |     fclose(db);
 47 |   }
 48 |   return result;
 49 | }
 50 | 
 51 | void ai_modules_select_query(int *state) {
 52 |   int target_id = 0;
 53 |   printf("Insert ID of the selected AI module:\n> ");
 54 |   if (1 != scanf("%d", &target_id)) {
 55 |     *state = ERROR;
 56 |   } else {
 57 |     ai_module *result = ai_modules_select(target_id, state);
 58 |     if (RUNNING == *state) {
 59 |       if (NULL == result) {
 60 |         printf("Module with inserted ID doesn't appear in the database.\n");
 61 |       } else {
 62 |         print_ai_module(*result);
 63 |       }
 64 |     }
 65 |     free(result);
 66 |   }
 67 | }
 68 | 
 69 | void ai_modules_insert_query(int *state) {
 70 |   ai_module new_module = input_ai_module(state);
 71 |   int result = ai_modules_insert(&new_module, state);
 72 |   if (RUNNING == *state) {
 73 |     if (0 == result) {
 74 |       printf("Database already has an AI module with that ID.\n");
 75 |     } else {
 76 |       printf("New AI module was successfully inserted into database!\n");
 77 |     }
 78 |   }
 79 | }
 80 | 
 81 | void ai_modules_update_query(int *state) {
 82 |   int target_id = 0;
 83 |   ai_module updated_module = input_ai_module(state);
 84 |   if (RUNNING != *state || !printf("Insert ID of the updated module:\n> ") ||  1 != scanf("%d", &target_id)) {
 85 |     *state = ERROR;
 86 |   } else {
 87 |     int result = ai_modules_update(target_id, &updated_module, state);
 88 |     if (RUNNING == *state) {
 89 |       if (0 == result) {
 90 |         printf("Module with inserted ID doesn't appear in the database.\n");
 91 |       } else {
 92 |         printf("The module was successfully updated!\n");
 93 |       }
 94 |     }
 95 |   }
 96 | }
 97 | 
 98 | void ai_modules_delete_query(int *state) {
 99 |   int target_id = 0;
100 |   printf("Insert ID of the deleted module:\n> ");
101 |   if (1 != scanf("%d", &target_id)) {
102 |     *state = ERROR;
103 |   } else {
104 |     int result = ai_modules_delete(target_id, state);
105 |     if (RUNNING == *state) {
106 |       if (0 == result) {
107 |         printf("Module with inserted ID doesn't appear in the database.\n");
108 |       } else {
109 |         printf("The module was successfully deleted!\n");
110 |       }
111 |     }
112 |   }
113 | }
114 | 
115 | void print_ai_module(ai_module printed_module) {
116 |   printf("  %d %s %d %d %d\n", printed_module.id, printed_module.name,
117 |       printed_module.module_level, printed_module.cell, printed_module.deletion_flag);
118 | }
119 | 
120 | ai_module input_ai_module(int *state) {
121 |   ai_module new_module = {0};
122 |   printf("Insert new module ID:\n> ");
123 |   if (1 != scanf("%d", &(new_module.id))) {
124 |     *state = ERROR;
125 |   } else if (!printf("Insert new module name:\n> ") ||  !clean_stdin()\
126 |               || NULL == fgets(new_module.name, 30, stdin)) {
127 |     *state = ERROR;
128 |   } else if (!printf("Insert new module memory level:\n> ") \
129 |               || 1 != scanf("%d", &(new_module.module_level))) {
130 |     *state = ERROR;
131 |   } else if (!printf("Insert new module memory cell:\n> ") || !clean_stdin()\
132 |               || 1 != scanf("%d", &(new_module.cell)) || !clean_stdin()) {
133 |     *state = ERROR;
134 |   }
135 |   new_module.name[strcspn(new_module.name, "\n")] = 0;
136 |   new_module.deletion_flag = 0;
137 |   return new_module;
138 | }
139 | 


--------------------------------------------------------------------------------
/src/db_master_tables/db_master_status_events.c:
--------------------------------------------------------------------------------
  1 | #include "db_master_status_events.h"
  2 | 
  3 | status_event *status_events_select(int id, int *state) {
  4 |   FILE *db = NULL;
  5 |   status_event *selected = NULL;
  6 |   if (NULL == (db = fopen("../../materials/master_status_events.db", "r+b"))) {
  7 |     *state = ERROR;
  8 |   } else {
  9 |     selected = select(db, id, sizeof(status_event));
 10 |     fclose(db);
 11 |   }
 12 |   return selected;
 13 | }
 14 | 
 15 | int status_events_delete(int id, int *state) {
 16 |   FILE *db = NULL;
 17 |   int result = 0;
 18 |   if (NULL == (db = fopen("../../materials/master_status_events.db", "r+b"))) {
 19 |     *state = ERROR;
 20 |   } else {
 21 |     result = delete(db, id, sizeof(status_event));
 22 |     fclose(db);
 23 |   }
 24 |   return result;
 25 | }
 26 | 
 27 | int status_events_insert(status_event *new_status_event, int *state) {
 28 |   FILE *db = NULL;
 29 |   int result = 0;
 30 |   if (NULL == (db = fopen("../../materials/master_status_events.db", "r+b"))) {
 31 |     *state = ERROR;
 32 |   } else {
 33 |     result = insert(db, new_status_event, sizeof(status_event));
 34 |     fclose(db);
 35 |   }
 36 |   return result;
 37 | }
 38 | 
 39 | int status_events_update(int id, status_event *updated_status_event, int *state) {
 40 |   FILE *db = NULL;
 41 |   int result = 0;
 42 |   if (NULL == (db = fopen("../../materials/master_status_events.db", "r+b"))) {
 43 |     *state = ERROR;
 44 |   } else {
 45 |     result = update(db, id, updated_status_event, sizeof(status_event));
 46 |     fclose(db);
 47 |   }
 48 |   return result;
 49 | }
 50 | 
 51 | void status_events_select_query(int *state) {
 52 |   int target_id = 0;
 53 |   printf("Insert ID of the selected event:\n> ");
 54 |   if (1 != scanf("%d", &target_id)) {
 55 |     *state = ERROR;
 56 |   } else {
 57 |     status_event *result = status_events_select(target_id, state);
 58 |     if (RUNNING == *state) {
 59 |       if (NULL == result) {
 60 |         printf("Event with inserted ID doesn't appear in the database.\n");
 61 |       } else {
 62 |         print_status_event(*result);
 63 |       }
 64 |     }
 65 |     free(result);
 66 |   }
 67 | }
 68 | 
 69 | void status_events_insert_query(int *state) {
 70 |   status_event new_event = input_status_event(state);
 71 |   int result = status_events_insert(&new_event, state);
 72 |   if (RUNNING == *state) {
 73 |     if (0 == result) {
 74 |       printf("Database already has an status event with that ID.\n");
 75 |     } else {
 76 |       printf("New status event was successfully inserted into database!\n");
 77 |     }
 78 |   }
 79 | }
 80 | 
 81 | void status_events_update_query(int *state) {
 82 |   int target_id = 0;
 83 |   status_event updated_event = input_status_event(state);
 84 |   if (RUNNING != *state || !printf("Insert ID of the updated event:\n> ") ||  1 != scanf("%d", &target_id)) {
 85 |     *state = ERROR;
 86 |   } else {
 87 |     int result = status_events_update(target_id, &updated_event, state);
 88 |     if (RUNNING == *state) {
 89 |       if (0 == result) {
 90 |         printf("Event with inserted ID doesn't appear in the database.\n");
 91 |       } else {
 92 |         printf("The status event was successfully updated!\n");
 93 |       }
 94 |     }
 95 |   }
 96 | }
 97 | 
 98 | void status_events_delete_query(int *state) {
 99 |   int target_id = 0;
100 |   printf("Insert ID of the deleted event:\n> ");
101 |   if (1 != scanf("%d", &target_id)) {
102 |     *state = ERROR;
103 |   } else {
104 |     int result = status_events_delete(target_id, state);
105 |     if (RUNNING == *state) {
106 |       if (0 == result) {
107 |         printf("Event with inserted ID doesn't appear in the database.\n");
108 |       } else {
109 |         printf("The status event was successfully deleted!\n");
110 |       }
111 |     }
112 |   }
113 | }
114 | 
115 | void print_status_event(status_event printed_event) {
116 |   printf("  %d %d %d %s %s\n", printed_event.id, printed_event.module_id,
117 |                      printed_event.new_status, printed_event.date, printed_event.time);
118 | }
119 | 
120 | status_event input_status_event(int *state) {
121 |   status_event new_event = {0};
122 |   printf("Insert new event ID:\n> ");
123 |   if (1 != scanf("%d", &(new_event.id))) {
124 |     *state = ERROR;
125 |   } else if (!printf("Insert new event module ID:\n> ") ||  !clean_stdin()\
126 |              || 1 != scanf("%d", &(new_event.module_id))) {
127 |     *state = ERROR;
128 |   } else if (!printf("Insert new event module status:\n> ") || !clean_stdin()\
129 |              || 1 != scanf("%d", &(new_event.new_status)) || !clean_stdin()) {
130 |     *state = ERROR;
131 |   }
132 |   time_t cur_seconds = time(NULL);
133 |   struct tm *cur_time = localtime(&cur_seconds);
134 |   strftime(new_event.date, 11, "%d.%m.%Y", cur_time);
135 |   strftime(new_event.time, 8, "%H:%M:%S", cur_time);
136 |   return new_event;
137 | }
138 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_02/README.md:
--------------------------------------------------------------------------------
  1 | # Exam_02_01. Некорректная работа программы №1.
  2 | 
  3 | ## Задание
  4 | 
  5 | **Уровень:** 1  
  6 | **Темы:** Ввод/вывод данных..  
  7 | **Директория для решения:** src/  
  8 | **Файлы решения:** main.c  
  9 | **Входные данные:** -  
 10 | **Выходные данные:** стандартный поток вывода (stdout)  
 11 | 
 12 | Необходимо исправить синтаксические, стилевые и логические ошибки, не изменяя работу программы. В конце ответа не должно быть переноса на новую строку.
 13 | 
 14 | ```c
 15 | #include <stdio.h>
 16 | int main (void)
 17 | {
 18 | 	int x = 0;
 19 | 
 20 | 	scanf ("%d", x);
 21 | 	printf("%05d", x);
 22 | 	return 0;
 23 | }
 24 | ```
 25 | 
 26 | ## Примеры
 27 | 
 28 | | Входные данные | Результат работы |  
 29 | | 0 | 00000 |  
 30 | | 1 | 00001 |  
 31 | | -10 | -0010 |  
 32 | | 666666 | 666666 |  
 33 | 
 34 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 35 | 
 36 | ________________________________
 37 | 
 38 | # Exam_02_02. Некорректная работа программы №2.
 39 | 
 40 | ## Задание
 41 | 
 42 | **Уровень:** 1  
 43 | **Темы:** Ввод/вывод данных..  
 44 | **Директория для решения:** src/  
 45 | **Файлы решения:** main.c  
 46 | **Входные данные:** -  
 47 | **Выходные данные:** стандартный поток вывода (stdout)  
 48 | 
 49 | Необходимо исправить синтаксические, стилевые и логические ошибки, не изменяя работу программы. В конце ответа не должно быть переноса на новую строку.
 50 | 
 51 | ```c
 52 | #include <stdio.h>
 53 | int main (void)
 54 | {
 55 | 	int x = -21;
 56 | 
 57 | 	scanf ("%d", x);
 58 | 	printf("%03d", x);
 59 | 
 60 | 	return 0;
 61 | }
 62 | ```
 63 | 
 64 | ## Примеры
 65 | 
 66 | | Входные данные | Результат работы |  
 67 | | 0 | 00000 |  
 68 | | 1 | 00001 |  
 69 | | -12 | -0012 |  
 70 | | 55555 | 55555 |  
 71 | 
 72 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 73 | 
 74 | ________________________________
 75 | 
 76 | # Exam_02_03. Некорректная работа программы №3.
 77 | 
 78 | ## Задание
 79 | 
 80 | **Уровень:** 1  
 81 | **Темы:** Ввод/вывод данных..  
 82 | **Директория для решения:** src/  
 83 | **Файлы решения:** main.c  
 84 | **Входные данные:** -  
 85 | **Выходные данные:** стандартный поток вывода (stdout)  
 86 | 
 87 | Написать программу для вывода на стандартный поток знаменитой фразы: "I'm Groot" (c) Groot  
 88 | В конце ответа не должно быть переноса на новую строку.
 89 | 
 90 | ## Примеры
 91 | 
 92 | | Входные данные | Результат работы |  
 93 | | | "I'm Groot" (c) Groot |  
 94 | 
 95 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 96 | 
 97 | ________________________________
 98 | 
 99 | # Exam_02_04. Путь к Блокноту
100 | 
101 | ## Задание
102 | 
103 | **Уровень:** 1  
104 | **Темы:** Ввод/вывод данных..  
105 | **Директория для решения:** src/  
106 | **Файлы решения:** main.c  
107 | **Входные данные:** -  
108 | **Выходные данные:** стандартный поток вывода (stdout)  
109 | 
110 | Предположим, что операционная система Windows установлена на диск С:, требуется написать программу для вывода полного пути до стандартной программы блокнот: C:\Windows\System32\notepad.exe  
111 | В конце ответа не должно быть переноса на новую строку.
112 | 
113 | **Примечание:** Полный или абсолютный путь - это путь, который указывает на одно и то же место в файловой системе, вне зависимости от текущего рабочего каталога. Полный путь в Windows всегда начинается с имени диска.
114 | 
115 | ## Примеры
116 | | Входные данные | Результат работы |  
117 | | | C:\Windows\System32\notepad.exe |  
118 | 
119 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
120 | 
121 | ________________________________
122 | 
123 | # Exam_02_05. 205.
124 | 
125 | ## Задание
126 | 
127 | **Уровень:** 1  
128 | **Темы:** Ввод/вывод данных..  
129 | **Директория для решения:** src/  
130 | **Файлы решения:** main.c  
131 | **Входные данные:** -  
132 | **Выходные данные:** стандартный поток вывода (stdout)  
133 | 
134 | Необходимо исправить синтаксические, стилевые и логические ошибки, не изменяя работу программы. Программа должна  вывести на экран число 205.  
135 | В конце ответа не должно быть переноса на новую строку.
136 | 
137 | ```c
138 | #include <stdio.h>
139 | int main (void)
140 | {
141 | 	int x = 205;
142 | 	printf("%d", &x);
143 | 	return 0;
144 | }
145 | ```
146 | 
147 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
148 | 


--------------------------------------------------------------------------------
/src/indices.c:
--------------------------------------------------------------------------------
  1 | #include "indices.h"
  2 | 
  3 | 
  4 | 
  5 | void init_indices(FILE *db, size_t struct_size, FILE *index_file) {
  6 |   fseek(db, 0, SEEK_END);
  7 |   int size = ftell(db) / struct_size;
  8 |   for (int i = 0; i < size; i++) {
  9 |     id_index cur_id = {.id = 0, .db_pos = i};
 10 |     fseek(db, i * struct_size, SEEK_SET);
 11 |     fread(&(cur_id.id), sizeof(int), 1, db);
 12 |     fseek(index_file, i * sizeof(id_index), SEEK_SET);
 13 |     fwrite(&cur_id, sizeof(id_index), 1, index_file);
 14 |   }
 15 |   index_initial_sort(0, size - 1, index_file);
 16 | }
 17 | 
 18 | void index_initial_sort(int begin, int end, FILE *index_file) {
 19 |   int left = begin;
 20 |   id_index left_index = {0};
 21 |   fseek(index_file, left * sizeof(id_index), SEEK_SET);
 22 |   fread(&left_index, sizeof(id_index), 1, index_file);
 23 |   int right = end;
 24 |   id_index right_index = {0};
 25 |   fseek(index_file, right * sizeof(id_index), SEEK_SET);
 26 |   fread(&right_index, sizeof(id_index), 1, index_file);
 27 |   id_index pivot_index = {0};
 28 |   fseek(index_file, sizeof(id_index) * (left + right) / 2, SEEK_SET);
 29 |   fread(&pivot_index, sizeof(id_index), 1, index_file);
 30 |   while (left <= right) {
 31 |     while (left_index.id < pivot_index.id && left < end) {
 32 |       left++;
 33 |       fseek(index_file, left * sizeof(id_index), SEEK_SET);
 34 |       fread(&left_index, sizeof(id_index), 1, index_file);
 35 |     }
 36 |     while (right_index.id > pivot_index.id && right > begin) {
 37 |       right--;
 38 |       fseek(index_file, right * sizeof(id_index), SEEK_SET);
 39 |       fread(&right_index, sizeof(id_index), 1, index_file);
 40 |     }
 41 |     if (left <= right) {
 42 |       swap_indices(left, right, &left_index, &right_index, index_file);
 43 |       left++;
 44 |       right--;
 45 |     }
 46 |   }
 47 |   if (begin < right) {
 48 |     index_initial_sort(begin, right, index_file);
 49 |   }
 50 |   if (end > left) {
 51 |     index_initial_sort(left, end, index_file);
 52 |   }
 53 | }
 54 | 
 55 | void swap_indices(int left, int right, id_index *left_index, id_index *right_index, FILE *index_file) {
 56 |   id_index temp = *left_index;
 57 |   fseek(index_file, left * sizeof(id_index), SEEK_SET);
 58 |   fwrite(right_index, sizeof(id_index), 1, index_file);
 59 |   *left_index = *right_index;
 60 |   fseek(index_file, right * sizeof(id_index), SEEK_SET);
 61 |   fwrite(&temp, sizeof(id_index), 1, index_file);
 62 |   *right_index = temp;
 63 | }
 64 | 
 65 | id_index index_binary_search(int id, int *shift, FILE *index_file) {
 66 |   fseek(index_file, 0, SEEK_END);
 67 |   int left = 0;
 68 |   int right = ftell(index_file) / sizeof(id_index);
 69 |   id_index found_index = {.db_pos = -1};
 70 |   while (left <= right && -1 == found_index.db_pos) {
 71 |     int middle = (left + right) / 2;
 72 |     id_index middle_index;
 73 |     fseek(index_file, middle * sizeof(id_index), SEEK_SET);
 74 |     fread(&middle_index, sizeof(id_index), 1, index_file);
 75 |     if (middle_index.id == id) {
 76 |       found_index = middle_index;
 77 |       if (NULL != shift) {
 78 |         *shift = middle;
 79 |       }
 80 |     } else if (middle_index.id < id) {
 81 |       left = middle + 1;
 82 |     } else {
 83 |       right = middle - 1;
 84 |     }
 85 |   }
 86 |   return found_index;
 87 | }
 88 | 
 89 | void insert_into_index(int id, int pos, FILE *index_file) {
 90 |   fseek(index_file, 0, SEEK_END);
 91 |   int i = ftell(index_file) / sizeof(id_index);
 92 |   id_index new_index = {.id = id, .db_pos = pos};
 93 |   fwrite(&new_index, sizeof(id_index), 1, index_file);
 94 |   id_index prev_index;
 95 |   if (i > 0) {
 96 |     fseek(index_file, (i - 1) * sizeof(id_index), SEEK_SET);
 97 |     fread(&prev_index, sizeof(id_index), 1, index_file);
 98 |     while (i > 0 && prev_index.id > new_index.id) {
 99 |       swap_indices(i - 1, i, &prev_index, &new_index, index_file);
100 |       new_index = prev_index;
101 |       fseek(index_file, -1, SEEK_CUR);
102 |       fread(&prev_index, sizeof(id_index), 1, index_file);
103 |       i--;
104 |     }
105 |   }
106 | }
107 | 
108 | void delete_from_index(int id, FILE *index_file) {
109 |   FILE *tmpfile = fopen("tempotempoindekususamadesu.tmp", "w+b");
110 |   fseek(index_file, 0, SEEK_END);
111 |   int size = ftell(index_file) / sizeof(id_index);
112 |   int found_target = 0;
113 |   for (int i = 0; i < size; i++) {
114 |     id_index cur_index = {0};
115 |     fseek(index_file, i * sizeof(id_index), SEEK_SET);
116 |     fread(&cur_index, sizeof(id_index), 1, index_file);
117 |     if (cur_index.id != id) {
118 |       fwrite(&cur_index, sizeof(id_index), 1, tmpfile);
119 |     } else {
120 |       found_target = 1;
121 |     }
122 |   }
123 |   if (found_target) {
124 |     index_file = freopen(NULL, "wb", index_file);
125 |     rewind(tmpfile);
126 |     for (int i = 0; i < size - 1; i++) {
127 |       id_index cur_index = {0};
128 |       fread(&cur_index, sizeof(id_index), 1, tmpfile);
129 |       fwrite(&cur_index, sizeof(id_index), 1, index_file);
130 |     }
131 |     index_file = freopen(NULL, "r+b", index_file);
132 |     rewind(index_file);
133 |   }
134 |   fclose(tmpfile);
135 |   remove("tempotempoindekususamadesu.tmp");
136 | }
137 | 
138 | void update_index(int id, int pos, FILE *index_file) {
139 |   int shift = 0;
140 |   id_index updated_index = index_binary_search(id, &shift, index_file);
141 |   updated_index.db_pos = pos;
142 |   fseek(index_file, shift * sizeof(id_index), SEEK_SET);
143 |   fwrite(&updated_index, sizeof(id_index), 1, index_file);
144 | }
145 | 
146 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_05/README.md:
--------------------------------------------------------------------------------
  1 | # Exam_05_01. Скалярное произведение.
  2 | 
  3 | ## Задание
  4 | 
  5 | **Уровень:** 3  
  6 | **Темы:** динамические массивы  
  7 | **Директория для решения:** src/  
  8 | **Файлы решения:** main.c  
  9 | **Входные данные:** стандартный поток ввода (stdin)  
 10 | **Выходные данные:** стандартный поток вывода (stdout)  
 11 | 
 12 | Написать программу, производящую скалярное умножение двух векторов n-мерного пространства. Через входной поток ввода stdin задается целое положительное число n, обозначающее размерность пространства, затем следуют 2 строки: n целочисленных координат первого вектора и n целочисленных координат второго, разделенные пробелом. Результат вычислений вывести на стандартный поток вывода stdout. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
 13 | 
 14 | **Примечание:** последовательность может быть любого размера.
 15 | 
 16 | ## Примеры
 17 | 
 18 | | Входные данные | Результат работы |  
 19 | | 1<br>7<br>3 | 21 |  
 20 | | 3<br>1 2 3<br>1 2 3 | 14 |  
 21 | 
 22 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 23 | 
 24 | ________________________________
 25 | 
 26 | # Exam_05_03. Вывод последовательности.
 27 | 
 28 | ## Задание
 29 | 
 30 | **Уровень:** 3  
 31 | **Темы:** динамические массивы  
 32 | **Директория для решения:** src/  
 33 | **Файлы решения:** main.c  
 34 | **Входные данные:** стандартный поток ввода (stdin)  
 35 | **Выходные данные:** стандартный поток вывода (stdout)  
 36 | 
 37 | Написать программу, производящую вывод элементов последовательности `x = (x_1, x_2, x_3, ..., x_n)` в следующем порядке `x_1 x_n x_2 x_{n-1}...`. Последовательность `x` состоит из целых неотрицательных чисел и задается на стандартном потоке ввода stdin, элементы последовательности разделены между собой пробелами, концом последовательности является число -1, которое обозначает конец последовательности и не является ее злементом. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
 38 | 
 39 | **Примечание:** за последним выведенным элементом не должно следовать пробела.
 40 | 
 41 | **Примечание:** последовательность может быть любого размера.
 42 | 
 43 | ## Примеры
 44 | 
 45 | | Входные данные | Результат работы |  
 46 | | 1 2 3 -1 | 1 3 2 |  
 47 | | 1 2 3 4 5 6 -1 | 1 6 2 5 3 4 |  
 48 | | -1 |  |  
 49 | 
 50 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 51 | 
 52 | ________________________________
 53 | 
 54 | # Exam_05_04. Removing repetitions.
 55 | 
 56 | ## Задание
 57 | 
 58 | **Уровень:** 3  
 59 | **Темы:** динамические массивы  
 60 | **Директория для решения:** src/  
 61 | **Файлы решения:** main.c  
 62 | **Входные данные:** стандартный поток ввода (stdin)  
 63 | **Выходные данные:** стандартный поток вывода (stdout)  
 64 | 
 65 | Написать программу, производящую удаление повторяющихся элементов последовательности, состоящей из целых неотрицательных чисел. Последовательность задается на стандартном потоке ввода stdin, элементы последовательности разделены между собой пробелами, концом последовательности является число -1, которое обозначает конец последовательности и не является ее злементом. Вывести элементы результирующей последовательности, разделенные между собой пробелами, на стандартный поток вывода stdout. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
 66 | 
 67 | **Примечание:** Порядок вывода элементов в результирующей последовательности определяется порядком первых вхождений соответствующих значений в первоначальной последовательности.
 68 | 
 69 | **Примечание:** последовательность может быть любого размера.
 70 | 
 71 | ## Примеры
 72 | 
 73 | | Входные данные | Результат работы |  
 74 | | 1 1 2 2 3 -1 | 1 2 3 |  
 75 | | 1 2 1 3 1 4 -1 | 1 2 3 4 |  
 76 | | -1 |  |  
 77 | 
 78 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 79 | 
 80 | ________________________________
 81 | 
 82 | # Exam_05_05. Реверс последовательности.
 83 | 
 84 | ## Задание
 85 | 
 86 | **Уровень:** 2  
 87 | **Темы:** динамические массивы  
 88 | **Директория для решения:** src/  
 89 | **Файлы решения:** main.c  
 90 | **Входные данные:** стандартный поток ввода (stdin)  
 91 | **Выходные данные:** стандартный поток вывода (stdout)  
 92 | 
 93 | Написать программу, осуществляющую вывод на стандартный поток stdout через пробел в обратном порядке элементов последовательности, состоящей из целых неотрицательных чисел. Последовательность задается на стандартный поток ввода stdin, элементы последовательности разделены между собой пробелами, концом последовательности является число -1, которое обозначает конец последовательности и не является ее элементом. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
 94 | 
 95 | **Примечание:** последовательность может быть любого размера.
 96 | 
 97 | ## Примеры
 98 | 
 99 | | Входные данные | Результат работы |  
100 | | 1 2 3 4 5 -1 | 5 4 3 2 1 |  
101 | | 1 1 1 2 2 2 -1 | 2 2 2 1 1 1 |  
102 | | -1 |  |  
103 | 
104 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
105 | 


--------------------------------------------------------------------------------
/src/db_master_levels.c:
--------------------------------------------------------------------------------
  1 | #include "db_master_levels.h"
  2 | 
  3 | level *levels_select(int id, int *state) {
  4 |   FILE *db = NULL;
  5 |   level *selected = NULL;
  6 |   if (NULL == (db = fopen("../materials/master_levels.db", "r+b"))) {
  7 |     *state = ERROR;
  8 |   } else {
  9 |     FILE *indices = NULL;
 10 |     if (NULL == (indices = fopen("../materials/levels_indices.db", "r+b"))) {
 11 |       *state = ERROR;
 12 |     } else {
 13 |       selected = select(db, indices, id, sizeof(level));
 14 |       fclose(indices);
 15 |     }
 16 |     fclose(db);
 17 |   }
 18 |   return selected;
 19 | }
 20 | 
 21 | int levels_delete(int id, int *state) {
 22 |   FILE *db = NULL;
 23 |   int result = 0;
 24 |   if (NULL == (db = fopen("../materials/master_levels.db", "r+b"))) {
 25 |     *state = ERROR;
 26 |   } else {
 27 |     FILE *indices = NULL;
 28 |     if (NULL == (indices = fopen("../materials/levels_indices.db", "r+b"))) {
 29 |       *state = ERROR;
 30 |     } else {
 31 |       result = delete(db, indices, id, sizeof(level));
 32 |       fclose(indices);
 33 |     }
 34 |     fclose(db);
 35 |   }
 36 |   return result;
 37 | }
 38 | 
 39 | int levels_insert(level *new_level, int *state) {
 40 |   FILE *db = NULL;
 41 |   int result = 0;
 42 |   if (NULL == (db = fopen("../materials/master_levels.db", "r+b"))) {
 43 |     *state = ERROR;
 44 |   } else {
 45 |     FILE *indices = NULL;
 46 |     if (NULL == (indices = fopen("../materials/levels_indices.db", "r+b"))) {
 47 |       *state = ERROR;
 48 |     } else {
 49 |       result = insert(db, indices, new_level, sizeof(level));
 50 |       fclose(indices);
 51 |     }
 52 |     fclose(db);
 53 |   }
 54 |   return result;
 55 | }
 56 | 
 57 | int levels_update(int id, level *updated_level, int *state) {
 58 |   FILE *db = NULL;
 59 |   int result = 0;
 60 |   if (NULL == (db = fopen("../materials/master_levels.db", "r+b"))) {
 61 |     *state = ERROR;
 62 |   } else {
 63 |     FILE *indices = NULL;
 64 |     if (NULL == (indices = fopen("../materials/levels_indices.db", "r+b"))) {
 65 |       *state = ERROR;
 66 |     } else {
 67 |       result = update(db, indices, id, updated_level, sizeof(level));
 68 |       fclose(indices);
 69 |     }
 70 |     fclose(db);
 71 |   }
 72 |   return result;
 73 | }
 74 | 
 75 | void levels_select_query(int *state) {
 76 |   int target_id = 0;
 77 |   printf("Insert number of the selected memory level:\n> ");
 78 |   if (1 != scanf("%d", &target_id)) {
 79 |     *state = ERROR;
 80 |   } else {
 81 |     level *result = levels_select(target_id, state);
 82 |     if (RUNNING == *state) {
 83 |       if (NULL == result) {
 84 |         printf("Level with inserted number doesn't appear in the database.\n");
 85 |       } else {
 86 |         print_level(*result);
 87 |       }
 88 |     }
 89 |     free(result);
 90 |   }
 91 | }
 92 | 
 93 | void levels_insert_query(int *state) {
 94 |   level new_level = input_level(state);
 95 |   int result = levels_insert(&new_level, state);
 96 |   if (RUNNING == *state) {
 97 |     if (0 == result) {
 98 |       printf("Database already has a memory level with that number.\n");
 99 |     } else {
100 |       printf("New memory level was successfully inserted into database!\n");
101 |     }
102 |   }
103 | }
104 | 
105 | void levels_update_query(int *state) {
106 |   int target_id = 0;
107 |   level updated_level = input_level(state);
108 |   if (RUNNING != *state || !printf("Insert number of the updated memory level:\n> ")\
109 |         ||  1 != scanf("%d", &target_id)) {
110 |     *state = ERROR;
111 |   } else {
112 |     int result = levels_update(target_id, &updated_level, state);
113 |     if (RUNNING == *state) {
114 |       if (1 == result) {
115 |         printf("Memory level with inserted number doesn't appear in the database.\n");
116 |       } else if (2 == result) {
117 |         printf("Memory level with inserted number is already in the database and doesn't"
118 |                " match with the old one.\n");
119 |       } else {
120 |         printf("The memory level was successfully updated!\n");
121 |       }
122 |     }
123 |   }
124 | }
125 | 
126 | void levels_delete_query(int *state) {
127 |   int target_id = 0;
128 |   printf("Insert number of the deleted memory level:\n> ");
129 |   if (1 != scanf("%d", &target_id)) {
130 |     *state = ERROR;
131 |   } else {
132 |     int result = levels_delete(target_id, state);
133 |     if (RUNNING == *state) {
134 |       if (0 == result) {
135 |         printf("Memory level with inserted ID doesn't appear in the database.\n");
136 |       } else {
137 |         printf("The memory level was successfully deleted!\n");
138 |       }
139 |     }
140 |   }
141 | }
142 | 
143 | void levels_all_query(int *state) {
144 |   FILE *db = NULL;
145 |   if (NULL == (db = fopen("../materials/master_levels.db", "rb"))) {
146 |     *state = ERROR;
147 |   } else {
148 |     rewind(db);
149 |     while (!feof(db)) {
150 |       level cur_level = {0};
151 |       fread(&cur_level, sizeof(level), 1, db);
152 |       if (!feof(db)) {
153 |         print_level(cur_level);
154 |       }
155 |     }
156 |     fclose(db);
157 |   }
158 | }
159 | 
160 | void print_level(level printed_level) {
161 |   printf("  %d %d %d\n", printed_level.id, printed_level.cells_amount, printed_level.protection_flag);
162 | }
163 | 
164 | level input_level(int *state) {
165 |   level new_level = {0};
166 |   printf("Insert new memory level number:\n> ");
167 |   if (1 != scanf("%d", &(new_level.id))) {
168 |     *state = ERROR;
169 |   } else if (!printf("Insert new memory level cells amount:\n> ") || !clean_stdin()\
170 |                   || 1 != scanf("%d", &(new_level.cells_amount))) {
171 |     *state = ERROR;
172 |   } else if (!printf("Insert new memory level protection flag:\n> ") || !clean_stdin()\
173 |                   || 1 != scanf("%d", &(new_level.protection_flag)) || !clean_stdin()) {
174 |     *state = ERROR;
175 |   }
176 |   return new_level;
177 | }
178 | 
179 | 


--------------------------------------------------------------------------------
/src/db_master_modules.c:
--------------------------------------------------------------------------------
  1 | #include "db_master_modules.h"
  2 | 
  3 | ai_module *ai_modules_select(int id, int *state) {
  4 |   FILE *db = NULL;
  5 |   ai_module *selected = NULL;
  6 |   if (NULL == (db = fopen("../materials/master_modules.db", "r+b"))) {
  7 |     *state = ERROR;
  8 |   } else {
  9 |     FILE *indices = NULL;
 10 |     if (NULL == (indices = fopen("../materials/modules_indices.db", "r+b"))) {
 11 |       *state = ERROR;
 12 |     } else {
 13 |       selected = select(db, indices, id, sizeof(ai_module));
 14 |       fclose(indices);
 15 |     }
 16 |     fclose(db);
 17 |   }
 18 |   return selected;
 19 | }
 20 | 
 21 | int ai_modules_delete(int id, int *state) {
 22 |   FILE *db = NULL;
 23 |   int result = 0;
 24 |   if (NULL == (db = fopen("../materials/master_modules.db", "r+b"))) {
 25 |     *state = ERROR;
 26 |   } else {
 27 |     FILE *indices = NULL;
 28 |     if (NULL == (indices = fopen("../materials/modules_indices.db", "r+b"))) {
 29 |       *state = ERROR;
 30 |     } else {
 31 |       result = delete(db, indices, id, sizeof(ai_module));
 32 |       fclose(indices);
 33 |     }
 34 |     fclose(db);
 35 |   }
 36 |   return result;
 37 | }
 38 | 
 39 | int ai_modules_insert(ai_module *new_ai_module, int *state) {
 40 |   FILE *db = NULL;
 41 |   int result = 0;
 42 |   if (NULL == (db = fopen("../materials/master_modules.db", "r+b"))) {
 43 |     *state = ERROR;
 44 |   } else {
 45 |     FILE *indices = NULL;
 46 |     if (NULL == (indices = fopen("../materials/modules_indices.db", "r+b"))) {
 47 |       *state = ERROR;
 48 |     } else {
 49 |       result = insert(db, indices, new_ai_module, sizeof(ai_module));
 50 |       fclose(indices);
 51 |     }
 52 |     fclose(db);
 53 |   }
 54 |   return result;
 55 | }
 56 | 
 57 | int ai_modules_update(int id, ai_module *updated_ai_module, int *state) {
 58 |   FILE *db = NULL;
 59 |   int result = 0;
 60 |   if (NULL == (db = fopen("../materials/master_modules.db", "r+b"))) {
 61 |     *state = ERROR;
 62 |   } else {
 63 |     FILE *indices = NULL;
 64 |     if (NULL == (indices = fopen("../materials/modules_indices.db", "r+b"))) {
 65 |       *state = ERROR;
 66 |     } else {
 67 |       result = update(db, indices, id, updated_ai_module, sizeof(ai_module));
 68 |       fclose(indices);
 69 |     }
 70 |     fclose(db);
 71 |   }
 72 |   return result;
 73 | }
 74 | 
 75 | void ai_modules_select_query(int *state) {
 76 |   int target_id = 0;
 77 |   printf("Insert ID of the selected AI module:\n> ");
 78 |   if (1 != scanf("%d", &target_id)) {
 79 |     *state = ERROR;
 80 |   } else {
 81 |     ai_module *result = ai_modules_select(target_id, state);
 82 |     if (RUNNING == *state) {
 83 |       if (NULL == result) {
 84 |         printf("Module with inserted ID doesn't appear in the database.\n");
 85 |       } else {
 86 |         print_ai_module(*result);
 87 |       }
 88 |     }
 89 |     free(result);
 90 |   }
 91 | }
 92 | 
 93 | void ai_modules_insert_query(int *state) {
 94 |   ai_module new_module = input_ai_module(state);
 95 |   int result = ai_modules_insert(&new_module, state);
 96 |   if (RUNNING == *state) {
 97 |     if (0 == result) {
 98 |       printf("Database already has an AI module with that ID.\n");
 99 |     } else {
100 |       printf("New AI module was successfully inserted into database!\n");
101 |     }
102 |   }
103 | }
104 | 
105 | void ai_modules_update_query(int *state) {
106 |   int target_id = 0;
107 |   ai_module updated_module = input_ai_module(state);
108 |   if (RUNNING != *state || !printf("Insert ID of the updated module:\n> ") ||  1 != scanf("%d", &target_id)) {
109 |     *state = ERROR;
110 |   } else {
111 |     int result = ai_modules_update(target_id, &updated_module, state);
112 |     if (RUNNING == *state) {
113 |       if (2 == result) {
114 |         printf("Module with inserted old ID doesn't appear in the database.\n");
115 |       } else if (1 == result) {
116 |         printf("Module with inserted new ID is already in the database and doesn't"
117 |                " match with the old one.\n");
118 |       } else {
119 |         printf("The memory level was successfully updated!\n");
120 |       }
121 |     }
122 |   }
123 | }
124 | 
125 | void ai_modules_delete_query(int *state) {
126 |   int target_id = 0;
127 |   printf("Insert ID of the deleted module:\n> ");
128 |   if (1 != scanf("%d", &target_id)) {
129 |     *state = ERROR;
130 |   } else {
131 |     int result = ai_modules_delete(target_id, state);
132 |     if (RUNNING == *state) {
133 |       if (0 == result) {
134 |         printf("Module with inserted ID doesn't appear in the database.\n");
135 |       } else {
136 |         printf("The module was successfully deleted!\n");
137 |       }
138 |     }
139 |   }
140 | }
141 | 
142 | void ai_modules_all_query(int *state) {
143 |   FILE *db = NULL;
144 |   if (NULL == (db = fopen("../materials/master_modules.db", "rb"))) {
145 |     *state = ERROR;
146 |   } else {
147 |     rewind(db);
148 |     while (!feof(db)) {
149 |       ai_module cur_module = {0};
150 |       fread(&cur_module, sizeof(ai_module), 1, db);
151 |       if (!feof(db)) {
152 |         print_ai_module(cur_module);
153 |       }
154 |     }
155 |     fclose(db);
156 |   }
157 | }
158 | 
159 | void print_ai_module(ai_module printed_module) {
160 |   printf("  %d %s %d %d %d\n", printed_module.id, printed_module.name,
161 |       printed_module.module_level, printed_module.cell, printed_module.deletion_flag);
162 | }
163 | 
164 | ai_module input_ai_module(int *state) {
165 |   ai_module new_module = {0};
166 |   printf("Insert new module ID:\n> ");
167 |   if (1 != scanf("%d", &(new_module.id))) {
168 |     *state = ERROR;
169 |   } else if (!printf("Insert new module name:\n> ") ||  !clean_stdin()\
170 |               || NULL == fgets(new_module.name, 30, stdin)) {
171 |     *state = ERROR;
172 |   } else if (!printf("Insert new module memory level:\n> ") \
173 |               || 1 != scanf("%d", &(new_module.module_level))) {
174 |     *state = ERROR;
175 |   } else if (!printf("Insert new module memory cell:\n> ") || !clean_stdin()\
176 |               || 1 != scanf("%d", &(new_module.cell)) || !clean_stdin()) {
177 |     *state = ERROR;
178 |   }
179 |   new_module.name[strcspn(new_module.name, "\n")] = 0;
180 |   new_module.deletion_flag = 0;
181 |   return new_module;
182 | }
183 | 


--------------------------------------------------------------------------------
/src/db_master_status_events.c:
--------------------------------------------------------------------------------
  1 | #include "db_master_status_events.h"
  2 | 
  3 | status_event *status_events_select(int id, int *state) {
  4 |   FILE *db = NULL;
  5 |   status_event *selected = NULL;
  6 |   if (NULL == (db = fopen("../materials/master_status_events.db", "r+b"))) {
  7 |     *state = ERROR;
  8 |   } else {
  9 |     FILE *indices = NULL;
 10 |     if (NULL == (indices = fopen("../materials/status_events_indices.db", "r+b"))) {
 11 |       *state = ERROR;
 12 |     } else {
 13 |       selected = select(db, indices, id, sizeof(status_event));
 14 |       fclose(indices);
 15 |     }
 16 |     fclose(db);
 17 |   }
 18 |   return selected;
 19 | }
 20 | 
 21 | int status_events_delete(int id, int *state) {
 22 |   FILE *db = NULL;
 23 |   int result = 0;
 24 |   if (NULL == (db = fopen("../materials/master_status_events.db", "r+b"))) {
 25 |     *state = ERROR;
 26 |   } else {
 27 |     FILE *indices = NULL;
 28 |     if (NULL == (indices = fopen("../materials/status_events_indices.db", "r+b"))) {
 29 |       *state = ERROR;
 30 |     } else {
 31 |       result = delete(db, indices, id, sizeof(status_event));
 32 |       fclose(indices);
 33 |     }
 34 |     fclose(db);
 35 |   }
 36 |   return result;
 37 | }
 38 | 
 39 | int status_events_insert(status_event *new_status_event, int *state) {
 40 |   FILE *db = NULL;
 41 |   int result = 0;
 42 |   if (NULL == (db = fopen("../materials/master_status_events.db", "r+b"))) {
 43 |     *state = ERROR;
 44 |   } else {
 45 |     FILE *indices = NULL;
 46 |     if (NULL == (indices = fopen("../materials/status_events_indices.db", "r+b"))) {
 47 |       *state = ERROR;
 48 |     } else {
 49 |       result = insert(db, indices, new_status_event, sizeof(status_event));
 50 |       fclose(indices);
 51 |     }
 52 |     fclose(db);
 53 |   }
 54 |   return result;
 55 | }
 56 | 
 57 | int status_events_update(int id, status_event *updated_status_event, int *state) {
 58 |   FILE *db = NULL;
 59 |   int result = 0;
 60 |   if (NULL == (db = fopen("../materials/master_status_events.db", "r+b"))) {
 61 |     *state = ERROR;
 62 |   } else {
 63 |     FILE *indices = NULL;
 64 |     if (NULL == (indices = fopen("../materials/status_events_indices.db", "r+b"))) {
 65 |       *state = ERROR;
 66 |     } else {
 67 |       result = update(db, indices, id, updated_status_event, sizeof(status_event));
 68 |       fclose(indices);
 69 |     }
 70 |     fclose(db);
 71 |   }
 72 |   return result;
 73 | }
 74 | 
 75 | void status_events_select_query(int *state) {
 76 |   int target_id = 0;
 77 |   printf("Insert ID of the selected event:\n> ");
 78 |   if (1 != scanf("%d", &target_id)) {
 79 |     *state = ERROR;
 80 |   } else {
 81 |     status_event *result = status_events_select(target_id, state);
 82 |     if (RUNNING == *state) {
 83 |       if (NULL == result) {
 84 |         printf("Event with inserted ID doesn't appear in the database.\n");
 85 |       } else {
 86 |         print_status_event(*result);
 87 |       }
 88 |     }
 89 |     free(result);
 90 |   }
 91 | }
 92 | 
 93 | void status_events_insert_query(int *state) {
 94 |   status_event new_event = input_status_event(state);
 95 |   int result = status_events_insert(&new_event, state);
 96 |   if (RUNNING == *state) {
 97 |     if (0 == result) {
 98 |       printf("Database already has an status event with that ID.\n");
 99 |     } else {
100 |       printf("New status event was successfully inserted into database!\n");
101 |     }
102 |   }
103 | }
104 | 
105 | void status_events_update_query(int *state) {
106 |   int target_id = 0;
107 |   status_event updated_event = input_status_event(state);
108 |   if (RUNNING != *state || !printf("Insert ID of the updated event:\n> ") ||  1 != scanf("%d", &target_id)) {
109 |     *state = ERROR;
110 |   } else {
111 |     int result = status_events_update(target_id, &updated_event, state);
112 |     if (RUNNING == *state) {
113 |       if (1 == result) {
114 |         printf("Event with inserted ID doesn't appear in the database.\n");
115 |       } else if (2 == result) {
116 |         printf("Event with inserted ID is already in the database and doesn't"
117 |                " match with the old one.\n");
118 |       } else {
119 |         printf("The memory level was successfully updated!\n");
120 |       }
121 |     }
122 |   }
123 | }
124 | 
125 | void status_events_delete_query(int *state) {
126 |   int target_id = 0;
127 |   printf("Insert ID of the deleted event:\n> ");
128 |   if (1 != scanf("%d", &target_id)) {
129 |     *state = ERROR;
130 |   } else {
131 |     int result = status_events_delete(target_id, state);
132 |     if (RUNNING == *state) {
133 |       if (0 == result) {
134 |         printf("Event with inserted ID doesn't appear in the database.\n");
135 |       } else {
136 |         printf("The status event was successfully deleted!\n");
137 |       }
138 |     }
139 |   }
140 | }
141 | 
142 | void status_events_all_query(int *state) {
143 |   FILE *db = NULL;
144 |   if (NULL == (db = fopen("../materials/master_status_events.db", "rb"))) {
145 |     *state = ERROR;
146 |   } else {
147 |     rewind(db);
148 |     while (!feof(db)) {
149 |       status_event cur_event = {0};
150 |       fread(&cur_event, sizeof(status_event), 1, db);
151 |       if (!feof(db)) {
152 |         print_status_event(cur_event);
153 |       }
154 |     }
155 |     fclose(db);
156 |   }
157 | }
158 | 
159 | void print_status_event(status_event printed_event) {
160 |   printf("  %d %d %d %s %s\n", printed_event.id, printed_event.module_id,
161 |                      printed_event.new_status, printed_event.date, printed_event.time);
162 | }
163 | 
164 | status_event input_status_event(int *state) {
165 |   status_event new_event = {0};
166 |   printf("Insert new event ID:\n> ");
167 |   if (1 != scanf("%d", &(new_event.id))) {
168 |     *state = ERROR;
169 |   } else if (!printf("Insert new event module ID:\n> ") ||  !clean_stdin()\
170 |              || 1 != scanf("%d", &(new_event.module_id))) {
171 |     *state = ERROR;
172 |   } else if (!printf("Insert new event module status:\n> ") || !clean_stdin()\
173 |              || 1 != scanf("%d", &(new_event.new_status)) || !clean_stdin()) {
174 |     *state = ERROR;
175 |   }
176 |   time_t cur_seconds = time(NULL);
177 |   struct tm *cur_time = localtime(&cur_seconds);
178 |   strftime(new_event.date, 11, "%d.%m.%Y", cur_time);
179 |   strftime(new_event.time, 8, "%H:%M:%S", cur_time);
180 |   return new_event;
181 | }
182 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_03/README.md:
--------------------------------------------------------------------------------
  1 | # Exam_03_01. Платиновый шар.
  2 | 
  3 | ## Задание
  4 | 
  5 | **Уровень:** 2  
  6 | **Темы:** типы данных, переменные, выражения, логические операции и математические функции.  
  7 | **Директория для решения:** src/  
  8 | **Файлы решения:** main.c  
  9 | **Входные данные:** стандартный поток ввода (stdin)  
 10 | **Выходные данные:** стандартный поток вывода (stdout)  
 11 | 
 12 | Написать программу, вычисляющую массу шара в килограммах, состоящего полностью из платины. Радиус шара (в метрах, вещественное число) задается на стандартном
 13 | потоке ввода stdin, а плотность платины составляет 21500 `кг/м^3`. Результат вычисления округлить по целого числа и вывести на стандартный поток вывода stdout. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
 14 | 
 15 | **Примечание:** формула объема шара: `V = (4 / 3) * рі * R^3`  
 16 | 
 17 | **Примечание:** формула плотности: `P = m / V`  
 18 | 
 19 | **Примечание:** В этом задании важна точность, поэтому советуем использовать константу `М_PI` (содержащую число пи) и функцию `double round (double x);` из библиотеки `<math.h>`, а также `double` вместо `float`.  
 20 | 
 21 | Вывод должен выглядеть таким образом - `printf("%.0lf", result);`
 22 | 
 23 | ## Примеры
 24 | 
 25 | | Входные данные | Результат работы |  
 26 | | 1 | 90059 |  
 27 | | 10 | 90058989 |  
 28 | 
 29 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 30 | 
 31 | ________________________________
 32 | 
 33 | # Exam_03_02. Перевод в градусную меру.
 34 | 
 35 | ## Задание
 36 | 
 37 | **Уровень:** 2  
 38 | **Темы:** типы данных, переменные, выражения, логические операции и математические функции.  
 39 | **Директория для решения:** src/  
 40 | **Файлы решения:** main.c  
 41 | **Входные данные:** стандартный поток ввода (stdin)  
 42 | **Выходные данные:** стандартный поток вывода (stdout)  
 43 | 
 44 | Написать программу, осуществляющую перевод величины из радианной меры в градусную. Радианная мера (вещественное число) задается на стандартном потоке ввода stdin, результат перевода необходимо математически округлить до целого числа и вывести на стандартный поток вывода stdout. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
 45 | 
 46 | **Примечание:** в одном радиане 57.29 градусов.
 47 | 
 48 | ## Примеры
 49 | 
 50 | | Входные данные | Результат работы |  
 51 | | 1 | 57 |  
 52 | | 2 | 115 |  
 53 | 
 54 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 55 | 
 56 | ________________________________
 57 | 
 58 | # Exam_03_03. Перестановка цифр.
 59 | 
 60 | ## Задание
 61 | 
 62 | **Уровень:** 4  
 63 | **Темы:** типы данных, переменные, выражения, логические операции и математические функции.  
 64 | **Директория для решения:** src/  
 65 | **Файлы решения:** main.c  
 66 | **Входные данные:** стандартный поток ввода (stdin)  
 67 | **Выходные данные:** стандартный поток вывода (stdout)  
 68 | 
 69 | Написать программу, осуществляющую перестановку крайних цифр в целом трехзначном числе. Целое трехзначное число задается на стандартном потоке ввода stdin, результат перестановки выводится в виде трехзначного числа с учетом ведущих нулей на стандартный поток вывода stdout.  В конце
 70 | ответа не должно быть переноса на новую строку.
 71 | 
 72 | **Примечание:** гарантируется, что на вход программе всегда подается целое трехзначное число.
 73 | 
 74 | ## Примеры
 75 | 
 76 | | Входные данные | Результат работы |  
 77 | | 159 | 951 |  
 78 | | 120 | 021 |  
 79 | | -123 | -321 |  
 80 | 
 81 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 82 | 
 83 | ________________________________
 84 | 
 85 | # Exam_03_04. Inside the interval
 86 | 
 87 | ## Задание
 88 | 
 89 | **Уровень:** 3  
 90 | **Темы:** типы данных, переменные, выражения, логические операции и математические функции.  
 91 | **Директория для решения:** src/  
 92 | **Файлы решения:** main.c  
 93 | **Входные данные:** стандартный поток ввода (stdin)  
 94 | **Выходные данные:** стандартный поток вывода (stdout)  
 95 | 
 96 | Три целых числа (A, B и C) задаются на стандартном потоке ввода stdin, необходимо вывести на стандартный поток вывода stdout `1`  в случае если С находится строго между A и B, в противном случае вывести `0`. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные данные. В случае любой ошибки выводить "n/a".
 97 | 
 98 | **Внимание:** условный оператор if может использоваться только для обработки ошибочного ввода.
 99 | 
100 | ## Примеры
101 | 
102 | | Входные данные | Результат работы |  
103 | | 0 9 4 | 1 |  
104 | | 0 1 4 | 0 |  
105 | | 0 0 0 | 0 |  
106 | 
107 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
108 | 
109 | ________________________________
110 | 
111 | # Exam_03_05. Логическое выражение
112 | 
113 | ## Задание
114 | 
115 | 
116 | **Уровень:** 2  
117 | **Темы:** типы данных, переменные, выражения, логические операции и математические функции.  
118 | **Директория для решения:** src/  
119 | **Файлы решения:** main.c  
120 | **Входные данные:** стандартный поток ввода (stdin)  
121 | **Выходные данные:** стандартный поток вывода (stdout)  
122 | 
123 | На стандартный поток ввода stdin поступают числа х, у и z, каждое из которых может принимать одно из двух значений (0 и 1). Необходимо вывести на стандартный поток вывода stdout единицу, если значение следуюдего выражения истинно: x and (z or y), в противном случае вывести ноль. В конце ответа не должно быть переноса на новую строку. Проверить на валидность введенные
124 | данные. В случае любой ошибки выводить "n/a".
125 | 
126 | 
127 | ## Примеры
128 | | Входные данные | Результат работы |  
129 | | 1 1 1 | 1 |  
130 | | 0 0 0 | 0 |  
131 | 
132 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
133 | 


--------------------------------------------------------------------------------
/Violin concerto No. 1, Op. 26 - Max Bruch/Exam_01/README.md:
--------------------------------------------------------------------------------
  1 | # Exam_01_01. Исправление ошибок №1.
  2 | 
  3 | ## Задание
  4 | 
  5 | **Уровень:** 1  
  6 | **Темы:** базовые типы данных, объявление переменных, оператор присваивания.  
  7 | **Директория для решения:** src/  
  8 | **Файлы решения:** main.c  
  9 | **Входные данные:** стандартный поток ввода (stdin)  
 10 | **Выходные данные:** стандартный поток вывода (stdout)   
 11 | 
 12 | При написании программы была допущена ошибка. Необходимо исправить синтаксические, стилевые ошибки, не изменяя работу программы.  
 13 | В конце ответа не должно быть переноса на новую строку.
 14 | 
 15 | ```c
 16 | #include <stdio.h>
 17 | 
 18 | int main(void)
 19 | {
 20 | 	INT a, b;
 21 | 	a = b = 1;
 22 | 
 23 | 	scanf ("%d %d", &a, &b);
 24 | 	printf("%d", a * b);
 25 | 
 26 | 	return 0;
 27 | }
 28 | ```
 29 | 
 30 | ## Примеры
 31 | 
 32 | | Входные данные | Результат работы |  
 33 | | 2 2 | 4 |  
 34 | | -4 4 | -16 |  
 35 | 
 36 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 37 | 
 38 | ________________________________
 39 | 
 40 | # Exam_01_02. Исправление ошибок №2.
 41 | 
 42 | ## Задание
 43 | 
 44 | **Уровень:** 1  
 45 | **Темы:** базовые типы данных, объявление переменных, оператор присваивания.  
 46 | **Директория для решения:** src/  
 47 | **Файлы решения:** main.c  
 48 | **Входные данные:** стандартный поток ввода (stdin)  
 49 | **Выходные данные:** стандартный поток вывода (stdout)  
 50 | 
 51 | При написании программы была допущена ошибка. Необходимо исправить синтаксические, стилевые ошибки, не изменяя работу программы. В конце ответа не должно быть переноса на новую строку.
 52 | 
 53 | ```c
 54 | #include <stdio.h>
 55 | 
 56 | int main(void)
 57 | {
 58 | 	int x1 = 1 x2 = 2;
 59 | 
 60 | 	scanf("%d %d", &x1, &x2);
 61 | 	printf("%d", x1 * x2);
 62 | 
 63 | 	return 0;
 64 | }
 65 | ```
 66 | 
 67 | ## Примеры
 68 | 
 69 | | Входные данные | Результат работы |  
 70 | | 2 2 | 4 |  
 71 | | -4 4 | -16 |  
 72 | 
 73 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
 74 | 
 75 | ________________________________
 76 | 
 77 | # Exam_01_03. Исправление ошибок №3.
 78 | 
 79 | ## Задание
 80 | 
 81 | **Уровень:** 1  
 82 | **Темы:** базовые типы данных, объявление переменных, оператор присваивания.  
 83 | **Директория для решения:** src/  
 84 | **Файлы решения:** main.c  
 85 | **Входные данные:** стандартный поток ввода (stdin)  
 86 | **Выходные данные:** стандартный поток вывода (stdout)  
 87 | 
 88 | При написании программы была допущена ошибка. Необходимо исправить синтаксические, стилевые ошибки, не изменяя работу программы.  
 89 | В конце ответа не должно быть переноса на новую строку.
 90 | 
 91 | ```c
 92 | #include <stdio.h>
 93 | 
 94 | int main(void)
 95 | {
 96 | 	int: first = 3, second = 4;
 97 | 	scanf("%d %d", &first, &second);
 98 | 	printf("%d", first * second);
 99 | 
100 | 	return 0;
101 | }
102 | ```
103 | 
104 | ## Примеры
105 | 
106 | | Входные данные | Результат работы |  
107 | | 2 2 | 4 |  
108 | | -4 4 | -16 |  
109 | 
110 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
111 | 
112 | ________________________________
113 | 
114 | # Exam_01_04. Исправление ошибок №4.
115 | 
116 | ## Задание
117 | 
118 | **Уровень:** 1  
119 | **Темы:** базовые типы данных, объявление переменных, оператор присваивания.  
120 | **Директория для решения:** src/  
121 | **Файлы решения:** main.c  
122 | **Входные данные:** стандартный поток ввода (stdin)  
123 | **Выходные данные:** стандартный поток вывода (stdout)  
124 | 
125 | При написании программы была допущена ошибка. Необходимо исправить синтаксические, стилевые ошибки, не изменяя работу программы.  
126 | В конце ответа не должно быть переноса на новую строку.
127 | 
128 | ```c
129 | #include <stdio.h>
130 | 
131 | int main(void)
132 | {
133 | 	int left = 2, int right = 1;
134 | 	scanf("%d %d", &left, &right);
135 | 	printf("%d", left * right);
136 | 
137 | 	return 0;
138 | }
139 | ```
140 | 
141 | ## Примеры
142 | 
143 | | Входные данные | Результат работы |  
144 | | 2 2 | 4 |  
145 | | -4 4 | -16 |  
146 | 
147 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
148 | 
149 | ________________________________
150 | 
151 | # Exam_01_05. Исправление ошибок №5.
152 | 
153 | ## Задание
154 | 
155 | **Уровень:** 1  
156 | **Темы:** базовые типы данных, объявление переменных, оператор присваивания.  
157 | **Директория для решения:** src/  
158 | **Файлы решения:** main.c  
159 | **Входные данные:** стандартный поток ввода (stdin)  
160 | **Выходные данные:** стандартный поток вывода (stdout)  
161 | 
162 | При написании программы была допущена ошибка. Необходимо исправить синтаксические, стилевые ошибки, не изменяя работу программы.  
163 | В конце ответа не должно быть переноса на новую строку.
164 | 
165 | ```c
166 | #include <stdio.h>
167 | 
168 | int main(void)
169 | {
170 | 	int x = 0; pi = 3.141;
171 | 
172 | 	scanf("%d", &x);
173 | 	printf("%.2f"，pi * x);
174 | 
175 | 	return 0;
176 | }
177 | ```
178 | 
179 | ## Примеры
180 | 
181 | | Входные данные | Результат работы |  
182 | | 0 | 0.00 |  
183 | | 2 | 6.28 |  
184 | 
185 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
186 | 
187 | ________________________________
188 | 
189 | # Exam_01_06. Исправление ошибок №6.
190 | 
191 | ## Задание
192 | 
193 | **Уровень:** 1  
194 | **Темы:** базовые типы данных, объявление переменных, оператор присваивания.  
195 | **Директория для решения:** src/  
196 | **Файлы решения:** main.c  
197 | **Входные данные:** стандартный поток ввода (stdin)  
198 | **Выходные данные:** стандартный поток вывода (stdout)  
199 | 
200 | При написании программы была допущена ошибка. Необходимо исправить синтаксические, стилевые ошибки, не изменяя работу программы.  
201 | В конце ответа не должно быть переноса на новую строку.
202 | 
203 | ```c
204 | #include <stdio.h>
205 | 
206 | int main(void)
207 | {
208 | 	int value = 1;
209 | 	double pi = "3.141";
210 | 
211 | 	scanf("%d", &value);
212 | 	printf("%.2f", value * pi);
213 | 
214 | 	return 0;
215 | }
216 | ```
217 | 
218 | ## Примеры
219 | 
220 | | Входные данные | Результат работы |  
221 | | 0 | 0.00 |  
222 | | 2 | 6.28 |  
223 | 
224 | **Внимание:** Мы любезно напоминаем вам, что процедура тестирования вашей программы включает анализ стиля кода. Пожалуйста, загляните в папку materials/. Также обязательно проверяйте вашу программу на утечки памяти!
225 | 


--------------------------------------------------------------------------------
/src/shared.c:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | 
  3 | void non_aggregative_query(int *state, void (*ai_modules_query)(int*),
  4 |                 void (*levels_query)(int*), void (*status_events_query)(int*)) {
  5 |   int table_number = choose_table(state);
  6 |   if (RUNNING == *state) {
  7 |     if (MODULES_TABLE == table_number) {
  8 |       ai_modules_query(state);
  9 |     } else if (LEVELS_TABLE == table_number) {
 10 |       levels_query(state);
 11 |     } else if (STATUS_EVENTS_TABLE == table_number) {
 12 |       status_events_query(state);
 13 |     }
 14 |   }
 15 | }
 16 | 
 17 | void active_modules_query(int *state) {
 18 |   FILE *module_db = NULL;
 19 |   FILE *status_db = NULL;
 20 |   if (NULL == (module_db = fopen("../materials/master_modules.db", "rb"))) {
 21 |     *state = ERROR;
 22 |   } else if (NULL == (status_db = fopen("../materials/master_status_events.db", "rb"))) {
 23 |     *state = ERROR;
 24 |   } else {
 25 |     fseek(module_db, 0, SEEK_END);
 26 |     int modules_size = ftell(module_db) / sizeof(ai_module);
 27 |     int count = 0;
 28 |     for (int i = 0; i < modules_size; i++) {
 29 |       ai_module cur_module = {0};
 30 |       fseek(module_db, i * sizeof(ai_module), SEEK_SET);
 31 |       fread(&cur_module, sizeof(ai_module), 1, module_db);
 32 |       int module_status = find_module_status(cur_module, status_db);
 33 |       if (1 == module_status) {
 34 |         count++;
 35 |         print_ai_module(cur_module);
 36 |       }
 37 |     }
 38 |     if (0 == count) {
 39 |       printf("There are no active AI modules!\n");
 40 |     }
 41 |     fclose(status_db);
 42 |   }
 43 |   if (NULL != module_db) {
 44 |     fclose(module_db);
 45 |   }
 46 | }
 47 | 
 48 | void memlevel_modules_query(int *state) {
 49 |   FILE *module_db = NULL;
 50 |   int memory_level = 0;
 51 |   printf("Insert the memory level:\n> ");
 52 |   if (1 != scanf("%d", &memory_level) || !clean_stdin() ||\
 53 |               NULL == (module_db = fopen(
 54 |               "../materials/master_modules.db", "rb"))) {
 55 |     *state = ERROR;
 56 |   } else {
 57 |     fseek(module_db, 0, SEEK_END);
 58 |     int modules_size = ftell(module_db) / sizeof(module_db);
 59 |     int count = 0;
 60 |     for (int i = 0; i < modules_size; i++) {
 61 |       ai_module cur_module = {0};
 62 |       fseek(module_db, i * sizeof(ai_module), SEEK_SET);
 63 |       fread(&cur_module, sizeof(ai_module), 1, module_db);
 64 |       if (cur_module.module_level == memory_level) {
 65 |         count++;
 66 |         print_ai_module(cur_module);
 67 |       }
 68 |     }
 69 |     if (0 == count) {
 70 |       printf("There are no AI modules on this memory level!\n");
 71 |     }
 72 |     fclose(module_db);
 73 |   }
 74 | }
 75 | 
 76 | void set_protected_module_query(int *state) {
 77 |   FILE *module_db = NULL;
 78 |   FILE *status_db = NULL;
 79 |   int module_id = 0;
 80 |   printf("Insert the module ID:\n> ");
 81 |   if (1 != scanf("%d", &module_id) || !clean_stdin() ||\
 82 |       NULL == (module_db = fopen("../materials/master_modules.db", "rb")) ||
 83 |       NULL == (status_db = fopen("../materials/master_status_events.db", "a+b"))) {
 84 |     *state = ERROR;
 85 |   } else {
 86 |     fseek(module_db, 0, SEEK_END);
 87 |     int modules_size = ftell(module_db) / sizeof(module_db);
 88 |     int target_found = 0;
 89 |     for (int i = 0; i < modules_size && !target_found; i++) {
 90 |       ai_module cur_module = {0};
 91 |       fseek(module_db, i * sizeof(ai_module), SEEK_SET);
 92 |       fread(&cur_module, sizeof(ai_module), 1, module_db);
 93 |       if (cur_module.id == module_id) {
 94 |         to_protected_mode_events(module_id, status_db);
 95 |         target_found = 1;
 96 |       }
 97 |     }
 98 |     if (!target_found) {
 99 |       printf("There is no module with such ID.\n");
100 |     } else {
101 |       printf("The AI module was successfully set to protected mode!\n");
102 |     }
103 |     fclose(module_db);
104 |     fclose(status_db);
105 |   }
106 | }
107 | 
108 | void move_module_query(int *state) {
109 |   FILE *module_db = NULL;
110 |   int module_id = 0;
111 |   int new_level = 0;
112 |   int new_cell = 0;
113 |   printf("Insert the module ID:\n> ");
114 |   if (1 != scanf("%d", &module_id) || !clean_stdin()) {
115 |     *state = ERROR;
116 |   } else if (!printf("Insert new memory level:\n> ") || 1 != scanf("%d", &new_level)\
117 |              || !clean_stdin()) {
118 |     *state = ERROR;
119 |   } else if (!printf("Insert new memory cell:\n> ") || 1 != scanf("%d", &new_cell)\
120 |              || !clean_stdin()) {
121 |     *state = ERROR;
122 |   } else if (NULL == (module_db = fopen("../materials/master_modules.db", "r+b"))) {
123 |     *state = ERROR;
124 |   } else {
125 |     fseek(module_db, 0, SEEK_END);
126 |     int modules_size = ftell(module_db) / sizeof(module_db);
127 |     int target_found = 0;
128 |     for (int i = 0; i < modules_size && !target_found; i++) {
129 |       ai_module cur_module = {0};
130 |       fseek(module_db, i * sizeof(ai_module), SEEK_SET);
131 |       fread(&cur_module, sizeof(ai_module), 1, module_db);
132 |       if (cur_module.id == module_id) {
133 |         cur_module.module_level = new_level;
134 |         cur_module.cell = new_cell;
135 |         fseek(module_db, i * sizeof(ai_module), SEEK_SET);
136 |         fwrite(&cur_module, sizeof(ai_module), 1, module_db);
137 |         target_found = 1;
138 |       }
139 |     }
140 |     if (!target_found) {
141 |       printf("There is no module with such ID.\n");
142 |     } else {
143 |       printf("The AI module was successfully moved to new memory level and cell!\n");
144 |     }
145 |     fclose(module_db);
146 |   }
147 | }
148 | 
149 | void set_protected_level_query(int *state) {
150 |   FILE *level_db = NULL;
151 |   int target_level = 0;
152 |   printf("Insert level number:\n> ");
153 |   if (1 != scanf("%d", &target_level) || !clean_stdin() ||\
154 |       NULL == (level_db = fopen("../materials/master_levels.db", "r+b"))) {
155 |     *state = ERROR;
156 |   } else {
157 |     fseek(level_db, 0, SEEK_END);
158 |     int levels_size = ftell(level_db) / sizeof(level);
159 |     int target_found = 0;
160 |     for (int i = 0; i < levels_size && !target_found; i++) {
161 |       level cur_level = {0};
162 |       fseek(level_db, i * sizeof(level), SEEK_SET);
163 |       fread(&cur_level, sizeof(level), 1, level_db);
164 |       if (cur_level.id == target_level) {
165 |         cur_level.protection_flag = 1;
166 |         fseek(level_db, i * sizeof(level), SEEK_SET);
167 |         fwrite(&cur_level, sizeof(level), 1, level_db);
168 |         target_found = 1;
169 |       }
170 |     }
171 |     if (!target_found) {
172 |       printf("There is no such memory level.\n");
173 |     } else {
174 |       printf("The protection flag at level %d was successfully set!\n", target_level);
175 |     }
176 |     fclose(level_db);
177 |   }
178 | }
179 | 
180 | void save_the_world(int *state) {
181 |   FILE *module_db = fopen("../materials/master_modules.db", "r+b");
182 |   FILE *level_db = fopen("../materials/master_levels.db", "r+b");
183 |   FILE *status_db = fopen("../materials/master_status_events.db", "r+b");
184 |   if (NULL == module_db || NULL == level_db || NULL == status_db) {
185 |     *state = ERROR;
186 |   } else {
187 |      turn_off_additional_modules(module_db, status_db);
188 |      set_deletion_flags(module_db);
189 |      to_protected_mode_events(0, status_db);
190 |      int moving_stage = 0;
191 |      moving_stage = move_main_module(module_db, level_db);
192 |      if (2 == moving_stage) {
193 |        printf("\n\nWORLD IS SAVED!!!!!!\n\n");
194 |      } else if (1 == moving_stage) {
195 |        printf("Where is the first level?\n");
196 |      } else if (0 == moving_stage) {
197 |        printf("Main module has disappeared...\n");
198 |      }
199 |   }
200 |   if (NULL != module_db) {
201 |     fclose(module_db);
202 |   }
203 |   if (NULL != level_db) {
204 |     fclose(level_db);
205 |   }
206 |   if (NULL != status_db) {
207 |     fclose(status_db);
208 |   }
209 | }
210 | 
211 | void turn_off_additional_modules(FILE *module_db, FILE *status_db) {
212 |   fseek(module_db, 0, SEEK_END);
213 |   fseek(status_db, 0, SEEK_END);
214 |   int module_size = ftell(module_db) / sizeof(ai_module);
215 |   int status_size = ftell(status_db) / sizeof(status_event);
216 |   for (int i = 0; i < module_size; i++) {
217 |     ai_module cur_module = {0};
218 |     fseek(module_db, i * sizeof(ai_module), SEEK_SET);
219 |     fread(&cur_module, sizeof(ai_module), 1, module_db);
220 |     if (cur_module.id != 0) {
221 |       time_t cur_seconds = time(NULL);
222 |       struct tm *cur_time = localtime(&cur_seconds);
223 |       status_event new_event = {0};
224 |       new_event.module_id = cur_module.id;
225 |       new_event.new_status = 0;
226 |       strftime(new_event.date, 11, "%d.%m.%Y", cur_time);
227 |       strftime(new_event.date, 8, "%H:%M:%S", cur_time);
228 |       new_event.id = find_max_status_id(status_size, status_db);
229 |       fseek(status_db, 0, SEEK_END);
230 |       fwrite(&new_event, sizeof(status_event), 1, status_db);
231 |     }
232 |   }
233 | }
234 | 
235 | void set_deletion_flags(FILE *module_db) {
236 |   fseek(module_db, 0, SEEK_END);
237 |   int module_size = ftell(module_db) / sizeof(ai_module);
238 |   for (int i = 0; i < module_size; i++) {
239 |     ai_module cur_module = {0};
240 |     fseek(module_db, i * sizeof(ai_module), SEEK_SET);
241 |     fread(&cur_module, sizeof(ai_module), 1, module_db);
242 |     if (cur_module.id != 0) {
243 |       cur_module.deletion_flag = 1;
244 |       fseek(module_db, i * sizeof(ai_module), SEEK_SET);
245 |       fwrite(&cur_module, sizeof(ai_module), 1, module_db);
246 |     }
247 |   }
248 | }
249 | 
250 | int move_main_module(FILE *module_db, FILE *level_db) {
251 |   fseek(module_db, 0, SEEK_END);
252 |   fseek(level_db, 0, SEEK_END);
253 |   int module_size = ftell(module_db) / sizeof(ai_module);
254 |   int level_size = ftell(level_db) / sizeof(level);
255 |   int found_target = 0;
256 |   for (int i = 0; i < module_size && !found_target; i++) {
257 |     ai_module cur_module = {0};
258 |     fseek(module_db, i * sizeof(ai_module), SEEK_SET);
259 |     fread(&cur_module, sizeof(ai_module), 1, module_db);
260 |     if (0 == cur_module.id) {
261 |       found_target = 1;
262 |       cur_module.module_level = 1;
263 |       cur_module.cell = 1;
264 |       fseek(module_db, i * sizeof(ai_module), SEEK_SET);
265 |       fwrite(&cur_module, sizeof(ai_module), 1, module_db);
266 |     }
267 |   }
268 |   for (int i = 0; i < level_size && 1 == found_target; i++) {
269 |     level cur_level = {0};
270 |     fseek(level_db, i * sizeof(level), SEEK_SET);
271 |     fread(&cur_level, sizeof(level), 1, level_db);
272 |     if (1 == cur_level.id) {
273 |       found_target = 2;
274 |       cur_level.protection_flag = 1;
275 |       fseek(level_db, i * sizeof(level), SEEK_SET);
276 |       fwrite(&cur_level, sizeof(level), 1, level_db);
277 |     }
278 |   }
279 |   return found_target;
280 | }
281 | 
282 | void to_protected_mode_events(int module_id, FILE *status_db) {
283 |   fseek(status_db, 0, SEEK_END);
284 |   int events_size = ftell(status_db);
285 |   int max_id = find_max_status_id(events_size, status_db);
286 |   status_event new_event = {0};
287 |   fseek(status_db, 0, SEEK_END);
288 |   new_event.module_id = module_id;
289 |   const int status_sequence[3] = {0, 1, 20};
290 |   for (int i = 0; i < 3; i++) {
291 |     new_event.id = max_id + i + 1;
292 |     new_event.new_status = status_sequence[i];
293 |     time_t cur_seconds = time(NULL);
294 |     struct tm *cur_time = localtime(&cur_seconds);
295 |     strftime(new_event.date, 11, "%d.%m.%Y", cur_time);
296 |     strftime(new_event.date, 8, "%H:%M:%S", cur_time);
297 |     fwrite(&new_event, sizeof(status_event), 1, status_db);
298 |   }
299 | }
300 | 
301 | int find_max_status_id(int size, FILE *status_db) {
302 |   int max_id = 0;
303 |   for (int i = 0; i < size; i++) {
304 |     int cur_id = 0;
305 |     fseek(status_db, i * sizeof(status_event), SEEK_SET);
306 |     fread(&cur_id, sizeof(int), 1, status_db);
307 |     if (cur_id > max_id) {
308 |       max_id = cur_id;
309 |     }
310 |   }
311 |   return max_id;
312 | }
313 | 
314 | int find_module_status(ai_module cur_module, FILE *status_db) {
315 |   int module_status = 0;
316 |   time_t last_time = 0;
317 |   fseek(status_db, 0, SEEK_END);
318 |   int status_size = ftell(status_db) / sizeof(status_event);
319 |   for (int j = status_size - 1; j >= 0; j--) {
320 |     status_event cur_event = {0};
321 |     fseek(status_db, j * sizeof(status_event), SEEK_SET);
322 |     fread(&cur_event, sizeof(status_event), 1, status_db);
323 |     if (cur_event.module_id == cur_module.id) {
324 |       struct tm event_time;
325 |       char full_time[20];
326 |       strcpy(full_time, cur_event.date);
327 |       strcat(full_time, " ");
328 |       strcat(full_time, cur_event.time);
329 |       strptime(full_time, "%d.%m.%Y %H:%M:%S", &event_time);
330 |       time_t event_time_sec = mktime(&event_time);
331 |       if (event_time_sec > last_time) {
332 |         last_time = event_time_sec;
333 |         module_status = cur_event.new_status;
334 |       }
335 |     }
336 |   }
337 |   return module_status;
338 | }
339 | 
340 | 
341 | 


--------------------------------------------------------------------------------
/exam_taks.c:
--------------------------------------------------------------------------------
   1 | 
   2 |    ===============================================================================
   3 | /* Task 1 - I'm Groot.  						lvl 1. 
   4 | 
   5 | Вывести на экран сообщение        "I'm Grood", (c) Grood  
   6 | Обратте внимание что должно быть выведено сообщение именно в таком формате с кавычками
   7 | На вход программы ничего не подается
   8 | --------------------------------------------------------------------------------*/
   9 | 
  10 | #include <stdio.h>
  11 | int main() {
  12 | 
  13 |     printf("\"I'm Grood\", (c) Grood"); 
  14 |     /* если поставить / перед  спец. символом, то он считывается как обычный символ, 
  15 |     это называется экранированием */
  16 |     return 0;
  17 | 	
  18 | }
  19 | 
  20 | ===============================================================================
  21 | /* Task 2 - Return five numbers  					lvl 1   
  22 |    
  23 | Дан шаблон программы, измените программу, чтобы она
  24 | считала на вход число и вывести его в формате ниже
  25 | Вход    Выход
  26 | 0       00000
  27 | 1       00001           
  28 | 10      00010
  29 | 666666  666666
  30 | --------------------------------------------------------------------------------*/
  31 | 	   
  32 | 	   
  33 | #include <stdio.h>
  34 | int main() {
  35 |     int num;
  36 |     scanf("%d", &num);
  37 |     printf("%05d", num);
  38 | 
  39 |     return 0;
  40 | }
  41 | 
  42 |   ===============================================================================
  43 | /* Task 3 - Radian calculating					lvl 2    
  44 | 
  45 | перевести радианы (действительное число) в градусы (целое число)
  46 | (проверка на то, что радианы >=0 НЕ НУЖНА, проверено мистейком)
  47 | Математически округлить ответ до двух знаков после запятой 
  48 | Дано 1 градус  = 57.29 рад
  49 | 
  50 | Пример
  51 | Вход Выход
  52 | 1     57
  53 | 2     115
  54 | --------------------------------------------------------------------------------*/	
  55 | 
  56 | 	 
  57 | #include <stdio.h>
  58 | int main() {
  59 |     
  60 |     int degree;
  61 |     float radian = 57.29;
  62 |     scanf("%d", &degree); 
  63 |     printf("%.f", degree * radian);
  64 |     
  65 |     return 0;
  66 | }
  67 | 
  68 | ===============================================================================
  69 | 
  70 | /* Task 4 - Своп максимальных и минимальных значений матрицы (изменено 25.08) */
  71 | 
  72 | 	
  73 | #include <stdio.h>
  74 | 
  75 | int main() {
  76 | 
  77 |   int M, N;
  78 | 
  79 |   if (scanf("%d", &M) != 1) {
  80 |     printf("n/a");
  81 |     return 1;
  82 |   }
  83 | 
  84 |   if (scanf("%d", &N) != 1) {
  85 |     printf("n/a");
  86 |     return 1;
  87 |   }
  88 | 
  89 |   int a[M][N];
  90 | 
  91 |   for (int i = 0; i < M; i++) {
  92 |     for (int j = 0; j < N; j++) {
  93 |       scanf("%d", &a[i][j]);
  94 |     }
  95 |   }
  96 | 
  97 |   int max_i = 0, min_i = 0, max = a[0][0], min = a[0][0], max_j = 0, min_j = 0;
  98 | 
  99 |   for (int i = 0; i < M; i++) {
 100 |     for (int j = 0; j < N; j++) {
 101 |       if (a[i][j] > max) {
 102 |         max = a[i][j];
 103 |         max_i = i;
 104 |         max_j = j;
 105 |       }
 106 |       if (a[i][j] < min) {
 107 |         min = a[i][j];
 108 |         min_i = i;
 109 |         min_j = j;
 110 |       }
 111 |     }
 112 |   }
 113 | 
 114 |   int tmp = a[min_i][min_j];
 115 |   a[min_i][min_j] = a[max_i][max_j];
 116 |   a[max_i][max_j] = tmp;
 117 | 
 118 |   for (int i = 0; i < M; i++) {
 119 |     for (int j = 0; j < N; j++) {
 120 |         printf("%d ", a[i][j]);
 121 |       }
 122 |       printf("\n");
 123 |     }
 124 | }
 125 | 
 126 | =====================================================================
 127 | /* Task 5 - На вход подается строка, является она палиндромом или нет  */
 128 | Вариант 1							
 129 | 	
 130 | #include <stdio.h>
 131 | #include <string.h>
 132 | 
 133 | int main(){
 134 |     char word[200];
 135 |     int len = 0;
 136 |     int flag = 0;
 137 | 
 138 |     while(scanf("%c", &word[len]) == 1 && word[len] != '\n') {
 139 |         if (word[len] >= 'a' && word[len] <= 'z')
 140 |             word[len] -= 32;
 141 |         len++;
 142 |     }
 143 | 
 144 |     
 145 |     for(int i=0;i < len ;i++){
 146 |         if(word[i] != word[len-i-1]){
 147 |             flag = 1;
 148 |             break;
 149 |            }
 150 |         }
 151 |     
 152 |     if (flag) {
 153 |         printf("NO");
 154 |     }    
 155 |     else {
 156 |         printf("YES");
 157 |     }
 158 |     return 0;
 159 | }
 160 | 
 161 | Вариант 2
 162 | 
 163 | #include <stdio.h>
 164 | #include <string.h>
 165 | int main() {
 166 |   char string[25], reverse_string[25] = {'\0'};
 167 |   int i, length = 0, flag = 0;
 168 |   scanf("%s", string);
 169 |   for (i = 0; string[i] != '\0'; i++) {
 170 |     length++;
 171 |   }
 172 |   for (i = length - 1; i >= 0; i--) {
 173 |     if (string[i] < 91)
 174 |       string[i] = string[i] + 32;
 175 |     reverse_string[length - i - 1] = string[i];
 176 |   }
 177 |   for (flag = 1, i = 0; i < length; i++) {
 178 |     if (reverse_string[i] != string[i])
 179 |       flag = 0;
 180 |   }
 181 |   if (flag == 1)
 182 |     printf("YES");
 183 |   else
 184 |     printf("NO");
 185 | }
 186 | */
 187 | 
 188 | =====================================================================
 189 | /* Task 6 - Умножение матриц*/
 190 | 
 191 | #include <stdio.h>
 192 | #include <stdlib.h>
 193 | 
 194 | int main() {
 195 |   int N;
 196 |   char term;
 197 | 
 198 |   if (scanf("%d%c", &N, &term) != 2 || term != '\n') {
 199 |     printf("n/a");
 200 |     return 1;
 201 |   }
 202 | 
 203 |   int A[N][N];
 204 |   int B[N][N];
 205 |   int C[N][N];
 206 | 
 207 |   //   int **A = (int **)malloc(N * sizeof(int *));
 208 |   //   int **B = (int **)malloc(N * sizeof(int *));
 209 |   //   int **C = (int **)malloc(N * sizeof(int *));
 210 | 
 211 |   //   for (int i = 0; i < N; i++) {
 212 |   //     A[i] = (int *)malloc(N * sizeof(int));
 213 |   //     B[i] = (int *)malloc(N * sizeof(int));
 214 |   //     C[i] = (int *)malloc(N * sizeof(int));
 215 |   //   }
 216 | 
 217 |   for (int i = 0; i < N; i++)
 218 |     for (int j = 0; j < N; j++) {
 219 |       if (scanf("%d", &A[i][j]) != 1) {
 220 |         printf("n/a");
 221 |         return 1;
 222 |       }
 223 |     }
 224 | 
 225 |   for (int i = 0; i < N; i++)
 226 |     for (int j = 0; j < N; j++) {
 227 |       if (scanf("%d", &B[i][j]) != 1) {
 228 |         printf("n/a");
 229 |         return 1;
 230 |       }
 231 |     }
 232 | 
 233 |   for (int i = 0; i < N; i++)
 234 |     for (int j = 0; j < N; j++) {
 235 |       C[i][j] = 0;
 236 |       for (int k = 0; k < N; k++)
 237 |         C[i][j] += A[i][k] * B[k][j];
 238 |     }
 239 | 
 240 |   for (int i = 0; i < N; i++) {
 241 |     for (int j = 0; j < N; j++) {
 242 |       if (j < N - 1) {
 243 |         printf("%d ", C[i][j]);
 244 |       } else {
 245 |         printf("%d", C[i][j]);
 246 |         printf("\n");
 247 |       }
 248 |     }
 249 |   }
 250 | }
 251 | 
 252 | 
 253 | ========================================================================
 254 | /* Task 5 - Перевод в верхний регистр первого символа каждого слова
 255 | 
 256 | Написать программу, осуществляющую перевод в верхний регистр 
 257 | первого символа каждого слова, разделенного пробелами в строке.
 258 | Строка, заканчивающаяся символом новой строки \n, задается на 
 259 | стандартном потоке ввода stdin и состоит из букв латинского алфавита,
 260 | цифр и пробелов, которые разделяют слова между собой. Преобразованную
 261 | строку вывести на стандартный поток вывода stdout. В конце ответа не 
 262 | должно быть переноса на новую строку.
 263 | 
 264 | Пример:			This is my time --> This Is My Time
 265 | 			area1234 --> Area1234
 266 | ----------------------------------------------------------------------*/
 267 | 
 268 | #include <stdio.h>
 269 | #include <stdlib.h>
 270 | 
 271 | void output(size_t i, char* array);
 272 | void change_reg(size_t i, char* array);
 273 | 
 274 | int main() {
 275 |     char* array = NULL;
 276 |     size_t i = 0;
 277 |     char box;
 278 |     while (scanf("%c", &box) != 0 && box != '\n') {
 279 |         array = realloc(array, (i + 1) * sizeof(char));
 280 |         array[i] = box;
 281 |         i++;
 282 |     }
 283 |     array[i] = '\0';
 284 |     change_reg(i, array);
 285 |     output(i, array);
 286 |     free(array);
 287 |     return 0;
 288 | }
 289 | 
 290 | // поиск  буквы в нижнем регистре и замена ее на букву в верхнем регистре
 291 | void change_reg(size_t i, char* array) {
 292 |     size_t j = 0;
 293 |     while (j < i) {
 294 |         if (array[0] < 123 && array[0] > 96) {
 295 |             array[0] = array[0] - 32;
 296 |         }
 297 |         if (array[j] == ' ') {
 298 |             if (array[j + 1] < 123 && array[j + 1] > 96) {
 299 |                 array[j + 1] = array[j + 1] - 32;
 300 |             }
 301 |         }
 302 |         j++;
 303 |     }
 304 | }
 305 | 
 306 | // вывод нового массива в терминале
 307 | void output(size_t i, char* array) {
 308 |     size_t f = 0;
 309 |     while (f < i) {
 310 |         printf("%c", array[f]);
 311 |         f++;
 312 |     }
 313 | }
 314 | 
 315 | =====================================================================
 316 | /* Task 6 
 317 | 
 318 | На вход подаётся три числа. Гарнтируется, что 
 319 | подаются только целые числа. Необходимо написать программу, 
 320 | которая бы выводила 1, если третье число массива расположено 
 321 | между первым и вторым. Не использовать if.
 322 | 
 323 | Пример ввода : 0 9 5
 324 | Пример вывода: 1
 325 | Пример ввода: 1 2 3
 326 | Пример вывода : 0
 327 | --------------------------------------------------------------- */
 328 | 	
 329 | 	
 330 | #include <stdio.h>
 331 | #include <math.h>
 332 | #include <stdlib.h>
 333 | 
 334 | int main() {
 335 |     int result;
 336 |     int array[3];
 337 |     int i = 0;
 338 |     while (i < 3) {
 339 |         scanf("%d", &array[i]);
 340 |         i++;
 341 |     }
 342 |     result = (array[2] > array[0] && array[2] < array[1]) || (array[2] < array[0] && array[2] > array[1]);
 343 |     printf("%d", result);
 344 |     return 0;
 345 | }
 346 | 
 347 | =====================================================================
 348 | /* Task 7 - Вывести число в обратном порядке*/
 349 | 
 350 | #include <stdio.h>
 351 | 
 352 | int main() {
 353 |     int a;
 354 |     if (scanf("%d", &a)) {
 355 |             int b = a%10;
 356 |             int c = a / 10;
 357 |             int d = c%10;
 358 |             int e = c / 10;
 359 |             int f = e%10;
 360 |         if (a >= 0) {
 361 |             printf("%d%d%d", b, d, f);
 362 |         }
 363 |         if (a < 0) {
 364 |             printf("-%d%d%d", b * (-1), d * (-1), f * (-1));
 365 |         }
 366 |     }
 367 |     return 0;
 368 | }
 369 | */
 370 | 
 371 | =====================================================================
 372 | /* Task 8 
 373 | 
 374 | Дана последовательность чисел. Конец последовательности -1. 
 375 | Вывести в порядке Вывести x1 xn x2 xn-1 x3 xn-2 и так далее
 376 | Реализация через динамический массив */
 377 | --------------------------------------------------------------
 378 | #include <stdio.h>
 379 | #include <stdlib.h>
 380 | 
 381 | int main() {
 382 |     int *str = malloc(1 * sizeof(int));
 383 |     int k = 0;
 384 |     int flag = 0;
 385 |     while(scanf("%d", &str[k]) == 1 && str[k] != -1) { // считываем строку
 386 |         int *tmp = realloc(str, k + 1);
 387 |         if (tmp == NULL) {
 388 |             flag = 1;
 389 |         } else {
 390 |         str = tmp;
 391 |         k++;
 392 |         }
 393 |     }
 394 | 
 395 |     if (flag == 0) {
 396 |     int *output = malloc((k + 1) * sizeof(int));
 397 |     int j = 0;
 398 |     for(int i = 0; i < k; i += 2)   { // записываем элементы с начала
 399 |         output[i] = str[j];
 400 |         j++;
 401 |     }
 402 | 
 403 |     j = k - 1;
 404 |     for(int i = 1; i < k; i += 2)   { // записываем элементы с конца
 405 |         output[i] = str[j];
 406 |         j--;
 407 |     }
 408 | 
 409 |     free(str);
 410 | 
 411 |     for(int i = 0; i < k; i++) {
 412 |         printf("%d ", output[i]);  // печатаем массив
 413 |     }
 414 | 
 415 |     free(output);
 416 |     }
 417 | 
 418 |     return 0;
 419 | }
 420 | 
 421 | =====================================================================
 422 | /* Task 9 - Дана последовательность чисел. Конец последовательности -1. Вывести в порядке Вывести x1 xn x2 xn-1 x3 xn-2 и так далее
 423 | Реализация через статик массив */
 424 | 
 425 | #include <stdio.h>
 426 | #include <stdlib.h>
 427 | 
 428 | int main() {
 429 |     int str[1000];
 430 |     int output[1000];
 431 |     int k = 0;
 432 |     while(scanf("%d", &str[k]) == 1 && str[k] != -1) { // считываем строку
 433 |         k++;
 434 |     }
 435 | 
 436 |     int j = 0;
 437 |     for(int i = 0; i < k; i += 2)   { // записываем элементы с начала
 438 |         output[i] = str[j];
 439 |         j++;
 440 |     }
 441 | 
 442 |     j = k - 1;
 443 |     for(int i = 1; i < k; i += 2)   { // записываем элементы с конца
 444 |         output[i] = str[j];
 445 |         j--;
 446 |     }
 447 | 
 448 |     for(int i = 0; i < k; i++) {
 449 |         printf("%d ", output[i]);  // печатаем массив
 450 |     }
 451 |     return 0;
 452 | }
 453 | */
 454 | 
 455 | =====================================================================
 456 | /* Task 10 - Факториал - реализация через статик массив */
 457 | 
 458 | #include <stdio.h>
 459 | #include <stdlib.h>
 460 | 
 461 | #define N 1000
 462 | 
 463 | int main() {
 464 |     int n;
 465 |     if(scanf("%d", &n) == 1) {
 466 |     n = n + 1;
 467 |     int arr[N][N];
 468 |     
 469 |     for (int i = 1; i < n; i++) {
 470 |         for (int j = 0; j < n; j++) {
 471 |             arr[i][j] = 0;
 472 |         }
 473 |     }
 474 | 
 475 |     arr[0][0] = 1;
 476 | 
 477 |     for (int i = 1; i < n; i++) {
 478 |         for (int j = 0; j < n; j++) {
 479 |             if (j == 0) {
 480 |                 arr[i][j] = 1;
 481 |             } else {
 482 |             arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
 483 |             }
 484 |         }
 485 |     }
 486 | 
 487 |     for (int j = 0; j < n; j++) {
 488 |         printf("%d ", arr[n - 1][j]);
 489 |     }
 490 |     return 0;
 491 |     }
 492 | }
 493 | 
 494 | =====================================================================
 495 | /* Task 11 - Задача перевода радиуса шара в радианы	
 496 | 
 497 | Найти массу шара. Радиус шара вводиться в консоль ( радиус имеет тип double).
 498 | Плотность шара = 21500 кг/м^3
 499 | Даны формулы:
 500 | V = (4/3) * pi * R^3
 501 | P = m / V
 502 | Вывести массу округлив ее до целого числа математически верно.
 503 | Примечание:
 504 | Использовать константу M_PI, и функцию double round(double) из библиотеки math.h
 505 | Вывод должен выглядеть так:
 506 | printf("%.0lf", result); 
 507 | r = 1, 10.    
 508 | 
 509 | 1. Посчитать обьем шара
 510 | 2. Вывести формулу массы, посчитать
 511 | 3. Вывести результат
 512 | 4. Сделать проверку на корректность ввода
 513 | 5. Cpplint
 514 | 6. Test for leaks 
 515 | -------------------------------------------------------------------------*/
 516 | Вариант 1
 517 | 	
 518 | #include <stdio.h>
 519 | #include <math.h>
 520 | 
 521 | int main() {
 522 |     // float density_of_the_sphere = 21500 кг/м^3 = 0,0215 кг/см^3
 523 |     double r = 0.0;
 524 |     char endline;
 525 |     if (scanf("%lf", &r)) {
 526 |         endline = getchar();
 527 |         if (endline == ' ' || endline == '\n') {
 528 |             double v = (4.0/3.0) * M_PI * pow(r, 3.0);
 529 |             double p = 0.0215;
 530 |             double m = p * v;
 531 |             double rounded_mass = round(m);
 532 |             printf("%lf\n", m);
 533 |             printf("%0lf", rounded_mass);
 534 |             } else {
 535 |                 printf("n/a");
 536 |             }
 537 |     } else {
 538 |         printf("n/a");
 539 |     }
 540 |     return 0;
 541 | }
 542 | 
 543 | 
 544 | ========  Вариант 2
 545 | 
 546 | #include <math.h>
 547 | #include <stdio.h>
 548 | 
 549 | int main() {
 550 |   int p = 21500;
 551 |   double r;
 552 |     if (scanf("%lf", &r) == 1) {
 553 |       double v = (4. / 3.) * M_PI * pow(r, 3);
 554 |       double m = p * v;
 555 |       double rounded_mass = round(m);
 556 |       printf("%.0lf", rounded_mass);
 557 |     } else {
 558 |       printf("n/a");
 559 |       return 0;
 560 |     }
 561 | }
 562 | 
 563 | =====================================================================
 564 | /* Task 12 - Транспонирование матрицы	*/
 565 | 
 566 | #include <stdio.h>
 567 | #include <stdlib.h>
 568 | #include <string.h>
 569 | 
 570 | int main() {
 571 | 	int n;
 572 | 	scanf_s("%d", &n);
 573 | 	int** pointer = malloc(n * sizeof(int*));
 574 | 	int* value = malloc(n * n * sizeof(int));
 575 | 
 576 | 	for (int i = 0; i < n; i++) {
 577 | 		pointer[i] = value + n * i;
 578 | 	}
 579 | 
 580 | 	for (int i = 0; i < n; i++) {
 581 | 		for (int j = 0; j < n; j++) {
 582 | 			scanf_s("%d", &pointer[i][j]);
 583 | 		}
 584 | 	}
 585 | 
 586 | 	for (int i = 0; i < n; i++) {
 587 | 		for (int j = 0; j < n; j++) {
 588 | 			printf("%d ", pointer[i][j]);
 589 | 		}
 590 | 		printf("\n");
 591 | 	}
 592 | 	printf("\n");
 593 | 
 594 | 	int** pointer_trans = malloc(n * sizeof(int*));
 595 | 	int* value_trans = malloc(n * n * sizeof(int));
 596 | 
 597 | 	for (int i = 0; i < n; i++) {
 598 | 		pointer_trans[i] = value_trans + n * i;
 599 | 	}
 600 | 
 601 | 	for (int i = 0; i < n; i++) {
 602 | 		for (int j = 0; j < n; j++) {
 603 | 			pointer_trans[i][j] = pointer[j][i];
 604 | 		}
 605 | 	}
 606 | 
 607 | 	for (int i = 0; i < n; i++) {
 608 | 		for (int j = 0; j < n; j++) {
 609 | 			printf("%d ", pointer_trans[i][j]);
 610 | 		}
 611 | 		printf("\n");
 612 | 	}
 613 | 	printf("\n");
 614 | 
 615 | 	int** p = malloc(n * sizeof(int*));
 616 | 	int* v = malloc(n * n * sizeof(int));
 617 | 
 618 | 	for (int i = 0; i < n; i++) {
 619 | 		p[i] = v + n * i;
 620 | 	}
 621 | 
 622 | 	int k = 0, l = 0, m = 0;
 623 | 	for (m = 0; m < n; m++) {
 624 | 		for (k = 0; k < n; k++) {
 625 | 			p[m][k] = 0;
 626 | 			for (l = 0; l < n; l++) {
 627 | 				p[m][k] += pointer_trans[m][l] * pointer[l][k];
 628 | 			}
 629 | 		}
 630 | 	}
 631 | 
 632 | 	for (int i = 0; i < n; i++) {
 633 | 		for (int j = 0; j < n; j++) {
 634 | 			printf("%d ", p[i][j]);
 635 | 		}
 636 | 		printf("\n");
 637 | 	}
 638 | 
 639 | 	free(value);
 640 | 	free(pointer);
 641 | 	free(value_trans);
 642 | 	free(pointer_trans);
 643 | 	free(v);
 644 | 	free(p);
 645 | 	return 0;
 646 | }
 647 | 
 648 | 
 649 | 
 650 | =====================================================================
 651 | /* Task 14 - Умножение матрица через динамический массив	*/
 652 | 
 653 | #include <stdio.h>
 654 | #include <stdlib.h>
 655 | 
 656 | void read_matrix(int **matrix, int *pflag, int N);
 657 | 
 658 | int main() {
 659 |   int N, flag = 0;
 660 |   if (scanf("%d", &N) == 1 && N > 0) {
 661 |     int **matrix1, **matrix2;
 662 | 
 663 |     matrix1 = malloc(N * sizeof(int *));
 664 |     for (int i = 0; i < N; i++) {
 665 |       matrix1[i] = malloc(N * sizeof(int));
 666 |     }
 667 | 
 668 |     for (int i = 0; i < N; i++) {
 669 |       for (int j = 0; j < N; j++) {
 670 |         flag = scanf("%d", &matrix1[i][j]);
 671 |       }
 672 |     }
 673 | 
 674 |     matrix2 = malloc(N * sizeof(int *));
 675 |     for (int i = 0; i < N; i++) {
 676 |       matrix2[i] = malloc(N * sizeof(int));
 677 |     }
 678 | 
 679 |     for (int i = 0; i < N; i++) {
 680 |       for (int j = 0; j < N; j++) {
 681 |         flag = scanf("%d", &matrix2[i][j]);
 682 |       }
 683 |     }
 684 | 
 685 |     if (flag == 0) {
 686 |       printf("n/a");
 687 |     } else {
 688 |       for (int i = 0; i < N; i++) {
 689 |         for (int j = 0; j < N; j++) {
 690 |           int sum = 0;
 691 |           for (int k = 0; k < N; k++) {
 692 |             sum += matrix1[i][k] * matrix2[k][j];
 693 |           }
 694 |           printf("%d", sum);
 695 |           if (j != N - 1) {
 696 |             printf(" ");
 697 |           }
 698 |         }
 699 |         if (i != N - 1) {
 700 |           printf("\n");
 701 |         }
 702 |       }
 703 |     }
 704 | 
 705 |     for (int i = 0; i < N; i++) {
 706 |       free(matrix1[i]);
 707 |       free(matrix2[i]);
 708 |     }
 709 |     free(matrix1);
 710 |     free(matrix2);
 711 |   } else {
 712 |     printf("n/a");
 713 |   }
 714 |   return 0;
 715 | }
 716 | 
 717 | =====================================================================
 718 | /* Task 15 - Умножение матриц через статик	*/
 719 | 
 720 | #include <stdio.h>
 721 | 
 722 | int main() {
 723 |   int N, flag = 0;
 724 |   if (scanf("%d", &N) == 1 && N > 0) {
 725 |     int matrix1[N][N], matrix2[N][N];
 726 | 
 727 |     for (int i = 0; i < N; i++) {
 728 |       for (int j = 0; j < N; j++) {
 729 |         flag = scanf("%d", &matrix1[i][j]);
 730 |       }
 731 |     }
 732 | 
 733 |     for (int i = 0; i < N; i++) {
 734 |       for (int j = 0; j < N; j++) {
 735 |         flag = scanf("%d", &matrix2[i][j]);
 736 |       }
 737 |     }
 738 | 
 739 |     if (flag == 0) {
 740 |       printf("n/a");
 741 |     } else {
 742 |       for (int i = 0; i < N; i++) {
 743 |         for (int j = 0; j < N; j++) {
 744 |           int sum = 0;
 745 |           for (int k = 0; k < N; k++) {
 746 |             sum += matrix1[i][k] * matrix2[k][j];
 747 |           }
 748 |           printf("%d", sum);
 749 |           if (j != N - 1) {
 750 |             printf(" ");
 751 |           }
 752 |         }
 753 |         if (i != N - 1) {
 754 |           printf("\n");
 755 |         }
 756 |       }
 757 |     }
 758 |   } else {
 759 |     printf("n/a");
 760 |   }
 761 |   return 0;
 762 | }
 763 | 
 764 | =====================================================================
 765 | /* Task 16 - ЗУдалить избыточные пробелы оставить 1 пробел между словами
 766 | нулевой элемент и последний элемент не могут быть пробелами не переводить 
 767 | на следующую строчку входная строка заканчивается \n */
 768 | 
 769 | #include <stdio.h>
 770 | #include <string.h>
 771 | int main() {
 772 |     char string[100];
 773 |     char new[100];
 774 |     fgets(string, 256, stdin);
 775 |     int j = 0;
 776 |     for (int i = 0; i < (int)strlen(string); i++) {
 777 |         if (string[i] == ' ') {
 778 |             if (string[i+1] == ' ' || j == 0 || string[i+1] == '\0') {continue;}
 779 |         }
 780 |         new[j] = string[i];
 781 |         j++;
 782 |     }
 783 |     new[j-2] = '\0';
 784 |     printf("%s", new);
 785 | }
 786 | 
 787 | =====================================================================
 788 | /* Task 17 - Своп максимума и минимума через реалок	*/
 789 | 
 790 | #include <stdio.h>
 791 | #include <stdlib.h>
 792 | 
 793 | int main() {
 794 | 	char *matrix = NULL;
 795 | 	int elem, i = 0;
 796 | 	while (scanf_s("%d", &elem) == 1 && elem != -1) {
 797 | 		matrix = realloc(matrix, (i + 1) * sizeof(int));
 798 | 		matrix[i] = elem;
 799 | 		i++;
 800 | 	}
 801 | 	int count = i - 1;
 802 | 
 803 | 	// reverse output
 804 | 
 805 | 	printf("%d", matrix[count]);
 806 | 	for (int j = count - 1; j >= 0; j--) {
 807 | 		printf(" %d", matrix[j]);
 808 | 	}
 809 | 
 810 | 	printf("\n");
 811 | 
 812 | 	// swap first min first max
 813 | 
 814 | 	int max = matrix[0];
 815 | 	int min = matrix[0];
 816 | 	int cmin, cmax;
 817 | 
 818 | 	for (int k = 0; k <= count; k++) {
 819 | 		if (matrix[k] < min) {
 820 | 			min = matrix[k];
 821 | 		}
 822 | 	}
 823 | 
 824 | 	int k = 0;
 825 | 	while (k <= count) {
 826 | 		if (matrix[k] == min) {
 827 | 			cmin = k;
 828 | 			break;
 829 | 		}
 830 | 		k++;
 831 | 	}
 832 | 
 833 | 	for (int k = 0; k <= count; k++) {
 834 | 		if (matrix[k] > max) {
 835 | 			max = matrix[k];
 836 | 		}
 837 | 	}
 838 | 
 839 | 	k = 0;
 840 | 	while (k <= count) {
 841 | 		if (matrix[k] == max) {
 842 | 			cmax = k;
 843 | 			break;
 844 | 		}
 845 | 		k++;
 846 | 	}
 847 | 
 848 | 	matrix[cmax] = min;
 849 | 	matrix[cmin] = max;
 850 | 
 851 | 	printf("%d", matrix[0]);
 852 | 	for (int j = 1; j <= count; j++) {
 853 | 		printf(" %d", matrix[j]);
 854 | 	}
 855 | 
 856 | 	printf("\n");
 857 | 
 858 | 	// sort
 859 | 
 860 | 	int temp;
 861 | 	for (int i = 0; i <= count - 1; i++) {
 862 | 		for (int j = 0; j <= count - i - 1; j++) {
 863 | 			if (matrix[j + 1] < matrix[j]) {
 864 | 				temp = matrix[j];
 865 | 				matrix[j] = matrix[j + 1];
 866 | 				matrix[j + 1] = temp;
 867 | 			}
 868 | 		}
 869 | 	}
 870 | 
 871 | 	printf("%d", matrix[0]);
 872 | 	for (int j = 1; j <= count; j++) {
 873 | 		printf(" %d", matrix[j]);
 874 | 	}
 875 | 
 876 | 	free(matrix);
 877 | 	return 0;
 878 | }
 879 | 
 880 | =====================================================================
 881 | /* Task 18  
 882 | 
 883 | Написать программу, осуществляющую удаление повторяющихся элементов в последовательности, 
 884 | состоящей из целых неотрицательных чисел. (Концом последовательности считать -1)
 885 | Порядок элементов в результирующей последовательности должен соответствовать 
 886 | порядку первых вхождений соответствующих чисел в исходной последовательности  */
 887 | ---------------------------------------------------------------------	
 888 | 	
 889 | #include <stdio.h>
 890 | #include <stdlib.h>
 891 | 
 892 | int main() {
 893 |   int *str = malloc(1 * sizeof(int));
 894 |   int k = 0;
 895 |   int flag = 0;
 896 |   while (scanf("%d", &str[k]) == 1 && str[k] != -1) { // считываем строку
 897 |     int *tmp = realloc(str, k + 1);
 898 |     if (tmp == NULL) {
 899 |       flag = 1;
 900 |     } else {
 901 |       str = tmp;
 902 |       k++;
 903 |     }
 904 |   }
 905 | 
 906 |   if (flag == 0) {
 907 | 
 908 |     int *out = calloc(k + 1, sizeof(int));
 909 |     int n = 0;
 910 |     for (int i = 0; i < k + 1; i++) {
 911 |       int counter = 0;
 912 |       for (int j = 0; j < k + 1; j++) {
 913 |         if (str[i] == out[j]) {
 914 |           counter++;
 915 |         }
 916 |       }
 917 |       if (counter == 0 && str[i] != -1) {
 918 |         out[n] = str[i];
 919 |         n++;
 920 |       }
 921 |     }
 922 |     for (int i = 0; i < n; i++) {
 923 |       printf("%d ", out[i]);
 924 |     }
 925 |     free(out);
 926 |   }
 927 |   free(str);
 928 |   return 1;
 929 | }
 930 | 
 931 | =====================================================================
 932 | /* Task 19 - Rotate matrix with malloc	*/
 933 | 
 934 | #include <stdio.h>
 935 | #include <stdlib.h>
 936 | #include <string.h>
 937 | 
 938 | int main() {
 939 | 	int n;
 940 | 	scanf("%d", &n);
 941 | 	int** pointer = malloc(n * sizeof(int*));
 942 | 	int* value = malloc(n * n * sizeof(int));
 943 | 
 944 | 	for (int i = 0; i < n; i++) {
 945 | 		pointer[i] = value + n * i;
 946 | 	}
 947 | 
 948 | 	for (int i = 0; i < n; i++) {
 949 | 		for (int j = 0; j < n; j++) {
 950 | 			scanf("%d", &pointer[i][j]);
 951 | 		}
 952 | 	}
 953 | 
 954 | 	for (int i = 0; i < n; i++) {
 955 | 		for (int j = 0; j < n; j++) {
 956 | 			printf("%d ", pointer[i][j]);
 957 | 		}
 958 | 		printf("\n");
 959 | 	}
 960 | 	printf("\n");
 961 | 
 962 | 	int** p = malloc(n * sizeof(int*));
 963 | 	int* v = malloc(n * n * sizeof(int));
 964 | 
 965 | 	for (int i = 0; i < n; i++) {
 966 | 		p[i] = v + n * i;
 967 | 	}
 968 | 
 969 | 	for (int i = 0; i < n; i++) {
 970 | 		for (int j = n - 1; j >= 0; j--) {
 971 | 			p[i][n - 1 - j] = pointer[j][i];
 972 | 		}
 973 | 	}
 974 | 
 975 |     for (int i = 0; i < n; i++) {
 976 | 		for (int j = 0; j < n; j++) {
 977 | 			printf("%d ", p[i][j]);
 978 | 		}
 979 | 		printf("\n");
 980 | 	}
 981 | 	printf("\n");
 982 | 
 983 | 	free(value);
 984 | 	free(pointer);
 985 | 	free(v);
 986 | 	free(p);
 987 | 	return 0;
 988 | }
 989 | 
 990 | =====================================================================
 991 | /* Task 20 - Snake side to side	*/
 992 | 
 993 | #include <stdio.h>
 994 | #include <stdlib.h>
 995 | int main() {
 996 |     int n;
 997 |     if (scanf("%d", &n) == 1 && n > 0) {
 998 |         int my_matrix[n][n];
 999 | 
1000 |         int count = 1;
1001 |         int dir_ball = 0;
1002 |         int x_b = 0;
1003 |         int y_b = 0;
1004 | 
1005 |         int left = 0;
1006 |         int right = n - 1;
1007 | 
1008 |         while (count != (n * n + 1)) {
1009 |             my_matrix[y_b][x_b] = count;
1010 |             count++;
1011 | 
1012 |             if (dir_ball == 0) {  // move right
1013 |                 if (x_b == right) {
1014 |                     y_b++;
1015 |                     dir_ball = 1;
1016 |                 } else {
1017 |                     x_b++;
1018 |                 }
1019 |             } else if (dir_ball == 1) {  // move left
1020 |                 if (x_b == left) {
1021 |                     y_b++;
1022 |                     dir_ball = 0;
1023 |                 } else {
1024 |                     x_b--;
1025 |                 }
1026 |             }
1027 |         }
1028 | 
1029 |         for (int i = 0; i < n; i++) {
1030 |             for (int j = 0; j < n; j++) {
1031 |                 printf("%d", my_matrix[i][j]);
1032 |                 if (j < n - 1) {
1033 |                     printf(" ");
1034 |                 }
1035 |             }
1036 |             if (i < n - 1)
1037 |                 printf("\n");
1038 |         }
1039 |     } else {
1040 |         printf("n/a");
1041 |     }
1042 | }
1043 | 
1044 | =====================================================================
1045 | /* Task 21 - Snake to center	*/
1046 | 
1047 | #include <stdio.h>
1048 | 
1049 | int main() {
1050 |     int n;
1051 |     if (scanf("%d", &n) == 1) {
1052 |         int my_matrix[n][n];
1053 | 
1054 |         int count = 0;
1055 |         int dir_ball = 0;
1056 |         int x_b = -1;
1057 |         int y_b = 0;
1058 | 
1059 |         int up = 1;
1060 |         int down = n - 1;
1061 |         int left = 0;
1062 |         int right = n - 1;
1063 | 
1064 |         while (count != (n * n + 1)) {
1065 |             my_matrix[y_b][x_b] = count;
1066 |             count++;
1067 | 
1068 |             if (dir_ball == 0) {  // move right
1069 |                 x_b++;
1070 |                 if (x_b == right) {
1071 |                     right--;
1072 |                     dir_ball = dir_ball + 1;
1073 |                 }
1074 |             } else if (dir_ball == 1) {  // move down
1075 |                 y_b++;
1076 |                 if (y_b == down) {
1077 |                     down--;
1078 |                     dir_ball = dir_ball + 1;
1079 |                 }
1080 |             } else if (dir_ball == 2) {  // move left
1081 |                 x_b--;
1082 |                 if (x_b == left) {
1083 |                     left++;
1084 |                     dir_ball = dir_ball + 1;
1085 |                 }
1086 |             } else if (dir_ball == 3) {  // move up
1087 |                 y_b--;
1088 |                 if (y_b == up) {
1089 |                     up++;
1090 |                     dir_ball = 0;
1091 |                 }
1092 |             }
1093 |         }
1094 | 
1095 |         for (int i = 0; i < n; i++) {
1096 |             for (int j = 0; j < n; j++) {
1097 |                 printf("%d", my_matrix[i][j]);
1098 |                 if (j < n - 1) {
1099 |                     printf(" ");
1100 |                 }
1101 |             }
1102 |             if (i < n - 1)
1103 |                 printf("\n");
1104 |         }
1105 |     } else {
1106 |         printf("n/a");
1107 |     }
1108 | }
1109 | 
1110 | =====================================================================
1111 | /* Task 21 - Snake spiral	*/
1112 | 
1113 | #include <stdio.h>
1114 | #include <stdlib.h>
1115 | 
1116 | int main() {
1117 |     int m;
1118 |     int i, j = 0;
1119 |     char end;
1120 | 
1121 |     if(scanf("%d%c", &m, &end) == 2 && end == '\n' && m > 0) { // end для проверки на нецелое число
1122 |         int **a = calloc(m, sizeof(int *)); // создаем динамическую матрицу (10 - 13 строки)
1123 |         for (int i = 0; i < m; i++) {
1124 |             a[i] = calloc(m, sizeof(int));
1125 |         }
1126 |         int flag = 0; // флаг определяет, в каком направлении по матрице мы движемся (0 - вправо, 1 - вниз, 2 - влево, 3 - вверх)
1127 |         int c = 1; // счетчик, значения которого записываем в массив
1128 |         while (c <= m * m) {
1129 |             if (flag == 0) {
1130 |                 while (j < m && a[i][j] == 0) {
1131 |                 a[i][j] = c;
1132 |                 c++;
1133 |                 j++;
1134 |                 }
1135 |                 j--; // тк прошла лишняя итерация и j выходит за пределы массива, откатываем его на единицу назад
1136 |                 i++; // спускаемся на строку ниже, чтобы не перезаписать значение в уже заполненную ячейку
1137 |                 flag = 1;
1138 |             } else if (flag == 1) {
1139 |                 while (i < m && a[i][j] == 0) {
1140 |                 a[i][j] = c;
1141 |                 c++;
1142 |                 i++;
1143 |                 }
1144 |                 i--; // откатываемся в пределы массива
1145 |                 j--; // откат, чтобы не перезаписывать значение
1146 |                 flag = 2;
1147 |             } else if (flag == 2) {
1148 |                 while (j > -1 && a[i][j] == 0) {
1149 |                 a[i][j] = c;
1150 |                 c++;
1151 |                 j--;
1152 |                 }
1153 |                 j++; // откатываемся в пределы массива
1154 |                 i--; // откат, чтобы не перезаписывать значение
1155 |                 flag = 3;
1156 |             } else if (flag == 3) {
1157 |                 while (i > -1 && a[i][j] == 0) {
1158 |                 a[i][j] = c;
1159 |                 c++;
1160 |                 i--;
1161 |                 }
1162 |                 i++; // откатываемся в пределы массива
1163 |                 j++; // откат, чтобы не перезаписывать значение
1164 |                 flag = 0;
1165 |             }
1166 | 
1167 |         }
1168 |         for (int i = 0; i < m; i++) {
1169 |             for (int j = 0; j < m; j++) {
1170 |                 printf("%d ", a[i][j]);
1171 |             }
1172 |             printf("\n");
1173 |         }
1174 |         for (int i = 0; i < m; i++) {
1175 |             free(a[i]); // чистим массивы строк
1176 |         }
1177 |         free(a); // чистим массив указателей
1178 |     }
1179 | }
1180 | 
1181 | =====================================================================
1182 | /* Task 23 - Структура - люди	*/
1183 | 
1184 | #include <stdio.h>
1185 | #define NMAX 20
1186 | struct Person {
1187 |         char first_name[NMAX];
1188 |         char last_name[NMAX];
1189 |         int height;
1190 |     };
1191 | void input(struct Person* people, int number_of_elements);
1192 | void output(struct Person* people, int number_of_elements, int h_number);
1193 | int main() {
1194 |     // Declaration of array named "people" of structure Person
1195 |     struct Person people[NMAX];
1196 |     int number_of_elements = 0;
1197 |     scanf("%d", &number_of_elements);
1198 |     input(people, number_of_elements);
1199 |     int h_number = 0;
1200 |     scanf("%d", &h_number);
1201 |     output(people, number_of_elements, h_number);
1202 |     
1203 |     return 0;
1204 | }
1205 | void input(struct Person* people, int number_of_elements) {
1206 |     for (int i = 0; i < number_of_elements; i++) {
1207 |         scanf("%s", people[i].first_name);
1208 |         scanf("%s", people[i].last_name);
1209 |         scanf("%d", &people[i].height);
1210 |     }
1211 | }
1212 | void output(struct Person* people, int number_of_elements, int h_number) {
1213 |     for (int i = 0; i < number_of_elements; i++) {
1214 |         if (people[i].height >= h_number) {
1215 |             printf("%s ", people[i].first_name);
1216 |             printf("%s", people[i].last_name);
1217 |             }
1218 |         if (i < number_of_elements - 2) {
1219 |             printf(", ");
1220 |         }
1221 |     }
1222 | }
1223 | 
1224 | =====================================================================
1225 | /* Task 24 - Структура имя фамилия рост*/
1226 | 
1227 | Вариант 1
1228 | #include <stdio.h>
1229 | 
1230 | struct data {
1231 |     char name[1000];
1232 |     char surname[1000];
1233 |     int height; 
1234 | };
1235 | 
1236 | int main() {
1237 |     int n; // количество структур
1238 |     scanf("%d", &n);
1239 |     struct data data[n];
1240 |     for (int i = 0; i < n; i++) {
1241 |         scanf("%s", data[i].name);
1242 |         scanf("%s", data[i].surname);
1243 |         scanf("%d", &data[i].height);
1244 |     }
1245 | 
1246 |     int limit;
1247 |     scanf("%d", &limit);
1248 | 
1249 |     for (int i = 0; i < n; i++) {
1250 |         if (data[i].height > limit) {
1251 |             printf("%s, %s\n", data[i].name, data[i].surname);
1252 |         }
1253 |     }
1254 | 
1255 | }
1256 | 
1257 | // Вариант 2 
1258 | 
1259 | #include <stdio.h>
1260 | #define NMAX 20
1261 | 
1262 | struct Person {
1263 |         char first_name[NMAX];
1264 |         char last_name[NMAX];
1265 |         int height;
1266 |     };
1267 | 
1268 | void input(struct Person* people, int number_of_elements);
1269 | void output(struct Person* people, int number_of_elements, int h_number);
1270 | 
1271 | int main() {
1272 | 
1273 |     // Declaration of array named "people" of structure Person
1274 |     struct Person people[NMAX];
1275 | 
1276 |     int number_of_elements = 0;
1277 |     scanf("%d", &number_of_elements);
1278 | 
1279 |     input(people, number_of_elements);
1280 | 
1281 |     int h_number = 0;
1282 |     scanf("%d", &h_number);
1283 | 
1284 |     output(people, number_of_elements, h_number);
1285 |     
1286 |     return 0;
1287 | }
1288 | 
1289 | void input(struct Person* people, int number_of_elements) {
1290 |     for (int i = 0; i < number_of_elements; i++) {
1291 |         scanf("%s", people[i].first_name);
1292 |         scanf("%s", people[i].last_name);
1293 |         scanf("%d", &people[i].height);
1294 |     }
1295 | }
1296 | 
1297 | void output(struct Person* people, int number_of_elements, int h_number) {
1298 |     for (int i = 0; i < number_of_elements; i++) {
1299 |         if (people[i].height >= h_number) {
1300 |             printf("%s ", people[i].first_name);
1301 |             printf("%s", people[i].last_name);
1302 |             }
1303 |         if (i < number_of_elements - 2) {
1304 |             printf(", ");
1305 |         }
1306 |     }
1307 | }
1308 | 
1309 | =====================================================================
1310 | /* Task 25 - Транспонирование матрицы через статик */
1311 | 
1312 | #include <stdio.h>
1313 | 
1314 | int main() {
1315 |     int N, flag = 1;
1316 |     if (scanf("%d", &N) == 1 && N > 0) {
1317 |         int matrix[N][N];
1318 |         for (int i = 0; i < N; i++) {
1319 |             for (int j = 0; j < N; j++) {
1320 |                 flag = scanf("%d", &matrix[i][j]);
1321 |             }
1322 |         }
1323 |         if (flag == 0) {
1324 |             printf("n/a");
1325 |         } else {
1326 |             for (int i = 0; i < N; i++) {
1327 |                 for (int j = 0; j < N; j++) {
1328 |                     printf("%d", matrix[j][i]);
1329 |                     if (j != N - 1) { printf(" "); }
1330 |                 }
1331 |                 if (i != N - 1) { printf("\n"); }
1332 |             }
1333 |         }
1334 |     }
1335 | 	
1336 |     return 0;
1337 | }
1338 | 
1339 | =====================================================================
1340 | /* Task 26 - Еще одно транспонирование матрицы	*/
1341 | 
1342 | #include <stdio.h>
1343 | 
1344 | int main() {
1345 |     int n;
1346 |     if (scanf("%d", &n) == 1 && n > 0) {
1347 |         int my_matrix[n][n];
1348 | 
1349 |         int bad = 0;
1350 |         for (int i = 0; i < n; i++) {
1351 |             for (int j = 0; j < n; j++) {
1352 |                 if (scanf("%d", &my_matrix[i][j]) != 1)
1353 |                     bad = 1;
1354 |                 if (bad)
1355 |                     break;
1356 |             }
1357 |             if (bad)
1358 |                 break;
1359 |         }
1360 |         if (!bad) {
1361 |             for (int i = 0; i < n; i++) {
1362 |                 for (int j = 0; j < n; j++) {
1363 |                     printf("%d", my_matrix[j][i]);
1364 |                     if (j < n - 1) {
1365 |                         printf(" ");
1366 |                     }
1367 |                 }
1368 |                 if (i < n - 1)
1369 |                     printf("\n");
1370 |             }
1371 |         } else {
1372 |             printf("n/a");
1373 |         }
1374 |     } else {
1375 |         printf("n/a");
1376 |     }
1377 | }
1378 | */
1379 | 
1380 | =====================================================================
1381 | /* Task 27 - split the digits	*/
1382 | 
1383 | #include <stdio.h>
1384 | 
1385 | int main()
1386 | {
1387 |     int num;
1388 |     
1389 |     scanf("%d",&num);
1390 |     
1391 |     while(num > 0) //do till num greater than  0
1392 |     {
1393 |         int mod = num % 10;  //split last digit from number
1394 |         printf("%d\n",mod); //print the digit. 
1395 |     
1396 |         num = num / 10;    //divide num by 10. num /= 10 also a valid one 
1397 |     }
1398 |     
1399 |     return 0;
1400 | }
1401 | 
1402 | 
1403 | =====================================================================
1404 | /* Task 28 - Биноминальный коэф	*/
1405 | 
1406 | #include <stdio.h>
1407 | 
1408 | int factorial(int number);
1409 | int c_formula(int number, int k);
1410 | 
1411 | int main() {
1412 |     int number;
1413 |     scanf("%d", &number);
1414 |     for (int k = 0; k <= number; k++) {
1415 |         printf("%d", c_formula(number, k));
1416 |         if (k != number) {
1417 |             printf(" ");
1418 |         }
1419 |     }
1420 |     return 0;
1421 | }
1422 | 
1423 | int factorial(int number) {
1424 |     int number_to_return = 1;
1425 |     for (int i = 1; i <= number; i++) {
1426 |         number_to_return *= i;
1427 |     }
1428 |     return number_to_return;
1429 | }
1430 | 
1431 | int c_formula(int number, int k) {
1432 |     int result = factorial(number) / (factorial(k) * factorial(number - k));
1433 |     return result;
1434 | }
1435 | 
1436 | =====================================================================
1437 | /* Task 29 - Структура: студенты */
1438 | 
1439 | Build a structure of Students, there is name and lastname and grade of a student
1440 | Create a program to output the first and lastname of those students, whose grades are at the top
1441 | Output result - "First name, Last name, Second first name, Second last name"
1442 | In case of invalid input, output - "n/a"
1443 | Maximum length of a name is 20 chars long, total number of students is entered beforehand. The input in entered one line at a time - \n
1444 | Grade cannot be negative. Name is a string without spaces and with a newline at the end
1445 | 
1446 | + 1. Build a structure of Students
1447 | + 2. Take input - total number of Students
1448 | + 3. Take input of names and grades 
1449 | + 4. Write a function to count how many of top students are there
1450 | + 5. Write a fucntion to output them to the screen
1451 | + 6. Invalid input
1452 | + 7. Test
1453 | + 8. Cpplint check
1454 | + 9. Push to Github
1455 | 
1456 | #include <stdio.h>
1457 | #define NMAX 20
1458 | 
1459 | struct Students {
1460 |     char first_name[NMAX];
1461 |     char last_name[NMAX];
1462 |     int semester_grade;
1463 | };
1464 | 
1465 | int input_number_of_students();
1466 | int input_names_and_grades(struct Students* array, int number_of_students);
1467 | int maximum_grade_of_students(struct Students* array, int number_of_students);
1468 | int count_top_grade_students(struct Students* array, int number_of_students, int maximum_grade_value);
1469 | void output_names_and_grades_of_top_students(struct Students* array, int number_of_students,
1470 | int number_of_top_students, int maximum_grade_value);
1471 | 
1472 | int main() {
1473 |     int number_of_students = input_number_of_students();
1474 |     if (number_of_students > 0) {
1475 |         struct Students array[number_of_students];
1476 |         if (input_names_and_grades(array, number_of_students) == 0) {
1477 |             int maximum_grade_value = maximum_grade_of_students(array, number_of_students);
1478 |             int number_of_top_students = count_top_grade_students(array,
1479 |             number_of_students, maximum_grade_value);
1480 |             output_names_and_grades_of_top_students(array, number_of_students,
1481 |             number_of_top_students, maximum_grade_value);
1482 |         } else {
1483 |             printf("n/a");
1484 |         }
1485 |     } else {
1486 |         printf("n/a");
1487 |     }
1488 |     return 0;
1489 | }
1490 | 
1491 | int maximum_grade_of_students(struct Students* array, int number_of_students) {
1492 |     int maximum_grade_value = 0;
1493 |     for (int i = 0; i < number_of_students; i++) {
1494 |         if (maximum_grade_value < array[i].semester_grade) {
1495 |             maximum_grade_value = array[i].semester_grade;
1496 |         }
1497 |     }
1498 |     return maximum_grade_value;
1499 | }
1500 | 
1501 | int count_top_grade_students(struct Students* array, int number_of_students, int maximum_grade_value) {
1502 |     int counter = 0;
1503 |     for (int j = 0; j < number_of_students; j++) {
1504 |         if (array[j].semester_grade == maximum_grade_value) {
1505 |             counter++;
1506 |         }
1507 |     }
1508 |     return counter;
1509 | }
1510 | void output_names_and_grades_of_top_students(struct Students* array, int number_of_students,
1511 | int number_of_top_students, int maximum_grade_value) {
1512 |     for (int i = 0; i < number_of_students; i++) {
1513 |         if (array[i].semester_grade == maximum_grade_value) {
1514 |             printf("%s %s %d", array[i].first_name, array[i].last_name, array[i].semester_grade);
1515 |             if (i < number_of_top_students) {
1516 |                 printf(", ");
1517 |             }
1518 |         }
1519 |     }
1520 | }
1521 | 
1522 | int input_names_and_grades(struct Students* array, int number_of_students) {
1523 |     char endline;
1524 |     int return_case = 0;
1525 |     for (int i = 0; i < number_of_students; i++) {
1526 |         if (!scanf("%s%c", array[i].first_name, &endline) || endline != '\n') {
1527 |             return_case = 1;
1528 |             break;
1529 |         }
1530 |         if (!scanf("%s%c", array[i].last_name, &endline) || endline != '\n') {
1531 |             return_case = 1;
1532 |             break;
1533 |         }
1534 |         if (!scanf("%d%c", &array[i].semester_grade, &endline) ||
1535 |         array[i].semester_grade < 0 || endline != '\n') {
1536 |             return_case = 1;
1537 |             break;
1538 |         }
1539 |     }
1540 |     return return_case;
1541 | }
1542 | 
1543 | int input_number_of_students() {
1544 |     int number;
1545 |     char endline;
1546 |     if (!scanf("%d%c", &number, &endline) || endline != '\n') {
1547 |         number = -1;
1548 |     }
1549 |     return number;
1550 | }
1551 | 
1552 | =====================================================================
1553 | /* Task 30 - Getting familiar with atoi			*/
1554 | 
1555 | #include <stdio.h>
1556 | #include <stdlib.h>
1557 | 
1558 | int main() {
1559 |     char char_numbers[3] = "123";
1560 |     int num_numbers = atoi(char_numbers);
1561 |     printf("%d\n", num_numbers * 3);
1562 |     printf("%s\n", char_numbers);
1563 |     return 0;
1564 | }
1565 | 
1566 | =====================================================================
1567 | /* Task 31 - Input multiply odd*/
1568 | 
1569 | #include <stdio.h>
1570 | 
1571 | int main() {
1572 |     int number = 0;
1573 |     int counter = 0;
1574 |     int array[5];
1575 |     while(counter != 5) {
1576 |         scanf("%d", &number);
1577 |         array[counter] = number;
1578 |         counter++;
1579 |     }
1580 |     int result_to_return = array[0];
1581 |     if (counter == 2) {
1582 |         printf("0");
1583 |     } 
1584 |     else if (counter == 1) {
1585 |         printf("%d", array[0]);
1586 |     } else {
1587 |         for (int i = 0; i < counter; i++) {
1588 |             if (i % 2 == 0) {
1589 |                 printf("i isn't even %d\n", array[i]);
1590 |                 result_to_return *= array[i];
1591 |             }
1592 |         }
1593 |     }
1594 |     printf("result - %d\n", result_to_return);
1595 |     return 0;
1596 | }
1597 | 
1598 | ввод не ограничен количеством целых чисел
1599 | на вывод: произведение нечетных чисел, если всего 2 числа  - выводить ноль, если одно число - вывести его (но положительным)
1600 | 
1601 | =====================================================================
1602 | /* Task 32 - Multiply every number by n-1 - Reworked with dynamic memory.c	*/
1603 | 	
1604 | Дана последовательность целых чиселЧисло nСимвол конца -1
1605 | Вывести x1 xn x2 xn-1 x3 xn-2 и так далее
1606 | 
1607 | #include <stdio.h>
1608 | #include <stdlib.h>
1609 | 
1610 | int main() {
1611 |     int kArrayLenght = 2, counter_for_output, temp, *pointer_to_the_array;
1612 |     pointer_to_the_array = (int*)malloc(sizeof(int));
1613 |     if (pointer_to_the_array == NULL) {
1614 |         printf("n/a");
1615 |         return 1;
1616 |     } else {
1617 |         for (int i = 0; i < kArrayLenght; i++) {
1618 |             if (!scanf("%d", &temp)) {
1619 |                 printf("n/a");
1620 |                 return 1;
1621 |             } else if (temp == -1) {
1622 |                 kArrayLenght = i;
1623 |             } else {
1624 |                 pointer_to_the_array[i] = temp;
1625 |                 kArrayLenght += 1;
1626 |                 pointer_to_the_array = (int*)realloc(pointer_to_the_array, (kArrayLenght)*sizeof(int));
1627 |                 }
1628 |         }
1629 |         counter_for_output = kArrayLenght;
1630 |         printf("Array of numbers after input:\n");
1631 |         for (int i = 0; i < kArrayLenght; i++) {
1632 |             printf("%d", pointer_to_the_array[i]);
1633 |             if (i < kArrayLenght - 1) {
1634 |                 printf(" ");
1635 |             } else if (i == kArrayLenght - 1) {
1636 |                 printf("\n");
1637 |             }
1638 |         }
1639 |         printf("Array of numbers multiplied:\n");
1640 |         for (int j = 0; j < kArrayLenght; j++) {
1641 |             printf("%d", pointer_to_the_array[j] * counter_for_output);
1642 |             counter_for_output--;
1643 |             if (j < kArrayLenght - 1) {
1644 |                 printf(" ");
1645 |             }
1646 |         }
1647 |     }
1648 |     free(pointer_to_the_array);
1649 | }
1650 | 
1651 | =====================================================================
1652 | /* Task 33- Неограниченный ввод целых чисел. Записать в обратном порядке введенные числа. The last symbol is newline.*/ 
1653 | 
1654 | + 1. Use malloc to allocate memory for the array of numbers
1655 | + 2. Take input
1656 | + 3. Use realloc to add more memory as I get more numbers
1657 | + 4. Work around invalid input
1658 | + 5. Test
1659 | + 6. Cpplint test
1660 | + 7. Add and push
1661 | 
1662 | 
1663 | #include <stdio.h>
1664 | #include <stdlib.h>
1665 | 
1666 | int main() {
1667 |     int realloc_counter = 1, *pointer_array_of_numbers, index_array = 0;
1668 |     pointer_array_of_numbers = (int*)malloc(realloc_counter * sizeof(int));
1669 | 
1670 |     if (pointer_array_of_numbers == NULL) {
1671 |         printf("Error - memory wasn't allocated");
1672 |         return 1;
1673 |     }
1674 | 
1675 |     char endline = ' ';
1676 | 
1677 |     while (endline != '\n') {
1678 |         if (scanf("%d%c", &pointer_array_of_numbers[index_array], &endline) &&
1679 |         ((endline == ' ') || (endline == '\n'))) {
1680 |             realloc_counter++;
1681 |             index_array++;
1682 |             pointer_array_of_numbers = (int*)realloc(pointer_array_of_numbers, realloc_counter * sizeof(int));
1683 |         } else {
1684 |             printf("n/a");
1685 |             free(pointer_array_of_numbers);
1686 |             pointer_array_of_numbers = NULL;
1687 |             return 1;
1688 |         }
1689 |     }
1690 | 
1691 |     // Output array in reverse
1692 |     for (int i = index_array - 1; i >= 0; i--) {
1693 |         printf("%d", pointer_array_of_numbers[i]);
1694 |         if (i != 0) {
1695 |             printf(" ");
1696 |         }
1697 |     }
1698 | 
1699 |     free(pointer_array_of_numbers);
1700 |     pointer_array_of_numbers = NULL;
1701 |     return 0;
1702 | }
1703 | 
1704 | =====================================================================
1705 | /* Task 34 - Transposition of any matrix			*/
1706 | 
1707 | #include <stdio.h>
1708 | 
1709 | int main() {
1710 |     int x, y;
1711 |     if (scanf("%d%d", &y, &x) == 2 && y > 0 && x > 0) {
1712 |         int my_matrix[y][x];
1713 |         int bad = 0;
1714 |         for (int i = 0; i < x; i++) {
1715 |             for (int j = 0; j < y; j++) {
1716 |                 if (scanf("%d", &my_matrix[j][i]) != 1)
1717 |                     bad = 1;
1718 |                 if (bad)
1719 |                     break;
1720 |             }
1721 |             if (bad)
1722 |                 break;
1723 |         }
1724 |         if (!bad) {
1725 |             for (int i = 0; i < y; i++) {
1726 |                 for (int j = 0; j < x; j++) {
1727 |                     printf("%d", my_matrix[i][j] * my_matrix[i][j]);
1728 |                     if (j < x - 1) {
1729 |                         printf(" ");
1730 |                     }
1731 |                 }
1732 |                 if (i < y - 1)
1733 |                     printf("\n");
1734 |             }
1735 |         } else {
1736 |             printf("n/a");
1737 |         }
1738 |     } else {
1739 |         printf("n/a");
1740 |     }
1741 | }
1742 | 
1743 | 
1744 | /* Task 38 - Задача с  FILE				  
1745 | 
1746 | Написать программу, осуществляющую подсчет количества цифр (0-9), которые содержатся в текстовом файле, путь которого задается на стандартном потоке ввода
1747 | (относительно кореновой директории), заканчивающеся символом новой строки \n.  Текст может содержать буквы латинского алфавита в верхнем и нижнем регистре, а также цифры (0-9) нижнего регистра.
1748 | (0-9) вывести на stdout без переноса строкию Проверить валидность. Ошибка "n/a". Путь к файлу всегда верный, и файл существует.
1749 | --------------------------------------------------------------------------------*/	
1750 | 
1751 | 	 
1752 | 
1753 | 
1754 | 
1755 | =====================================================================
1756 | 
1757 | 
1758 | =====================================================================
1759 | /* Task 38 - Ссылки на сайт с задачами*/
1760 | https://studassistent.ru/c
1761 | 
1762 | =========================================== На сортировку ==================================================================
1763 | 
1764 | #include <stdio.h>
1765 | #include <math.h>
1766 | 
1767 | 
1768 | int main () {
1769 |     int x, y, z;
1770 |     if (scanf("%d%d%d" , &x , &y, &z) == 3) {
1771 |         if (x < 0 || x > 1 || y < 0 || y > 1 || z < 0 || z > 1)
1772 |         printf("n/a");
1773 |     }
1774 |     if (x == (y||z)) {
1775 |         printf("%d", x);
1776 |         return 0;
1777 |     }
1778 | }
1779 | ======
1780 | int main () {
1781 |     double x;
1782 |     if (scanf("%.0lf", &x) != 1) {
1783 |         printf("n/a");
1784 |         return 1;
1785 |     }else {
1786 | 
1787 |     double y = x * 57.29;
1788 |     double z = round(y);
1789 |     printf("%.0lf", z);
1790 |     return 0;
1791 |     }
1792 |      
1793 | }
1794 | 
1795 | =====
1796 | int main()
1797 | {
1798 |     int x, y, z;
1799 |     if (scanf("%d%d%d", &x, &y, &z) == 3)
1800 |     {
1801 |         if (x < 0 || x > 1 || y < 0 || y > 1 || z < 0 || z > 1)
1802 |         {
1803 |             printf("n/a");
1804 |         return 0;
1805 |     }
1806 |     if (x == (y||z)) {
1807 |         printf("%d", x);
1808 |         return 0;
1809 |     }
1810 |     printf("n/a");
1811 |     return 0;
1812 | }
1813 | }
1814 | 
1815 | =====
1816 | 	
1817 | int main() {
1818 |     int x = 0;
1819 |     int y1,y2,y3;
1820 |     scanf("%d", &x);
1821 |     if( x > 0) {
1822 |         y1 = x /100;
1823 |         y2 = (x/10) %10;
1824 |         y3 = x % 10;
1825 |         printf("%d%d%d", y3, y2, y1);
1826 |     }else{
1827 |         x = x * (-1);
1828 |         y1 = x /100;
1829 |         y2 = (x/10) %10;
1830 |         y3 = x % 10;
1831 |         printf("-%d%d%d", y3, y2, y1);
1832 |     }
1833 |     return 0;
1834 | }
1835 | 
1836 | ====
1837 | 	
1838 | int main (void) {
1839 |         double x;
1840 | 
1841 |     if (scanf("%lf", &x) > 1 && getchar() == '\n') {
1842 |         printf("n/a");
1843 |         return 1;
1844 |         }else{
1845 |         double y = (57.29 * x);
1846 |         double z = round (y);
1847 |     printf("%.0lf", z);
1848 | }
1849 |     return 0;
1850 | }
1851 | ====
1852 | 	
1853 | /* 3.01
1854 | #include <stdio.h>
1855 | #include <math.h>
1856 | 
1857 | int main()
1858 | {
1859 |    double x;
1860 |     if ((scanf("%lf", &x) != 1)) {
1861 |            printf("n/a");
1862 |         }else{
1863 |             double y = 21500 * (4.0/3.0) * M_PI * (pow(x,3));
1864 |             double result = round (y);
1865 |             printf("%.0lf", result);
1866 |         }
1867 |         return 0;
1868 | }
1869 | 
1870 | */
1871 | 
1872 | /* 3.02 
1873 | #include <stdio.h>
1874 | #include <math.h>
1875 | 
1876 | int main (void) {
1877 |         double x;
1878 |     if ((scanf("%lf", &x) != 1)) {
1879 |         printf("n/a");
1880 |     return 1;
1881 |         }else{
1882 |         double y = (57.29 * x);
1883 |         double z = round (y);
1884 |         printf("%.0lf", z);
1885 | }
1886 |     return 0;
1887 | }
1888 | */
1889 | 
1890 | /* 3.02(2 variant)
1891 | #include <stdio.h>
1892 | #include <math.h>
1893 | 
1894 | int main (void) {
1895 |         double x;
1896 |     if ((scanf("%lf", &x) != 1)) {
1897 |         printf("n/a");
1898 |     return 1;
1899 |         }else{
1900 |         double y = (57.29 * x);
1901 |         double z = round (y);
1902 |         printf("%.0lf", z);
1903 | }
1904 |     return 0;
1905 | }
1906 | */
1907 | 
1908 | /* 3.03
1909 | #include <stdio.h>
1910 | 
1911 | int main () {
1912 |     int x = 0; // наше число
1913 |     int y1,y2,y3; // разделение по разрядам
1914 |     scanf("%d", &x);
1915 |     if (x>0){
1916 |    
1917 |             y1 = x/100;
1918 |             y2 = (x/10)%10;
1919 |             y3 = x %10;
1920 |             printf("%d%d%d", y3,y2,y1);
1921 |     }
1922 |     else {
1923 |         x=x*(-1);
1924 |         y1 = x/100;
1925 |             y2 = (x/10)%10;
1926 |             y3 = x %10;
1927 |             printf("-%d%d%d", y3,y2,y1);
1928 |     }
1929 | 
1930 |     return 0;
1931 | }
1932 | */
1933 | 
1934 | /* 3.05
1935 | #include <stdio.h>
1936 | int main()
1937 | {
1938 |     int x, y, z;
1939 | 
1940 |     if (scanf("%d%d%d", &x, &y, &z) == 3)
1941 |     {
1942 |         if (x < 0 || x > 1 || y < 0 || y > 1 || z < 0 || z > 1)
1943 |         {
1944 |             printf("n/a");
1945 |             return 0;
1946 |         }
1947 |         if (x == (y || z)){
1948 |             printf("%d", x);
1949 |             return 0;
1950 |             }
1951 |     }
1952 |     printf("n/a");
1953 |     return 0;
1954 | }
1955 | */
1956 | 
1957 | /* 4.02
1958 | #include <stdio.h>
1959 | 
1960 | int max(int *data, int *m);
1961 | // int output(int *a, int *m);
1962 | int main() {
1963 |   int df;
1964 |   int data[100000];
1965 | 
1966 |   if (scanf("%d", &df) != 1) {
1967 |     printf("n/a");
1968 |     return (0);
1969 |   }
1970 |   int i = 0;
1971 |   while (df != -1) {
1972 |     data[i] = df;
1973 |     scanf("%d", &df);
1974 |     i++;
1975 |   }
1976 |   int max_value = data[0];
1977 |   for (int j = 0; j < i; j++) {
1978 |     if (data[j] > max_value) {
1979 |       max_value = data[j];
1980 |     }
1981 |   }
1982 |   printf("%d", max_value);
1983 | }
1984 | */
1985 | 
1986 | /* 5.02
1987 | #include <stdio.h>
1988 | 
1989 | int main() {
1990 |   int df;
1991 |   int data[100000];
1992 | 
1993 |   int i = 0;
1994 |   if (scanf("%d", &df) != 1) {
1995 |     printf("n/a");
1996 |     return (0);
1997 |   }
1998 |   while (df != -1) {
1999 |     data[i] = df;
2000 |     scanf("%d", &df);
2001 |     i++;
2002 |   }
2003 |   int max_value = 0;
2004 |   int min_value = 0;
2005 |   for (int j = 0; j < i; j++) {
2006 |     if (data[j] > data[max_value]) {
2007 |       max_value = j;
2008 |     }
2009 |     if (data[j] < data[min_value]) {
2010 |       min_value = j;
2011 |     }
2012 |   }
2013 |   int tmp = data[min_value];
2014 |   data[min_value] = data[max_value];
2015 |   data[max_value] = tmp;
2016 |   for (int j = 0; j < i - 1; j++) {
2017 |     printf("%d ", data[j]);
2018 |   }
2019 |   printf("%d", data[i - 1]);
2020 | }
2021 | */
2022 | 
2023 | /* 5.03
2024 | #include <stdio.h>
2025 | // #define N_MAX 10000;
2026 | 
2027 | int main() {
2028 |   double df;
2029 | 
2030 |   // int m;
2031 |   int data[10000];
2032 | 
2033 |   if (scanf("%lf", &df) != 1) {
2034 |     printf("n/a");
2035 |     return (0);
2036 |   }
2037 |   int i = 0;
2038 |   while (df != -1) {
2039 |     data[i] = df;
2040 |     scanf("%lf", &df);
2041 |     i++;
2042 |   }
2043 |   printf("%d\n", i);
2044 |   int size = i;
2045 |   //int j = size;
2046 | 
2047 |   for (int k = 0; k < size ; k += 1) {
2048 |     if (k == 0) {
2049 |         printf("%d", data[k]);
2050 |     } else {
2051 |         printf(" %d", data[k]);
2052 |     }
2053 |     if (size - 1 > k) {
2054 |       printf(" %d", data[size - 1]);
2055 |       size--;
2056 |     }
2057 |   }
2058 |   return (0);
2059 | }
2060 | */
2061 | 
2062 | /* 5.04
2063 | #include <stdio.h>
2064 | #include <stdlib.h>
2065 | 
2066 | int main(){
2067 |     int size = 1;
2068 |     int counter = 0;
2069 |     char c ;
2070 |     int *data = (int*) malloc(size * sizeof(int));
2071 |     while (c != '\n'){
2072 |         counter++;
2073 |         if(counter > size){
2074 |             size *= 2;
2075 |             data = (int* )realloc(data, size * sizeof(int));
2076 |         }
2077 |         scanf("%d%c", &data[counter - 1], &c);
2078 |         
2079 |     }
2080 |     for(int i = 0; i < counter; i++){
2081 |         if(i == counter -1){
2082 |             printf("%d", data[i]);
2083 |         }else{
2084 |         printf("%d ", data[i]);   
2085 |         }
2086 |     }
2087 |     return 0;
2088 | }   
2089 | */
2090 | 
2091 | /*
2092 | // Удалить последнее вхождение подстроки в строке
2093 | 
2094 | #include <stdio.h>
2095 | #include <stdlib.h>
2096 | #include <string.h>
2097 | #define N 200
2098 |                                                                      
2099 | void reverse_string(char *);
2100 | char *sub_string(char *, char *);
2101 | 
2102 | int main() {
2103 |     char string[N], substr[N];
2104 |     char *result;
2105 |     char c;
2106 |     int i = 0;
2107 | 
2108 |     while (scanf("%c", &c) == 1) {
2109 |         if (c == '\n') {
2110 |             string[i] = '\0';
2111 |             break;
2112 |         }
2113 |         string[i++] = c;
2114 |     }
2115 |     i = 0;
2116 |     while (scanf("%c", &c) == 1) {
2117 |         if (c == '\n') {
2118 |             substr[i] = '\0';
2119 |             break;
2120 |         }
2121 |         substr[i++] = c;
2122 |     }
2123 | 
2124 |     reverse_string(string);
2125 |     reverse_string(substr);
2126 | 
2127 |     result = sub_string(string, substr);
2128 | 
2129 |     printf("%s", result);
2130 |     return 0;
2131 | }
2132 | 
2133 | char *sub_string(char *string, char *substr) {
2134 |     int i = 0, j = 0, k = 0, n = 0, flag = 0;
2135 |     char *res = string;
2136 |     for (i = 0; res[i] != '\0'; i++) {
2137 |         k = i;
2138 |         if (!flag) {
2139 |             while (res[i] == substr[j]) {
2140 |                 i++, j++;
2141 |                 if (j == (int)strlen(substr)) {
2142 |                     flag = 1;
2143 |                     break;
2144 |                 }
2145 |             }
2146 |         }
2147 |         if (flag == 0) {
2148 |             i = k;
2149 |             j = 0;
2150 |         } else if (flag == 1) {
2151 |             res[n++] = res[i];
2152 |             continue;
2153 |         } else {
2154 |             flag = 0;
2155 |         }
2156 |         res[n++] = res[i];
2157 |     }
2158 |     res[n] = '\0';
2159 |     reverse_string(res);
2160 |     return res;
2161 | }
2162 | 
2163 | void reverse_string(char *str) {
2164 |     if (str == 0) {
2165 |         return;
2166 |     }
2167 |     if (*str == 0) {
2168 |         return;
2169 |     }
2170 | 
2171 |     char *start = str;
2172 |     char *end = start + strlen(str) - 1;
2173 |     char temp;
2174 | 
2175 |     while (end > start) {
2176 |         temp = *start;
2177 |         *start = *end;
2178 |         *end = temp;
2179 |         ++start;
2180 |         --end;
2181 |     }
2182 | }
2183 | 
2184 | 
2185 | =====================================================================
2186 | /* Task 13 - Дана последовательность целх числе. Число н. Символ конца -1. 
2187 | Вывести х1 хн х2 хн-1 х3 хн-2	*/
2188 | 
2189 | #include <stdio.h>
2190 | #include <stdlib.h>
2191 | 
2192 | int main() {
2193 |     int kArrayLenght = 2, counter_for_output, temp, *pointer_to_the_array;
2194 |     pointer_to_the_array = (int*)malloc(sizeof(int));
2195 |     if (pointer_to_the_array == NULL) {
2196 |         printf("n/a");
2197 |         return 1;
2198 |     } else {
2199 |         for (int i = 0; i < kArrayLenght; i++) {
2200 |             if (!scanf("%d", &temp)) {
2201 |                 printf("n/a");
2202 |                 return 1;
2203 |             } else if (temp == -1) {
2204 |                 kArrayLenght = i;
2205 |             } else {
2206 |                 pointer_to_the_array[i] = temp;
2207 |                 kArrayLenght += 1;
2208 |                 pointer_to_the_array = (int*)realloc(pointer_to_the_array, (kArrayLenght)*sizeof(int));
2209 |                 }
2210 |         }
2211 |         counter_for_output = kArrayLenght;
2212 |         printf("Array of numbers after input:\n");
2213 |         for (int i = 0; i < kArrayLenght; i++) {
2214 |             printf("%d", pointer_to_the_array[i]);
2215 |             if (i < kArrayLenght - 1) {
2216 |                 printf(" ");
2217 |             } else if (i == kArrayLenght - 1) {
2218 |                 printf("\n");
2219 |             }
2220 |         }
2221 |         printf("Array of numbers multiplied:\n");
2222 |         for (int j = 0; j < kArrayLenght; j++) {
2223 |             printf("%d", pointer_to_the_array[j] * counter_for_output);
2224 |             counter_for_output--;
2225 |             if (j < kArrayLenght - 1) {
2226 |                 printf(" ");
2227 |             }
2228 |         }
2229 |     }
2230 |     free(pointer_to_the_array);
2231 | }
2232 | 
2233 | 
2234 | 
2235 | // Дано целое число, вывести максимальную его цифру
2236 | 
2237 | #include <stdio.h>
2238 | int max_digit(int number);  // Не ленитесь выносить логические куски кода в функции, их проще отлаживать, чем огромный main.
2239 | 
2240 | int main(void) {
2241 |   int number;
2242 | 
2243 |   if (scanf("%d", &number) != 1) {  // Задачу не встречал - не знаю нужна ли здесь проверка на n/a или проверка на отрицательное число.
2244 |     printf("n/a");
2245 |   } else {
2246 |     printf("%d", max_digit(number));
2247 |   }
2248 | 
2249 |   return 0;
2250 | }
2251 | 
2252 | int max_digit(int number) {
2253 |   int max_digit = 0;  // Давайте переменным осмысленные названия - код и отладка проще восприниматься будет.
2254 | 
2255 |   if (number < 0) {  // Если в условии число может быть отрицательным, то нам удобнее его сделть положительным.
2256 |     number *= -1;
2257 |   }
2258 | 
2259 |   while (number) {  // Пока number != 0. Если number изначально равен нулю, то у нас уже max_digit = 0 выше.
2260 |     int digit = number % 10;  // Получаем число единиц в числе, то есть правую цифру. 123 % 10 = 3;
2261 | 
2262 |     if (digit > max_digit) {  // Обновляем ответ (наибольшую цифру).
2263 |       max_digit = digit;
2264 |     }
2265 | 
2266 |     number /= 10;  // Получаем число десятков в числе, то есть число без последней цифры. 123 / 10 = 12;
2267 |   }
2268 | 
2269 |   return max_digit;
2270 | }
2271 | 
2272 | 
2273 | 
2274 | // Найти максимальное число из непустой последовательности неотрицательных чисел, кончающейся на -1.
2275 | #include <stdio.h>
2276 | 
2277 | int main(void) {
2278 |   int number = 0;
2279 |   int max_value = -1;
2280 | 
2281 |   while (number != -1) {
2282 |     scanf("%d", &number);
2283 |     if (number > max_value) {
2284 |       max_value = number;
2285 |     }
2286 |   }
2287 | 
2288 |   printf("%d", max_value);
2289 | 
2290 |   return 0;
2291 | }
2292 | 
2293 | 
2294 | Задания для решений: 
2295 | 5 - вывести матрицу с числами от 1 до н^2 по змейке из левого верхнего угла в центр (как на степике)
2296 | 4 - повернуть матрицу на 90 градусов по часовой стрелке 
2297 | 3 - вывести массив неопределенной длины (ввод заканчивается на -1) задом наперед 
2298 | 2 - перевести радианы (действительное число) в градусы (целое число)
2299 | 1 - вывести строчку, где внутри есть " и '
2300 | 
2301 | 3 - поменять Макс и мин в массиве, заканчивающемся на -1
2302 | 
2303 | 1. Исправить программу, там чёт простое, типа int pi = 3.14 было
2304 | 2. Перевести из радианов в градусы (проверка на то, что радианы >=0 НЕ НУЖНА, проверено мистейком)
2305 | 3. Дано целое число, вывести максимальную его цифру  // решена
2306 | 4. Есть матрица, надо поменять местам строки, содержащие первые вхождения максимального и минимального элементов матрицы
2307 | 5. На вход подаётся положительное число, надо вывести матрицу, заполненную числами от 1 до n^2 по спирали, типа
2308 | 1 2 3
2309 | 8 9 4
2310 | 7 6 5
2311 | ================
2312 | */
2313 | 


--------------------------------------------------------------------------------