├── resources ├── solutions │ ├── .clang-format │ ├── .gitignore │ ├── pointers_and_references │ │ ├── task01.cpp │ │ ├── task02.cpp │ │ ├── task14.cpp │ │ ├── task04.cpp │ │ ├── task06.cpp │ │ ├── main.cpp │ │ ├── task06_2.cpp │ │ ├── task03.cpp │ │ ├── task05.cpp │ │ └── demo.cpp │ ├── basic_operators │ │ ├── task04.cpp │ │ ├── task13.cpp │ │ └── task09.cpp │ ├── files │ │ ├── task11test.txt │ │ ├── chisla.txt │ │ ├── task01.cpp │ │ └── task11.cpp │ ├── loops │ │ ├── task21.cpp │ │ ├── task13.cpp │ │ └── task24.cpp │ ├── strings │ │ ├── task04.cpp │ │ ├── task03.cpp │ │ ├── task10.cpp │ │ ├── task01.cpp │ │ ├── task09.cpp │ │ ├── task02.cpp │ │ ├── task14.cpp │ │ ├── task08.cpp │ │ └── task13.cpp │ ├── double_type │ │ ├── task02.cpp │ │ ├── task06.cpp │ │ ├── task05.cpp │ │ ├── task03.cpp │ │ ├── task04.cpp │ │ ├── task07.cpp │ │ └── task01.cpp │ ├── nested_loops │ │ ├── task01.cpp │ │ ├── task02.cpp │ │ ├── task06.cpp │ │ ├── task03.cpp │ │ ├── task05.cpp │ │ ├── task04.cpp │ │ ├── task10.cpp │ │ └── task09.cpp │ ├── recursion │ │ ├── task05.cpp │ │ ├── task01.cpp │ │ ├── task04.cpp │ │ ├── task06.cpp │ │ ├── task02.cpp │ │ ├── task15.cpp │ │ ├── task12.cpp │ │ ├── task16.cpp │ │ ├── task14.cpp │ │ ├── task00.cpp │ │ ├── task13.cpp │ │ └── task21.cpp │ ├── functions │ │ ├── task02.cpp │ │ ├── task09.cpp │ │ ├── task10.cpp │ │ ├── task13.cpp │ │ ├── task15.cpp │ │ └── task17.cpp │ ├── built-in │ │ ├── task03.cpp │ │ ├── task04.cpp │ │ └── task05.cpp │ ├── arrays │ │ ├── task11.cpp │ │ ├── task01.cpp │ │ ├── task16.cpp │ │ ├── task05.cpp │ │ ├── task06.cpp │ │ └── task19.cpp │ ├── dynamic_memory │ │ ├── task01.cpp │ │ ├── task06.cpp │ │ ├── task11.cpp │ │ ├── task03.cpp │ │ ├── task08.cpp │ │ ├── task10.cpp │ │ ├── task16.cpp │ │ ├── task14.cpp │ │ ├── task17.cpp │ │ └── task16_bonus.cpp │ ├── multidimensional_arrays │ │ ├── task02.cpp │ │ ├── task12.cpp │ │ ├── task03.cpp │ │ ├── task06.cpp │ │ ├── task09.cpp │ │ ├── task07.cpp │ │ ├── task04.cpp │ │ ├── task05.cpp │ │ ├── task20.cpp │ │ ├── task08.cpp │ │ ├── task01.cpp │ │ ├── task19.cpp │ │ ├── task16.cpp │ │ └── task14.cpp │ ├── conditional_operators │ │ ├── task06.cpp │ │ ├── task04.cpp │ │ ├── task13.cpp │ │ └── task14.cpp │ ├── char_type │ │ └── task04.cpp │ ├── vector │ │ ├── task04.cpp │ │ └── task04-2.cpp │ ├── structs │ │ ├── task11.cpp │ │ ├── task12.cpp │ │ └── task03.cpp │ ├── archives │ │ └── homeworks │ │ │ └── 2020 │ │ │ └── 3 │ │ │ ├── task04.txt │ │ │ └── task04.cpp │ ├── boolean_expressions_answers.md │ ├── numeral_systems_answers.md │ └── bonus │ │ └── blackjack.cpp ├── content_index │ ├── week15.md │ ├── week09.md │ ├── week04.md │ ├── week11.md │ ├── bonus.md │ ├── week12.md │ ├── week06.md │ ├── week14.md │ ├── week05.md │ ├── week07.md │ ├── week13.md │ ├── week10.md │ ├── week08.md │ ├── week02.md │ ├── week01.md │ └── week03.md ├── tasks │ ├── src │ │ └── structs-1.png │ ├── archives │ │ ├── homeworks │ │ │ ├── 2019 │ │ │ │ ├── 1.pdf │ │ │ │ ├── 2.pdf │ │ │ │ ├── 3.pdf │ │ │ │ └── summer.pdf │ │ │ └── 2020 │ │ │ │ ├── 1.pdf │ │ │ │ ├── 2.pdf │ │ │ │ ├── 3.pdf │ │ │ │ ├── 4.pdf │ │ │ │ └── summer.pdf │ │ ├── example_theoretical_problems.md │ │ ├── example_test_problems.md │ │ ├── example_exam_problems.md │ │ ├── exams │ │ │ ├── 2019_exam_problems.md │ │ │ ├── 2020_exam_problems_summer.md │ │ │ └── 2020_exam_problems.md │ │ └── test │ │ │ └── 2020_test_problems.md │ ├── boolean_expressions.md │ ├── numeral_systems.md │ ├── bitwise_operators.md │ ├── built-in.md │ ├── vector.md │ ├── char_type.md │ ├── pointers_and_references.md │ ├── bonus │ │ └── blackjack.md │ ├── double_type.md │ ├── pre_exam_test.md │ ├── functions.md │ ├── strings.md │ ├── files.md │ └── basic_operators.md └── bonus │ ├── built-in.md │ ├── arrays.md │ ├── multidimensional_arrays.md │ ├── python.md │ ├── loops.md │ ├── text_files.md │ ├── variables.md │ ├── operators.md │ ├── recursion.md │ ├── functions.md │ ├── vector.md │ ├── structs.md │ ├── pointers_and_references.md │ ├── conditionals.md │ ├── cpp.md │ ├── vs_code.md │ └── intro.md └── README.md /resources/solutions/.clang-format: -------------------------------------------------------------------------------- 1 | IndentWidth: 4 -------------------------------------------------------------------------------- /resources/solutions/.gitignore: -------------------------------------------------------------------------------- 1 | *out 2 | *exe 3 | *swp 4 | -------------------------------------------------------------------------------- /resources/content_index/week15.md: -------------------------------------------------------------------------------- 1 | Седмица 15 2 | ================================= 3 | **Преговор** 4 | -------------------------------------------------------------------------------- /resources/tasks/src/structs-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/src/structs-1.png -------------------------------------------------------------------------------- /resources/bonus/built-in.md: -------------------------------------------------------------------------------- 1 | ## Вградени функции 2 | [Списък с всички вградени функции в С++](https://www.programiz.com/cpp-programming/library-function) -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2019/1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2019/1.pdf -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2019/2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2019/2.pdf -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2019/3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2019/3.pdf -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2020/1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2020/1.pdf -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2020/2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2020/2.pdf -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2020/3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2020/3.pdf -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2020/4.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2020/4.pdf -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2019/summer.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2019/summer.pdf -------------------------------------------------------------------------------- /resources/tasks/archives/homeworks/2020/summer.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SinestroWhite/Introduction-To-Programming/HEAD/resources/tasks/archives/homeworks/2020/summer.pdf -------------------------------------------------------------------------------- /resources/bonus/arrays.md: -------------------------------------------------------------------------------- 1 | ## Масиви 2 | - [Arrays in C++](https://www.youtube.com/watch?v=ENDaJi08jCU&t=1s) 3 | - [Static Arrays in C++ (std::array)](https://www.youtube.com/watch?v=Hw42GkHPyvk) 4 | 5 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a = 5; 5 | int &b = a; 6 | 7 | b = 3; 8 | 9 | std::cout << a; 10 | 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/task02.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b; 5 | std::cin >> a >> b; 6 | 7 | std::cout << &a << ' ' << &b; 8 | 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /resources/solutions/basic_operators/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, x; 5 | 6 | std::cin >> a >> b >> x; 7 | 8 | std::cout << (a < x && x < b) << std::endl; 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /resources/solutions/files/task11test.txt: -------------------------------------------------------------------------------- 1 | kek 2 | askjdlaksd 3 | askdjajsdlk 4 | a 5 | askjdlaksdasdasd 6 | askjdlakjdlkajdlkajsdlkjaslkdj 7 | asd 8 | sdasd 9 | sdasd 10 | askjdlakjdlkajdlkajsdlkjaslkdjaskdjalksdjalskjd 11 | asdasd 12 | asdsd 13 | -------------------------------------------------------------------------------- /resources/bonus/multidimensional_arrays.md: -------------------------------------------------------------------------------- 1 | ## Многомерни масиви 2 | - [Multidimensional arrays](https://www.geeksforgeeks.org/multidimensional-arrays-c-cpp/) 3 | - [More multidimensional arrays](https://www.programiz.com/cpp-programming/multidimensional-arrays) -------------------------------------------------------------------------------- /resources/bonus/python.md: -------------------------------------------------------------------------------- 1 | ##Python 2 | 3 | Теория 4 | ------ 5 | [Python](https://docs.google.com/file/d/1xeqEPkfO3gZlwrMXZdUGbEPjMvsOA7zT/edit?usp=sharing&ouid=115687390792091108365/view) 6 | 7 | Викторини 8 | --------- 9 | [Python](https://forms.gle/2zGbDnHX9tLVZ91fA) -------------------------------------------------------------------------------- /resources/content_index/week09.md: -------------------------------------------------------------------------------- 1 | Седмица 9 2 | ================================= 3 | 4 | **Контролно 2** 5 | 6 | Задачи 7 | ------ 8 | [Подготовка за контролно 3](../tasks/pre_exam_test.md) 9 | 10 | [Решения на задачите](../solutions/pre_exam_test.cpp) 11 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/task14.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int magic(float &a) { return *(int *)&a; } 4 | 5 | int main() { 6 | float a; 7 | std::cin >> a; 8 | 9 | std::cout << magic(a); 10 | 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /resources/bonus/loops.md: -------------------------------------------------------------------------------- 1 | ## Цикли 2 | 3 | - [Loops in C++ video](https://www.youtube.com/watch?v=_1AwR-un4Hk) 4 | - [Loops in C / C++](https://www.geeksforgeeks.org/loops-in-c-and-cpp/) 5 | 6 | ## Вложени цикли 7 | - [Nested Loops](https://www.tutorialspoint.com/cplusplus/cpp_nested_loops.htm) -------------------------------------------------------------------------------- /resources/solutions/loops/task21.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, m; 5 | 6 | std::cin >> n >> m; 7 | 8 | int product = 1; 9 | for (int i = 0; i <= m; i++) { 10 | product *= (n + i); 11 | } 12 | 13 | std::cout << product << "\n"; 14 | } -------------------------------------------------------------------------------- /resources/bonus/text_files.md: -------------------------------------------------------------------------------- 1 | ## Текстови файлове 2 | 3 | - [Файлове с последователен достъп](https://docs.google.com/document/d/18oyZRVjo0cHLvi5H6t1RjF4z1SvAnbK8kHjssIZR8FY/edit) 4 | - [Файлове с пряк достъп](https://docs.google.com/document/d/15dRWcf5jq1191Lx1uZSthzcoX4MwEfj9uXKaqGN8VQw/edit) 5 | 6 | -------------------------------------------------------------------------------- /resources/solutions/strings/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char str[] = "ASDFGH"; 6 | const int caseDiff = 32; 7 | for (int i = 0; i < strlen(str); i++) { 8 | str[i] += caseDiff; 9 | } 10 | std::cout << str << "\n"; 11 | } -------------------------------------------------------------------------------- /resources/bonus/variables.md: -------------------------------------------------------------------------------- 1 | ## Променливи и константи. Област на действие 2 | 3 | - [Още за char](https://programist.alle.bg/uroci/urok-char/) 4 | - [Variables in C++ (Video)](https://www.youtube.com/watch?v=zB9RI8_wExo) 5 | - [Variables in C++ (Article)](https://www.geeksforgeeks.org/variables-in-c/) 6 | -------------------------------------------------------------------------------- /resources/solutions/double_type/task02.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | double input; 6 | 7 | std::cin >> input; 8 | 9 | bool isWhole = (floor(input) == input); 10 | 11 | std::cout << isWhole << std::endl; 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /resources/solutions/nested_loops/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | for (int i = 1; i <= 5; ++i) { 7 | for (int j = 1; j <= i; ++j) { 8 | cout << j; 9 | } 10 | cout << endl; 11 | } 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task05.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int binom(const int m, const int n) { 4 | if (m == 0 || n == 0 || n == m) { 5 | return 1; 6 | } 7 | return binom(m - 1, n - 1) + binom(m - 1, n); 8 | } 9 | 10 | int main() { 11 | std::cout << binom(10, 11); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /resources/bonus/operators.md: -------------------------------------------------------------------------------- 1 | ## Оператори 2 | 3 | [Операции в C/C++](https://www.geeksforgeeks.org/operators-c-c/) 4 | [Стандартен вход и изход в C++](https://www.tutorialspoint.com/cplusplus/cpp_basic_input_output.htm) 5 | [Побитови операции](https://docs.google.com/document/d/1dccZzNjO0JxycvtYQl5bsLhoq63K0ZFovvM51wRx5Tw/edit) -------------------------------------------------------------------------------- /resources/solutions/nested_loops/task02.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | // x + y = n 9 | for (int i = 0; i <= n; ++i) { 10 | cout << i << " + " << n - i << " = " << n << endl; 11 | } 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /resources/solutions/functions/task02.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | bool isOdd(const int num) { return num % 2; } 4 | 5 | bool isEven(const int num) { return !isUneven(num); } 6 | 7 | int main() { 8 | int input; 9 | std::cin >> input; 10 | std::cout << isEven(input) << "\n"; 11 | 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /resources/solutions/double_type/task06.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const double PI = 3.14159265; 4 | 5 | int main() { 6 | double x; 7 | 8 | std::cin >> x; 9 | 10 | double cosx = (PI * PI - 4 * x * x) / (PI * PI + x * x); 11 | 12 | std::cout << cosx << std::endl; 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /resources/content_index/week04.md: -------------------------------------------------------------------------------- 1 | Седмица 4 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [GitHub web interface](TODO) 7 | 8 | **Затвърждаване на взетия дотук материал** 9 | 10 | Задачи 11 | ------ 12 | [Вложени цикли](../tasks/nested_loops.md) 13 | 14 | Решения 15 | ------- 16 | [Вложени цикли](../solutions/nested_loops) -------------------------------------------------------------------------------- /resources/solutions/double_type/task05.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const double PI = 3.14159265; 4 | 5 | int main() { 6 | double x; 7 | 8 | std::cin >> x; 9 | 10 | double sinx = (16 * x * (PI - x)) / (5 * PI * PI - 4 * x * (PI - x)); 11 | 12 | std::cout << sinx << std::endl; 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /resources/solutions/nested_loops/task06.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | 9 | for (int i = 100; i <= 999; ++i) { 10 | if (i % 10 + (i / 10) % 10 + i / 100 == n) { 11 | cout << i << endl; 12 | } 13 | } 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void swap(int *pa, int *pb) { 4 | int temp = *pa; 5 | *pa = *pb; 6 | *pb = temp; 7 | } 8 | 9 | int main() { 10 | int a, b; 11 | std::cin >> a >> b; 12 | 13 | swap(&a, &b); 14 | 15 | std::cout << a << ' ' << b; 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /resources/solutions/built-in/task03.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int input; 6 | 7 | std::cin >> input; 8 | 9 | // Hint: 2^(log2(n)) = n 10 | 11 | int closestPowerOfTwo = pow(2, ceil(log2(input))); 12 | 13 | std::cout << closestPowerOfTwo << std::endl; 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /resources/solutions/double_type/task03.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | double input; 6 | 7 | std::cin >> input; 8 | 9 | double sqrtInput = sqrt(input); 10 | bool isSqrtWhole = (floor(sqrtInput) == sqrtInput); 11 | 12 | std::cout << isSqrtWhole << std::endl; 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int fibonacci(const int n) { 4 | if (n == 1) { 5 | return 0; 6 | } 7 | if (n == 2) { 8 | return 1; 9 | } 10 | return fibonacci(n - 2) + fibonacci(n - 1); 11 | } 12 | 13 | int main() { 14 | int n; 15 | std::cin >> n; 16 | std::cout << fibonacci(n) << "\n"; 17 | } -------------------------------------------------------------------------------- /resources/content_index/week11.md: -------------------------------------------------------------------------------- 1 | Седмица 11 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Динамична памет](https://drive.google.com/file/d/1eGU0bzZOcPqcAOYkTi_AOFgTO3jZrTyS/view?usp=sharing) 7 | 8 | Задачи 9 | ------ 10 | [Динамична памет](../tasks/dynamic_memory.md) 11 | 12 | Решения 13 | ------- 14 | [Динамична памет](../solutions/dynamic_memory/) 15 | 16 | -------------------------------------------------------------------------------- /resources/solutions/arrays/task11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define N 5 4 | int main() { 5 | char arr[N] = {'g', 'f', 'q', 'f', 'g'}; 6 | 7 | bool flag = true; 8 | for (int i = 0; i < N / 2; i++) { 9 | if (arr[i] != arr[N - i - 1]) { 10 | flag = false; 11 | } 12 | } 13 | 14 | std::cout << flag << '\n'; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int pow(const int x, const int n) { 5 | if (n == 0) { 6 | return 1; 7 | } 8 | 9 | if (n > 0) { 10 | return x * pow(x, n - 1); 11 | } 12 | 13 | return x * 1 / pow(x, n + 1); 14 | } 15 | 16 | int main() { 17 | std::cout << pow(5, 3); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /resources/bonus/recursion.md: -------------------------------------------------------------------------------- 1 | ## Pекурсия 2 | - [Recursion](https://www.learncpp.com/cpp-tutorial/recursion/) 3 | - [What on Earth is Recursion? - Computerphile](https://www.youtube.com/watch?v=Mv9NEXX1VHc) 4 | - [Recursion 'Super Power' (in Python) - Computerphile](https://www.youtube.com/watch?v=8lhxIOAfDss) 5 | - [Tail Recursion Explained - Computerphile](https://www.youtube.com/watch?v=_JtPhF8MshA) 6 | 7 | -------------------------------------------------------------------------------- /resources/solutions/arrays/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int number; 5 | int arr[50]; 6 | std::cin >> number; 7 | for (int i = 0; i < number; i++) { 8 | std::cin >> arr[i]; 9 | } 10 | double sum = 0; 11 | for (int i = 0; i < number; i++) { 12 | sum += arr[i]; 13 | } 14 | std::cout << sum / number << "\n"; 15 | return 0; 16 | } -------------------------------------------------------------------------------- /resources/solutions/files/chisla.txt: -------------------------------------------------------------------------------- 1 | 474 481 122 294 246 134 304 172 139 268 235 374 79 157 110 403 388 496 74 330 30 312 285 324 189 436 183 214 305 182 444 6 112 146 206 55 280 319 143 493 441 468 473 11 81 84 100 45 470 308 101 186 307 334 290 376 316 482 225 321 135 464 433 382 109 397 338 71 448 187 69 165 328 97 149 401 108 85 83 480 317 141 70 423 262 224 118 298 174 99 457 258 391 313 278 181 58 456 21 437 2 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task06.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void printReverse(unsigned int n) { 4 | if (n < 10) { 5 | std::cout << n << '\n'; 6 | return; 7 | } 8 | 9 | std::cout << n % 10; 10 | 11 | printReverse(n / 10); 12 | } 13 | 14 | int main() { 15 | unsigned int n; 16 | std::cin >> n; 17 | 18 | printReverse(n); 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /resources/bonus/functions.md: -------------------------------------------------------------------------------- 1 | ## Функции 2 | - [Подпрограми](https://docs.google.com/document/d/15uhdWUoXkIVBCCKG-4ZfXNqzUyF561zjnxjUL7ORdrc/edit) 3 | - [Functions in C/C++ (Video)](https://www.youtube.com/watch?v=V9zuox47zr0) 4 | - [Functions in C/C++](https://www.geeksforgeeks.org/functions-in-c/) 5 | - [Понятието “чиста функция”. Параметри по подразбиране за функции](https://www.geeksforgeeks.org/default-arguments-c/) 6 | 7 | -------------------------------------------------------------------------------- /resources/bonus/vector.md: -------------------------------------------------------------------------------- 1 | STL vector 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [std::vector](https://drive.google.com/file/d/1Sw78-R0GoyI86zsqB90BSLPqH-tiW3D4/view?usp=sharing) 7 | 8 | Викторини 9 | --------- 10 | [std::vector](https://forms.gle/HATfi6idtxrkRWwJA) 11 | 12 | Задачи 13 | ------ 14 | [Bектор](../tasks/vector.md) 15 | 16 | Решения 17 | ------- 18 | [Вектор](../solutions/vector/) -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/task06.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX_SIZE 50 4 | 5 | int main() { 6 | int arr[MAX_SIZE]; 7 | 8 | int n; 9 | std::cin >> n; 10 | 11 | for (int i = 0; i < n; i++) { 12 | std::cin >> *(arr + i); 13 | } 14 | 15 | for (int i = 0; i < n; i++) { 16 | std::cout << *(arr + i) << '\n'; 17 | } 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /resources/bonus/structs.md: -------------------------------------------------------------------------------- 1 | Седмица 12 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Структури](https://drive.google.com/file/d/1DlKFWLFt5QEAtjWNlQm0bKDGirbsDHHb/view?usp=sharing) 7 | 8 | Викторини 9 | --------- 10 | [Cтруктури](https://forms.gle/dZofZh5spiofwmGh8) 11 | 12 | Задачи 13 | ------ 14 | [Cтруктури](../tasks/structs.md) 15 | 16 | Решения 17 | ------- 18 | [Cтруктури](../solutions/structs/) 19 | 20 | -------------------------------------------------------------------------------- /resources/solutions/double_type/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const double APPLES_PER_TREE = 115; 5 | const double APPLES_PER_BASKET = 80; 6 | 7 | int main() { 8 | int trees; 9 | 10 | std::cin >> trees; 11 | 12 | int totalApples = trees * APPLES_PER_TREE; 13 | 14 | std::cout << ceil((double)totalApples / APPLES_PER_BASKET) << std::endl; 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /resources/solutions/arrays/task16.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define N 20 4 | int main() { 5 | bool arr[N] = {}; 6 | 7 | int numb; 8 | std::cin >> numb; 9 | int len = 0; 10 | do { 11 | arr[len++] = numb % 2; 12 | numb /= 2; 13 | } while (numb != 0); 14 | 15 | for (int i = len - 1; i >= 0; i--) { 16 | std::cout << arr[i]; 17 | } 18 | std::cout << '\n'; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int arr[] = {1, 2, 3, 7, 8}; 5 | // addresses 6 | for (int i = 0; i < 5; i++) { 7 | std::cout << (arr + i) << ' '; 8 | } 9 | std::cout << '\n'; 10 | 11 | // values 12 | for (int i = 0; i < 5; i++) { 13 | std::cout << *(arr + i) << '\t'; 14 | } 15 | std::cout << '\n'; 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/task06_2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int arr[] = {1, 2, 3, 7, 8}; 5 | // addresses 6 | for (int i = 0; i < 5; i++) { 7 | std::cout << (arr + i) << ' '; 8 | } 9 | std::cout << '\n'; 10 | 11 | // values 12 | for (int i = 0; i < 5; i++) { 13 | std::cout << *(arr + i) << '\t'; 14 | } 15 | std::cout << '\n'; 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /resources/solutions/built-in/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int first, second; 6 | 7 | std::cin >> first >> second; 8 | 9 | int magnitudeOfFirst = floor(log10(first)); 10 | int magnitudeOfSecond = floor(log10(second)); 11 | int difference = abs(magnitudeOfFirst - magnitudeOfSecond); 12 | 13 | std::cout << difference << std::endl; 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /resources/content_index/bonus.md: -------------------------------------------------------------------------------- 1 | Допълнителни материали 2 | ================================= 3 | 4 | - [Езици за програмиране](https://docs.google.com/file/d/1-cHs9o5upXup-wSb4vBV82rc6fa4LXSS) 5 | - [Python](python.md) 6 | - [IT професии](https://docs.google.com/file/d/1hiPTcIeImOAccAjI87kvW38dLJIM5FFK/) 7 | - [vector](../bonus/vector.md) 8 | - [STL string](https://drive.google.com/file/d/1EcTh7k-ldd3d9kXWoitstyYgC-ydGp5A/view?usp=sharing) 9 | - [Структури](../bonus/structs.md) -------------------------------------------------------------------------------- /resources/content_index/week12.md: -------------------------------------------------------------------------------- 1 | Седмица 12 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [git init](https://docs.google.com/file/d/1VPI8zGAx1KGKc64E-2jbVy7zu2kUngEk/edit) 7 | 8 | [git commit](https://docs.google.com/file/d/1IV4dUoWC1v6dPjuO281ixOsufrB7FNvR/edit?rtpof=true&sd=true) 9 | 10 | [git branch](https://docs.google.com/file/d/146FR59wUfoSDk3g1jYaudmDa1gTlFGB2/edit?rtpof=true&sd=true) 11 | 12 | Викторини 13 | --------- 14 | TODO 15 | 16 | 17 | -------------------------------------------------------------------------------- /resources/content_index/week06.md: -------------------------------------------------------------------------------- 1 | Седмица 6 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Масиви](https://drive.google.com/file/d/1NNkObHSMl1Q1S662kCwlVJDJFr4mc6L9/view?usp=sharing) 7 | 8 | Викторини 9 | --------- 10 | [Масиви](https://forms.gle/dYDzUvyyvoHmrHbv6) 11 | 12 | Задачи 13 | ------ 14 | [Mасиви](../tasks/arrays.md) 15 | 16 | Решения 17 | ------- 18 | [Mасиви](../solutions/arrays/) 19 | 20 | Бонус 21 | ----- 22 | [Mасиви](../bonus/arrays.md) 23 | -------------------------------------------------------------------------------- /resources/solutions/arrays/task05.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define size 7 5 | int main() { 6 | int arr[size] = {1, 5, 7, 12, 5, 1, 2}; 7 | 8 | int max_ind = 0; 9 | 10 | for (int i = 1; i < size; i++) { 11 | if (arr[max_ind] < arr[i]) { 12 | max_ind = i; 13 | } 14 | } 15 | 16 | std::cout << "Max element arr[" << max_ind << "] is " << arr[max_ind] 17 | << "\n"; 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /resources/solutions/functions/task09.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int askUser(const int from, const int to) { 4 | int tmp; 5 | do { 6 | std::cin >> tmp; 7 | } while (tmp < from || tmp > to); 8 | 9 | return tmp; 10 | } 11 | 12 | int main() { 13 | const int MIN = 0, MAX = 9; 14 | int a = askUser(MIN, MAX); 15 | int b = askUser(MIN, MAX); 16 | int c = askUser(MIN, MAX); 17 | 18 | std::cout << a << ' ' << b << ' ' << c << '\n'; 19 | } 20 | -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | std::cin >> n; 6 | 7 | int *arr = new int[n]; 8 | 9 | for (size_t i = 0; i < n; i++) { 10 | std::cin >> arr[i]; 11 | } 12 | 13 | double average = 0; 14 | for (size_t i = 0; i < n; i++) { 15 | average += arr[i]; 16 | } 17 | 18 | average /= n; 19 | 20 | std::cout << average; 21 | 22 | delete[] arr; 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/task03.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void swap(int &first, int &second) { 5 | int temp = first; 6 | first = second; 7 | second = temp; 8 | 9 | // first += second; 10 | // second = first - second; 11 | // first -= second; 12 | } 13 | 14 | int main() { 15 | int a, b; 16 | std::cin >> a >> b; 17 | 18 | swap(a, b); 19 | 20 | std::cout << a << ' ' << b; 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /resources/content_index/week14.md: -------------------------------------------------------------------------------- 1 | Седмица 14 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Рекурсия](https://drive.google.com/file/d/1ltVRg7LSUHess_2QAXH-lgSj1jbFOelP/view?usp=sharing) 7 | 8 | Викторини 9 | --------- 10 | [Pекурсия](https://forms.gle/X7KNKWmHSkhvzXFm6) 11 | 12 | Задачи 13 | ------ 14 | [Pекурсия](../tasks/recursion.md) 15 | 16 | Решения 17 | ------- 18 | [Pекурсия](../solutions/recursion/) 19 | 20 | Бонус 21 | ------- 22 | [Pекурсия](../bonus/recursion.md) 23 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task02.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int first_n_naturals_sum(const int n) { 4 | if (n == 1) { 5 | return 0; 6 | } 7 | // 0 1 2 3 4 5 8 | return n - 1 + first_n_naturals_sum(n - 1); 9 | } 10 | 11 | int first_n_naturals_sum_v2(const int n) { 12 | if (n == 1) { 13 | return 1; 14 | } 15 | // 1 2 3 4 5 16 | return n + first_n_naturals_sum(n - 1); 17 | } 18 | 19 | int main() { 20 | std::cout << first_n_naturals_sum(5) << "\n"; 21 | return 0; 22 | } -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task06.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int N, K; 5 | std::cin >> N >> K; 6 | 7 | int *arr = new int[N]; 8 | 9 | for (int i = 0; i < N; i++) { 10 | std::cin >> arr[i]; 11 | } 12 | 13 | int index = 0; 14 | for (int i = 0; i < N; i++) { 15 | std::cout << arr[index] << ' '; 16 | index += K; 17 | if (index > N) { 18 | index -= N; 19 | } 20 | } 21 | 22 | delete[] arr; 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /resources/solutions/nested_loops/task03.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n = 4, m = 10; 7 | 8 | cout << "| X | "; 9 | for (int i = n; i < m; ++i) { 10 | cout << i << " | "; 11 | } 12 | cout << endl; 13 | 14 | for (int i = n; i < m; ++i) { 15 | cout << "| " << i << " | "; 16 | for (int j = n; j < m; ++j) { 17 | cout << i * j << " | "; 18 | } 19 | cout << endl; 20 | } 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /resources/solutions/nested_loops/task05.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int b1, b2, b5, p; 7 | cin >> b1 >> b2 >> b5 >> p; 8 | 9 | for (int i = 0; i <= b1; ++i) { 10 | for (int j = 0; j <= b2; ++j) { 11 | for (int k = 0; k <= b5; ++k) { 12 | if (i * 1 + j * 2 + k * 5 == p) { 13 | cout << i << " " << j << " " << k << endl; 14 | } 15 | } 16 | } 17 | } 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /resources/solutions/double_type/task07.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const double PI = 3.14159265; 4 | 5 | int main() { 6 | double r, phi; 7 | 8 | std::cin >> r >> phi; 9 | 10 | double real = r * ((PI * PI - 4 * phi * phi) / (PI * PI + phi * phi)); 11 | double imaginary = 12 | r * ((16 * phi * (PI - phi)) / (5 * PI * PI - 4 * phi * (PI - phi))); 13 | 14 | std::cout << "a=" << real; 15 | std::cout << " "; 16 | std::cout << "b=" << imaginary << std::endl; 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/task05.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | std::cin >> n; 6 | 7 | int *buffer = new int[n]; 8 | 9 | for (size_t i = 0; i < n; i++) { 10 | std::cin >> buffer[i]; 11 | } 12 | 13 | int maxIndex = 0; 14 | for (size_t i = 1; i < n; i++) { 15 | if (buffer[i] > buffer[maxIndex]) { 16 | maxIndex = i; 17 | } 18 | } 19 | 20 | std::cout << &buffer[maxIndex] << ' ' << buffer[maxIndex]; 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /resources/solutions/functions/task10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | double average(const int N, ...) { 6 | if (N == 0) { 7 | return INT_MIN; 8 | } 9 | 10 | va_list args; 11 | double sum = 0; 12 | 13 | va_start(args, N); 14 | 15 | for (int i = 0; i < N; i++) { 16 | sum += va_arg(args, int); 17 | } 18 | 19 | va_end(args); 20 | return sum / N; 21 | } 22 | 23 | int main() { 24 | std::cout << average(4, 1, 2, 3, 4) << "\n"; 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /resources/solutions/basic_operators/task13.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, x; 5 | 6 | std::cin >> a >> b >> x; 7 | 8 | if (x < a) { 9 | std::cout << "1" << std::endl; 10 | } else if (x == a) { 11 | std::cout << "2" << std::endl; 12 | } else if (a < x && x < b) { 13 | std::cout << "3" << std::endl; 14 | } else if (x == b) { 15 | std::cout << "4" << std::endl; 16 | } else if (x > b) { 17 | std::cout << "5" << std::endl; 18 | } 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /resources/solutions/nested_loops/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | 9 | for (int i = 1; i <= n; ++i) { 10 | for (int j = i; j <= n; ++j) { 11 | for (int k = j; k <= n; ++k) { 12 | if (i * i + j * j == k * k || i * i + k * k == j * j || 13 | k * k + j * j == i * i) { 14 | cout << i << " " << j << " " << k << endl; 15 | } 16 | } 17 | } 18 | } 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /resources/content_index/week05.md: -------------------------------------------------------------------------------- 1 | Седмица 5 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Функции](https://drive.google.com/file/d/1PCkW_q9UoMWP4aE7nJW19SggJNNEYPU1/view?usp=sharing) 7 | 8 | Викторини 9 | --------- 10 | [Фунцкии](https://forms.gle/Epg1g3Z61KEw9954A) 11 | 12 | Задачи 13 | ------ 14 | [Функции](../tasks/functions.md) 15 | 16 | Решения 17 | ------- 18 | [Функции](../solutions/functions/) 19 | 20 | Практически задачи 21 | --------- 22 | [Блекджек](../tasks/bonus/blackjack.md) 23 | 24 | Бонус 25 | ----- 26 | [Фунцкии](../bonus/functions.md) 27 | -------------------------------------------------------------------------------- /resources/content_index/week07.md: -------------------------------------------------------------------------------- 1 | Седмица 7 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Многомерни масиви](https://drive.google.com/file/d/1KAkYQEMB7zz0G2V9d7v6JBJX4W7WEOm0/view?usp=sharing) 7 | 8 | Викторини 9 | --------- 10 | [Многомерни масиви](https://forms.gle/psZSAHsuHhCtyXba6) 11 | 12 | Задачи 13 | ------ 14 | [Многомерни масиви](../tasks/multidimensional_arrays.md) 15 | 16 | Решения 17 | ------- 18 | [Многомерни масиви](../solutions/multidimensional_arrays/) 19 | 20 | Бонус 21 | ----- 22 | [Многомерни масиви](../bonus/multidimensional_arrays.md) 23 | -------------------------------------------------------------------------------- /resources/content_index/week13.md: -------------------------------------------------------------------------------- 1 | Седмица 13 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [git merge](https://docs.google.com/file/d/1bH2Nk3lYC6PXFj3OqjdKZ1zXsSosRUw9/edit?rtpof=true&sd=true) 7 | 8 | [git remote](https://docs.google.com/file/d/16dXPpUVvm5fJWse8y0wRCYuH8Hwy723-/edit?rtpof=true&sd=true) 9 | 10 | [GitHub cli](https://drive.google.com/file/d/1bjjTl6ewUhdx5a8aYOrl0-F2cPqGLnot/view?usp=sharing) 11 | 12 | Викторини 13 | --------- 14 | TODO 15 | 16 | Задачи 17 | ------ 18 | [Git](https://github.com/Mapmo/Introduction-To-Programming-Git) 19 | 20 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task15.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | bool isDifferent(int arr[], int size) { 6 | 7 | if (size <= 1) { 8 | return true; 9 | } 10 | 11 | int j = size - 2; 12 | for (; j >= 0; --j) { 13 | if (arr[j] == arr[size - 1]) { 14 | return false; 15 | } 16 | } 17 | 18 | --size; 19 | return isDifferent(arr, size); 20 | } 21 | 22 | int main() { 23 | 24 | int arr[] = {2, 3, 8, 4, 18, 11, 1}; 25 | cout << isDifferent(arr, 7) << endl; 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /resources/solutions/recursion/task12.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | bool isRising(int *arr, int size) { 5 | if (size < 2) { 6 | return true; 7 | } 8 | 9 | if (arr[0] > arr[1]) { 10 | return false; 11 | } 12 | 13 | return isRising(arr + 1, size - 1); 14 | } 15 | 16 | int main() { 17 | int n; 18 | std::cin >> n; 19 | 20 | int *arr = new int[n]; 21 | 22 | for (int i = 0; i < n; ++i) { 23 | std::cin >> arr[i]; 24 | } 25 | 26 | std::cout << isRising(arr, n); 27 | 28 | delete[] arr; 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task02.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | //Да се състави програма, която намира броя на отрицателните елементи във всеки 5 | //ред на двумерен масив. 6 | int main() { 7 | const int N = 3, M = 4; 8 | int arr[N][M] = {{1, 2, -3, 4}, {-5, -5, 4, 6}, {1, 2, 3, 0}}; 9 | int counter = 0; 10 | for (int row = 0; row < N; ++row) { 11 | for (int col = 0; col < M; ++col) { 12 | if (arr[row][col] < 0) { 13 | counter++; 14 | } 15 | } 16 | } 17 | 18 | std::cout << counter << "\n"; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /resources/solutions/strings/task03.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int MAX_BUFFER_SIZE = 100; 5 | 6 | int main() { 7 | char str[MAX_BUFFER_SIZE]; 8 | 9 | std::cin.getline(str, MAX_BUFFER_SIZE); 10 | 11 | int count = 0, size = std::strlen(str); 12 | 13 | for (int i = 1; i < size; ++i) { 14 | if (str[i] == ' ' && str[i - 1] != ' ') { 15 | ++count; 16 | } 17 | } 18 | if (str[size - 1] != ' ') { 19 | ++count; 20 | std::cout << "SPECIAL EDGE WORD" << std::endl; 21 | } 22 | 23 | std::cout << count << std::endl; 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /resources/solutions/double_type/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const double EPSILON = 0.000001; 4 | 5 | bool areSame(double a, double b) { 6 | double diff = (a > b ? (a - b) : (b - a)); 7 | 8 | return diff < EPSILON; 9 | } 10 | 11 | int main() { 12 | double celsius, fahrenheit; 13 | 14 | std::cin >> celsius >> fahrenheit; 15 | 16 | // (5 / 9) and (double)(5 / 9) don't work 17 | // (5.0 / 9.0), ((double)5 / 9), and (5 / (double)9) work 18 | 19 | bool result = areSame((fahrenheit - 32) * (5.0 / 9.0), celsius); 20 | 21 | std::cout << result << std::endl; 22 | 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /resources/bonus/pointers_and_references.md: -------------------------------------------------------------------------------- 1 | ## Пойнтъри и референции 2 | - [Introduction to pointers](https://www.learncpp.com/cpp-tutorial/introduction-to-pointers/) 3 | - [Pointers and const](https://www.learncpp.com/cpp-tutorial/pointers-and-const/) 4 | - [C++ Pointers and Arrays](https://www.programiz.com/cpp-programming/pointers-arrays) 5 | 6 |
7 | 8 | - [Pointers vs References in C++](https://www.geeksforgeeks.org/pointers-vs-references-cpp/) 9 | - [Lvalue references](https://www.learncpp.com/cpp-tutorial/lvalue-references/) 10 | 11 |
12 | 13 | - [The "Clockwise/Spiral Rule"](https://c-faq.com/decl/spiral.anderson.html) 14 | 15 | -------------------------------------------------------------------------------- /resources/solutions/functions/task13.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int digit_count(int input, const int k) { 4 | int counter = 0, last_digit; 5 | do { 6 | last_digit = input % 10; 7 | if (last_digit == k) { 8 | counter++; 9 | } 10 | input /= 10; 11 | } while (input > 0); 12 | return counter; 13 | } 14 | 15 | int main() { 16 | int k, input, counter = 0; 17 | std::cin >> k >> input; 18 | while (input > 0) { 19 | if (digit_count(input, k) > 1) { 20 | counter++; 21 | } 22 | std::cin >> input; 23 | } 24 | std::cout << counter << "\n"; 25 | return 0; 26 | } -------------------------------------------------------------------------------- /resources/solutions/recursion/task16.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | void insertInVector(vector &arr, const int toInsert, int i) { 7 | 8 | if (arr.empty()) { 9 | arr.push_back(toInsert); 10 | } 11 | 12 | if (arr.size() <= i) { 13 | return; 14 | } 15 | 16 | if (arr[i] > toInsert) { 17 | arr.insert(arr.begin() + i, toInsert); 18 | return; 19 | } 20 | 21 | insertInVector(arr, toInsert, ++i); 22 | } 23 | 24 | int main() { 25 | 26 | vector arr = {1, 5, 7, 8, 9, 11, 15}; 27 | 28 | insertInVector(arr, 6, 0); 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /resources/solutions/arrays/task06.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a[] = {1, 55, 120, 120, 450, 888, 9123}; 5 | int b[] = {7, 32, 91, 120, 120, 450, 888}; 6 | 7 | int counter = 0; 8 | for (int i = 0; i < sizeof(a) / sizeof(int); i++) { 9 | for (int j = 0; j < sizeof(b) / sizeof(int); j++) { 10 | if (a[i] == b[j]) { 11 | counter++; 12 | while (a[i] == a[i+1]) { 13 | i++; 14 | } 15 | while (b[j] == b[j+1]) { 16 | j++; 17 | } 18 | } 19 | } 20 | } 21 | std::cout << counter << "\n"; 22 | } -------------------------------------------------------------------------------- /resources/solutions/conditional_operators/task06.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define EPS 0.0000001 5 | 6 | int main() { 7 | double a = 0; 8 | std::cin >> a; 9 | int b = a; 10 | double diff = (a > b) ? a - b : b - a; 11 | 12 | if (diff < EPS) { 13 | if (b % 2 == 1) { 14 | std::cout << "Odd integer\n"; 15 | } else { 16 | std::cout << "Even integer\n"; 17 | } 18 | } else { 19 | if (a > 0) { 20 | std::cout << "Positive "; 21 | } else { 22 | std::cout << "Negative "; 23 | } 24 | std::cout << " rational\n"; 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /resources/content_index/week10.md: -------------------------------------------------------------------------------- 1 | Седмица 10 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Референции](https://drive.google.com/file/d/1XEC9ECvcOFD7RN_O3ks3rEx-PQOq-p7q/view?usp=sharing) 7 | 8 | [Пойнтъри](https://drive.google.com/file/d/1iuYRTiykAXkQZ6x24VNRncndfKxFX4UF/view?usp=sharing) 9 | 10 | Викторини 11 | --------- 12 | [Референции и пойнтъри](https://forms.gle/x6QtkLNYxb68xYFU7) 13 | 14 | Задачи 15 | ------ 16 | [Пойнтъри и референции](../tasks/pointers_and_references.md) 17 | 18 | Решения 19 | ------- 20 | [Пойнтъри и референции](../solutions/pointers_and_references/) 21 | 22 | Бонус 23 | ----- 24 | [Пойнтъри и референции](../bonus/pointers_and_references.md) 25 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task14.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | bool isPalindrome(const string &str) { 6 | 7 | if (str.size() <= 1) { 8 | return true; 9 | } 10 | 11 | if (str.front() != str.back()) { 12 | return false; 13 | } 14 | 15 | str.pop_back(); 16 | str.pop_front(); 17 | 18 | return isPalindrome(str); 19 | } 20 | 21 | bool isPalindrome(char str[], const int &size, int i) { 22 | 23 | if (size <= 1) { 24 | return true; 25 | } 26 | 27 | if (str[i] != str[size - i]) { 28 | return false; 29 | } 30 | 31 | ++i; 32 | return isPalindrome(str, size, i); 33 | } 34 | 35 | int main() { return 0; } 36 | -------------------------------------------------------------------------------- /resources/bonus/conditionals.md: -------------------------------------------------------------------------------- 1 | ## Условни оператори 2 | - [Логически изрази](https://programist.alle.bg/uroci/bool/) 3 | - [Булева алгебра](https://en.wikipedia.org/wiki/Boolean_algebra) 4 | - [Булеви изрази](https://ucha.se/watch/10088/bulevi-izrazi-operatsii-za-sravnenie) 5 | - [Decision Making in C / C++](https://www.geeksforgeeks.org/decision-making-c-c-else-nested-else/) 6 | - [Decision Making in C / C++](https://www.geeksforgeeks.org/switch-statement-cc/) 7 | - [Conditional or Ternary Operator in C/C++](https://www.geeksforgeeks.org/conditional-or-ternary-operator-in-c-c/) 8 | - [CONDITIONS and BRANCHES in C++](https://www.youtube.com/watch?v=qEgCT87KOfc) 9 | - [Ternary Operators in C++](https://www.youtube.com/watch?v=ezqsL-st8qg) 10 | 11 | -------------------------------------------------------------------------------- /resources/solutions/built-in/task05.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | srand(time(0)); 6 | 7 | // Use `rand() % (max - min + 1) + min` to generate a number between `min` 8 | // and `max` 9 | int uppercaseLetterASCII = rand() % ((int)'Z' - (int)'A' + 1) + (int)'A'; 10 | 11 | int zeroOrOne = rand() % 2; 12 | 13 | // If 0: letterASCII = uppercaseLetterASCII (the random uppercase letter) 14 | // If 1: letterASCII is uppercaseLetterASCII converted to lowercase 15 | int letterASCII = uppercaseLetterASCII + zeroOrOne * ((int)'a' - (int)'A'); 16 | 17 | char letter = (char)letterASCII; 18 | 19 | std::cout << letter << std::endl; 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | bool check(int **matrix, const int N, const int M) { 4 | for (int i = 0; i < N; i++) { 5 | for (int j = 0; j < M; j++) { 6 | if (matrix[i][j] < 0) { 7 | return true; 8 | } 9 | } 10 | } 11 | return false; 12 | } 13 | 14 | int main() { 15 | int N, M; 16 | std::cin >> N >> M; 17 | 18 | int **matrix = new int *[N]; 19 | for (int i = 0; i < N; i++) { 20 | matrix[i] = new int[M]; 21 | } 22 | 23 | std::cout << check(matrix, N, M) << '\n'; 24 | 25 | for (int i = 0; i < N; i++) { 26 | delete[] matrix[i]; 27 | } 28 | delete[] matrix; 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task12.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | const int N = 4, M = 4; 5 | int arr[N][M] = { 6 | {1 ,5 ,7, 4}, 7 | {1, 0, -4, 2}, 8 | {-6, -5, -100, -5}, 9 | {12, 64, 8, -6} 10 | }; 11 | 12 | int arr2[N][M] = { 13 | {-1, 5 ,5, 5}, 14 | {5, 1, 0, 0}, 15 | {5, 0, 1, 2}, 16 | {5, 0, 2, 1} 17 | }; 18 | 19 | bool mirror = true; 20 | for (int i = 0; i < N && mirror; i++) { 21 | for (int j = 0; j < M; j++) { 22 | if (arr2[i][j] != arr2[j][i]) { 23 | mirror = false; 24 | break; 25 | } 26 | } 27 | } 28 | std::cout << mirror << '\n'; 29 | } -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task03.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | char *allocate(const int n) { 4 | char *arr = new char[n]; 5 | 6 | for (int i = 0; i < n; i++) { 7 | std::cin >> arr[i]; 8 | } 9 | return arr; 10 | } 11 | 12 | bool symmectric(char *arr, const int size) { 13 | for (int i = 0; i < size / 2; i++) { 14 | if (arr[i] != arr[size - i - 1]) { 15 | return false; 16 | } 17 | } 18 | return true; 19 | } 20 | 21 | int main() { 22 | int n; 23 | std::cin >> n; 24 | 25 | char *arr = allocate(n); 26 | if (symmectric(arr, n)) { 27 | std::cout << "Da\n"; 28 | } else { 29 | std::cout << "Ne\n"; 30 | } 31 | 32 | delete[] arr; 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /resources/solutions/strings/task10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int str_to_int(char* str) { 5 | int number = 0; 6 | bool negative = (str[0] == '-'); 7 | 8 | // 12345 5*10^0 + 4* 10^1 + 3* 10^2 .... 9 | for (int i = 0 + negative; i < strlen(str); i++) { 10 | number *= 10; 11 | number += str[i] - '0'; 12 | } 13 | 14 | if (negative) { 15 | return number * -1; 16 | } 17 | return number; 18 | } 19 | 20 | int main() { 21 | char str1[100]; 22 | char str2[100]; 23 | std::cin >> str1 >> str2; 24 | 25 | int str1_num = str_to_int(str1); 26 | int str2_num = str_to_int(str2); 27 | 28 | std::cout << (str1_num > str2_num ? str1_num : str2_num) << "\n"; 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task03.cpp: -------------------------------------------------------------------------------- 1 | // Да се състави програма, която намира и извежда сумата 2 | // от всеки ред на двумерен целочислен масив. 3 | 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | int main() { 10 | 11 | int N, M; 12 | 13 | cin >> N >> M; 14 | 15 | vector> arr(N); 16 | 17 | int temp; 18 | for (int i = 0; i < N; ++i) { 19 | for (int j = 0; j < M; ++j) { 20 | cin >> temp; 21 | arr[i].push_back(temp); 22 | } 23 | } 24 | 25 | for (int i = 0; i < N; ++i) { 26 | int sum = 0; 27 | for (int j = 0; j < M; ++j) { 28 | sum += arr[i][j]; 29 | } 30 | cout << sum << " "; 31 | } 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /resources/solutions/strings/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int MAX_BUFFER_SIZE = 100; 5 | 6 | int strlen(char str[]) { 7 | int size = 0; 8 | 9 | while (str[size] != '\0') { 10 | size++; 11 | } 12 | 13 | return size; 14 | } 15 | 16 | int main() { 17 | char str[MAX_BUFFER_SIZE]; 18 | 19 | std::cin.getline(str, MAX_BUFFER_SIZE); 20 | 21 | int size = strlen(str); 22 | 23 | bool isPalindrome = true; 24 | for (int i = 0; i < size / 2; ++i) { 25 | if (str[i] != str[size - 1 - i]) { 26 | isPalindrome = false; 27 | break; 28 | } 29 | } 30 | 31 | std::cout << (isPalindrome ? "Is a palindrome" : "Isn't a palindrome") 32 | << std::endl; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /resources/content_index/week08.md: -------------------------------------------------------------------------------- 1 | Седмица 8 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Символни низове](https://drive.google.com/file/d/1D2rJlcVp4ikCB5p415od7SRdT9X-5KmM/view?usp=sharing) 7 | 8 | 9 | [Текстови файлове](https://drive.google.com/file/d/1Y2Npnt4XimyM_niTO3HVp11jndMDQJps/view?usp=sharing) 10 | 11 | Викторини 12 | --------- 13 | [Символни низове](https://forms.gle/HAHG2f5uPhk2BTZ8A) 14 | 15 | [Текстови файлове](https://forms.gle/y7KB4PMRiD2nXAeh7) 16 | 17 | Задачи 18 | ------ 19 | [Символни низове](../tasks/strings.md) 20 | 21 | [Tекстови файлове](../tasks/files.md) 22 | 23 | Решения 24 | ------- 25 | [Символни низове](../solutions/strings/) 26 | 27 | [Текстови файлове](../solutions/files/) 28 | 29 | Бонус 30 | ----- 31 | [Tекстови файлове](../bonus/text_files.md) 32 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task06.cpp: -------------------------------------------------------------------------------- 1 | // Дадена е квадратна реална матрица А с размерност kxk. Да се състави програма, 2 | // която намира и извежда неотрицателните елементи върху главния диагонал. 3 | 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | int main() { 10 | 11 | int K; 12 | 13 | cin >> K; 14 | 15 | vector> arr(K); 16 | 17 | double input; 18 | for (int i = 0; i < K; ++i) { 19 | for (int j = 0; j < K; ++j) { 20 | cin >> input; 21 | arr[i].push_back(input); 22 | } 23 | } 24 | 25 | for (int i = 0; i < K; ++i) { 26 | if (arr[i][i] >= 0) { 27 | cout << arr[i][i] << " "; 28 | } 29 | } 30 | 31 | cout << endl; 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /resources/bonus/cpp.md: -------------------------------------------------------------------------------- 1 | ## Какво е С++. Какво е компилатор. Как работи. 2 | 3 | - [How C++ Works](https://www.youtube.com/watch?v=SfGuIVzE_Os) 4 | - [How the C++ Compiler Works](https://www.youtube.com/watch?v=3tIqpEmWMLI) 5 | - [Difference between C and C++](https://www.geeksforgeeks.org/difference-between-c-and-c/) 6 | - [C++ 14](https://en.cppreference.com/w/cpp/14) 7 | - [Features of C++ 17 with Examples](https://www.geeksforgeeks.org/features-of-c17-with-examples/?ref=rp) 8 | 9 | ## Видеа 10 | - [Телерик част 1](https://www.youtube.com/watch?v=X79P_71UkLY&list=PLF4lVL1sPDSmDZFqwBR6ZfSPjESSKy4cB) 11 | - [Телерик част 2](https://www.youtube.com/watch?v=nrExyptmpo4&list=PLF4lVL1sPDSmCydDTYGUVmoVYDveKyz--) 12 | - [Телерик част 3](https://www.youtube.com/watch?v=VcfTV7Fx0Js&list=PLF4lVL1sPDSm6-69K-hgaVrPcIcnJ8_jd) 13 | -------------------------------------------------------------------------------- /resources/solutions/strings/task09.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | //Напишете програма, която въвежда знаков низ S и като резултат отпечатва онези 4 | //малки латински букви, които не се съдържат в низа. 5 | 6 | #define all 26 7 | 8 | const int MAX_BUFFER_SIZE = 100; 9 | 10 | int main() { 11 | char sample[MAX_BUFFER_SIZE]; 12 | std::cin.getline(sample, MAX_BUFFER_SIZE); 13 | 14 | bool letter[all] = {}; 15 | 16 | int size = std::strlen(sample); 17 | 18 | for (int i = 0; i < size; i++) { 19 | if (sample[i] >= 'a' && sample[i] <= 'z') { 20 | letter[sample[i] - 'a'] = true; 21 | } 22 | } 23 | 24 | for (int i = 0; i < all; i++) { 25 | if (!letter[i]) { 26 | std::cout << char(i + 'a') << '\n'; 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /resources/solutions/char_type/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define BEG 'A' 4 | #define END 'Z' 5 | 6 | int main() { 7 | char input, symmetric; 8 | std::cin >> input; 9 | 10 | // Solution 1 11 | symmetric = BEG + (END - input); 12 | 13 | /* 14 | const char MID = (BEG + END) / 2; 15 | char distance; 16 | 17 | * Solution 2 18 | if (input <= MID) { 19 | distance = input - BEG; 20 | symmetric = END - distance; 21 | } 22 | else { 23 | distance = END - input; 24 | symmetric = BEG + distance; 25 | } 26 | 27 | * Solution 3 28 | distance = (input <= MID ? input - BEG : END - input); 29 | symmetric = (input <= MID ? END - distance : BEG + distance); 30 | */ 31 | std::cout << symmetric; 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task09.cpp: -------------------------------------------------------------------------------- 1 | // Дадена е квадратна реална матрица А с размерност kxk. 2 | // Да се състави програма, която намира произведението 3 | // от елементите извън вторичния главен диагонал. 4 | 5 | #include 6 | 7 | using namespace std; 8 | 9 | int main() { 10 | 11 | int K; 12 | cin >> K; 13 | 14 | // K < 50 15 | int arr[50][50]; 16 | 17 | for (int i = 0; i < K; ++i) { 18 | for (int j = 0; j < K; ++j) { 19 | cin >> arr[i][j]; 20 | } 21 | } 22 | 23 | int proiz = 1; 24 | for (int i = 0; i < K; ++i) { 25 | for (int j = 0; j < K; ++j) { 26 | if (j != K - i - 1) { 27 | proiz *= arr[i][j]; 28 | } 29 | } 30 | } 31 | 32 | cout << proiz << endl; 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /resources/solutions/strings/task02.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int MAX_BUFFER_SIZE = 100; 5 | const int SPECIAL_SYMBOLS_COUNT = 3; 6 | 7 | int main() { 8 | char str[MAX_BUFFER_SIZE]; 9 | 10 | std::cin.getline(str, MAX_BUFFER_SIZE); 11 | 12 | char special_symbols[SPECIAL_SYMBOLS_COUNT] = {'!', '?', ','}; 13 | int special_symbols_counter[SPECIAL_SYMBOLS_COUNT]{}; 14 | 15 | int size = std::strlen(str); 16 | 17 | for (int i = 0; i < size; ++i) { 18 | for (int symbol_index = 0; symbol_index < SPECIAL_SYMBOLS_COUNT; 19 | symbol_index++) { 20 | if (str[i] == special_symbols[symbol_index]) { 21 | ++special_symbols_counter[symbol_index]; 22 | break; 23 | } 24 | } 25 | } 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /resources/bonus/vs_code.md: -------------------------------------------------------------------------------- 1 | ## Visual studio code setup 2 | 3 | ### How to install Visual studio code: 4 | https://letmegooglethat.com/?q=download+vs+code 5 | 6 | ### How to start using C++ 7 | https://letmegooglethat.com/?q=vscode+c%2B%2B 8 | 9 | ### Suggested extensions: 10 | * [C++ syntax and more](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools-extension-pack) 11 | * [C++ formatter](https://marketplace.visualstudio.com/items?itemName=xaver.clang-format) 12 | * [Guide how to use it](https://www.youtube.com/watch?v=rd8-aVc3Krg) 13 | * By deafult, it uses indentation of just 2 spaces, you can change that by creating a new file called .clang-format where your code is: [example](../solutions/.clang-format) 14 | * [Remove trailing whitespaces](https://marketplace.visualstudio.com/items?itemName=shardulm94.trailing-spaces) -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task07.cpp: -------------------------------------------------------------------------------- 1 | // Дадена е квадратна реална матрица А с размерност nxn. 2 | // Да се състави програма, която намира сумата от елементите под 3 | // главния диагонал (включително главният диагонал). 4 | 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | int main() { 11 | 12 | int N; 13 | 14 | cin >> N; 15 | 16 | vector> arr(N); 17 | 18 | double temp; 19 | for (int i = 0; i < N; ++i) { 20 | for (int j = 0; j < N; ++j) { 21 | cin >> temp; 22 | arr[i].push_back(temp); 23 | } 24 | } 25 | 26 | double sum = 0; 27 | for (int i = 0; i < N; ++i) { 28 | for (int j = 0; j <= i; ++j) { 29 | sum += arr[i][j]; 30 | } 31 | } 32 | 33 | cout << sum << "\n"; 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /resources/solutions/functions/task15.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int get_number() { 4 | int tmp; 5 | std::cin >> tmp; 6 | return tmp; 7 | } 8 | 9 | bool form_triangle(const int a, const int b, const int c) { 10 | if (a < 0 || b < 0 || c < 0) { 11 | return false; 12 | } 13 | if (a + b <= c) { 14 | return false; 15 | } 16 | if (b + c <= a) { 17 | return false; 18 | } 19 | if (a + c <= b) { 20 | return false; 21 | } 22 | return true; 23 | } 24 | 25 | int main() { 26 | int a, b, c, n; 27 | std::cin >> n; 28 | for (int i = 0; i < n; i++) { 29 | a = get_number(); 30 | b = get_number(); 31 | c = get_number(); 32 | if (form_triangle(a, b, c)) { 33 | std::cout << a << ' ' << b << ' ' << c << '\n'; 34 | } 35 | } 36 | return 0; 37 | } -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task04.cpp: -------------------------------------------------------------------------------- 1 | // Да се състави програма, която установява дали целочисленият двумерен 2 | // масив А с размерност mxn съдържа отрицателен елемент. 3 | 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | int main() { 10 | 11 | int N, M; 12 | 13 | cin >> N >> M; 14 | 15 | vector> arr(N); 16 | 17 | int temp; 18 | for (int i = 0; i < N; ++i) { 19 | for (int j = 0; j < M; ++j) { 20 | cin >> temp; 21 | arr[i].push_back(temp); 22 | } 23 | } 24 | 25 | for (int i = 0; i < N; ++i) { 26 | for (int j = 0; j < M; ++j) { 27 | if (arr[i][j] < 0) { 28 | cout << "YES\n"; 29 | return 0; 30 | } 31 | } 32 | } 33 | 34 | cout << "NO\n"; 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task05.cpp: -------------------------------------------------------------------------------- 1 | // Да се състави програма, която установява дали реалният 2 | // двумерен масив А с размерност mxn съдържа елемента Х. 3 | 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | int main() { 10 | 11 | int N, M; 12 | double X; 13 | 14 | cin >> N >> M >> X; 15 | 16 | vector> arr(N); 17 | 18 | double temp; 19 | for (int i = 0; i < N; ++i) { 20 | for (int j = 0; j < M; ++j) { 21 | cin >> temp; 22 | arr[i].push_back(temp); 23 | } 24 | } 25 | 26 | for (int i = 0; i < N; ++i) { 27 | for (int j = 0; j < M; ++j) { 28 | if (arr[i][j] == X) { 29 | cout << "YES\n"; 30 | return 0; 31 | } 32 | } 33 | } 34 | 35 | cout << "NO\n"; 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task08.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int rows, cols; 6 | std::cin >> rows >> cols; 7 | 8 | int **mat = new int *[rows]; 9 | for (size_t row = 0; row < rows; row++) { 10 | mat[row] = new int[cols]; 11 | for (size_t col = 0; col < cols; col++) { 12 | std::cin >> mat[row][col]; 13 | } 14 | } 15 | 16 | int min; 17 | for (size_t row = 0; row < rows; row++) { 18 | min = INT_MAX; 19 | 20 | for (size_t col = 0; col < cols; col++) { 21 | if (mat[row][col] < min) { 22 | min = mat[row][col]; 23 | } 24 | } 25 | 26 | std::cout << min << '\n'; 27 | } 28 | 29 | for (size_t row = 0; row < rows; row++) { 30 | delete[] mat[row]; 31 | } 32 | delete[] mat; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /resources/solutions/strings/task14.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int MAX_BUFFER_SIZE = 100; 5 | 6 | int main() { 7 | char str[MAX_BUFFER_SIZE]; 8 | 9 | std::cin.getline(str, MAX_BUFFER_SIZE); 10 | 11 | int size = std::strlen(str); 12 | 13 | size_t leftIndex = 0, rightIndex = 0; 14 | 15 | for (int index = 0; index < size; ++index) { 16 | for (int reverseIndex = size - 1; reverseIndex >= index; 17 | --reverseIndex) { 18 | if (str[index] == str[reverseIndex]) { 19 | if ((reverseIndex - index) > (rightIndex - leftIndex)) { 20 | leftIndex = index; 21 | rightIndex = reverseIndex; 22 | } 23 | break; 24 | } 25 | } 26 | } 27 | 28 | std::cout << leftIndex << ' ' << rightIndex << '\n'; 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task20.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | // Дадени са матриците A и B, с размери NxM и PxQ. Да се изведе произведението 5 | // на A и B, ако това е възможно, или да се изведе съобщение, че не е. 6 | int main() { 7 | const int m1_rows = 4, m2_rows = 3, m1_cols = 3, m2_cols = 2; 8 | int mat1[m1_rows][m1_cols] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {1, 1, 1}}, 9 | mat2[m2_rows][m2_cols] = {{6, 7}, {8, 9}, {1, 2}}; 10 | int mat3[m1_rows][m2_cols]; 11 | 12 | for (int i = 0; i < m1_rows; i++) { 13 | for (int j = 0; j < m2_cols; j++) { 14 | mat3[i][j] = 0; 15 | for (int k = 0; k < m2_rows; k++) { 16 | mat3[i][j] += mat1[i][k] * mat2[k][j]; 17 | } 18 | std::cout << mat3[i][j] << " "; 19 | } 20 | std::cout << "\n"; 21 | } 22 | 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /resources/solutions/vector/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | bool in(const int element, const std::vector vec) { 5 | for (int i = 0; i < vec.size(); i++) { 6 | if (vec[i] == element) { 7 | return true; 8 | } 9 | } 10 | return false; 11 | } 12 | 13 | int main() { 14 | std::vector arr1 = {1, 5, 1, 2, 1, 10, 23, 81, 0, 2, 6, 1, 8, 23, 1}; 15 | std::vector arr2; 16 | 17 | for (int i = 0; i < arr1.size() - 1; i++) { 18 | for (int j = i + 1; j < arr1.size(); j++) { 19 | if (arr1[i] == arr1[j]) { 20 | if (!in(arr1[i], arr2)) { 21 | arr2.push_back(arr1[i]); 22 | } 23 | } 24 | } 25 | } 26 | 27 | for (int i = 0; i < arr2.size(); i++) { 28 | std::cout << arr2[i] << ' '; 29 | } 30 | std::cout << '\n'; 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /resources/solutions/functions/task17.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void sort_array(const int N, int arr[]) { 5 | // sizeof не работи и затова трябва да се подаде големината на масива 6 | //от друга страна можем да работим директно със стойностите на самия масив 7 | int min = INT_MAX, min_ind; 8 | for (int i = 0; i < N; i++) { 9 | for (int j = i; j < N; j++) { 10 | if (arr[j] < min) { 11 | min = arr[j]; 12 | min_ind = j; 13 | } 14 | } 15 | std::swap(arr[i], arr[min_ind]); 16 | min = INT_MAX; 17 | } 18 | } 19 | 20 | int main() { 21 | const int size = 7; 22 | int arr[size] = {5, 54, 123, 6, 12, 6, 8}; 23 | 24 | sort_array(size, arr); 25 | 26 | for (int i = 0; i < size; i++) { 27 | std::cout << arr[i] << ' '; 28 | } 29 | std::cout << "\n"; 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task08.cpp: -------------------------------------------------------------------------------- 1 | // Дадена е квадратна матрица Х с размерност kxk и цяло число s. 2 | // Да се състави програма, която намира сумата от онези елементи 3 | // на матрицата Х, сборът от индексите на които е равен на s. 4 | 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | int main() { 11 | 12 | int N, S; 13 | 14 | cin >> N >> S; 15 | 16 | vector> arr(N); 17 | 18 | int temp; 19 | for (int i = 0; i < N; ++i) { 20 | for (int j = 0; j < N; ++j) { 21 | cin >> temp; 22 | arr[i].push_back(temp); 23 | } 24 | } 25 | 26 | int sum = 0; 27 | for (int i = 0; i < N; ++i) { 28 | for (int j = 0; j < N; ++j) { 29 | if (i + j == S) { 30 | sum += arr[i][j]; 31 | } 32 | } 33 | } 34 | 35 | cout << sum << "\n"; 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /resources/solutions/vector/task04-2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | std::vector arr1 = {1, 5, 1, 2, 1, 10, 23, 81, 0, 2, 6, 1, 8, 23, 1}; 6 | std::vector arr2; 7 | 8 | for (int i = 0; i < arr1.size() - 1; i++) { 9 | for (int j = i + 1; j < arr1.size(); j++) { 10 | if (arr1[i] > arr1[j]) { 11 | int tmp = arr1[j]; 12 | arr1[j] = arr1[i]; 13 | arr1[i] = tmp; 14 | } 15 | } 16 | } 17 | 18 | for (int i = 0; i < arr1.size() - 1; i++) { 19 | if (arr1[i] == arr1[i + 1]) { 20 | arr2.push_back(arr1[i]); 21 | while (arr1[i] == arr1[i + 1]) { 22 | i++; 23 | } 24 | } 25 | } 26 | 27 | for (int i = 0; i < arr2.size(); i++) { 28 | std::cout << arr2[i] << ' '; 29 | } 30 | std::cout << '\n'; 31 | 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task00.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | bool is_pally(const std::vector vec) { 5 | std::vector reverse; 6 | for (int i = vec.size() - 1; i >= 0; i--) { 7 | reverse.push_back(vec[i]); 8 | } 9 | return vec == reverse; 10 | } 11 | 12 | bool is_possible(std::vector vec, int remaining) { 13 | if (remaining < 0) { 14 | return false; 15 | } 16 | 17 | if (is_pally(vec)) { 18 | return true; 19 | } 20 | 21 | std::vector left_side = vec, right_side = vec; 22 | left_side.erase(left_side.begin()); 23 | right_side.pop_back(); 24 | 25 | remaining--; 26 | return is_possible(left_side, remaining) || 27 | is_possible(right_side, remaining); 28 | } 29 | 30 | int main() { 31 | int N; 32 | std::cin >> N; 33 | 34 | std::vector vec = {1, 2, 3, 2, 5, 6}; 35 | 36 | std::cout << is_possible(vec, N) << "\n"; 37 | 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int rows; 6 | std::cin >> rows; 7 | 8 | int *cols_arr = new int[rows]; 9 | for (size_t row = 0; row < rows; row++) { 10 | std::cin >> cols_arr[row]; 11 | } 12 | 13 | int **mat = new int *[rows]; 14 | for (size_t row = 0; row < rows; row++) { 15 | mat[row] = new int[cols_arr[row]]; 16 | for (size_t col = 0; col < cols_arr[row]; col++) { 17 | std::cin >> mat[row][col]; 18 | } 19 | } 20 | 21 | long sum; 22 | for (size_t row = 0; row < rows; row++) { 23 | sum = 0; 24 | 25 | for (size_t col = 0; col < cols_arr[row]; col++) { 26 | sum += mat[row][col]; 27 | } 28 | 29 | std::cout << sum << '\n'; 30 | } 31 | 32 | delete[] cols_arr; 33 | 34 | for (size_t row = 0; row < rows; row++) { 35 | delete[] mat[row]; 36 | } 37 | delete[] mat; 38 | 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /resources/solutions/arrays/task19.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int len(int a) { 4 | int size = 1; 5 | a /= 10; 6 | while (a > 0) { 7 | size++; 8 | a /= 10; 9 | } 10 | return size; 11 | } 12 | 13 | bool compare(int a, int b) { 14 | while (len(a) < len(b)) { 15 | a *= 10; 16 | } 17 | 18 | while (len(b) < len(a)) { 19 | b *= 10; 20 | } 21 | 22 | return a > b; 23 | } 24 | 25 | void sortLex(const int n, int *a) { 26 | for (int i = 0; i < n - 1; i++) { 27 | for (int j = i + 1; j < n; j++) { 28 | if (compare(a[i], a[j])) { 29 | int c = a[i]; 30 | a[i] = a[j]; 31 | a[j] = c; 32 | } 33 | } 34 | } 35 | } 36 | 37 | #define SIZE 5 38 | 39 | int main() { 40 | int arr[SIZE] = {1, 10, 20, 103, 5}; 41 | sortLex(SIZE, arr); 42 | for (int i = 0; i < SIZE; i++) { 43 | std::cout << arr[i] << ' '; 44 | } 45 | std::cout << std::endl; 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /resources/bonus/intro.md: -------------------------------------------------------------------------------- 1 | # Въведение 2 | 3 | ## Езици за програмиране 4 | 5 | [Кратка презентация](https://drive.google.com/file/d/1-cHs9o5upXup-wSb4vBV82rc6fa4LXSS/view?usp=sharing) 6 | 7 | 8 | ## Блок схема и пример за алгоритъм 9 | 10 | - [Flowchart](https://en.wikipedia.org/wiki/Flowchart) 11 | - [Разработване на алгоритми и блок-схеми](https://postvai.com/it/avtomatiziran-algoritam-blog-shema.html) 12 | - [Задачи за блок-схеми](http://1001zadachi.com/switch_%D0%BF%D0%BE%D1%81%D0%BE%D0%BA%D0%B0/itemlist/category/20-%D0%B1%D0%BB%D0%BE%D0%BA_%D1%81%D1%85%D0%B5%D0%BC%D0%B0_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D1%8A%D0%BC.html) 13 | 14 | ## Платформи със задачи 15 | - [https://www.hackerrank.com/domains/cpp](https://www.hackerrank.com/domains/cpp) 16 | - [https://leetcode.com/problemset/all/](https://leetcode.com/problemset/all/) 17 | - [http://www.math.bas.bg/infos/comp.html](http://www.math.bas.bg/infos/comp.html) 18 | - [https://www.codewars.com/](https://www.codewars.com/) 19 | - [Задачи на информатика](https://drive.google.com/file/d/1GJnlIAIhmRKobb9D2oX20OrcNxTIePG_/view?usp=sharing) 20 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task13.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /* Iterative solution 4 | * 5 | int search(vector& nums, int target) { 6 | int low = 0, high = nums.size(); 7 | while (low < high) { 8 | int mid = (high + low) / 2; 9 | if (nums[mid] == target) { 10 | return mid; 11 | } 12 | else if (nums[mid] < target) { 13 | low = mid + 1; 14 | } 15 | else { 16 | high = mid; 17 | } 18 | } 19 | return -1; 20 | } 21 | */ 22 | 23 | int binary_search(const std::vector &nums, const int low, const int high, 24 | const int target) { 25 | if (low >= high) { 26 | return -1; 27 | } 28 | 29 | int mid = (high + low) / 2; 30 | 31 | if (nums[mid] == target) { 32 | return mid; 33 | } else if (nums[mid] < target) { 34 | return binary_search(nums, mid + 1, high, target); 35 | } 36 | return binary_search(nums, low, mid, target); 37 | } 38 | -------------------------------------------------------------------------------- /resources/content_index/week02.md: -------------------------------------------------------------------------------- 1 | Седмица 2 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Променливи](https://drive.google.com/file/d/1HDcNCg4ZZI2nP1KE34PlBj5lZKL1Pryn/view?usp=sharing) 7 | 8 | [Оператори, връщащи стойност](https://drive.google.com/file/d/1HT_KqTEmDCikOUsHJmwB5PbNPUw3VwsO/view?usp=sharing) 9 | 10 | 11 | Викторини 12 | --------- 13 | [Променливи](https://docs.google.com/forms/d/e/1FAIpQLSc1-teg7ZPZt1rW_8SjY62H1SUjZ3gLPl2RwylH1l-cXXHyIQ/viewform?usp=sf_link) 14 | 15 | [Oператори, връщащи стойност](https://docs.google.com/forms/d/e/1FAIpQLScY1jalEmxrQ-9PCRLFPiA-uJlbN4TFZOAdzgEe9kwfyuQwAw/viewform?usp=sf_link) 16 | 17 | Задачи 18 | ------ 19 | [Tип char](../tasks/char_type.md) 20 | 21 | [Tип double](../tasks/double_type.md) 22 | 23 | [Oператори](../tasks/basic_operators.md) 24 | 25 | [Побитови операции](../tasks/bitwise_operators.md) 26 | 27 | Решения 28 | ------- 29 | [Tип char](../solutions/char_type/) 30 | 31 | [Tип double](../solutions/double_type/) 32 | 33 | [Oператори](../solutions/basic_operators/) 34 | 35 | Бонус 36 | ----- 37 | [Типове данни](../bonus/variables.md) 38 | 39 | [Оператори](../bonus/operators.md) -------------------------------------------------------------------------------- /resources/solutions/structs/task11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | struct point { 7 | double x; 8 | double y; 9 | }; 10 | 11 | double get_distance(point first, point second) { 12 | double x_difference = first.x - second.x; 13 | double y_difference = first.y - second.y; 14 | return sqrt(x_difference * x_difference + y_difference * y_difference); 15 | } 16 | 17 | int main() { 18 | point first_point, second_point, temp_point; 19 | 20 | std::cout << "Enter the coordinates of the first point\n"; 21 | std::cin >> first_point.x >> first_point.y; 22 | 23 | std::cout << "Enter the coordinates of the second point\n"; 24 | std::cin >> second_point.x >> second_point.y; 25 | 26 | temp_point.x = first_point.x; 27 | temp_point.y = second_point.y; 28 | 29 | double side_a, side_b; 30 | side_a = get_distance(first_point, temp_point); 31 | side_b = get_distance(second_point, temp_point); 32 | 33 | std::cout << "The sides do " << (side_a == side_b ? "" : "not ") 34 | << "form a square diagonal\n"; 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /resources/solutions/archives/homeworks/2020/3/task04.txt: -------------------------------------------------------------------------------- 1 | Обяснение на решението: 2 | 3 | Използва се структура trie, която съдържа масив от указатели към trie. Това представлява възел от дърво, където всеки елемент отговаря на съответната буква от латинската азбука. 4 | Идеята е всяка буква от подадената дума да си има собствен възел от дървото. 5 | Създаваме първоначален възел solution. 6 | 7 | Функцията split рекурсивно намира всички възможни думи, които можем да получим както е по условие, като за всяка дума извиква функцията put. 8 | 9 | Функцията put се извиква върху първоначалния възел solution за всяка възможно дума, която сме получили. 10 | Това, което put прави е да задели динамично нови възли за всяка буква от думата, която сме му подали, ако вече не е била заделена памет за нея вече. 11 | 12 | При всяко ново заделяне на динамична памет се извършва инкрементиране на променливата count. По този начин ако е имало повтаряща се дума, много бързо се установява това и се спестяват много памет и време. 13 | 14 | Накрая се извиква функцията free, за да се освободи всяка памет, която сме заделили. 15 | 16 | За повече информация: https://en.wikipedia.org/wiki/Trie 17 | -------------------------------------------------------------------------------- /resources/content_index/week01.md: -------------------------------------------------------------------------------- 1 | Седмица 1 2 | ================================= 3 | 4 | [Анкета преди започването на курса](https://docs.google.com/forms/d/e/1FAIpQLSfu5H7CZ3T6n2kBItLo7w-fgOd9gJryMnJfB5ABVk8n_SMQPw/viewform?usp=sf_link) 5 | 6 | Теория 7 | ------ 8 | [Как да учим по УП](https://docs.google.com/file/d/1goJkKsw9bjda1ZgzWGmHnVT4cFuhSMKd/edit#slide=id.p1) 9 | 10 | [Бройни системи](https://drive.google.com/file/d/1uB-t8U2VO51UbURDE-I8XPzmkmK4sOPp/view?usp=sharing) 11 | 12 | [Въведение в С++](https://drive.google.com/file/d/1j6c08FDdCZhY7jBNurkJ91n-zNwCAoJt/view?usp=sharing) 13 | 14 | [Билдване на С++ сорс код](https://drive.google.com/file/d/1xnRr-PC2YPki8E54gse-nopGJn33dYkT/view?usp=sharing) 15 | 16 | Викторини 17 | --------- 18 | [C++](https://docs.google.com/forms/d/e/1FAIpQLSetEdoGxVi3f1ape-MEbwU2xEdXBNRBxe6hpJN7Uw6Z1HHxhw/viewform?usp=sf_link) 19 | 20 | Задачи 21 | ------ 22 | [Бройни системи](../tasks/numeral_systems.md) 23 | 24 | Решения 25 | ------- 26 | [Бройни системи](../solutions/numeral_systems_answers.md) 27 | 28 | Бонус 29 | ----- 30 | [Въведение](../bonus/intro.md) 31 | 32 | [Visual Studio code](../bonus/vs_code.md) 33 | 34 | [C++](../bonus/cpp.md) 35 | -------------------------------------------------------------------------------- /resources/solutions/strings/task08.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | bool check_str(char* str, int start_index, const char* target) { 5 | for (int i = 0; i < strlen(target); i++) { 6 | if (str[start_index + i] != target[i]) { 7 | return false; 8 | } 9 | } 10 | return true; 11 | } 12 | 13 | int main() { 14 | char str1[] = "asdasdbeginasdasendasdasbeginasdasend begin"; // false 15 | char str2[] = "endginbegin"; // true 16 | 17 | int count_begin = 0, count_end = 0; 18 | /* 19 | for (int i = 0; i < strlen(str1); i++) { 20 | if (str1[i] == 'b') { 21 | count_begin += check_str(str1, i, "begin"); 22 | } 23 | if (str1[i] == 'e') { 24 | count_end += check_str(str1, i, "end"); 25 | } 26 | } 27 | */ 28 | for (int i = 0; i < strlen(str2); i++) { 29 | if (str2[i] == 'b') { 30 | count_begin += check_str(str2, i, "begin"); 31 | } 32 | if (str2[i] == 'e') { 33 | count_end += check_str(str2, i, "end"); 34 | } 35 | } 36 | std::cout << (count_begin == count_end) << "\n"; 37 | return 0; 38 | } -------------------------------------------------------------------------------- /resources/solutions/loops/task13.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int number; 5 | std::cin >> number; 6 | 7 | int n_len = 0, tmp = number; 8 | 9 | // Get length of the number 10 | while (tmp > 0) { 11 | n_len++; 12 | tmp /= 10; 13 | } 14 | 15 | // Get a remainder that we will use to remove the first digits 16 | int remainder = 1; 17 | for (int i = 1; i < n_len; i++) { 18 | remainder *= 10; 19 | } 20 | 21 | // Remove the first digit 22 | number %= remainder; 23 | remainder /= 10; 24 | n_len--; 25 | 26 | // Print the first digit and then remove the first 2 digits while number > 0 27 | for (int i = 0; i < n_len; i += 2) { 28 | int digit = number / remainder; 29 | std::cout << ' ' << digit; 30 | remainder /= 10; // decrease remainder to remove the odd digit as well 31 | if (remainder > 0) { 32 | number %= 33 | remainder; // if remainder == 0, floating exception is thrown 34 | } 35 | remainder /= 10; // decrease remainder to remove the next even digit 36 | } 37 | std::cout << '\n'; 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | //Задача Да се състави програма, която намира и извежда минималният елемент на 4 | //всеки ред на двумерен масив. На първия ред от стандартния вход да се въведат 5 | //размерите на масива, а на следващите редове и самият масив. 6 | int main() { 7 | int row_size, col_size, tmp_input; 8 | std::vector tmp_vector; 9 | std::cin >> row_size >> col_size; 10 | 11 | std::vector> matrix; 12 | for (int row = 0; row < row_size; row++) { 13 | matrix.push_back(tmp_vector); 14 | for (int col = 0; col < col_size; col++) { 15 | std::cin >> tmp_input; 16 | matrix[row].push_back(tmp_input); 17 | } 18 | } 19 | 20 | for (int row = 0; row < row_size; row++) { 21 | int min = matrix[row][0]; 22 | for (int col = 1; col < col_size; col++) { 23 | if (min > matrix[row][col]) { 24 | min = matrix[row][col]; 25 | } 26 | } 27 | std::cout << "The lowest element for row " << row + 1 << " is " << min 28 | << "\n"; 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [Седмица 1 - Въведение](resources/content_index/week01.md) 2 | 3 | [Седмица 2 - Променливи. Оператори връщащи стойности](resources/content_index/week02.md) 4 | 5 | [Седмица 3 - Вградени функции. Условни оператори. Цикли](resources/content_index/week03.md) 6 | 7 | [Седмица 4 - Вложени цикли](resources/content_index/week04.md) 8 | 9 | [Седмица 5 - Функции](resources/content_index/week05.md) 10 | 11 | [Седмица 6 - Масиви](resources/content_index/week06.md) 12 | 13 | [Седмица 7 - Многомерни масиви](resources/content_index/week07.md) 14 | 15 | [Седмица 8 - Символни низове. Работа с файлове](resources/content_index/week08.md) 16 | 17 | [Седмица 9 - Контролно 2](resources/content_index/week09.md) 18 | 19 | [Седмица 10 - Референции. Пойнтъри.](resources/content_index/week10.md) 20 | 21 | [Седмица 11 - Динамична памет](resources/content_index/week11.md) 22 | 23 | [Седмица 12 - Git основи](resources/content_index/week12.md) 24 | 25 | [Седмица 13 - Git branch management](resources/content_index/week13.md) 26 | 27 | [Седмица 14 - Рекурсия](resources/content_index/week14.md) 28 | 29 | [Седмица 15 - Преговор](resources/content_index/week15.md) 30 | 31 | [Допълнителни материали](resources/content_index/bonus.md) 32 | 33 | [Архив](resources/tasks/archives) 34 | -------------------------------------------------------------------------------- /resources/content_index/week03.md: -------------------------------------------------------------------------------- 1 | Седмица 3 2 | ================================= 3 | 4 | Теория 5 | ------ 6 | [Вградени функции](https://docs.google.com/file/d/1fgI57GL0hJTF3Qd4hG2JwN3_ThE0CWLC/edit?usp=sharing&ouid=115687390792091108365&rtpof=true&sd=true) 7 | 8 | [Условни оператори](https://drive.google.com/file/d/1pA4CHA92qosF2hGPmplDl4a0ZPUV7jB3/view?usp=sharing) 9 | 10 | [Цикли](https://drive.google.com/file/d/1JQ9siYUeYPtPgHlfqJCyOZNLuSrgLvIw/view?usp=sharing) 11 | 12 | Викторини 13 | --------- 14 | [Условни оператори](https://forms.gle/Ve1RvXnU1FEjzJev7) 15 | 16 | [Цикли](https://forms.gle/WCg2P7r5XKGddHqY6) 17 | 18 | Задачи 19 | ------ 20 | [Вградени функции](../tasks/built-in.md) 21 | 22 | [Булеви изрази](../tasks/boolean_expressions.md) 23 | 24 | [Условни оператори](../tasks/conditional_operators.md) 25 | 26 | [Цикли](../tasks/loops.md) 27 | 28 | Решения 29 | ------- 30 | [Вградени функции](../solutions/built-in/) 31 | 32 | [Булеви изрази](../solutions/boolean_expressions_answers.md) 33 | 34 | [Условни оператори](../solutions/conditional_operators/) 35 | 36 | [Цикли](../solutions/loops/) 37 | 38 | Бонус 39 | ----- 40 | [Вградени функции](../bonus/built-in.md) 41 | 42 | [Условни оператори](../bonus/conditionals.md) 43 | 44 | [Цикли](../bonus/loops.md) 45 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task19.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | // 5 | int main() { 6 | const int ROW = 4, COL = 6; 7 | int arr[ROW][COL] = {{1, 2, 3, 4, 5, 6}, 8 | {7, 8, 9, 10, 11, 12}, 9 | {13, 14, 15, 16, 17, 18}, 10 | {19, 20, 21, 22, 23, 24}}; 11 | int i = 0, cur_row = 0, cur_col = 0, row_range = ROW, col_range = COL; 12 | 13 | while (cur_row < row_range && cur_col < col_range) { 14 | for (i = cur_col; i < col_range; i++) { 15 | std::cout << arr[cur_row][i] << " "; 16 | } 17 | cur_row++; 18 | 19 | for (i = cur_row; i < row_range; i++) { 20 | std::cout << arr[i][col_range - 1] << " "; 21 | } 22 | col_range--; 23 | 24 | if (cur_row < row_range) { 25 | for (i = col_range - 1; i >= cur_col; i--) { 26 | std::cout << arr[row_range - 1][i] << " "; 27 | } 28 | row_range--; 29 | } 30 | if (cur_col < col_range) { 31 | for (i = row_range - 1; i >= cur_row; i--) { 32 | std::cout << arr[i][cur_col] << " "; 33 | } 34 | cur_col++; 35 | } 36 | } 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /resources/solutions/pointers_and_references/demo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define COLS 9 5 | int main() { 6 | int a = 5, b = 5, c = a; 7 | int &a_ref = a, &b_ref = b, &c_ref = c; 8 | int *a_ptr = &a, *b_ptr = &b, *c_ptr = &c; 9 | int a_ptr_deref = *a_ptr, b_ptr_deref = *b_ptr, c_ptr_deref = *c_ptr; 10 | 11 | std::cout << "\t\ta\t\tb\t\tc\t\ta_ref\t\tb_ref\t\tc_ref\t\ta_ptr\t\tb_" 12 | "ptr\t\tc_ptr\ta_ptr_deref\tb_ptr_deref\tc_ptr_deref"; 13 | std::cout << "\n"; 14 | 15 | std::cout << "Value" 16 | << "\t\t"; 17 | std::cout << a << "\t\t" << b << "\t\t" << c << "\t\t" << a_ref << "\t\t" 18 | << b_ref << "\t\t" << c_ref << "\t" << a_ptr << "\t" << b_ptr 19 | << "\t" << c_ptr << "\t\t" << a_ptr_deref << "\t\t" << b_ptr_deref 20 | << "\t\t" << c_ptr_deref; 21 | std::cout << "\n"; 22 | 23 | std::cout << "Address" 24 | << "\t"; 25 | std::cout << &a << "\t" << &b << "\t" << &c << "\t" << &a_ref << "\t" 26 | << &b_ref << "\t" << &c_ref << "\t" << &a_ptr << "\t" << &b_ptr 27 | << "\t" << &c_ptr << "\t" << &a_ptr_deref << "\t" << &b_ptr_deref 28 | << "\t" << &c_ptr_deref; 29 | std::cout << "\n"; 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task16.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define col_size 2 4 | #define row_size 6 5 | 6 | void swap_rows(int arr[][col_size], int N, int M) { 7 | for (int i = 0; i < col_size; i++) { 8 | int tmp = arr[N][i]; 9 | arr[N][i] = arr[M][i]; 10 | arr[M][i] = tmp; 11 | } 12 | } 13 | 14 | bool compare(int arr[][col_size], int N, int M) { 15 | for (int i = 0; i < col_size; i++) { 16 | if (arr[N][i] != arr[M][i]) { 17 | return arr[N][i] < arr[M][i]; 18 | } 19 | } 20 | return true; 21 | } 22 | 23 | void sort_array(int arr[][col_size]) { 24 | for (int i = 0; i < row_size - 1; i++) { 25 | for (int j = i + 1; j < row_size; j++) { 26 | if (!compare(arr, i, j)) { 27 | swap_rows(arr, i, j); 28 | } 29 | } 30 | } 31 | } 32 | 33 | void print_array(int arr[][2]) { 34 | for (int i = 0; i < row_size; i++) { 35 | for (int j = 0; j < col_size; j++) { 36 | std::cout << arr[i][j] << ' '; 37 | } 38 | std::cout << "\n"; 39 | } 40 | std::cout << "\n"; 41 | } 42 | 43 | int main() { 44 | int arr[][2] = {{1, 4}, {3, 16}, {4, 5}, {1, 2}, {20, 0}, {6, 7}}; 45 | sort_array(arr); 46 | print_array(arr); 47 | 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /resources/solutions/basic_operators/task09.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, c; 5 | 6 | std::cin >> a >> b >> c; 7 | 8 | if (a > b && a > c) { 9 | // a is biggest 10 | if (b > c) { 11 | // b is middle 12 | // c is lowest 13 | std::cout << a << ' ' << b << ' ' << c << std::endl; 14 | } else { 15 | // c is middle 16 | // b is lowest 17 | std::cout << a << ' ' << c << ' ' << b << std::endl; 18 | } 19 | } else if (b > a && b > c) { 20 | // b is biggest 21 | if (a > c) { 22 | // a is middle 23 | // c is lowest 24 | std::cout << b << ' ' << a << ' ' << c << std::endl; 25 | } else { 26 | // c is middle 27 | // a is lowest 28 | std::cout << b << ' ' << c << ' ' << a << std::endl; 29 | } 30 | } else { 31 | // c is biggest 32 | if (a > b) { 33 | // a is middle 34 | // b is lowest 35 | std::cout << c << ' ' << a << ' ' << b << std::endl; 36 | } else { 37 | // b is middle 38 | // a is lowest 39 | std::cout << c << ' ' << b << ' ' << a << std::endl; 40 | } 41 | } 42 | 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task16.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int size; 5 | std::cin >> size; 6 | 7 | int **mat = new int *[size]; 8 | for (size_t i = 0; i < size; i++) { 9 | mat[i] = new int[size]; 10 | for (size_t j = 0; j < size; j++) { 11 | std::cin >> mat[i][j]; 12 | } 13 | } 14 | 15 | for (size_t iter = 0; iter < size / 2; iter++) { 16 | // Right 17 | for (size_t col = iter; col < size - iter - 1; col++) { 18 | std::cout << mat[iter][col] << ' '; 19 | } 20 | 21 | // Down 22 | for (size_t row = iter; row < size - iter - 1; row++) { 23 | std::cout << mat[row][size - iter - 1] << ' '; 24 | } 25 | 26 | // Left 27 | for (size_t col = size - iter - 1; col > iter; col--) { 28 | std::cout << mat[size - iter - 1][col] << ' '; 29 | } 30 | 31 | // Up 32 | for (size_t row = size - iter - 1; row > iter; row--) { 33 | std::cout << mat[row][iter] << ' '; 34 | } 35 | } 36 | 37 | // FIX for odd number of rows 38 | if (size % 2) { 39 | std::cout << mat[size / 2][size / 2] << ' '; 40 | } 41 | 42 | for (size_t i = 0; i < size; i++) { 43 | delete[] mat[i]; 44 | } 45 | delete[] mat; 46 | 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /resources/solutions/recursion/task21.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | bool isStringInside(const string &str, const string &toFind) { 7 | for (int i = 0; i < str.size(); ++i) { 8 | if (str[i] == toFind[0]) { 9 | int j = 0; 10 | while (i < str.size() && j < toFind.size() && str[i] == toFind[j]) { 11 | ++j; 12 | ++i; 13 | } 14 | if (j == toFind.size()) { 15 | return true; 16 | } 17 | } 18 | } 19 | 20 | return false; 21 | } 22 | 23 | bool isStringInsideRecursive(const string &str, const string &toFind, int i) { 24 | if (str.empty() && !toFind.empty()) { 25 | return false; 26 | } 27 | 28 | if (str.size() <= i) { 29 | return false; 30 | } 31 | 32 | if (str[i] == toFind[0]) { 33 | int j = 0; 34 | while (i < str.size() && j < toFind.size() && str[i] == toFind[j]) { 35 | ++j; 36 | ++i; 37 | } 38 | if (j == toFind.size()) { 39 | return true; 40 | } 41 | } 42 | 43 | ++i; 44 | return isStringInsideRecursive(str, toFind, i); 45 | } 46 | 47 | int main() { 48 | string str = "dfghjkl;lkjhgfdfghjkl"; 49 | string toFind = "fgh9"; 50 | 51 | cout << isStringInsideRecursive(str, toFind, 0) << endl; 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /resources/solutions/multidimensional_arrays/task14.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define N 5 5 | void nulify(bool arr[N][N], const int row, const int col) { 6 | std::vector> cells = {{row, col}}; 7 | 8 | while (!cells.empty()) { 9 | // xy[0] - row 10 | // xy[1] - col 11 | std::vector xy = cells[0]; 12 | cells.erase(cells.begin()); 13 | 14 | if (arr[xy[0]][xy[1]] == 0) { 15 | continue; 16 | } 17 | 18 | arr[xy[0]][xy[1]] = 0; 19 | if (xy[0] > 0) { 20 | cells.push_back({xy[0] - 1, xy[1]}); 21 | } 22 | 23 | if (xy[1] > 0) { 24 | cells.push_back({xy[0], xy[1] - 1}); 25 | } 26 | 27 | if (xy[0] < N - 1) { 28 | cells.push_back({xy[0] + 1, xy[1]}); 29 | } 30 | 31 | if (xy[1] < N - 1) { 32 | cells.push_back({xy[0], xy[1] + 1}); 33 | } 34 | } 35 | } 36 | 37 | int main() { 38 | bool arr[N][N] = { 39 | {1, 1, 0, 0, 1}, {1, 0, 0, 0, 1}, {1, 1, 1, 0, 1}, 40 | {0, 0, 0, 0, 1}, {1, 1, 0, 0, 1}, 41 | }; 42 | 43 | int counter = 0; 44 | for (int i = 0; i < N; i++) { 45 | for (int j = 0; j < N; j++) { 46 | if (arr[i][j] == 1) { 47 | counter++; 48 | nulify(arr, i, j); 49 | } 50 | } 51 | } 52 | 53 | std::cout << counter << '\n'; 54 | return 0; 55 | } 56 | -------------------------------------------------------------------------------- /resources/tasks/boolean_expressions.md: -------------------------------------------------------------------------------- 1 | # Булеви изрази 2 | 3 | 1. **Задача** Нека са дадени числата a и b. Да се напише булев израз, който има стойност истина, ако а е по-малко от b. 4 | 5 | --- 6 | 7 |
8 | 9 | 2. **Задача** Нека е дадено естествено число а. Да се напише булев израз, който има стойност истина, ако а се дели на 2. 10 | 11 | --- 12 | 13 |
14 | 15 | 3. **Задача** Нека са дадени две естествени числа a и b. Да се напише булев израз, който има стойност истина, ако а дели b без остатък. 16 | 17 | --- 18 | 19 |
20 | 21 | 4. **Задача** Нека са дадени две естествени числа a и b. Да се напише булев израз, който има стойност истина, ако a повдигнато на квадрат дава b. 22 | 23 | --- 24 | 25 |
26 | 27 | 5. **Задача** Нека са дадени три естествени числа a, b и c. Да се напише булев израз, който проверява дали дали a и b са сравними относно c. (a и b се наричат делими по модул ако имат равни остатъци при делене с c) 28 | 29 | --- 30 | 31 |
32 | 33 | 6. **Задача** Да се напише булев израз, който приема естествено число - година и има стойност истина, ако годината е високосна. Упътване: Една година е високосна, ако се дели на 4 и не се дели на 100 или ако се дели на 400. 34 | 35 | --- 36 | 37 |
38 | 39 | 7. **Задача** Нека са дадени положителните естествени числа a, b и c. Да се напише булев израз, който има стойност истина, ако квадратното уравнение ax2 + bx + c = 0 има два реални, различни корена. 40 | -------------------------------------------------------------------------------- /resources/solutions/archives/homeworks/2020/3/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define letters 26 4 | 5 | struct trie { 6 | trie *children[letters] = {}; 7 | }; 8 | 9 | void put(trie *solution, const std::string &input, int &counter) { 10 | if (input.size() == 0) { 11 | return; 12 | } 13 | 14 | int first_letter_id = input[0] - 'a'; 15 | if (solution->children[first_letter_id] == nullptr) { 16 | counter++; 17 | solution->children[first_letter_id] = new trie; 18 | } 19 | 20 | std::string tmp = input; 21 | tmp.erase(tmp.begin()); 22 | put(solution->children[first_letter_id], tmp, counter); 23 | } 24 | 25 | void free(trie *solution) { 26 | for (int i = 0; i < letters; i++) { 27 | if (solution->children[i] != nullptr) { 28 | free(solution->children[i]); 29 | delete solution->children[i]; 30 | } 31 | } 32 | } 33 | 34 | void split(trie *const solution, const std::string &input, int &counter) { 35 | put(solution, input, counter); 36 | for (int i = 0; i < input.size(); i++) { 37 | std::string tmp = input; 38 | tmp.erase(tmp.begin() + i); 39 | split(solution, tmp, counter); 40 | } 41 | } 42 | 43 | int main() { 44 | int counter = 0; 45 | trie *solution = new trie; 46 | std::string input; 47 | std::cin >> input; 48 | 49 | split(solution, input, counter); 50 | free(solution); 51 | 52 | std::cout << counter << "\n"; 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /resources/solutions/files/task01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int squaredDigitsSum(int n) { 5 | int r = 0, sum = 0; 6 | 7 | while (n > 0) { 8 | r = n % 10; 9 | sum = sum + (r * r); 10 | n = n / 10; 11 | } 12 | 13 | return sum; 14 | } 15 | 16 | bool isHappy(int num) { 17 | int new_n = num; 18 | 19 | while (new_n != 1 && new_n != 4) { 20 | new_n = squaredDigitsSum(new_n); 21 | } 22 | 23 | if (new_n == 1) { 24 | return true; 25 | } 26 | 27 | return false; 28 | } 29 | 30 | bool isPrime(int num) { 31 | // 0 and 1 are not prime numbers 32 | if (num == 0 || num == 1) { 33 | return false; 34 | } else { 35 | for (int i = 2; i <= num / 2; ++i) { 36 | if (num % i == 0) { 37 | return false; 38 | } 39 | } 40 | } 41 | 42 | return true; 43 | } 44 | 45 | int main() { 46 | std::fstream chisla("chisla.txt", std::fstream::in), 47 | primes("primes.txt", std::fstream::out), 48 | happies("happies.txt", std::fstream::out); 49 | 50 | if (!chisla.is_open() || !primes.is_open() || !happies.is_open()) { 51 | return 1; 52 | } 53 | 54 | int chislo; 55 | while (chisla >> chislo) { 56 | if (isPrime(chislo)) { 57 | primes << chislo << '\n'; 58 | } 59 | if (isHappy(chislo)) { 60 | happies << chislo << '\n'; 61 | } 62 | } 63 | 64 | return 0; 65 | } 66 | -------------------------------------------------------------------------------- /resources/solutions/files/task11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | const int MAX_BUFFER_SIZE = 1024; 6 | 7 | int main() { 8 | char filePath[MAX_BUFFER_SIZE]; 9 | 10 | std::cin >> filePath; 11 | 12 | std::ifstream file(filePath); 13 | 14 | if (!file.is_open()) { 15 | std::cout << "ERROR OPENING FILE\n"; 16 | return 1; 17 | } 18 | 19 | bool areSet = false; 20 | size_t smallestRowIndex, smallestRowSize, biggestRowIndex, biggestRowSize; 21 | 22 | char buffer[MAX_BUFFER_SIZE]; 23 | 24 | for (int i = 1; file.getline(buffer, MAX_BUFFER_SIZE); ++i) { 25 | size_t size = std::strlen(buffer); 26 | 27 | if (!areSet) { 28 | smallestRowIndex = i; 29 | smallestRowSize = size; 30 | biggestRowIndex = i; 31 | biggestRowSize = size; 32 | areSet = true; 33 | } 34 | 35 | if (size < smallestRowSize) { 36 | smallestRowIndex = i; 37 | smallestRowSize = size; 38 | } 39 | 40 | if (size > biggestRowSize) { 41 | biggestRowIndex = i; 42 | biggestRowSize = size; 43 | } 44 | } 45 | 46 | if (areSet) { 47 | std::cout << "Smallest row index/size: " << smallestRowIndex << '/' 48 | << smallestRowSize << '\n'; 49 | std::cout << "Biggest row index/size: " << biggestRowIndex << '/' 50 | << biggestRowSize << '\n'; 51 | } 52 | 53 | file.close(); 54 | } 55 | -------------------------------------------------------------------------------- /resources/tasks/numeral_systems.md: -------------------------------------------------------------------------------- 1 | # Бройни системи 2 | 3 | **Бройната система** представлява символен метод за представяне на числата посредством ограничен брой символи, наречени цифри. Съществуват два вида бройни системи – непозиционни и позиционни. 4 | 5 | Таблица с основните превръщания: 6 | 7 | **Decimal**|**Binary**|**Octal**|**Hexadecimal** 8 | -----|-----|-----|----- 9 | 0|0000|0|0 10 | 1|0001|1|1 11 | 2|0010|2|2 12 | 3|0011|3|3 13 | 4|0100|4|4 14 | 5|0101|5|5 15 | 6|0110|6|6 16 | 7|0111|7|7 17 | 8|1000|10|8 18 | 9|1001|11|9 19 | 10|1010|12|A 20 | 11|1011|13|B 21 | 12|1100|14|C 22 | 13|1101|15|D 23 | 14|1110|16|E 24 | 15|1111|17|F 25 | 26 | ## Задачи 27 | 28 | 1. **Задача** Превърнете в двоична бройна система: 29 | 30 | - 10(10); 31 | - 132(10); 32 | - 1010(10); 33 | - AF1(16); 34 | - 21(16); 35 | - 17(8). 36 | 37 | --- 38 | 39 |
40 | 41 | 2. **Задача** Превърнете в шестнадесетична бройна система: 42 | - 10(10); 43 | - 132(10); 44 | - 1010(10); 45 | - 1101(2); 46 | - 11010001(2); 47 | - 1010101110(2); 48 | - 71(8). 49 | 50 | --- 51 | 52 |
53 | 54 | 3. **Задача** Колко най-малко бита са необходими, за да се представят в двоичен вид числата: 55 | - 10(10); 56 | - -132(10); 57 | - -1010(10); 58 | - 65(10); 59 | - -65(10); 60 | - -1024(10); 61 | -------------------------------------------------------------------------------- /resources/tasks/archives/example_theoretical_problems.md: -------------------------------------------------------------------------------- 1 | # Примерни задачи за теоретично контролно 2 | 3 | 1. **Задача**. Опишете последователно какво ще изведе на екрана следният програмен фрагмент. Обосновете отговора си. 4 | 5 | ```cpp 6 | for (int i = 9; i<=23; cout << i << endl) i++; 7 | ``` 8 | 9 | --- 10 | 11 |
12 | 13 | 2. **Задача**. Преобразувайте от двоична в шестнадесетична бройна система следното число: 110100101. Опишете как сте направили преобразуванието. 14 | 15 | --- 16 | 17 |
18 | 19 | 3. **Задача**. Напишете как ще дефинирате целочислена константа с име MAX_VALUE и стойност 67 (в шестнайсетична бройна система). 20 | 21 | --- 22 | 23 |
24 | 25 | 4. **Задача**. Колко най-малко бита са необходими, за да се представи в двоичен вид числото -65 (минус шестдесет и пет). Обосновете отговора си. 26 | 27 | --- 28 | 29 |
30 | 31 | 5. **Задача**. Ще се компилира ли следният програмен фрагмент: 32 | 33 | ```cpp 34 | int num1 = 5; 35 | int num2 = 13; 36 | num2 ++ = ++ num1 + 12; 37 | ``` 38 | Обяснете защо мислите така. В случай че компилацията е възможна, каква стойност ще има променливата num2 след изпълнението му? 39 | 40 | --- 41 | 42 |
43 | 44 | 6. **Задача**. Напишете еквивалентен код на следния програмен фрагмент, като използвате оператор switch (и не използвате if): 45 | ```cpp 46 | int a; 47 | if (a == 1) 48 | cout << “one”; 49 | if (a != 3) 50 | cout << “13”; 51 | else if ( a > 3) 52 | cout << “big”; 53 | else 54 | cout << “error”; 55 | ``` 56 | -------------------------------------------------------------------------------- /resources/solutions/structs/task12.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct Point { 5 | float x, y; 6 | }; 7 | 8 | struct Circle { 9 | Point center; 10 | float r; 11 | }; 12 | 13 | enum RelativePosition { NO_COMMON_POINTS, TOUCHING, INTERSECTING, SAME }; 14 | 15 | double get_distance(const Circle &A, const Circle &B) { 16 | double x_diff = A.center.x - B.center.x; 17 | double y_diff = A.center.y - B.center.y; 18 | return sqrt(x_diff * x_diff + y_diff * y_diff); 19 | } 20 | 21 | RelativePosition findRelativePosition(const Circle &A, const Circle &B) { 22 | double distance = get_distance(A, B); 23 | double rs = A.r + B.r; 24 | if (distance == 0) { 25 | // Same circles 26 | if (A.r == B.r) { 27 | return SAME; 28 | } 29 | // Little circle inside a bigger one with same center 30 | return NO_COMMON_POINTS; 31 | } 32 | 33 | // Little circle inside a bigger one with different centers 34 | if (distance < abs(A.r - B.r)) { 35 | return NO_COMMON_POINTS; 36 | } 37 | 38 | // Two separate circles 39 | if (distance > rs) { 40 | return NO_COMMON_POINTS; 41 | } 42 | 43 | // Touching from the outside 44 | if (distance == rs) { 45 | return TOUCHING; 46 | } 47 | 48 | // Touching from the inside 49 | if (distance == abs(A.r - B.r)) { 50 | return TOUCHING; 51 | } 52 | 53 | return INTERSECTING; 54 | } 55 | 56 | int main() { 57 | Circle first = {0, 0, 2}, second = {0, 1, 1}; 58 | std::cout << findRelativePosition(first, second) << '\n'; 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task14.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void print_matrix(int **mat, size_t rows, size_t cols) { 4 | for (size_t row = 0; row < rows; row++) { 5 | for (size_t col = 0; col < cols; col++) { 6 | std::cout << mat[row][col] << '\t'; 7 | } 8 | std::cout << '\n'; 9 | } 10 | } 11 | 12 | // returns true if row1 <= row2 13 | bool are_these_rows_sorted(int *row1, int *row2, size_t cols) { 14 | int index = 0; 15 | 16 | while (index < cols && row1[index] == row2[index]) { 17 | ++index; 18 | } 19 | 20 | if (index == cols) { 21 | return true; 22 | } 23 | 24 | return row1[index] < row2[index]; 25 | } 26 | 27 | void swap_rows(int *&row1, int *&row2) { 28 | int *temp = row1; 29 | row1 = row2; 30 | row2 = temp; 31 | } 32 | 33 | int main() { 34 | size_t rows, cols; 35 | std::cin >> rows >> cols; 36 | 37 | int **mat = new int *[rows]; 38 | for (size_t row = 0; row < rows; row++) { 39 | mat[row] = new int[cols]; 40 | for (size_t col = 0; col < cols; col++) { 41 | std::cin >> mat[row][col]; 42 | } 43 | } 44 | 45 | for (size_t iter = 0; iter < rows; iter++) { 46 | for (size_t row = 0; row < rows - 1; row++) { 47 | if (!are_these_rows_sorted(mat[row], mat[row + 1], cols)) { 48 | swap_rows(mat[row], mat[row + 1]); 49 | } 50 | } 51 | } 52 | 53 | print_matrix(mat, rows, cols); 54 | 55 | for (size_t row = 0; row < rows; row++) { 56 | delete[] mat[row]; 57 | } 58 | delete[] mat; 59 | 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /resources/solutions/conditional_operators/task04.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | // Credits Georgi 5 | int a, b, c, tmp = 0; 6 | std::cin >> a >> b >> c; // 0 1 3 7 | 8 | if (a > b) { 9 | tmp = a; 10 | a = b; 11 | b = tmp; 12 | } 13 | 14 | if (a > c) { 15 | tmp = a; 16 | a = c; 17 | c = tmp; 18 | } 19 | 20 | if (b > c) { 21 | tmp = b; 22 | b = c; 23 | c = tmp; 24 | } 25 | std::cout << a << ' ' << b << ' ' << c << '\n'; 26 | 27 | /* Aleternative solution 28 | * Credits: Mapmo 29 | 30 | int a,b,c; 31 | std::cin >> a >> b >> c; 32 | 33 | if (a < b) { 34 | if (a < c) { 35 | std::cout << a << ' '; 36 | if (b < c) { 37 | std::cout << b << ' ' << c << '\n'; 38 | } 39 | else { 40 | std::cout << c << ' ' << b << '\n'; 41 | } 42 | } 43 | else { 44 | std::cout << c << ' ' << a << ' ' << b << '\n'; 45 | } 46 | } 47 | else { 48 | if (b < c) { 49 | std::cout << b << ' '; 50 | if (a < c) { 51 | std::cout << a << ' ' << c << '\n'; 52 | } 53 | else { 54 | std::cout << c << ' ' << a << '\n'; 55 | } 56 | } 57 | else { 58 | std::cout << c << ' ' << b << ' ' << a << '\n'; 59 | } 60 | } 61 | */ 62 | return 0; 63 | } 64 | -------------------------------------------------------------------------------- /resources/solutions/boolean_expressions_answers.md: -------------------------------------------------------------------------------- 1 | # Булеви изрази 2 | 3 | 1. **Задача** Нека са дадени числата a и b. Да се напише булев израз, който има стойност истина, ако а е по-малко от b. 4 | 5 | **Решение**: `a < b` 6 | 7 |
8 | 9 | 2. **Задача** Нека е дадено естествено число а. Да се напише булев израз, който има стойност истина, ако а се дели на 2. 10 | 11 | **Решение**: `a % 2 == 0` 12 | 13 |
14 | 15 | 3. **Задача** Нека са дадени две естествени числа a и b. Да се напише булев израз, който има стойност истина, ако а дели b без остатък. 16 | 17 | **Решение**: `a % b == 0` 18 | 19 |
20 | 21 | 4. **Задача** Нека са дадени две естествени числа a и b. Да се напише булев израз, който има стойност истина, ако a повдигнато на квадрат дава b. 22 | 23 | **Решение**: `a * a == b` 24 | 25 |
26 | 27 | 5. **Задача** Нека са дадени три естествени числа a, b и c. Да се напише булев израз, който проверява дали дали a и b са сравними относно c. (a и b се наричат делими по модул ако имат равни остатъци при делене с c) 28 | 29 | **Решение**: `a % c == b % c` 30 | 31 |
32 | 33 | 6. **Задача** Да се напише булев израз, който приема естествено число - година и има стойност истина, ако годината е високосна. Упътване: Една година е високосна, ако се дели на 4 и не се дели на 100 или ако се дели на 400. 34 | 35 | **Решение**: `a % 4 == 0 && a % 100 != 0 && a % 400 == 0` 36 | 37 |
38 | 39 | 7. **Задача** Нека са дадени положителните естествени числа a, b и c. Да се напише булев израз, който има стойност истина, ако квадратното уравнение ax2 + bx + c = 0 има два реални, различни корена. 40 | 41 | **Решение**: Нека D2 = b2 - 4ac. Булевият израз е: D2 > 0 42 | 43 | 44 | -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task17.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int **init(const int rows, const int cols) { 4 | int **tmp = new int *[rows]; 5 | for (int i = 0; i < rows; i++) { 6 | tmp[i] = new int[cols]; 7 | for (int j = 0; j < cols; j++) { 8 | std::cin >> tmp[i][j]; 9 | } 10 | } 11 | return tmp; 12 | } 13 | 14 | void destroy(int **matrix, const int rows) { 15 | for (int i = 0; i < rows; i++) { 16 | delete[] matrix[i]; 17 | } 18 | delete[] matrix; 19 | } 20 | int **multiply(int **A, const int N, const int M, int **B, const int P, 21 | const int Q) { 22 | if (M != P) { 23 | return nullptr; 24 | } 25 | int **C = new int *[N]; 26 | for (int i = 0; i < N; i++) { 27 | C[i] = new int[Q]; 28 | for (int j = 0; j < Q; j++) { 29 | C[i][j] = 0; 30 | } 31 | } 32 | 33 | for (int i = 0; i < N; i++) { 34 | for (int j = 0; j < P; j++) { 35 | for (int k = 0; k < P; k++) { 36 | C[i][j] += A[i][k] * B[k][j]; 37 | } 38 | } 39 | } 40 | return C; 41 | } 42 | 43 | int main() { 44 | const int N = 2, M = 3, P = 3, Q = 3; 45 | 46 | int **A = init(N, M); 47 | int **B = init(P, Q); 48 | 49 | int **answer = multiply(A, N, M, B, P, Q); 50 | if (answer == nullptr) { 51 | std::cerr << "Invalid arguments\n"; 52 | return 0; 53 | } 54 | 55 | for (int i = 0; i < N; i++) { 56 | for (int j = 0; j < P; j++) { 57 | std::cout << answer[i][j] << ' '; 58 | } 59 | std::cout << '\n'; 60 | } 61 | 62 | destroy(A, N); 63 | destroy(B, P); 64 | destroy(answer, N); 65 | return 0; 66 | } 67 | -------------------------------------------------------------------------------- /resources/solutions/strings/task13.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | const int MAX_ROWS = 20; 7 | const int MAX_COLS = 30; 8 | const int MAX_TITLE_SIZE = 100 + 1; 9 | 10 | bool isLexOrder(char row[][MAX_TITLE_SIZE], int size) { 11 | for (int i = 0; i < size - 1; ++i) { 12 | if (strcmp(row[i], row[i + 1]) > 0) { 13 | return false; 14 | } 15 | } 16 | 17 | return true; 18 | } 19 | 20 | void printWordLengths(char str[]) { 21 | int counter = 0; 22 | 23 | for (int i = 0; str[i] != '\0'; ++i) { 24 | if (str[i] == ' ') { 25 | cout << counter << " "; 26 | counter = 0; 27 | } else { 28 | ++counter; 29 | } 30 | } 31 | 32 | cout << counter << " "; 33 | } 34 | 35 | void revealPassword(char library[][MAX_COLS][MAX_TITLE_SIZE], int rows, 36 | int columns) { 37 | for (int i = 0; i < rows; ++i) { 38 | if (isLexOrder(library[i], columns)) { 39 | if (columns % 2 == 0) { 40 | printWordLengths(library[i][columns / 2 - 1]); 41 | } else { 42 | printWordLengths(library[i][columns / 2]); 43 | } 44 | } 45 | } 46 | 47 | cout << endl; 48 | } 49 | 50 | int main() { 51 | char library[MAX_ROWS][MAX_COLS][MAX_TITLE_SIZE] = { 52 | {"Algebra", "Analytic Geometry", "Calculus"}, 53 | {"Databases", "Artificial Intelligence", "Functional Programming"}, 54 | {"Data Structures and Algorithms", "Introduction to Programming", 55 | "Object-oriented Programming"}}; 56 | 57 | int rows = 3; 58 | int columns = 3; 59 | 60 | revealPassword(library, rows, columns); 61 | 62 | return 0; 63 | } 64 | -------------------------------------------------------------------------------- /resources/solutions/dynamic_memory/task16_bonus.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int rows, cols; 5 | std::cin >> rows >> cols; 6 | 7 | int **mat = new int *[rows]; 8 | for (size_t i = 0; i < rows; i++) { 9 | mat[i] = new int[cols]; 10 | for (size_t j = 0; j < cols; j++) { 11 | std::cin >> mat[i][j]; 12 | } 13 | } 14 | 15 | int min_size = (rows < cols ? rows : cols); 16 | 17 | for (size_t iter = 0; iter < min_size / 2; iter++) { 18 | // Right 19 | for (size_t col = iter; col < cols - iter - 1; col++) { 20 | std::cout << mat[iter][col] << ' '; 21 | } 22 | 23 | // Down 24 | for (size_t row = iter; row < rows - iter - 1; row++) { 25 | std::cout << mat[row][cols - iter - 1] << ' '; 26 | } 27 | 28 | // Left 29 | for (size_t col = cols - iter - 1; col > iter; col--) { 30 | std::cout << mat[rows - iter - 1][col] << ' '; 31 | } 32 | 33 | // Up 34 | for (size_t row = rows - iter - 1; row > iter; row--) { 35 | std::cout << mat[row][iter] << ' '; 36 | } 37 | } 38 | 39 | // FIX for odd number of rows 40 | if (min_size % 2) { 41 | if (min_size == rows) { 42 | // Problematic row 43 | for (size_t col = min_size / 2; col <= cols - min_size / 2 - 1; 44 | ++col) { 45 | std::cout << mat[min_size / 2][col] << ' '; 46 | } 47 | } else { 48 | // Problematic col 49 | for (size_t row = min_size / 2; row <= rows - min_size / 2 - 1; 50 | ++row) { 51 | std::cout << mat[row][min_size / 2] << ' '; 52 | } 53 | } 54 | } 55 | 56 | for (size_t i = 0; i < rows; i++) { 57 | delete[] mat[i]; 58 | } 59 | delete[] mat; 60 | 61 | return 0; 62 | } 63 | -------------------------------------------------------------------------------- /resources/solutions/conditional_operators/task13.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | enum Months { Jan = 1, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec }; 4 | #define LOW 28 5 | #define HIGH 29 6 | #define SHORT 30 7 | #define LONG 31 8 | 9 | int main() { 10 | int day, month, year; 11 | 12 | std::cin >> day; 13 | std::cin >> month; 14 | std::cin >> year; 15 | 16 | if (day > LONG || month > Dec || year < 0) { 17 | std::cerr << "Invalid date\n"; 18 | return 1; 19 | } 20 | 21 | bool isFeb = month == Feb; 22 | bool isShort = 23 | (month == Apr || month == Jun || month == Sep || month == Nov); 24 | bool isLong = isFeb == isShort; 25 | 26 | if (day < LOW) { 27 | day++; 28 | } else if (day < SHORT && (isShort || isLong)) { 29 | day++; 30 | } else if (day < LONG && isLong) { 31 | day++; 32 | } else if (day == SHORT && isShort) { 33 | day = 1; 34 | month++; 35 | } else if (day == LONG && isLong) { 36 | day = 1; 37 | if (month == Dec) { 38 | month = Jan; 39 | year++; 40 | } else { 41 | month++; 42 | } 43 | } else if (month == Feb) { 44 | if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) { 45 | if (day == LOW) { 46 | day++; 47 | } else if (day == HIGH) { 48 | day = 1; 49 | month++; 50 | } else { 51 | std::cerr << "Invalid date\n"; 52 | return 1; 53 | } 54 | } else if (day == LOW) { 55 | day = 1; 56 | month++; 57 | } else { 58 | std::cerr << "Invalid date\n"; 59 | return 1; 60 | } 61 | } else { 62 | std::cerr << "Invalid date\n"; 63 | return 1; 64 | } 65 | std::cout << day << ' ' << month << ' ' << year << '\n'; 66 | 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /resources/tasks/bitwise_operators.md: -------------------------------------------------------------------------------- 1 | # Побитови операции 2 | 3 | 1. **Задача** Да се напише функция, която установява дали едно число е четно или нечетно. 4 | 5 | --- 6 | 7 |
8 | 9 | 2. **Задача** Да се напише програма, която приема число **n** и установява дали **m**-тия бит е 1. 10 | 11 | --- 12 | 13 |
14 | 15 | 3. **Задача** Да се напише програма, която приема две числа **n** и **m** и връща произведението на **n** * 2**m**. 16 | 17 | --- 18 | 19 |
20 | 21 | 4. **Задача** Да се напише програма, която приема число **n** и връща **-n** - 1. 22 | 23 | --- 24 | 25 |
26 | 27 | 5. **Задача** Да се напише програма, която има предварително избрано число **key** и приема число **value**, а след това генерира криптирана стойност на **value** - **crypt**, която се извежда на екрана. След това кара потребителя да въведе **key** и се опитва да декриптира **crypt** до оригиналното състояние - **value**. 28 | 29 | **Пример**:
30 | при **key** = 51223:
31 | 32 | ```text 33 | Enter value: 15 34 | Your crypt is: 51224 35 | Enter key to decrypt: 51223 36 | You value was: 15 37 | ``` 38 | --- 39 | 40 |
41 | 42 | Задачи за самостоятелна работа: 43 | - [Binary Digits](https://drive.google.com/file/d/0B0DgZGtV0C9HUHkwZmNsN3VjNDg/view?usp=sharing) 44 | - [Formula Bit 1](https://drive.google.com/file/d/0B0DgZGtV0C9HQlRKZEtlUzlWdUk/view?usp=sharing) 45 | - [Subset Sums](http://drive.google.com/open?id=0B0DgZGtV0C9HdmFHb3FRUmtfYlk) 46 | - [Dancing Bits](http://drive.google.com/open?id=0B0DgZGtV0C9HcjBLcWREckd4ZTg) 47 | - [Fall Down](http://drive.google.com/open?id=0B0DgZGtV0C9HVWNVZ2tXazBpQ28) 48 | - [We All Love Bits!](http://drive.google.com/open?id=0B0DgZGtV0C9HcTBNclVnVDJxRlU) 49 | - [Lines](http://drive.google.com/open?id=0B0DgZGtV0C9HLXZpSDVpTWZ0LUE) 50 | - [Odd Numbers](http://drive.google.com/open?id=0B0DgZGtV0C9HMFRsOS16bXlKS2s) 51 | - [Carpets](http://drive.google.com/open?id=0B0DgZGtV0C9HQnlURDdMRjRpLWs) 52 | - [Pillars](http://drive.google.com/open?id=0B0DgZGtV0C9HUkZwVlVMaE9qWWs) 53 | 54 | -------------------------------------------------------------------------------- /resources/solutions/numeral_systems_answers.md: -------------------------------------------------------------------------------- 1 | # Бройни системи 2 | 3 | **Бройната система** представлява символен метод за представяне на числата посредством ограничен брой символи, наречени цифри. Съществуват два вида бройни системи – непозиционни и позиционни. 4 | 5 | Таблица с основните превръщания: 6 | 7 | **Decimal**|**Binary**|**Octal**|**Hexadecimal** 8 | -----|-----|-----|----- 9 | 0|0000|0|0 10 | 1|0001|1|1 11 | 2|0010|2|2 12 | 3|0011|3|3 13 | 4|0100|4|4 14 | 5|0101|5|5 15 | 6|0110|6|6 16 | 7|0111|7|7 17 | 8|1000|10|8 18 | 9|1001|11|9 19 | 10|1010|12|A 20 | 11|1011|13|B 21 | 12|1100|14|C 22 | 13|1101|15|D 23 | 14|1110|16|E 24 | 15|1111|17|F 25 | 26 | ## Задачи 27 | 28 | 1. **Задача** Превърнете в двоична бройна система: 29 | 30 | - 10(10) = 1010(2); 31 | - 132(10) = 10000100(2); 32 | - 1010(10) = 1111110010(2); 33 | - AF1(16) = 101011110001(2); 34 | - 21(16) = 100001(2); 35 | - 17(8) = 001 001 111 = 1111(2). 36 | 37 | --- 38 | 39 |
40 | 41 | 2. **Задача** Превърнете в шестнадесетична бройна система: 42 | - 10(10) = A(16); 43 | - 132(10) = 84(16); 44 | - 1010(10) = 3F2(16); 45 | - 1101(2) = D(16); 46 | - 11010001(2) = D1(16); 47 | - 1010101110(2) = 2AE(16); 48 | - 71(8) = 39(16) (Първо преобразувате в десетична и после в шестнайсетична). 49 | 50 | --- 51 | 52 |
53 | 54 | 3. **Задача** Колко най-малко бита са необходими, за да се представят в двоичен вид числата: 55 | - 10(10) = 4 (24); 56 | - -132(10) = 9 (28 + 1); 57 | - -1010(10) = 11 (210 + 1); 58 | - 65(10) = 7 (27); 59 | - -65(10) = 8 (27 + 1); 60 | - -1024(10) = 12 (211 + 1, 1024 не е по-малко от 210); 61 | -------------------------------------------------------------------------------- /resources/tasks/archives/example_test_problems.md: -------------------------------------------------------------------------------- 1 | # Примерни задачи за второ контролно 2 | 3 | 1. **Задача**. Да се напише функция, която връща като резултат най-голямото число в предаден като параметър масив от естествени числа. Да се напише програма, която използва написаната функция, за да въведе от конзолата масив от цели числа и да изведе най-голямото от тях. 4 | 5 | --- 6 | 7 |
8 | 9 | 2. **Задача**. Да се напише функция, която по дадено число в интервала 0-86000, го интерпретира като брой секунди от началото на деня и връща като резултат часа във формат HH:MM. Да се напише програма, която използва написаната функция, за да въведе от конзолата цяло число, и по него да изчисли и изведе часа във формат HH:MM. 10 | 11 | --- 12 | 13 |
14 | 15 | 3. **Задача**. Да се напише функция на C++, която приема като параметър едномерен масив от дробни числа и връща като резултат сумата на елементите му с нечетни индекси. Функцията да не извиква други функции. Да се напише програма, която извиква написаната функция върху три масива от дробни числа (с едно число, с три числа и един избран от вас) и извежда на екрана резултатите за всеки от тях. 16 | 17 | --- 18 | 19 |
20 | 21 | 4. **Задача**. Да се напише void функция на C++, която приема като параметър цяло положително число и го преобразува в средното аритметично на цифрите му (закръглено надолу). Функцията да не извиква други функции. Да се напише програма, която извиква написаната функция върху три цели числа (едноцифрено, двуцифрено и избрано от вас) и извежда на екрана резултатите за всяко от тях. 22 | 23 | --- 24 | 25 |
26 | 27 | 5. **Задача**. Да се напише функция на C++, която приема като параметър едномерен масив от цели числа и връща като резултат сумата на четните числа в него. Да се напише програма, която извиква написаната функция върху три масива от цели числа (с едно число, с три числа и един избран от вас) и извежда на екрана резултатите за всеки от тях. 28 | 29 | --- 30 | 31 |
32 | 33 | 6. **Задача**. Да се напише функция на C++, която приема като параметър цяло положително число и връща като резултат сумата от цифрите му. Функцията да не извиква други функции. Да се напише програма, която извиква написаната функция върху три цели числа (едноцифрено, двуцифрено и избрано от вас) и извежда на екрана резултатите за всяко от тях. 34 | -------------------------------------------------------------------------------- /resources/tasks/built-in.md: -------------------------------------------------------------------------------- 1 | # Вградени функции 2 | 3 | 1. **Задача** Кубично уравнение от вида $x^3+px+q=0$, където $4p^3+27q^2 >0$, има един реален корен, който може да се намери с формулата на Кардано: 4 | 5 | $$x=\sqrt[3]{-\frac q2+\sqrt{\frac{q^2}4+\frac{p^3}{27}}} +\sqrt[3]{-\frac q2-\sqrt{\frac{q^2}4+\frac{p^3}{27}}}$$ 6 | 7 | Да се напише програма, която въвежда **p** и **q** и изчислява този корен. 8 | 9 | **Пример**:
10 | Вход: 11 | ```text 12 | 2 3 13 | ``` 14 | Изход: 15 | ```text 16 | -1 17 | ``` 18 | --- 19 | 20 |
21 | 22 | 2. **Задача** Внасяме **K** лева при сложна годишна лихва от **p** процента. Да се напише програма, която въвежда **K**, **p** и **n** и изчислява с каква сума ще разполагаме след **n** години. Формулата за сложна лихва е: 23 | 24 | $$K_n=K\bigg(1+\frac{p}{100} \bigg)^n$$ 25 | 26 | **Пример**:
27 | Вход: 28 | ```text 29 | 4000 4 8 30 | ``` 31 | Изход: 32 | ```text 33 | 5474.28 34 | ``` 35 | --- 36 | 37 |
38 | 39 | 3. **Задача** Да с напише програма, която въвежда положително число и изчислява най-малката степен на двойката, която е по-голяма от въведеното число. 40 | 41 | Примерно приложение на такъв алгоритъм е в компютърната графика, където понякога се налага размерът на една текстура да бъде степен на двойката. 42 | 43 | **Пример**:
44 | Вход: 45 | ```text 46 | 1234 47 | ``` 48 | Изход: 49 | ```text 50 | 2048 51 | ``` 52 | --- 53 | 54 | **[Решение](../solutions/built-in/task03.cpp)** 55 | 56 |
57 | 58 | 4. **Задача** Да се напише програма, която въвежда две неотрицателни числа и изчислява с колко [порядъка](https://en.wikipedia.org/wiki/Order_of_magnitude) се различават. 59 | 60 | **Пример**:
61 | Вход: 62 | ```text 63 | 100 50000 64 | ``` 65 | Изход: 66 | ```text 67 | 2 68 | ``` 69 | 70 | --- 71 | 72 | Вход: 73 | ```text 74 | 600000 800 75 | ``` 76 | Изход: 77 | ```text 78 | 3 79 | ``` 80 | --- 81 | 82 | **[Решение](../solutions/built-in/task04.cpp)** 83 | 84 |
85 | 86 | 5. **Задача** Да се напише програма, която извежда случайна буква (малка или главна) от латинската азбука. 87 | 88 | --- 89 | 90 | **[Решение](../solutions/built-in/task05.cpp)** 91 | -------------------------------------------------------------------------------- /resources/tasks/vector.md: -------------------------------------------------------------------------------- 1 | # Вектор 2 | 3 | 1. **Задача** Да се въведе вектор от **n** цели числа. Да се пресметне тяхното средно аритметично. 4 | 5 | --- 6 | 7 |
8 | 9 | 2. **Задача** Да се въведе число **n** и да се генерира случаен вектор от **n** елемента - цели числа. Да се създаде вектор, съдържащ индексите на всички елементи, които са по-големи от средното аритметично на елементите на случайния вектор. 10 | 11 | --- 12 | 13 |
14 | 15 | 3. **Задача** Да се въведе число **n**, да се въведе вектор от **n** елемента от тип string и буква. Да се изведат индексите на елементите на вектора, които започват с тази буква. 16 | 17 | --- 18 | 19 |
20 | 21 | 4. **Задача** Да се въведе число **n** и вектор от **n** елемента, които са естествени числа. Да се създаде и изведе втори вектор, съдържащ само числата, които се срещат поне 2 пъти в първия вектор. 22 | 23 | --- 24 | 25 | **[Решение (1)](../solutions/vector/task04.cpp)** 26 | 27 | **[Решение (2)](../solutions/vector/task04-2.cpp)** 28 | 29 |
30 | 31 | 5. **Задача** Да се въведе число **n** и вектор от **n** цели числа. Да се генерира случаен вектор също от **n** цели числа. Да се създаде и изведе вектор, съдържащ индексите на числата от първия вектор, които се по-големи от съответните числа във втория вектор. 32 | 33 | --- 34 | 35 |
36 | 37 | 6. **Задача** Да се въведат два вектора **a** и **b** с по **n** числа тип double. Да се създаде и изведе друг вектор с елементи, решения на уравнението aix+ bi = 0 (0 <= i < **n**). 38 | 39 | --- 40 | 41 |
42 | 43 | 7. **Задача** Да се въведе число **n** и да се генерира случаен вектор от **n** елемента, които са естествени числа. Да се създаде и изведе втори вектор, съдържащ само числата, които се срещат поне 2 пъти в първия вектор. 44 | 45 | --- 46 | 47 |
48 | 49 | 8. **Допълнителна задача** Да се напише програма, която въвежда координатите на n точки от равнината, намира всички двойки точки, през които може да се построи права успоредни на оста Оx в правоъгълна координатна система и извежда тези от тях, за които разстоянието между тях не надминава 10 мерни единици. 50 | 51 | **Пример**:
52 | Вход: 53 | ```cpp 54 | n=6 55 | P1{20, -3}, 56 | P2{6 , 4}, 57 | P3{1, 4}, 58 | P4{3, -6}, 59 | P5{-8, -3}, 60 | P6{3, 12} 61 | ``` 62 | Изход: 63 | ```cpp 64 | P2{6 , 4} 65 | P3{1, 4} 66 | ``` 67 | -------------------------------------------------------------------------------- /resources/tasks/char_type.md: -------------------------------------------------------------------------------- 1 | # Символен тип (char) 2 | 3 | 1. **Задача** Да се състави програма, която прочита от клавиатурата цяло число от 0 до 255 и извежда съответстващия му символ според ASCII таблицата. 4 | 5 | **Пример**:
6 | Вход: 7 | ```text 8 | 65 9 | ``` 10 | Изход: 11 | ```text 12 | А 13 | ``` 14 | --- 15 | 16 |
17 | 18 | 2. **Задача** Да се състави програма, която прочита от клавиатурата латинска буква голяма и извежда поредния й номер в латинската азбука. 19 | 20 | **Пример**:
21 | Вход: 22 | ```text 23 | A 24 | ``` 25 | Изход: 26 | ```text 27 | 1 28 | ``` 29 | --- 30 | 31 |
32 | 33 | 3. **Задача** Да се състави програма, която прочита от клавиатурата две латински букви и извежда сумата от съответните им ASCII-кодове. 34 | 35 | **Пример**:
36 | Вход: 37 | ```text 38 | A B 39 | ``` 40 | Изход: 41 | ```text 42 | 131 43 | ``` 44 | --- 45 | 46 |
47 | 48 | 4. **Задача** Да се състави програма, която прочита от клавиатурата голяма латинска буква и извежда голямата латинска буква, която е симетрично разположена спрямо въведената, по отношение на средата на латинската азбука. 49 | 50 | **Пример**:
51 | Вход: 52 | ```text 53 | X 54 | ``` 55 | Изход: 56 | ```text 57 | C 58 | ``` 59 | --- 60 | **[Решение](../solutions/char_type/task04.cpp)** 61 | 62 |
63 | 64 | 5. **Задача** Да се състави програма, която прочита от клавиатурата две цифри (**като знаци** от таблицата ASCII), преобразува ги в числа и извежда тяхното произведение. 65 | 66 | **Пример**:
67 | Вход: 68 | ```text 69 | 5 6 70 | ``` 71 | Изход: 72 | ```text 73 | 30 74 | ``` 75 | --- 76 | 77 |
78 | 79 | 6. **Задача** Да се състави програма, която прочита от клавиатурата два реда по три цифри (**като знаци** от таблицата ASCII), преобразува ги като числа и отпечатва тяхната сума. 80 | 81 | **Пример**:
82 | Вход: 83 | ```text 84 | 456 85 | 789 86 | ``` 87 | Изход: 88 | ```text 89 | 1245 90 | ``` 91 | --- 92 | 93 |
94 | 95 | Задачи за самостоятелна работа: 96 | - [Подарък](http://www.math.bas.bg/infos/files/2011-11-27-E3.pdf) ([автоматично оценяване](https://arena.maycamp.com/practice/open_contest?contest_id=86)) 97 | - [Щастлив номер](http://www.math.bas.bg/infos/files/2008-12-02-E3.pdf) 98 | - [Парола](http://www.math.bas.bg/infos/files/2016-12-17-E3.pdf) 99 | - [Торти](http://www.math.bas.bg/infos/files/2014-01-07-E2.pdf) ([автоматично оценяване](https://arena.maycamp.com/practice/open_contest?contest_id=113)) 100 | - [Щастлив билет](http://www.math.bas.bg/infos/files/2012-01-05-E2.pdf) ([автоматично оценяване](https://arena.maycamp.com/practice/open_contest?contest_id=89)) 101 | - [Климатик](http://www.math.bas.bg/infos/files/2014-01-07-E3.pdf) ([автоматично оценяване](https://arena.maycamp.com/practice/open_contest?contest_id=113)) 102 | -------------------------------------------------------------------------------- /resources/solutions/structs/task03.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | /* 6 | Задача За учениците в един клас се съхранява следната информация: пълно име, 7 | успех от I срок, успех от II срок. Напишете програма, която въвежда 8 | информация за учениците и: отпечатва името на ученика с най-слаб успех за 9 | първи срок; отпечатва първото име на ученика с най-висок среден успех за 10 | годината. 11 | */ 12 | 13 | const int semesters = 2; 14 | struct student { 15 | std::string name; 16 | double scores[semesters]; 17 | }; 18 | 19 | int main() { 20 | std::vector all_students; 21 | int students_count; 22 | 23 | std::cout << "How many students will be in the class?\n"; 24 | std::cin >> students_count; 25 | 26 | for (int i = 0; i < students_count; i++) { 27 | student tmp; 28 | std::cin >> tmp.name; 29 | for (int j = 0; j < semesters; j++) { 30 | std::cin >> tmp.scores[j]; 31 | } 32 | all_students.push_back(tmp); 33 | } 34 | 35 | for (int i = 0; i < all_students.size(); i++) { 36 | std::cout << "We have a student called " << all_students[i].name 37 | << " he has the following marks: "; 38 | for (int j = 0; j < semesters; j++) { 39 | std::cout << all_students[i].scores[j] << " "; 40 | } 41 | std::cout << "\n"; 42 | } 43 | 44 | double lowest = 7; 45 | std::vector names; 46 | for (int i = 0; i < all_students.size(); i++) { 47 | if (all_students[i].scores[0] < lowest) { 48 | lowest = all_students[i].scores[0]; 49 | names.clear(); 50 | names.push_back(all_students[i].name); 51 | } else if (all_students[i].scores[0] == lowest) { 52 | names.push_back(all_students[i].name); 53 | } 54 | } 55 | 56 | std::cout << "These are the poorest students with score " << lowest 57 | << ":\n"; 58 | for (int i = 0; i < names.size(); i++) { 59 | std::cout << names[i] << "\n"; 60 | } 61 | 62 | names.clear(); 63 | double highest_average = 1; 64 | for (int i = 0; i < all_students.size(); i++) { 65 | double student_average = 0.0; 66 | for (int j = 0; j < semesters; j++) { 67 | student_average += all_students[i].scores[j]; 68 | } 69 | student_average /= semesters; 70 | if (student_average > highest_average) { 71 | highest_average = student_average; 72 | names.clear(); 73 | names.push_back(all_students[i].name); 74 | } else if (student_average == highest_average) { 75 | names.push_back(all_students[i].name); 76 | } 77 | } 78 | 79 | std::cout << "These are the best students with average score " 80 | << highest_average << ":\n"; 81 | for (int i = 0; i < names.size(); i++) { 82 | std::cout << names[i] << "\n"; 83 | } 84 | 85 | return 0; 86 | } 87 | -------------------------------------------------------------------------------- /resources/tasks/archives/example_exam_problems.md: -------------------------------------------------------------------------------- 1 | # Примерни задачи за изпит 2 | 3 | 1. **Задача**. Да се напише функция на C++, която приема като параметър два едномерни сортирани целочислени масива с елементи от тип int и връща като резултат трети масив (който съдържа всички елементи на двата масива и само тях), който също е сортиран. 4 | 5 | Забележка: да не се използват библиотечни функции за сортиране на масиви. Предполага се, че входните масиви са сортирани преди да се извика написаната функция. 6 | 7 | --- 8 | 9 |
10 | 11 | 2. **Задача**. Да се напише функция на C++, която приема като параметри две отсечки в декартовата координатна система. За представянето на отсечка, използвайте създадена от вас структура (struct, запис). Функцията да върне дължината на общата им част, ако отсечките лежат на права, успоредна на една от координатните оси или -1 в противен случай. 12 | 13 | --- 14 | 15 |
16 | 17 | 3. **Задача**. Да се напише функция на С++, която отпечатва в конзолата запълнен правоъгълник с размерност **nxm**, където **n**, **m** и символът за отпечатване на правоъгълника се предават като параметри на функцията. Правоъгълникът да е центриран (приема се, че конзолата има 25 реда и 80 символа на ред). 18 | 19 | --- 20 | 21 |
22 | 23 | 4. **Задача**. Да се напише функция на С++, която приема като параметри цяло число **n** и двумерна числова квадратна матрица с размери **nxn** и връща като резултат сумата на елементите над главния ѝ диагонал. 24 | 25 | --- 26 | 27 |
28 | 29 | 5. **Задача**. Да се напише функция на С++, която приема като параметри параметри цяло число **n** и двумерна числова квадратна матрица **А** с размери **nxn** и връща като резултат транспонираната матрица на **А**. 30 | 31 | --- 32 | 33 |
34 | 35 | 6. **Задача**. Да се напише функция на C++, със сигнатура `double sqrt_a(double a, double eps)`, която намира корен квадратен с точност eps, по следната формула: 36 | 37 | $$x_{k+1} = \frac{1}{2}\bigg(x_k + \frac{a}{x_k}\bigg), \ k = 1, 2, 3 \dots , \ a = x_1$$ 38 | 39 | Изчисленията завършват, когато: 40 | 41 | $$|x_{k+1} -\ x_k| < eps$$ 42 | 43 | --- 44 | 45 |
46 | 47 | 7. **Задача**. Да се напише функция на С++, със сигнатура `void Revert(char[])`, която преобразува подадения като параметър символен низ, като замества всички малки букви от латинската азбука с главни и обратно. Да не се използва вградената библиотека string. 48 | 49 | --- 50 | 51 |
52 | 53 | 8. **Задача**. Да се напише функция на С++, със сигнатура `bool CheckDate(char[])`, която да проверява дали входния параметър е коректна дата във формат DD.MM. Да не се използва вградената библиотека string. 54 | 55 | --- 56 | 57 |
58 | 59 | 9. **Задача**. Да се напише функция на C++, със сигнатура `int DigitPos(long num, int k)`, която връща като резултат k-тата цифра на числото num или -1, ако такава не съществува. Брои се от ляво на дясно и се започва от 1. 60 | 61 | --- 62 | 63 |
64 | 65 | 10. **Задача**. Да се напише функция на C++, със сигнатура `bool doExist(char* symbols, char* word)`, която проверява дали думата word, се среща в символният низ symbols. Да не се използва вградената библиотека string. 66 | -------------------------------------------------------------------------------- /resources/tasks/pointers_and_references.md: -------------------------------------------------------------------------------- 1 | # Pointers and References 2 | 3 | 1. **Задача** Напишете програма, която създава променлива от тип int и референция към същата променлива, а после променя стойността на променливата, използвайки референцията. 4 | 5 | --- 6 | 7 | **[Решение](../solutions/pointers_and_references/task01.cpp)** 8 | 9 |
10 | 11 | 2. **Задача** Напишете програма, която въвежда две числа и отпечатва адресите на променливите, в които са съхранени. 12 | 13 | --- 14 | 15 | **[Решение](../solutions/pointers_and_references/task02.cpp)** 16 | 17 |
18 | 19 | 3. **Задача** Напишете функция, която разменя стойностите на две променливи. 20 | 21 | --- 22 | 23 | **[Решение](../solutions/pointers_and_references/task03.cpp)** 24 | 25 |
26 | 27 | 4. **Задача** Напишете функция, която разменя стойностите на две променливи (с пойнтeри). 28 | 29 | --- 30 | 31 | **[Решение](../solutions/pointers_and_references/task04.cpp)** 32 | 33 |
34 | 35 | 5. **Задача** Напишете програма, която въвежда масив от **N** числа и изведете адреса на най-голямото от тях. 36 | 37 | --- 38 | 39 | **[Решение](../solutions/pointers_and_references/task05.cpp)** 40 | 41 |
42 | 43 | 6. **Задача** Напишете програма, която извежда елементите на масив без оператора `[]`. 44 | 45 | --- 46 | 47 | **[Решение (1)](../solutions/pointers_and_references/task06.cpp)** 48 | 49 | **[Решение (2)](../solutions/pointers_and_references/task06_2.cpp)** 50 | 51 |
52 | 53 | 7. **Задача** Напишете функция, която проверява дали един указател сочи към даден адрес. 54 | 55 | --- 56 | 57 |
58 | 59 | 8. **Задача** Напишете функция, която приема два указателя и определя кой от тях има по-голяма стойност. 60 | 61 | --- 62 | 63 |
64 | 65 | 9. **Задача** Напишете функция, която приема референция към пойнтър и му променя стойността на `nullptr`. 66 | 67 | --- 68 | 69 |
70 | 71 | 10. **Задача** Напишете функция, която приема референция към пойнтер към `int` и принтира адреса на пойнтера, адреса в пойнтера и стойността на адреса в пойнтера. 72 | 73 | --- 74 | 75 |
76 | 77 | 11. **Задача** Напишете функция, която приема пойнтер към масив от `int` и връща `sizeof(arr)/sizeof(arr[0])`. Това размерът на масива ли е? Ако не - какво е? 78 | 79 | --- 80 | 81 |
82 | 83 | 12. **Задача** Напишете функция, която приема пойнтер към масив от `unsigned long long` и размера му и връща стойността на последния елемент без да се използва оператора `[]`. 84 | 85 | --- 86 | 87 |
88 | 89 | 13. **Задача** Напишете функция, която взима два пойнтера - единият към `int`, а другият към пойнтер към `int`, и казва дали вторият пойнтер сочи към първия. 90 | 91 | --- 92 | 93 |
94 | 95 | 14. **Задача** Напишете функция, която взима референция към `float` и връща стойността на цялото число, образувано от прочитането на същата памет, която ползва `float`-а, като `int`. 96 | 97 | --- 98 | 99 | **[Решение](../solutions/pointers_and_references/task14.cpp)** 100 | 101 |
102 | 103 | 15. **Задача** Напишете функция, която segfault-ва когато ѝ се подаде числото 5. 104 | -------------------------------------------------------------------------------- /resources/solutions/loops/task24.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int number; 5 | std::cin >> number; 6 | 7 | int length = 1; 8 | int temp_length = number; 9 | while (temp_length / 10 > 0) { 10 | temp_length /= 10; 11 | length++; 12 | } 13 | std::cout << length << "\n"; 14 | 15 | int first_digit = number; 16 | for (int i = 0; i < length - 1; i++) { 17 | first_digit /= 10; 18 | } 19 | int last_digit = number % 10; 20 | int sum = first_digit + last_digit; 21 | std::cout << sum << "\n"; 22 | 23 | int swapped_digits = last_digit; 24 | int ten_by_length = 1; 25 | for (int i = 0; i < length - 1; i++) { 26 | ten_by_length *= 10; 27 | } 28 | swapped_digits *= ten_by_length; 29 | swapped_digits += number % ten_by_length - last_digit + first_digit; 30 | std::cout << swapped_digits << "\n"; 31 | 32 | int product = 1; 33 | int temp_product = number; 34 | while (temp_product > 0) { 35 | product *= temp_product % 10; 36 | temp_product /= 10; 37 | } 38 | std::cout << product << "\n"; 39 | 40 | int reverse_digits = last_digit; 41 | int temp_reversed = number / 10; 42 | while (temp_reversed > 0) { 43 | reverse_digits *= 10; 44 | reverse_digits += temp_reversed % 10; // 432 45 | temp_reversed /= 10; 46 | } 47 | std::cout << reverse_digits << "\n"; 48 | 49 | std::cout << "The number is " << (number == reverse_digits ? "" : "not ") 50 | << "a palindrome\n"; 51 | 52 | int zero = 0, one = 0, two = 0, three = 0, four = 0, five = 0, six = 0, 53 | seven = 0, eight = 0, nine = 0; 54 | for (int i = 0; i < length; i++) { 55 | int last_digit = number % 10; 56 | switch (last_digit) { 57 | case 0: 58 | zero++; 59 | break; 60 | case 1: 61 | one++; 62 | break; 63 | case 2: 64 | two++; 65 | break; 66 | case 3: 67 | three++; 68 | break; 69 | case 4: 70 | four++; 71 | break; 72 | case 5: 73 | five++; 74 | break; 75 | case 6: 76 | six++; 77 | break; 78 | case 7: 79 | seven++; 80 | break; 81 | case 8: 82 | eight++; 83 | break; 84 | case 9: 85 | nine++; 86 | break; 87 | } 88 | number /= 10; 89 | } 90 | 91 | if (zero > 0) { 92 | std::cout << "0 - " << zero << "\n"; 93 | } 94 | if (one > 0) { 95 | std::cout << "1 - " << one << "\n"; 96 | } 97 | if (two > 0) { 98 | std::cout << "2 - " << two << "\n"; 99 | } 100 | if (three > 0) { 101 | std::cout << "3 - " << three << "\n"; 102 | } 103 | if (four > 0) { 104 | std::cout << "4 - " << four << "\n"; 105 | } 106 | if (five > 0) { 107 | std::cout << "5 - " << five << "\n"; 108 | } 109 | if (six > 0) { 110 | std::cout << "6 - " << six << "\n"; 111 | } 112 | if (seven > 0) { 113 | std::cout << "7 - " << seven << "\n"; 114 | } 115 | if (eight > 0) { 116 | std::cout << "8 - " << eight << "\n"; 117 | } 118 | if (nine > 0) { 119 | std::cout << "9 - " << nine << "\n"; 120 | } 121 | 122 | return 0; 123 | } 124 | -------------------------------------------------------------------------------- /resources/solutions/bonus/blackjack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | const int MIN_POINTS_FROM_CARD = 1; // 1 point from an ace 8 | const int MAX_POINTS_FROM_CARD = 10; // 2-10 points from 2-10 9 | const int FACE_CARDS = 3; // Jack, Queen, King 10 | 11 | const int MAX_POINTS = 21; 12 | const int COMPUTER_STOPS_AFTER = 18; 13 | 14 | int drawCard() { 15 | // Use `rand() % (max - min + 1) + min` to generate a number between `min` 16 | // and `max` Here, we want to generate 1-13 (ace, 2-10, or a face card) 17 | int card = 18 | MIN_POINTS_FROM_CARD + 19 | rand() % (MAX_POINTS_FROM_CARD - MIN_POINTS_FROM_CARD + 1 + FACE_CARDS); 20 | 21 | if (card > MAX_POINTS_FROM_CARD) { 22 | // Face cards are worth the max points (10) 23 | card = MAX_POINTS_FROM_CARD; 24 | } 25 | 26 | return card; 27 | } 28 | 29 | int main() { 30 | srand(time(0)); 31 | 32 | int firstCard = drawCard(); 33 | int secondCard = drawCard(); 34 | 35 | cout << "Your first card is " << firstCard << "." << endl; 36 | cout << "Your second card is " << secondCard << "." << endl; 37 | 38 | int playerPoints = firstCard + secondCard; 39 | int computerPoints = drawCard() + drawCard(); 40 | 41 | bool playerStillPlaying = true; 42 | bool computerStillPlaying = true; 43 | 44 | while (playerStillPlaying || computerStillPlaying) { 45 | if (playerStillPlaying) { 46 | cout << endl; 47 | 48 | cout << "You have " << playerPoints << " points." << endl; 49 | cout << "Hit or Stand (H / S)? "; 50 | 51 | char choice; 52 | cin >> choice; 53 | 54 | if (choice == 'H' || choice == 'h') { 55 | int card = drawCard(); 56 | cout << "You drew " << card << "." << endl; 57 | 58 | playerPoints += card; 59 | 60 | if (playerPoints > MAX_POINTS) { 61 | cout << endl; 62 | cout << "You broke " << MAX_POINTS << " points. You lose!" 63 | << endl; 64 | return 0; 65 | } 66 | } else { 67 | playerStillPlaying = false; 68 | } 69 | } 70 | 71 | if (computerStillPlaying) { 72 | cout << endl; 73 | 74 | if (computerPoints >= COMPUTER_STOPS_AFTER) { 75 | cout << "Dealer: I'll play with this hand." << endl; 76 | computerStillPlaying = false; 77 | } else { 78 | cout << "Dealer: I'll take another card." << endl; 79 | computerPoints += drawCard(); 80 | } 81 | } 82 | } 83 | 84 | cout << endl; 85 | 86 | cout << "Dealer: I have " << computerPoints << " points. "; 87 | 88 | if (computerPoints > MAX_POINTS) { 89 | cout << "I broke " << MAX_POINTS << ", so you win!" << endl; 90 | return 0; 91 | } 92 | 93 | cout << "You have " << playerPoints << ". "; 94 | 95 | if (computerPoints > playerPoints) { 96 | cout << "You lose." << endl; 97 | } else if (playerPoints > computerPoints) { 98 | cout << "You win!" << endl; 99 | } else { 100 | cout << "It's a tie!" << endl; 101 | } 102 | 103 | return 0; 104 | } 105 | -------------------------------------------------------------------------------- /resources/solutions/nested_loops/task10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void printTimesIfCorrect(int hoursTensStart, int hoursOnesStart, 4 | int minutesTensStart, int minutesOnesStart, 5 | int secondsTensStart, int secondsOnesStart, 6 | // int hoursTensFinal, // is a * 7 | int hoursOnesFinal, int minutesTensFinal, 8 | // int minutesOnesFinal, // is a * 9 | // int secondsTensFinal, // is a * 10 | int secondsOnesFinal, int hoursDelta, int minutesDelta, 11 | int secondsDelta) { 12 | int hoursTemp = hoursTensStart * 10 + hoursOnesStart; 13 | int minutesTemp = minutesTensStart * 10 + minutesOnesStart; 14 | int secondsTemp = secondsTensStart * 10 + secondsOnesStart; 15 | 16 | secondsTemp += secondsDelta; 17 | if (secondsTemp >= 60) { 18 | minutesTemp += secondsTemp / 60; 19 | secondsTemp %= 60; 20 | } 21 | 22 | minutesTemp += minutesDelta; 23 | if (minutesTemp >= 60) { 24 | hoursTemp += minutesTemp / 60; 25 | minutesTemp %= 60; 26 | } 27 | 28 | hoursTemp += hoursDelta; 29 | if (hoursTemp > 12) { 30 | hoursTemp %= 12; 31 | } 32 | 33 | bool hoursOnesMatch = hoursTemp % 10 == hoursOnesFinal, 34 | minutesTensMatch = minutesTemp / 10 == minutesTensFinal, 35 | secondsOnesMatch = secondsTemp % 10 == secondsOnesFinal; 36 | 37 | if (hoursOnesMatch && minutesTensMatch && secondsOnesMatch) { 38 | int hoursTensFinal = hoursTemp / 10, 39 | minutesOnesFinal = minutesTemp % 10, 40 | secondsTensFinal = secondsTemp / 10; 41 | 42 | std::cout << hoursTensStart << hoursOnesStart << ':' << minutesTensStart 43 | << minutesOnesStart << ':' << secondsTensStart 44 | << secondsOnesStart << ' ' << hoursTensFinal << hoursOnesFinal 45 | << ':' << minutesTensFinal << minutesOnesFinal << ':' 46 | << secondsTensFinal << secondsOnesFinal << '\n'; 47 | } 48 | } 49 | 50 | void solve(int hoursOnesStart, int minutesTensStart, int secondsOnesStart, 51 | int hoursOnesFinal, int minutesTensFinal, int secondsOnesFinal, 52 | int hoursDelta, int minutesDelta, int secondsDelta) { 53 | for (size_t hoursTensStart = 0; hoursTensStart <= 1; ++hoursTensStart) { 54 | for (size_t minutesOnesStart = 0; minutesOnesStart <= 9; 55 | ++minutesOnesStart) { 56 | for (size_t secondsTensStart = 0; secondsTensStart <= 5; 57 | secondsTensStart++) { 58 | printTimesIfCorrect( 59 | hoursTensStart, hoursOnesStart, minutesTensStart, 60 | minutesOnesStart, secondsTensStart, secondsOnesStart, 61 | hoursOnesFinal, minutesTensFinal, secondsOnesFinal, 62 | hoursDelta, minutesDelta, secondsDelta); 63 | } 64 | } 65 | } 66 | } 67 | 68 | int main() { 69 | 70 | // по-нататък ще учим как се вкарват сложни данни, затова сега ще ги 71 | // hardcode-нем в main-а 72 | 73 | int hoursOnesStart = 2, minutesTensStart = 5, secondsOnesStart = 6; 74 | int hoursOnesFinal = 1, minutesTensFinal = 0, secondsOnesFinal = 2; 75 | int hoursDelta = 10, minutesDelta = 19, secondsDelta = 26; 76 | 77 | solve(hoursOnesStart, minutesTensStart, secondsOnesStart, hoursOnesFinal, 78 | minutesTensFinal, secondsOnesFinal, hoursDelta, minutesDelta, 79 | secondsDelta); 80 | } 81 | -------------------------------------------------------------------------------- /resources/tasks/archives/exams/2019_exam_problems.md: -------------------------------------------------------------------------------- 1 | # Задачи от изпит - 2019/2020 2 | 3 | 1. **Задача**. Да се напише функция на C++, със сигнатура `int AnalyzeArray(int arr[], int l)`, където l е дължината на масива, която да връща 1, ако масивът може да бъде разделен на две части, с равни суми на елементите им и 0 – в противен случай. Функцията да връща -1, при невалидни входни данни. 4 | 5 | Например: 6 | 7 | `AnalyzeArray({1,3,0,0,4}, 5)` = 1;
8 | `AnalyzeArray({1,6,1,0,5,199}, 6)` = 0 9 | 10 | --- 11 | 12 |
13 | 14 | 2. **Задача**. Да се напише функция на С++, със сигнатура `int CheckStr(char[])`, която проверява, дали символите на входния масив, който трябва да е с дължина поне 2 символа, може да се пренаредят така, че той да стане палиндром. Функцията да връща -1, при невалидни входни данни. 15 | 16 | Например: 17 | 18 | `CheckStr("beblehl")` = 1 // „belhleb”
19 | `CheckStr("asdfgjk")` = 0;
20 | `CheckStr(NULL)` = -1 21 | 22 | --- 23 | 24 |
25 | 26 | 3. **Задача**. Да се напише функция на C++, със сигнатура `void ConvertNum(long &)`, която преобразува подаденото като параметър число в същото число, но прочетено наобратно. 27 | 28 | --- 29 | 30 |
31 | 32 | 4. **Задача**. Да се напише функция на С++, със сигнатура `int CheckTimeStr(char[])`, която да проверява дали входния параметър е коректнo изписан час във формат HH:MM:SS (HH - час е във формат 0-24, MM - минути, SS - секунди). Функцията да връща -1, при некоректни входни данни. 33 | 34 | --- 35 | 36 |
37 | 38 | 5. **Задача**. Да се напише функция на С++, със сигнатура `char * CheckStr(char [])`, която връща масив, който съдържа всички повтарящи се символи във входящия масив. 39 | 40 | Например: 41 | 42 | `CheckStr("aif8sltt8f")` = "f8t";
43 | `CheckStr("asdfgjk")` = ""; 44 | 45 | --- 46 | 47 |
48 | 49 | 6. **Задача**. Да се напише функция на C++, със сигнатура `int NumCalc(long num, int k, int l)`, която връща като резултат сумата на k-тата и l-тата цифри на num, или -1 при некоректни входни данни. 50 | 51 | --- 52 | 53 |
54 | 55 | 7. **Задача**. Да се напише функция на C++, със сигнатура `int AnalyzeArray(int arr[], int l)`, където l е дължината на масива, която да връща 1, ако масивът може да бъде разделен на две части, с равни суми на елементите им и 0 – в противен случай. Функцията да връща -1, при невалидни входни данни. 56 | 57 | Например: 58 | 59 | AnalyzeArray({1,3,0,0,4}) = 1;
60 | AnalyzeArray({1,6,1,0,5,199}) = 0 61 | 62 | --- 63 | 64 |
65 | 66 | 8. **Задача**. Да се напише функция на C++, със сигнатура `bool doExist(char* symbols, char* word)`, която проверява дали думата word, се среща в символният низ symbols, прочетен наобратно. 67 | 68 | --- 69 | 70 |
71 | 72 | 9. **Задача**. Да се напише функция на C++, със сигнатура `double calculateMatrix(int** matr, int m)`, която приема като параметър квадратна матрица с размерност m и връща като резултат сумата на елементите които са по двата ѝ диагонала. 73 | 74 | --- 75 | 76 |
77 | 78 | 10. **Задача**. Да се напише функция на C++, със сигнатура `char* GetWord(char str[])`, която връща като резултат най-дългата дума в масива str. За дума се счита всяка последователност от символи, която е отделена отляво и отдясно с един или няколко интервала и/или табулации, а също и началото и края на низа. 79 | 80 | --- 81 | 82 |
83 | 84 | 11. **Задача**. В даден масив от цели числа, фиксиран се нарича такъв елемент, стойността на който е равна на индекса му. Да се напише функция на С++, със със сигнатура `bool AnalyzeArr(int arr[], int length)`, която проверява дали в масива arr съществуват поне два фиксирани елемента. Функцията да връща false също и при некоректни входни данни. 85 | -------------------------------------------------------------------------------- /resources/tasks/bonus/blackjack.md: -------------------------------------------------------------------------------- 1 | # Блекджек 2 | 3 | Да се напише опростена версия на играта Блекджек. 4 | 5 | Играта да протече като "диалог" между крупието (компютъра) и потребителя. Двамата играчи събират точки на базата на картите, които изтеглят. Асото дава 1 точка, картите 2-10 дават съответно 2-10 точки, а валето, дамата и попът също дават 10 точки. Печели играчът, който стигне най-близо до 21 точки, без да ги превиши. 6 | 7 | Първо се раздават по две карти на двамата играчи. След това играчите се редуват в играта, като всеки може да изтегли колкото карти иска. На всеки ход играчите имат възможността да изтеглят още една карта (hit) или да спрат да теглят (stand). След като и двамата играчи са решили да спрат да теглят карти, печели този с повече точки. Ако обаче нечии точки надвишават 21, другият играч автоматично печели. Това условие се проверява в полза на компютъра: ако потребителят надвиши 21 точки, той губи веднага; ако пък компютърът надвиши 21, това се разбира чак след като потребителят спре да тегли карти. 8 | 9 | Компютърът спира да тегли карти след като стигне 18 точки. 10 | 11 | Напомняме: Хазартът е убил динозаврите. Играта да се използва само за учебни цели! 12 | 13 | [Решение](../../solutions/bonus/blackjack.cpp) 14 | 15 | Примерни игри: 16 | ``` 17 | Your first card is 1. 18 | Your second card is 7. 19 | 20 | You have 8 points. 21 | Hit or Stand (H / S)? H 22 | You drew 2. 23 | 24 | Dealer: I'll play with this hand. 25 | 26 | You have 10 points. 27 | Hit or Stand (H / S)? H 28 | You drew 10. 29 | 30 | You have 20 points. 31 | Hit or Stand (H / S)? S 32 | 33 | Dealer: I have 18 points. You have 20. You win! 34 | ``` 35 | 36 | --- 37 | 38 | ``` 39 | Your first card is 3. 40 | Your second card is 2. 41 | 42 | You have 5 points. 43 | Hit or Stand (H / S)? H 44 | You drew 10. 45 | 46 | Dealer: I'll take another card. 47 | 48 | You have 15 points. 49 | Hit or Stand (H / S)? H 50 | You drew 6. 51 | 52 | Dealer: I'll take another card. 53 | 54 | You have 21 points. 55 | Hit or Stand (H / S)? S 56 | 57 | Dealer: I'll play with this hand. 58 | 59 | Dealer: I have 21 points. You have 21. It's a tie! 60 | ``` 61 | 62 | --- 63 | 64 | ``` 65 | Your first card is 4. 66 | Your second card is 10. 67 | 68 | You have 14 points. 69 | Hit or Stand (H / S)? H 70 | You drew 10. 71 | 72 | You broke 21 points. You lose! 73 | ``` 74 | 75 | --- 76 | 77 | ``` 78 | Your first card is 3. 79 | Your second card is 10. 80 | 81 | You have 13 points. 82 | Hit or Stand (H / S)? H 83 | You drew 4. 84 | 85 | Dealer: I'll take another card. 86 | 87 | You have 17 points. 88 | Hit or Stand (H / S)? S 89 | 90 | Dealer: I'll take another card. 91 | 92 | Dealer: I'll take another card. 93 | 94 | Dealer: I'll play with this hand. 95 | 96 | Dealer: I have 20 points. You have 17. You lose. 97 | ``` 98 | 99 | --- 100 | 101 | ``` 102 | Your first card is 1. 103 | Your second card is 10. 104 | 105 | You have 11 points. 106 | Hit or Stand (H / S)? H 107 | You drew 8. 108 | 109 | Dealer: I'll take another card. 110 | 111 | You have 19 points. 112 | Hit or Stand (H / S)? S 113 | 114 | Dealer: I'll play with this hand. 115 | 116 | Dealer: I have 24 points. I broke 21, so you win! 117 | ``` 118 | 119 | --- 120 | 121 | ``` 122 | Your first card is 10. 123 | Your second card is 10. 124 | 125 | You have 20 points. 126 | Hit or Stand (H / S)? S 127 | 128 | Dealer: I'll take another card. 129 | 130 | Dealer: I'll take another card. 131 | 132 | Dealer: I'll take another card. 133 | 134 | Dealer: I'll take another card. 135 | 136 | Dealer: I'll take another card. 137 | 138 | Dealer: I'll play with this hand. 139 | 140 | Dealer: I have 24 points. I broke 21, so you win! 141 | ``` 142 | -------------------------------------------------------------------------------- /resources/tasks/archives/exams/2020_exam_problems_summer.md: -------------------------------------------------------------------------------- 1 | # Задачи от поправителен изпит - 2020/2021 2 | 3 | 1. **Задача**. Да се напише функция на С++, със сигнатура `int largestSeq(int[], int N)`, която връща сумата на най голямата поредица (без прекъсване) в целочислен масив с дължина N от четни числа. 4 | 5 | **Пример**: 6 | 7 | Вход: 8 | ```cpp 9 | arr = {2, 4, 3, 11, 12, 168, 144, 5, 9, 62, 98, 1}, N = 12 10 | ``` 11 | Изход: 12 | ```cpp 13 | 324 14 | ``` 15 | --- 16 | 17 |
18 | 19 | 2. **Задача**. Да се напише функция на С++, със сигнатура `int* numOfWords(char[])`, която за даден символен низ проверява броя на думите с четна и нечетна дължина (дума наричаме всяка последователност от символи, която е оградена от интервали или началото/края на низа) и връща масив с тези две числа. 20 | 21 | **Пример**: 22 | 23 | Вход: 24 | ```cpp 25 | " This is an example string " 26 | ``` 27 | Изход: 28 | ```cpp 29 | {34, 1} 30 | ``` 31 | --- 32 | 33 |
34 | 35 | 3. **Задача**. Да се напише функция на С++, със сигнатура `int* mergeArrays(int[], int[], int m)`, която за два масива с еднаква дължина m връща масив със сумите им, изчислени по следния начин: първи елемент (от първия масив) + последен елемент (от втория масив), втори елемент (от първия масив)+ предпоследн елемент (от втория масив), …, и т.н. 36 | 37 | **Пример**: 38 | 39 | Вход: 40 | ```cpp 41 | А = {1, 2, 3, 4}, В = {2, 5, 7, 11} 42 | ``` 43 | Изход: 44 | ```cpp 45 | { 12, 9, 8, 6 } 46 | ``` 47 | --- 48 | 49 |
50 | 51 | 4. **Задача**. Да се напише функция на С++, със сигнатура `void convertMax(int*, int N)`, която за подаден като параметър целочислен масив с дължина N, намира най големия му елемент (max). След това преобразува масива, като го обръща и добавя към всеки негов елемент стойността на max, освен на самия max. 52 | 53 | **Пример**: 54 | 55 | Вход: 56 | ```cpp 57 | arr = {11, 5, 2, 27, 4, 8, 2} 58 | ``` 59 | Изход: 60 | ```cpp 61 | arr = {29, 35, 31, 27, 29, 32, 38} 62 | ``` 63 | --- 64 | 65 |
66 | 67 | 5. **Задача**. Да се напише функция на С++, със сигнатура `int* cntWords(char[])`, която за подаден като параметър символен низ, връща масив, който съдържа като първи елемент броят на думите, които са изписани само с малки букви от латинската азбука, а като втори елемент - броят на думите, които са изписани само с главни букви от латинската азбука. (ASCII кодовете на A-Z => 65-90 и на a-z => 97-122 в ASCII) 68 | 69 | **Пример**: 70 | 71 | Вход: 72 | ```cpp 73 | " This IS an exAMple STRING F&OR this eXErcise. ” 74 | ``` 75 | Изход: 76 | ```cpp 77 | {2, 2} 78 | ``` 79 | --- 80 | 81 |
82 | 83 | 6. **Задача**. Да се напише функция на C++, със сигнатура `long convertNumber(char* num)`, която връща като резултат сумата от трите най-големи ASCII кода на елементите на символния низ num. 84 | 85 | --- 86 | 87 |
88 | 89 | 7. **Задача**. Да се напише функция на C++, със сигнатура `long convertNumber(char* num)`, която връща като резултат сумата от ASCII кодовете на цифрите на числото, представено с арабски цифри чрез символния низ num. Ако num не съдържа коректно число (т.е. има символи, които не принадлежат на множеството от арабски цифри от 0 до 9), функцията да връща -1. 90 | 91 | --- 92 | 93 |
94 | 95 | 8. **Задача**. Да се напише функция на C++, със сигнатура `double mySin(double x, long n)`, която изчислява тригонометричната функция sin(x) по следната зависимост: 96 | 97 | --- 98 | 99 |
100 | 101 | 9. **Задача**. Да се напише функция на С++, със сигнатура `char* Encode(char *)`, която преобразува подадения като параметър символен низ, като замества всички символи в него с ASCII кодовете им . За разделител между преобразуваните символи да се използва ‘_’. Функцията да връща като резултат преобразувания низ, а оригиналният низ, да остане непроменен. 102 | 103 | **Пример**: 104 | 105 | Вход: 106 | ```cpp 107 | " abc " 108 | ``` 109 | Изход: 110 | ```text 111 | 97_98_99 112 | ``` 113 | -------------------------------------------------------------------------------- /resources/tasks/double_type.md: -------------------------------------------------------------------------------- 1 | # Числа с плаваща запетая (`float` и `double`) 2 | 3 | 1. **Задача** Да се състави програма, която прочита две реални числа: `C` - температура в градуси Целзий (°C) и `F` - температура в градуси Фаренхайт (°F). Да се изведе дали двете температури са еднакви. 4 | 5 | Преобразуването от °F към °C става по следната формула: $°C=(°F-32)\times\dfrac{5}{9}$ 6 | 7 | **Пример**:
8 | Вход: 9 | ```text 10 | 37 98.6 11 | ``` 12 | Изход: 13 | ```text 14 | 1 15 | ``` 16 | Пояснение: 37 °C = 98.6 °F 17 | 18 | --- 19 | 20 | Вход: 21 | ```text 22 | 0 0 23 | ``` 24 | Изход: 25 | ```text 26 | 0 27 | ``` 28 | Пояснение: 0 °C = 32 °F ≠ 0 °F 29 | 30 | --- 31 | 32 | **[Решение](../solutions/double_type/task01.cpp)** 33 | 34 |
35 | 36 | 2. **Задача** Да се състави програма, която прочита реално число и извежда дали то е цяло. 37 | 38 | **Пример**:
39 | Вход: 40 | ```text 41 | -23 42 | ``` 43 | Изход: 44 | ```text 45 | 1 46 | ``` 47 | 48 | --- 49 | 50 | Вход: 51 | ```text 52 | 5.3 53 | ``` 54 | Изход: 55 | ```text 56 | 0 57 | ``` 58 | --- 59 | 60 | **[Решение](../solutions/double_type/task02.cpp)** 61 | 62 |
63 | 64 | 3. **Задача** Да се състави програма, която прочита реално число и извежда дали то е точен квадрат. 65 | 66 | **Пример**:
67 | Вход: 68 | ```text 69 | 15129 70 | ``` 71 | Изход: 72 | ```text 73 | 1 74 | ``` 75 | 76 | --- 77 | 78 | Вход: 79 | ```text 80 | 123 81 | ``` 82 | Изход: 83 | ```text 84 | 0 85 | ``` 86 | --- 87 | 88 | **[Решение](../solutions/double_type/task03.cpp)** 89 | 90 |
91 | 92 | 4. **Задача** Едно ябълково дърво дава 115 ябълки. В една кошница се побират 80 ябълки. Да се състави програма, която по даден брой дървета извежда колко кошници са необходими, за да се поберат всички ябълки. 93 | 94 | **Пример**:
95 | Вход: 96 | ```text 97 | 3 98 | ``` 99 | Изход: 100 | ```text 101 | 5 102 | ``` 103 | --- 104 | 105 | **[Решение](../solutions/double_type/task04.cpp)** 106 | 107 |
108 | 109 | 5. **Задача** Да се състави програма, която по дадено реално число $x$ извежда стойността на $\sin{x}$ по следната формула (`x` е в радиани): 110 | 111 | $$ \sin x \approx \frac{16x (\pi - x)}{5\pi^2 - 4x (\pi - x)} $$ 112 | 113 | **Пример**:
114 | Вход: 115 | ```text 116 | 0.523599 117 | ``` 118 | Изход (приблизителен): 119 | ```text 120 | 0.5 121 | ``` 122 | Пояснение: 0.523599 rad ≈ π/6 rad = 30° 123 | 124 | --- 125 | 126 | **[Решение](../solutions/double_type/task05.cpp)** 127 | 128 |
129 | 130 | 6. **Задача** Да се състави програма, която по дадено реално число $x$ извежда стойността на $\cos{x}$ по следната формула (`x` е в радиани): 131 | 132 | $$ \cos x \approx \frac{\pi^2 - 4 x^2}{\pi^2 + x^2} $$ 133 | 134 | **Пример**:
135 | Вход: 136 | ```text 137 | 1.047198 138 | ``` 139 | Изход (приблизителен): 140 | ```text 141 | 0.5 142 | ``` 143 | --- 144 | 145 | **[Решение](../solutions/double_type/task06.cpp)** 146 | 147 |
148 | 149 | 7. **Задача** Да се състави програма, която прочита две реални числа $r$ и $\varphi$, които са съответно модул и аргумент (в радиани) на комплексно число, представено в тригонометричен вид $z = r(\cos{\varphi}+i\sin{\varphi})$. Да се изведат реалната и имагинерната част $a$ и $b$ на комплексното число в алгебричен вид $z=a+bi$ с точност до третата цифра след десетичната запетая. 150 | 151 | **Пример**:
152 | Вход: 153 | ```text 154 | 3 0.523599 155 | ``` 156 | Изход (приблизителен): 157 | ```text 158 | a=2.598 b=1.5 159 | ``` 160 | Пояснение: $3(\cos(\dfrac{\pi}{6} + i\sin(\dfrac{\pi}{6})) = 3(\dfrac{\sqrt{3}}{2} + \dfrac{1}{2}i) = \dfrac{3\sqrt{3}}{2} + \dfrac{3}{2}i$ 161 | 162 | --- 163 | 164 | **[Решение](../solutions/double_type/task07.cpp)** 165 | -------------------------------------------------------------------------------- /resources/solutions/conditional_operators/task14.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //Напишете програма, която приема число n (-1000 <= n <= 1000), която изписва 4 | //стойността на n с думи. Помислете за някакъв pattern, който може да се 5 | //преизползва. 6 | 7 | int main() { 8 | int input; 9 | std::cin >> input; 10 | 11 | if (input < 0) { 12 | std::cout << "minus "; 13 | input *= -1; 14 | } 15 | 16 | if (input == 1000) { 17 | std::cout << "hilqda\n"; 18 | return 0; 19 | } 20 | 21 | if (input > 99) { 22 | const int hundreds = input / 100; 23 | input %= 100; 24 | switch (hundreds) { 25 | case 1: 26 | std::cout << "sto "; 27 | break; 28 | case 2: 29 | std::cout << "dvesta "; 30 | break; 31 | case 3: 32 | std::cout << "trista "; 33 | break; 34 | case 4: 35 | std::cout << "chetiristotin "; 36 | break; 37 | case 5: 38 | std::cout << "petstotin "; 39 | break; 40 | case 6: 41 | std::cout << "sheststotin "; 42 | break; 43 | case 7: 44 | std::cout << "sedemstotin "; 45 | break; 46 | case 8: 47 | std::cout << "osemstotin "; 48 | break; 49 | case 9: 50 | std::cout << "devetstotin "; 51 | break; 52 | } 53 | 54 | if (input == 0) { 55 | std::cout << "\n"; 56 | return 0; 57 | } 58 | 59 | if (input % 10 == 0 || input < 20) { 60 | std::cout << "i "; 61 | } 62 | } 63 | 64 | if (input > 19) { 65 | const int tens = input / 10; 66 | switch (tens) { 67 | case 2: 68 | std::cout << "dvaiset "; 69 | break; 70 | case 3: 71 | std::cout << "triiset "; 72 | break; 73 | case 4: 74 | std::cout << "chetireset "; 75 | break; 76 | case 5: 77 | std::cout << "petdeset "; 78 | break; 79 | case 6: 80 | std::cout << "sheiset "; 81 | break; 82 | case 7: 83 | std::cout << "sedemdeset "; 84 | break; 85 | case 8: 86 | std::cout << "osemdeset "; 87 | break; 88 | case 9: 89 | std::cout << "devetdeset "; 90 | break; 91 | } 92 | 93 | if (input % 10 > 0) { 94 | std::cout << "i "; 95 | input %= 10; 96 | } else { 97 | std::cout << "\n"; 98 | return 0; 99 | } 100 | } 101 | 102 | switch (input) { 103 | case 0: 104 | std::cout << "nula"; 105 | break; 106 | case 1: 107 | std::cout << "edno"; 108 | break; 109 | case 2: 110 | std::cout << "dve"; 111 | break; 112 | case 3: 113 | std::cout << "tri"; 114 | break; 115 | case 4: 116 | std::cout << "chetiri"; 117 | break; 118 | case 5: 119 | std::cout << "pet"; 120 | break; 121 | case 6: 122 | std::cout << "shest"; 123 | break; 124 | case 7: 125 | std::cout << "sedem"; 126 | break; 127 | case 8: 128 | std::cout << "osem"; 129 | break; 130 | case 9: 131 | std::cout << "devet"; 132 | break; 133 | case 10: 134 | std::cout << "deset"; 135 | break; 136 | case 11: 137 | std::cout << "edinaiset"; 138 | break; 139 | case 12: 140 | std::cout << "dvanaiset"; 141 | break; 142 | case 13: 143 | std::cout << "trinaiset"; 144 | break; 145 | case 14: 146 | std::cout << "chetirinaiset"; 147 | break; 148 | case 15: 149 | std::cout << "petnaiset"; 150 | break; 151 | case 16: 152 | std::cout << "shestnaiset"; 153 | break; 154 | case 17: 155 | std::cout << "sedemnaiset"; 156 | break; 157 | case 18: 158 | std::cout << "osemnaiset"; 159 | break; 160 | case 19: 161 | std::cout << "devetnaiset"; 162 | break; 163 | } 164 | 165 | std::cout << "\n"; 166 | return 0; 167 | } 168 | -------------------------------------------------------------------------------- /resources/tasks/pre_exam_test.md: -------------------------------------------------------------------------------- 1 | # Примерни задачи за трето контролно 2 | 3 | **[Решения на всички задачи](../solutions/pre_exam_test.cpp)** 4 | 5 | 1. **Задача** Да се напише функция `int Task1(const int arr[], const unsigned size)`, която връща сумата на елементите на `arr`. 6 | 7 | --- 8 | 9 |
10 | 11 | 2. **Задача** Да се напише функция `int Task2(const int arr[], const unsigned size)`, която връща сумата на четните елементи на `arr`. 12 | 13 | --- 14 | 15 |
16 | 17 | 3. **Задача** Да се напише функция `int Task3(const int arr[], const unsigned size)`, която връща най-големия елемент на `arr`. 18 | 19 | --- 20 | 21 |
22 | 23 | 4. **Задача** Да се напише функция `int Task4(const int arr[], const unsigned size)`, която връща най-големия нечетен елемент на `arr` или 0, ако няма нечетни елементи. 24 | 25 | --- 26 | 27 |
28 | 29 | 5. **Задача** Да се напише функция `int Task5(const int arr[], const unsigned size)`, която връща най-малкия четен елемент на `arr` или 1, ако няма четни елементи. 30 | 31 | --- 32 | 33 |
34 | 35 | 6. **Задача** Да се напише функция `int Task6(const int arr[], const unsigned size)`, която връща сумата на четните положителни елементи на `arr`. 36 | 37 | --- 38 | 39 |
40 | 41 | 7. **Задача** Да се напише функция `int Task7(const int arr[], const unsigned size)`, която връща най-големия елемент с четен индекс в `arr`. 42 | 43 | --- 44 | 45 |
46 | 47 | 8. **Задача** Да се напише функция `int Task8(const int arr[], const unsigned size)`, която връща сумата на елементите с нечетни индекси в `arr` или 0, ако има само един елемент. 48 | 49 | --- 50 | 51 |
52 | 53 | 9. **Задача** Да се напише функция `int Task9(const int arr[], const unsigned size)`, която връща сумата на първия и последния елемент на `arr`. 54 | 55 | --- 56 | 57 |
58 | 59 | 10. **Задача** Да се напише функция `bool Task10(const int arr[], const unsigned size)`, която проверява дали има два равни съседни елемента в `arr`. 60 | 61 | --- 62 | 63 |
64 | 65 | 11. **Задача** Да се напише функция `void Task11(int arr[], const unsigned size)`, която обръща знаците на всички елементи на `arr`. 66 | 67 | --- 68 | 69 |
70 | 71 | 12. **Задача** Да се напише функция `bool Task12(const int arr[], const unsigned size)`, която връща `true`, ако повечето елементи на `arr` са четни и `false` в противен случай. 72 | 73 | --- 74 | 75 |
76 | 77 | 13. **Задача** Да се напише функция `bool Task13(int arr[], const unsigned size)`, която проверява дали `arr` е сортиран във възходящ ред. 78 | 79 | --- 80 | 81 |
82 | 83 | 14. **Задача** Да се напише функция `bool Task14(int arr[], const unsigned size)`, която проверява дали `arr` е сортиран в низходящ ред. 84 | 85 | --- 86 | 87 |
88 | 89 | 15. **Задача** Да се напише функция `bool Task15(const int arr[], const unsigned size, const unsigned numb)`, която проверява дали `numb` се съдържа в `arr`. 90 | 91 | --- 92 | 93 |
94 | 95 | 16. **Задача** Да се напише функция `unsigned Task16(const char arr[])`, която имплементира `strlen`. 96 | 97 | --- 98 | 99 |
100 | 101 | 17. **Задача** Да се напише функция `void Task17(char arr[])`, която заменя всички символи `+` с `-` в `arr`. 102 | 103 | --- 104 | 105 |
106 | 107 | 18. **Задача** Да се напише функция `bool Task18(const char arr[])`, която проверява дали `arr` съдържа символите `U` и `P`. 108 | 109 | --- 110 | 111 |
112 | 113 | 19. **Задача** Да се напише функция `void Task19(char arr[])`, която преобразува буквите в `arr` в малки букви. 114 | 115 | --- 116 | 117 |
118 | 119 | 20. **Задача** Да се напише функция `void Task20(char arr[])`, която разменя малките и главните букви в `arr`. 120 | 121 | --- 122 | 123 |
124 | 125 | 21. **Задача** Да се напише функция `void Task21(const unsigned numb)`, която получава като аргумент брой секунди и ги принтира във формат `HH:MM`. 126 | 127 | --- 128 | 129 |
130 | 131 | 22. **Задача** Да се напише функция `double Task22(unsigned numb)`, която намира средноартиметичната стойност на цифрите в `numb`. 132 | 133 | Съвет: Делението на цели числа връща цяло число, дори и функцията да връща `double`. 134 | 135 | Съвет 2: Внимателно използвайте `log10`. 136 | -------------------------------------------------------------------------------- /resources/solutions/nested_loops/task09.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, m; 5 | std::cin >> n >> m; 6 | int width = 1 + (n - 1) * 2; 7 | for (int i = 0; i < width; i++) { 8 | std::cout << '+'; 9 | } 10 | std::cout << '\n'; 11 | if (m) { 12 | for (int i = 0; i < n; i++) { 13 | for (int j = i; j < n - 1; j++) { 14 | std::cout << '+'; 15 | } 16 | for (int j = 0; j < 1 + i * 2; j++) { 17 | std::cout << '#'; 18 | } 19 | for (int j = i; j < n - 1; j++) { 20 | std::cout << '+'; 21 | } 22 | std::cout << '\n'; 23 | } 24 | for (int i = 0; i < n - 1; i++) { 25 | for (int j = 0; j < n - 1; j++) { 26 | std::cout << '+'; 27 | } 28 | std::cout << '#'; 29 | for (int j = 0; j < n - 1; j++) { 30 | std::cout << '+'; 31 | } 32 | std::cout << '\n'; 33 | } 34 | } else { 35 | for (int i = 0; i < n - 1; i++) { 36 | for (int j = 0; j < n - 1; j++) { 37 | std::cout << '+'; 38 | } 39 | std::cout << '#'; 40 | for (int j = 0; j < n - 1; j++) { 41 | std::cout << '+'; 42 | } 43 | std::cout << '\n'; 44 | } 45 | for (int i = n - 1; i >= 0; i--) { 46 | for (int j = i; j < n - 1; j++) { 47 | std::cout << '+'; 48 | } 49 | for (int j = 0; j < 1 + i * 2; j++) { 50 | std::cout << '#'; 51 | } 52 | for (int j = i; j < n - 1; j++) { 53 | std::cout << '+'; 54 | } 55 | std::cout << '\n'; 56 | } 57 | } 58 | for (int i = 0; i < width; i++) { 59 | std::cout << '+'; 60 | } 61 | std::cout << '\n'; 62 | return 0; 63 | } 64 | 65 | /* 66 | Alternative solution: 67 | 68 | #include 69 | #include 70 | 71 | using namespace std; 72 | 73 | int main() { 74 | int n; 75 | bool m; 76 | cin >> n >> m; 77 | 78 | int base = 2*n - 1; 79 | 80 | for (int i = 1; i <= base; ++i) { 81 | cout << '+'; 82 | } 83 | cout << endl; 84 | 85 | if (m) { 86 | for (int i = 1; i <= n; ++i) { 87 | int numberOfSharps = 2*i - 1; 88 | int numberOfPluses = (base - numberOfSharps)/2; 89 | 90 | for (int j = 1; j <= numberOfPluses; ++j) { 91 | cout << '+'; 92 | } 93 | 94 | for (int j = 1; j <= numberOfSharps; ++j) { 95 | cout << '#'; 96 | } 97 | 98 | for (int j = 1; j <= numberOfPluses; ++j) { 99 | cout << '+'; 100 | } 101 | 102 | cout << endl; 103 | } 104 | 105 | for (int i = 1; i < n; ++i) { 106 | int numberOfPluses = (base - 1)/2; 107 | 108 | for (int j = 1; j <= numberOfPluses; ++j) { 109 | cout << '+'; 110 | } 111 | 112 | cout << '#'; 113 | 114 | for (int j = 1; j <= numberOfPluses; ++j) { 115 | cout << '+'; 116 | } 117 | 118 | cout << endl; 119 | } 120 | } else { 121 | for (int i = 1; i < n; ++i) { 122 | int numberOfPluses = (base - 1)/2; 123 | 124 | for (int j = 1; j <= numberOfPluses; ++j) { 125 | cout << '+'; 126 | } 127 | 128 | cout << '#'; 129 | 130 | for (int j = 1; j <= numberOfPluses; ++j) { 131 | cout << '+'; 132 | } 133 | 134 | cout << endl; 135 | } 136 | 137 | for (int i = n; i > 0; --i) { 138 | int numberOfSharps = 2 * i - 1; 139 | int numberOfPluses = (base - numberOfSharps) / 2; 140 | 141 | for (int j = 1; j <= numberOfPluses; ++j) { 142 | cout << '+'; 143 | } 144 | 145 | for (int j = 1; j <= numberOfSharps; ++j) { 146 | cout << '#'; 147 | } 148 | 149 | for (int j = 1; j <= numberOfPluses; ++j) { 150 | cout << '+'; 151 | } 152 | cout << endl; 153 | } 154 | 155 | } 156 | 157 | for (int i = 1; i <= base; ++i) { 158 | cout << '+'; 159 | } 160 | 161 | return 0; 162 | } 163 | */ 164 | -------------------------------------------------------------------------------- /resources/tasks/functions.md: -------------------------------------------------------------------------------- 1 | # Функции 2 | 3 | 1. **Задача** Да се състави функция `sum(const int a, const int b)`, която приема две числа и връща като резултат сбора им.
4 | 5 | **Пример**:
6 | Вход: 7 | ```text 8 | 5 6 9 | ``` 10 | Изход: 11 | ```text 12 | 11 13 | ``` 14 | --- 15 | 16 |
17 | 18 | 2. **Задача** Да се напише функция `isEven(const int num)`, която връща дали дадено число е четно или не. 19 | 20 | --- 21 | 22 | **[Решение](../solutions/functions/task02.cpp)** 23 | 24 |
25 | 26 | 3. **Задача** Да се напише функция `min(int a, int b)`, която връща по-малкото от двете числа a и b. 27 | 28 | --- 29 | 30 |
31 | 32 | 4. **Задача** Напишете функция `abs(const int num)`, която връща като резултат абсолютната стойност на числото num. 33 | 34 | --- 35 | 36 |
37 | 38 | 5. **Задача** Напишете функция `trunc(const double num)`, която извършва операцията truncate върху подаденото число num. (Премахва всички числа след десетичната запетая) 39 | 40 | --- 41 | 42 |
43 | 44 | 6. **Задача** Напишете функция `ascii(const char symbol)`, която връща като резултат ascii номера на параметъра symbol. 45 | 46 | --- 47 | 48 |
49 | 50 | 7. **Задача** Напишете функция `pow(const int num, const unsigned N)`, която връща като резултат числото num повдигнато на степен N, където N е строго положително 51 | 52 | --- 53 | 54 |
55 | 56 | 8. **Задача** Напишете функция `calculate(const int a, const int b, char action)`, където action може да бъде `[+-\*/%]`. Програмата да връща като резултат съответното действие, а ако не се укаже символ да върне сбора на числата 57 | 58 | --- 59 | 60 |
61 | 62 | 9. **Задача** Напишете функция, `askUser(const int from, const int to)`, която кара потребителя да въвежда числа докато не въведе число, което да е в указания интервал, а като резултат връща въпросното число. 63 | 64 | --- 65 | 66 | **[Решение](../solutions/functions/task09.cpp)** 67 | 68 |
69 | 70 | 10. **Задача** Напишете функция, която да получава `average(const int N, ...)`, която получава параметър N, който указва колко числа ще се подадат, а след това връща като средното на числата, които потребителят е подал след N. 71 | 72 | --- 73 | 74 | **[Решение](../solutions/functions/task10.cpp)** 75 | 76 |
77 | 78 | 11. **Задача** Да се състави програма, която по зададен интервал [**K**,**L**] (**K** и **L** цели положителни числа не по-големи от 100000) отпечатва всички числа в интервала [**K**,**L**], които имат две съседни еднакви цифри в записа си. 79 | 80 | **Пример**:
81 | Вход: 82 | ```text 83 | 60 120 84 | ``` 85 | Изход: 86 | ```text 87 | 66 77 88 99 100 110 111 112 113 114 115 116 117 118 119 88 | ``` 89 | --- 90 | 91 |
92 | 93 | 12. **Задача** Да се състави програма, която въвежда от клавиатурата три цели числа **m**, **n** и **k** и извежда всички числа в интервала [**m**,**n**] (0 < **m** < **n** <= 1000000), за които средното аритметично от цифрите е по-голямо или равно на **k** (0 < **k** < 10). 94 | 95 | **Пример**:
96 | Вход: 97 | ```text 98 | 10 50 6 99 | ``` 100 | Изход: 101 | ```text 102 | 39 48 49 103 | ``` 104 | --- 105 | 106 |
107 | 108 | 13. **Задача** Да се състави функция, която по дадено цяло число **n** и цифра **k** определя колко пъти в записа на числото се среща цифрата k. Като се използва тази функция да се състави програма, която чете от клавиатурата цифра **k** и последователност от цели числа до въвеждане на отрицателно число или 0 и отпечатва броя на тези от въведените числа, които имат цифрата **k** в записа си поне два пъти. 109 | 110 | **Пример**:
111 | Вход: 112 | ```text 113 | 7 77 25 29 777 177 24 3787 0 114 | ``` 115 | Изход: 116 | ```text 117 | 4 118 | ``` 119 | --- 120 | **[Решение](../solutions/functions/task13.cpp)** 121 | 122 |
123 | 124 | 14. **Задача** Дадена е редица от N на брой цели числа. Намерете НОД и НОК на всички числа. 125 | 126 | **Пример**
127 | Вход: 128 | ```text 129 | 5 130 | 32 4 16 6 50 131 | ``` 132 | Изход: 133 | ```text 134 | NOD: 2 135 | NOK: 2400 136 | ``` 137 | --- 138 | 139 |
140 | 141 | 15. **Задача** Дадена е матрица, съдържаща **N** реда и 3 колони. Да се напише функция, която отпечатва на екрана всички редове, числата от които могат да са страни на триъгълник. Да се използва помощна функция, проверяваща дали три числа са страни на триъгълник. 142 | 143 | *Въвеждането също да става с функция. 144 | 145 | **Пример**
146 | Вход: 147 | ```text 148 | 5 149 | 1 1 1 150 | 3 4 5 151 | 3 8 6 152 | -1 4 4 153 | 1 2 0 154 | ``` 155 | Изход: 156 | ```text 157 | 1 1 1 158 | 3 4 5 159 | 3 8 6 160 | ``` 161 | --- 162 | **[Решение](../solutions/functions/task15.cpp)** 163 | 164 |
165 | 166 | 16. **Задача** Да се състави функция, която по цяло число **n** определя дали в двоичното му представяне няма повтарящи се съседни битове. 167 | 168 | **Пример**
169 | Вход: 170 | ```text 171 | 85 172 | ``` 173 | Изход: 174 | ```text 175 | true 176 | ``` 177 | 178 | --- 179 | 180 | Вход: 181 | ```text 182 | 93 183 | ``` 184 | Изход: 185 | ```text 186 | false 187 | ``` 188 | --- 189 | Обяснение на примерите: 190 | ``` 191 | 85 → 1010101 192 | 93 → 1011101 193 | ``` 194 | -------------------------------------------------------------------------------- /resources/tasks/strings.md: -------------------------------------------------------------------------------- 1 | # String 2 | 3 | 1. **Задача** Да се напише програма, която установява дали даден низ е палиндром, т.е. четен отляво надясно и отдясно наляво е един и същ. 4 | 5 | --- 6 | 7 | **[Решение](../solutions/strings/task01.cpp)** 8 | 9 |
10 | 11 | 2. **Задача** Да се напише програма, която намира броя на срещанията на всеки символ от вида `!` , `?` , `,` в даден низ. 12 | 13 | --- 14 | 15 | **[Решение](../solutions/strings/task02.cpp)** 16 | 17 |
18 | 19 | 3. **Задача** Даден е низ. Да се напише програма, която намира броя на думите в низа. Дума е редица от символи. Разделител между думите е символът интервал. 20 | 21 | --- 22 | 23 | **[Решение](../solutions/strings/task03.cpp)** 24 | 25 |
26 | 27 | 4. **Задача** Даден е низ, образуван от главни латински букви. Да напише програма, която преобразува низа, но от съответните малките латински букви. 28 | 29 | --- 30 | 31 | **[Решение](../solutions/strings/task04.cpp)** 32 | 33 |
34 | 35 | 5. **Задача** Напишете програма, която въвежда два знакови низа S1 и S2 и като резултат отпечатва онези малки латински букви, които се съдържат в низа S1, но не се съдържат в низа S2. 36 | 37 | --- 38 | 39 |
40 | 41 | 6. **Задача** Даден е низ, образуван от главни латински букви. Да се напише програма, която установява дали буквите, участващи в низа са различни. 42 | 43 | --- 44 | 45 |
46 | 47 | 7. **Задача** Напишете подпрограма, определя колко пъти символният низ S2 се съдържа в S1. 48 | 49 | --- 50 | 51 |
52 | 53 | 8. **Задача** Да се напише програма, която установява дали броят на срещанията на думата 'begin' в даден низ е равен на броя на срещанията на думата 'end' в същия низ. 54 | 55 | --- 56 | **[Решение](../solutions/strings/task08.cpp)** 57 | 58 |
59 | 60 | 9. **Задача** Напишете програма, която въвежда знаков низ S и като резултат отпечатва онези малки латински букви, които не се съдържат в низа. 61 | 62 | --- 63 | 64 | **[Решение](../solutions/strings/task09.cpp)** 65 | 66 |
67 | 68 | 10. **Задача** Дадени са две цели числа, записани като знакови низове. Напишете програма, която определя кое от двете числа е по-голямо. 69 | 70 | --- 71 | **[Решение](../solutions/strings/task10.cpp)** 72 | 73 |
74 | 75 | 11. **Задача** Да се напише програма, която сортира във възходящ ред елементите на редица от числа във формата на низове. 76 | 77 | --- 78 | 79 |
80 | 81 | 12. **Задача** Напишете програма, която въвежда цяло число и извежда двоичния (шeстнадесетичният) му запис. 82 | 83 | --- 84 | 85 |
86 | 87 | 13. **Задача** Професор Х крие парола. На всеки ред от библиотеката му са подредени книги, най-много 20 реда книги, с до 30 книги на ред. Книгите на някои от редовете са подредени по азбучен ред на заглавията си, всяко от които е до 100 символа. 88 | 89 | Паролата за сейфа на професор X се определя от числата, които задават последователните дължини на думите в заглавията на книгите, разположени точно в средата на редовете, в които книгите са подредени в азбучен ред. Ако на реда има четен брой книги, за паролата се използва книгата, намираща се по-близо до началото на реда. Думите в заглавията на книгите са разделени от точно един интервал. Дължините на думите формират паролата в реда, в който се срещат, от най-горния към най-долния ред на библиотеката. 90 | 91 | Библиотеката на Х може да се представи като двумерен масив **a** от низове с **m** реда по **n** низа всеки, представящи заглавията на книгите. Да се дефинира функция ***revealPassword***, която по подадени **a**, **m** и **n**, извежда на стандартния изход паролата на професор X като последователност от числа, разделени с по един интервал. 92 | 93 | **Пример:**
94 | 95 | 96 | 97 | 98 |
AlgebraAnalytic GeometryCalculus
DatabasesArtificial IntelligenceFunctional Programming
Data Structures and AlgorithmsIntroduction to ProgrammingObject-oriented Programming
99 | 100 | Тогава паролата на професор X е поредицата от числа `8 8 12 2 11`, получена от дължините на подчертаните думи. Думите “Artificial Intelligence” не участват в паролата, защото книгите на втория ред не са подредени по азбучен ред на заглавията си. 101 | 102 | --- 103 | 104 | **[Решение](../solutions/strings/task13.cpp)** 105 | 106 |
107 | 108 | 14. **Задача** Да се състави функция, която приема като параметър низ с произволна дължина и връща като резултат позициите на двойката **еднакви** символи, които са максимално отдалечени един от друг. Ако в низа съществуват няколко двойки максимално отдалечени символи, функцията да връща позициите на най-ляво разположената двойка. Счита се, че номерата на позициите започват от 0. 109 | 110 | **Пример**:
111 | Вход: 112 | ```cpp 113 | "this is just a simple example" 114 | ``` 115 | Изход: 116 | ```text 117 | 4 21 118 | ``` 119 | Пояснение: символи ' ' (интервали) са на позиции, съответно 4 и 21, намират се на разстояние 17 символа един от друг и няма друга двойка еднакви символи, които са на по-голямо разстояние един от друг. 120 | 121 | --- 122 | 123 | **[Решение](../solutions/strings/task14.cpp)** 124 | 125 |
126 | 127 | Задачи за самостоятелна работа: 128 | - [Шоколад](http://www.math.bas.bg/infos/files/2008-12-02-D3.pdf) 129 | - [Думи](http://www.math.bas.bg/infos/files/2011-05-08-E4.pdf) 130 | -------------------------------------------------------------------------------- /resources/tasks/archives/test/2020_test_problems.md: -------------------------------------------------------------------------------- 1 | # Давани задачи от второ контролно - 2020/2021 2 | 3 | 1. **Задача**. Да се напише програма, която приема като вход две цели положителни числа **n** и **m** и извежда като резултат разликата между първата и **m**-тата цифра на **n**. Брои се от 1 и от дясно наляво. Ако не съществува цифра с позиция **m**, да се изведе -10. 4 | 5 | --- 6 | 7 |
8 | 9 | 2. **Задача**. Да се напише програма, която приема като вход цяло число **n** в интервала [0, 20], последвано от масив от **n** на брой цели числа. Програмата да извежда в конзолата индекса на най-дясното число в масива, което е по-голямо от средноаратметичната стойност на съседите си. Ако няма такова число да извежда -1. Задачата да се реши с рекурсия. 10 | 11 | Пояснение: За определеност считаме, че нулевият и последният индекс в масива не са валиден резултат, тъй като имат само по един съсед. 12 | 13 | --- 14 | 15 |
16 | 17 | 3. **Задача**. Да се напише програма, която извежда **true** ако сборът на цифрите на дадено цяло число е равен на числото, образувано от първите му 2 цифри (считано отляво надясно) и **false**, ако числото не изпълнява това условие. 18 | 19 | --- 20 | 21 |
22 | 23 | 4. **Задача**. Да се напише програма, която въвежда от клавиатурата число **n** и последвано от **n** на брой цели числа. Програмата трябва да изведе сбора от цифрите на всички **n** числа (без самото число **n**). Задачата да се реши чрез рекурсия. 24 | 25 | --- 26 | 27 |
28 | 29 | 5. **Задача**. Да се напише програма, която проверява дали дадено число в рамките на **int** съдържа поне 2 еднакви цифри. 30 | 31 | **Пример**:
32 | Вход: 33 | ```text 34 | 1 35 | ``` 36 | Изход: 37 | ```text 38 | 0 39 | ``` 40 | --- 41 | Вход: 42 | ```text 43 | 22 44 | ``` 45 | Изход: 46 | ```text 47 | 1 48 | ``` 49 | --- 50 | Вход: 51 | ```text 52 | 2233 53 | ``` 54 | Изход: 55 | ```text 56 | 1 57 | ``` 58 | --- 59 | Вход: 60 | ```text 61 | -56 62 | ``` 63 | Изход: 64 | ```text 65 | 0 66 | ``` 67 | --- 68 | 69 |
70 | 71 | 6. **Задача**. **Q** = 6174 наричаме константа на Капрекар. За четирицифрено число **L**, докато **L** е различно от **Q** извършваме следната операция: заменяме **L** с разликата на най-голямото и най-малкото число, които могат да се образуват след разместване на цифрите на числото **L**. Напишете програма, която получава като вход **L** и връща като резултат колко пъти е необходимо да повторим горната операция, за да се достигне до **Q**. Задачата да се реши с рекурсия. 72 | 73 | **Примери**:
74 | Вход: 75 | ```text 76 | 6174 77 | ``` 78 | Изход: 79 | ```text 80 | 0 81 | ``` 82 | --- 83 | Вход: 84 | ```text 85 | 1746 86 | ``` 87 | Изход: 88 | ```text 89 | 1 90 | ``` 91 | Пояснение: 92 | 1. 7641 - 1467 = 6174 93 | 94 | --- 95 | Вход: 96 | ```text 97 | 5644 98 | ``` 99 | Изход: 100 | ```text 101 | 3 102 | ``` 103 | Пояснение: 104 | 1. 6544 - 4456 = 2088 105 | 2. 8820 - 0288 = 8532 106 | 3. 8532 - 2358 = 6174 107 | 108 | --- 109 | 110 |
111 | 112 | 7. **Задача**. Да се напише програма, която приема като вход цяло число и връща като резултат дали то съдържа три последователни поредни арабски цифри (намаляващи или нарастващи). 345 - 1, 84547 - 0 113 | 114 | --- 115 | 116 |
117 | 118 | 8. **Задача**. Да се напише програма, която приема като вход цяло естествено число **n**, след което се въвеждат **n** на брой цели числа, като всяко отрицателно число да бъде превърнато в положително. Програмата трябва да събере въведените числа, като след това пресметне произведението от цифрите на полученото число. Напишете рекурсия, която пресмята всяко следващо произведение получено от цифрите на предходното, докато не се получи едно едноцифрено число. Рекурсивната функция трябва да брои броя на итерациите като всяко едно произведение се зачита за една итерация. Програмата трябва да изведе последното получено едно цифрено число и броя на итерациите, които са били направени да се получи числото. 119 | 120 | --- 121 | 122 |
123 | 124 | 9. **Задача**. Да се напише програма, която приема като вход редица от естествени числа и връща като изход сумата от цифрите на тези числа. 125 | 126 | --- 127 | 128 |
129 | 130 | 10. **Задача**. Да се напише програма, която приема като вход цяло положително число, по-малко от 3000 и извежда на екрана следващите **n** високосни години. Задачата да се реши с рекурсия. 131 | 132 | Пояснение: Година, деляща се на числото 4 без остатък, е високосна, ако годината обаче също се дели без остатък на 100, то тя не е високосна. Но ако годината също се дели без остатък и на 400, то тя пак ще е високосна. 133 | 134 | --- 135 | 136 |
137 | 138 | 11. **Задача**. Да се напише програма, която извежда **true** ако сборът на цифрите на дадено цяло число е равен на числото, образувано от последните му 2 цифри (считано отляво надясно) и **false**, ако числото не изпълнява това условие. 139 | 140 | --- 141 | 142 |
143 | 144 | 12. **Задача**. Да се напише програма, която приема като вход цяло число **n**, последвано от масив от **n** на брой цели числа, както и две цели числа **S** (start) и **E** (end). Програмата да преработва масива, като редът на числата между S-тия и E-тия индекс включително да бъде обърнат. Ако въведените числа **S** и **Е** не са коректни, масивът да остане без промяна. Накрая програмата да извежда в конзолата последователно първоначалния и преобразувания низ. Задачата да се реши с рекурсия. 145 | -------------------------------------------------------------------------------- /resources/tasks/archives/exams/2020_exam_problems.md: -------------------------------------------------------------------------------- 1 | # Задачи от изпит - 2020/2021 2 | 3 | 1. **Задача**. Да се напише функция на C++, със сигнатура `int AnalyzeArray(int arr[], int l)`, където l е дължината на масива, която да връща 1, ако масивът може да бъде разделен на две части, с равни суми на елементите им и 0 – в противен случай. Функцията да връща -1, при невалидни входни данни. 4 | 5 | **Пример**:
6 | Вход: 7 | ```cpp 8 | {1,3,0,0,4} 9 | ``` 10 | Изход: 11 | ```cpp 12 | 1 13 | ``` 14 | --- 15 | Вход: 16 | ```cpp 17 | {1,6,1,0,5,199} 18 | ``` 19 | Изход: 20 | ```cpp 21 | 0 22 | ``` 23 | --- 24 | 25 |
26 | 27 | 2. **Задача**. Да се напише функция на C++ със сигнатура `char* revandreplace(char *)`, която приема като параметър низ, обръща го огледално и заменя буквите 'e' и 'y' (ако ги има) съответно с '!' и '\*'. 28 | 29 | **Пример**: 30 | 31 | Вход: 32 | ``` 33 | I left you alone 34 | ``` 35 | Изход: 36 | ``` 37 | !nola uo* tf!l I 38 | ``` 39 | --- 40 | 41 |
42 | 43 | 3. **Задача**. Да се напише функция на С++, със сигнатура `bool CheckDate(char[])`, която да проверява дали входния параметър е високосна година, записана точно в следния формат "YYYY g." 44 | 45 | Пояснение: Високосна година, наричаме такава година, която се дели на 4 и ако се дели на 100, също се дели и на 400 (всички деления са без остатък). 46 | 47 | --- 48 | 49 |
50 | 51 | 4. **Задача**. Да се напише функция на C++ със сигнатура `int* countletters(int[], int[], int N)`, която приема като параметри два целочислени масива с еднаква дължина N. Функцията да провери дали сумите на елементите с еднакви индекси в двата масива съответстват на ASCII кодовете на малка или главна буква от латинската азбука. Върнатият резултат да бъде масив, от два елемента, на първата позиция на който се намира броя на главните букви от така формираните суми, а на втората позиция - броя на малките букви (A-Z => 65-90 и a-z => 97-122 в ASCII). 52 | 53 | **Пример**: 54 | 55 | Вход: 56 | ```cpp 57 | {3, 5, 11, 2, 9}, {1, 4, 32, 71, 5}, 5 58 | ``` 59 | Изход: 60 | ```cpp 61 | {1,0} 62 | ``` 63 | --- 64 | 65 |
66 | 67 | 5. **Задача**. Да се напише функция на C++ със сигнатура `bool checkstr(char*)`, която приема като параметър низ и проверява дали той е поредица от редуващи се малки и големи букви от латинската азбука. 68 | 69 | **Примери**: 70 | 71 | Вход: 72 | ``` 73 | aZaAaCfEa 74 | ``` 75 | Изход: 76 | ``` 77 | true 78 | ``` 79 | --- 80 | Вход: 81 | ``` 82 | bAzCBaFbK 83 | ``` 84 | Изход: 85 | ``` 86 | false 87 | ``` 88 | --- 89 | Вход: 90 | ``` 91 | bAzC$aFbK 92 | ``` 93 | Изход: 94 | ``` 95 | false 96 | ``` 97 | --- 98 | 99 |
100 | 101 | 6. **Задача**. Да се напише функция на C++ със сигнатура `char* GetWord(char [])`, която проверява колко думи в подадения като параметър низ започват със символа 'а'. Функцията да върне масив, който съдържа като първи елемент броя на думите, които започва с 'а' и като втори елемент - общия брой думи в масива. 102 | 103 | Пояснение: Дума се нарича всяка последователност от символи, която не включва един или повече интервала и/или табулации ('\t') или е ограничена от началото и/или края на низа. 104 | 105 | **Пример**: 106 | 107 | Вход: 108 | ```cpp 109 | " It took about an hour to answer all the questions. " 110 | ``` 111 | Изход: 112 | ```cpp 113 | {4, 10} 114 | ``` 115 | --- 116 | 117 |
118 | 119 | 7. **Задача**. Да се напише функция на C++, със сигнатура `int AnalyzeNum(long N)` която връща като резултат средната цифра на числото N. Средна цифра, наричаме такава, за която броят M, M>0 на останалите цифри в числото, които са по-големи или по-малки от нея е еднакъв. Функцията да връща -1, ако няма такава цифра. 120 | 121 | **Примери**: 122 | 123 | Вход: 124 | ``` 125 | 314 126 | ``` 127 | Изход: 128 | ``` 129 | 3 130 | ``` 131 | --- 132 | Вход: 133 | ``` 134 | 442 135 | ``` 136 | Изход: 137 | ``` 138 | -1 139 | ``` 140 | --- 141 | Вход: 142 | ``` 143 | 5462141 144 | ``` 145 | Изход: 146 | ``` 147 | 4 148 | ``` 149 | --- 150 | 151 |
152 | 153 | 8. **Задача**. Да се напише функция на С++, със сигнатура `void ConvertArr(long arr[], long S, long E)`, която преобразува масива arr, като редът на елементите между S-тия и E-тия индекс в масива включително е обърнат огледално (счита се, че E винаги е по-малко от дължината на подадения като параметър масив). Ако въведените числа S и Е не са коректни, масивът да не се променя. 154 | 155 | **Пример**: 156 | 157 | Вход: 158 | ```cpp 159 | arr = {4, 5, 6, 7, 8, 9, 0, 1}, S = 2, E = 5 160 | ``` 161 | Изход: 162 | ```cpp 163 | {4, 5, 9, 8, 7, 6, 0, 1} 164 | ``` 165 | --- 166 | 167 |
168 | 169 | 9. **Задача**. Да се напише функция на С++, със сигнатура `int findElement(long arr[], int l)`, която връща индекса на най-десния елемент на масива arr (с дължина l), който е по-голям от средноаритметичната стойност на съседите си. Ако няма такъв елемент, функцията да връща -1. 170 | 171 | **Пример**: 172 | 173 | Вход: 174 | ```cpp 175 | {2, 3, 17, 8, 1, 9} 176 | ``` 177 | Изход: 178 | ```cpp 179 | 2 180 | ``` 181 | --- 182 | 183 |
184 | 185 | 10. **Задача**. Да се напише функция на C++ със сигнатура `int** mergearrays(int*, int*, int m)`, която приема като параметри два масива с еднаква дължина m и връща като резултат двумерен масив който ги съдържа (всеки един от подадените като параметри масиви е един ред в новия масив). 186 | 187 | **Пример**: 188 | 189 | Вход: 190 | ```cpp 191 | А = {3, 5, 11, 2, 9}, В = {1, 4, 32, 71, 5} 192 | ``` 193 | Изход: 194 | ```cpp 195 | { {3, 5, 11, 2, 9}, {1, 4, 32, 71, 5} } 196 | ``` 197 | -------------------------------------------------------------------------------- /resources/tasks/files.md: -------------------------------------------------------------------------------- 1 | 2 | # Работа с файлове 3 | 4 | 1. **Задача** Да се състави програма, която: 5 | - създава файла "chisla.txt", елементите на който са 100 произволни цели числа от интервала [1,500]; 6 | - прочита съдържанието на "chisla.txt" и създава два нови файла съдържащи съответно всички прости и всички щастливи числа съдържащи се във файла "chisla.txt". 7 | 8 | --- 9 | 10 | **[Решение](../solutions/files/task01.cpp)** 11 | 12 |
13 | 14 | 2. **Задача** Да се състави програма, която: 15 | 16 | - създава файл f от реални числа; 17 | - преписва положителните му елементи във файл g; 18 | - извежда съдържанието на двата файла. 19 | 20 | За всяка подточка да се състави отделна функция. Програмата да работи с меню по избор. 21 | 22 | --- 23 | 24 |
25 | 26 | 3. **Задачи** Да се състави програма, която: 27 | - създава файл, съдържащ всички прости числа не надминаващи дадено естествено число n; 28 | - извежда съдържанието на файла на екрана. 29 | 30 | За всяка подточка да се състави отделна функция. Програмата да работи с меню по избор. 31 | 32 | --- 33 | 34 |
35 | 36 | 4. **Задачи** Да се състави програма, която: 37 | - създава файл съдържащ цели числа; 38 | - добавя елемент в края на създаденият файл; 39 | - извежда съдържанието на файла на екрана. 40 | 41 | За всяка подточка да се състави отделна функция. Програмата да работи с меню по избор. 42 | 43 | --- 44 | 45 |
46 | 47 | 5. **Задача** Да се състави програма, която: 48 | - създава файл, съдържащ всички числа на Фибоначи от интервала [1 ; n]; 49 | - извежда съдържанието на файла на екрана; 50 | - проверява дали числото k се съдържа във файла 51 | 52 | За всяка подточка да се състави отделна функция. Програмата да работи с меню по избор. 53 | 54 | --- 55 | 56 |
57 | 58 | 6. **Задачи** За учениците от десети клас в училище се съхранява следната информация: име, фамилия,извинени и неизвинени отсъствия. Да се напише програма, която: 59 | 60 | - създава файл съдържащ информация за учениците; 61 | - извежда съдържанието на файла; 62 | - намира общия брой извинени и неизвинени отсъствия; 63 | - намира името/-ната на ученика/-ците с най-много неизвинени отсъствия; 64 | - по въведено име на ученик - извежда информацията за него; 65 | - сортира по име във възходящ ред въведените данни; 66 | - по въведено име на ученик - изтрива данните за него 67 | - по въведено име на ученик - актуализира данните за него . 68 | 69 | --- 70 | 71 |
72 | 73 | 7. **Задачи** Да се състави програма, която: 74 | 75 | - създава файл елементите на който са записи, съдържащи информация за учениците от една група (име, номер, среден успех); 76 | - програмата да сортира по номера елементите на файла; 77 | - да се изведе съдържанието на файла. 78 | 79 | За всяка подточка да се състави отделна функция. Програмата да работи с меню по избор. 80 | 81 | --- 82 | 83 |
84 | 85 | 8. **Задачи** Да се състави програма, която: 86 | - създава файл елементите на който са структури, съдържащи информация за учениците от една група (име, номер, среден успех, отсъствия); 87 | - програмата да изведе данните за учениците с отличен успех, а след това за тези със слаб успех; 88 | - извежда всички ученици с повече от 14 отсъствия. 89 | 90 | За всяка подточка да се състави отделна функция. Програмата да работи с меню по избор. 91 | 92 | --- 93 | 94 |
95 | 96 | 9. **Задачи** Да се напише програма, която създава текстов файл, съдържащ информация за студентите от една група. Всяка компонента на файла съдържа: име, факултетен номер и среден успех на студент. Програмата да извежда името и средния успех на всеки студент. 97 | 98 | --- 99 | 100 |
101 | 102 | 10. **Задачи** Да се напише програма, която сгъстява текстов файл, като изтрива всички интервали в него. 103 | 104 | --- 105 | 106 |
107 | 108 | 11. **Задача** Да се напише програма, която намира поредния номер на най-дългия (най-късия) ред на даден текстов файл. 109 | 110 | --- 111 | 112 | **[Решение](../solutions/files/task11.cpp)** 113 | 114 |
115 | 116 | 12. **Задача** Изречение е редица от символи, започваща с главна буква и завършваща с `.`, `!` или `?`. Да се намери броят на изреченията в даден текстов файл. 117 | 118 | --- 119 | 120 |
121 | 122 | 13. **Задача** Дума е редица от букви или число. Да се намери броят на думите в даден текстов файл. 123 | 124 | --- 125 | 126 |
127 | 128 | 14. **Задача** В текстов файл е записана редица от числа, разделени с интервали, табулации или преминаване на нов ред. Да се намери средно-аритметичното на числата. 129 | 130 | --- 131 | 132 |
133 | 134 | 15. **Задача** Да се напише програма, която създава файл, съдържащ информация за студентите от един курс. Всяка компонента на файла съдържа: факултетен номер, име и среден успех на студент. Факултетните номера започват от 42900 и завършват с 43150. Програмата да може да извършва следните действия: 135 | 136 | - вмъква компонента за новозаписан студент; 137 | - изтрива компонента за студент; 138 | - променя полето “среден успех” на зададен чрез факултетен номер студент; 139 | - извежда върху екрана компонентите на файла; 140 | - намира студентите с указан успех и ги записва в текстовия файл print.txt. 141 | 142 | --- 143 | 144 |
145 | 146 | 16. **Задача** Да се напише програма, която създава файл, съдържащ информация за книгите на една библиотека. Всяка компонента на файла съдържа: инвентарен номер, заглавие, автор, националност и година на издаване. Инвентарните номера започват от 400000 и завършват с 450000. Програмата да може да извършва следните действия: 147 | 148 | - включва нова книга във файла; изтрива книга от файла; 149 | - променя всички полета, без инвентарен номер, на зададена чрез инвентарен номер книга; 150 | - извежда върху екрана компонентите на файла; 151 | - намира книгите от указна националност; 152 | - намира книгите издадени през указана година. 153 | -------------------------------------------------------------------------------- /resources/tasks/basic_operators.md: -------------------------------------------------------------------------------- 1 | # Операции, изрази и области. Вход и изход 2 | 3 | 1. **Задача** Да се въведат две числа - а и b. Да се изведе тяхната разлика. 4 | 5 | **Пример**:
6 | Вход: 7 | ```text 8 | 2 6 9 | ``` 10 | Изход: 11 | ```text 12 | -4 13 | ``` 14 | --- 15 | 16 | Още задачи за работа с целочислен тип може да намерите [тук](https://programist.alle.bg/zada4i/zada4i-tema2/). 17 | 18 |
19 | 20 | 2. **Задача** Да се въведе положително число а. Да се изведе: 21 | - лицето и обиколката на квадрат със страна а; 22 | - дължината на окръжност с радиус а; 23 | - лицето и обиколката на равностранен триъгълник със страна а. 24 | 25 | Приемаме, че sqrt(3) = 1.73. 26 | 27 | **Пример**:
28 | Вход: 29 | ```text 30 | 4 31 | ``` 32 | Изход: 33 | ```text 34 | square: p=16 s=16 35 | circle: p=25.12 36 | triangle: p=12 s=6.92 37 | ``` 38 | --- 39 | 40 |
41 | 42 | 3. **Задача** Да се въведе число, което да представлява сума в лева и да се изведе конвертираната сума в евро при курс на лева спрямо еврото 0.511306792. Да се въведе сумата в левове и да се изведе в евро. 43 | 44 | **Пример**:
45 | Вход: 46 | ```text 47 | 2 48 | ``` 49 | Изход: 50 | ```text 51 | 1.022613584 52 | ``` 53 | --- 54 | 55 | Още задачи за работа с реален тип може да намерите [тук](https://programist.alle.bg/zada4i/double/). 56 | 57 |
58 | 59 | 4. **Задача** Напише програма, която въвежда 3 числа `a`, `b` и `x` и извежда дали `x ∈ (a,b)` 60 | 61 | **Пример**:
62 | Вход: 63 | ```text 64 | 1 5 3 65 | ``` 66 | Изход: 67 | ```text 68 | 1 69 | ``` 70 | --- 71 | Вход: 72 | ```text 73 | 2 4 6 74 | ``` 75 | Изход: 76 | ```text 77 | 0 78 | ``` 79 | --- 80 | 81 | **[Решение](../solutions/basic_operators/task04.cpp)** 82 | 83 |
84 | 85 | 5. **Задача** Напишете програма, която въвежда две числа - a и b и връща (a + b)3 86 | 87 | **Пример**:
88 | Вход: 89 | ```text 90 | 2 3 91 | ``` 92 | Изход: 93 | ```text 94 | 125 95 | ``` 96 | --- 97 | 98 |
99 | 100 | 6. **Задача** Огледално на дадено число наричаме това, съставено от цифрите му в обратен ред. Да се въведе **четирицифрено** число и да се изведе огледалното му. 101 | 102 | **Пример**:
103 | Вход: 104 | ```text 105 | 7121 106 | ``` 107 | Изход: 108 | ```text 109 | 1217 110 | ``` 111 | --- 112 | 113 |
114 | 115 | 7. **Задача** Да се въведе цяло **четирицифрено** число. Да се изведе сумата, произведението и средноаритметично от цифрите му. 116 | 117 | **Пример**:
118 | Вход: 119 | ```text 120 | 1432 121 | ``` 122 | Изход: 123 | ```text 124 | sum=10 p=24 avr=2.5 125 | ``` 126 | --- 127 | 128 |
129 | 130 | 8. **Задача** Да се въведат две числа - а и b, различни от 0. Да се разменят стойностите им (по три начина, без да се използва функцията swap). 131 | 132 | **Пример**:
133 | Вход: 134 | ```text 135 | a=2 136 | b=9 137 | ``` 138 | Изход: 139 | ```text 140 | a=9 b=2 141 | ``` 142 | --- 143 | 144 |
145 | 146 | 9. **Задача** Напишете програма, която въвежда 3 числа `a`, `b` и `c` и ги извежда сортирани 147 | 148 | **Пример**:
149 | Вход: 150 | ```text 151 | 1 2 3 152 | ``` 153 | Изход: 154 | ```text 155 | 1 2 3 156 | ``` 157 | --- 158 | Вход: 159 | ```text 160 | 8 4 -5 161 | ``` 162 | Изход: 163 | ```text 164 | -5 4 8 165 | ``` 166 | --- 167 | **[Решение](../solutions/basic_operators/task09.cpp)** 168 | 169 |
170 | 171 | 9. **Задача** Напишете потребителски интерфейс, който изисква от потребителя да въведе количество от даден продукт (по ваш избор) и цената му. Нека софтуерът попита за три различни продукта. Накрая изведете сметката на потребителя: какъв брой от какво си е поръчал и колко ще му струва. 172 | 173 | **Пример**:
174 | Вход: 175 | ```text 176 | Apples: 2 0.6 177 | Oranges: 1 1.5 178 | Bananas: 3 0.78 179 | ``` 180 | Изход: 181 | ```text 182 | Your order is: apples for 1.2, oranges for 1.5 and bananas for 2.34. Total: 5.04. 183 | ``` 184 | --- 185 | 186 |
187 | 188 | 11. **Задача** Напишете програма, която въвежда три естествени числа a, b и c и като резултат връща корените на квадратното уравнение a2x + bx + c = 0 (приемете, че винаги ще има реални корени). 189 | 190 | **Пример**:
191 | Вход: 192 | ```text 193 | a=1 194 | b=2 195 | c=1 196 | ``` 197 | Изход: 198 | ```text 199 | x1= -1 200 | x2 = -1 201 | ``` 202 | --- 203 | 204 | 205 |
206 | 207 | 12. **Задача** Напишете програма, която въвежда две неотрицателни числа и изписва по-голямото от тях. (А можете ли без да използвате сравнение?) 208 | 209 | **Пример**:
210 | Вход: 211 | ```text 212 | 3 5 213 | ``` 214 | Изход: 215 | ```text 216 | 5 217 | ``` 218 | --- 219 | 220 |
221 | 222 | 13. **Задача** Напишете програма, която въвежда 3 числа `a`, `b` и `x` и съответно извежда: 223 | - `1` - Ако `x < a` 224 | - `2` - Ако `x = a` 225 | - `3` - Ако `x ∈ (a,b)` 226 | - `4` - Ако `x = b` 227 | - `5` - Ако `x > b` 228 | 229 |
230 | 231 | **Пример**:
232 | Вход: 233 | ```text 234 | 1 5 3 235 | ``` 236 | Изход: 237 | ```text 238 | 3 239 | ``` 240 | --- 241 | Вход: 242 | ```text 243 | 1 3 5 244 | ``` 245 | Изход: 246 | ```text 247 | 5 248 | ``` 249 | --- 250 | Вход: 251 | ```text 252 | 1 3 3 253 | ``` 254 | Изход: 255 | ```text 256 | 4 257 | ``` 258 | --- 259 | **[Решение](../solutions/basic_operators/task13.cpp)** 260 | 261 |
262 | 263 | 14. **Задача** Напишете програма, която въвежда десетично число и го извежда на екрана в шестнайсетичен формат. 264 | 265 | **Пример**:
266 | Вход: 267 | ```text 268 | 101 269 | ``` 270 | Изход: 271 | ```text 272 | 65 273 | ``` 274 | --- 275 | 276 |
277 | 278 | 15. **Задача** Напишете програма, която въвежда десетично число и го извежда на екрана в осмичен формат. 279 | 280 | **Пример**:
281 | Вход: 282 | ```text 283 | 132 284 | ``` 285 | Изход: 286 | ```text 287 | 204 288 | ``` 289 | --------------------------------------------------------------------------------