kaloyankibarev07 1.0.0
dotnet add package kaloyankibarev07 --version 1.0.0
NuGet\Install-Package kaloyankibarev07 -Version 1.0.0
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="kaloyankibarev07" Version="1.0.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="kaloyankibarev07" Version="1.0.0" />
<PackageReference Include="kaloyankibarev07" />
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add kaloyankibarev07 --version 1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: kaloyankibarev07, 1.0.0"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package kaloyankibarev07@1.0.0
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=kaloyankibarev07&version=1.0.0
#tool nuget:?package=kaloyankibarev07&version=1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Numerics; using System.Runtime.InteropServices; using static System.Collections.Specialized.BitVector32;
namespace kaloyankibarev07 { public class kaloyankibarev { ТЕСТ 1
Дайте пример за конзолна програма, която чете две цели числа, въведени от потребителя, и отпечатва по-голямото от двете.
Не използвайте вградените функционалности в.NET! Решете задачата с условна конструкция!
int a = int.Parse(Console.ReadLine());
int b = int.Parse(Console.ReadLine());
if (a > b)
Console.WriteLine(a);
else
Console.WriteLine(b);
Дайте пример за while цикъл в C#, който отпечатва числата от 1 до 10(включително), всяко на отделен ред. int num = 1;
while (num ⇐ 10)
{
Console.WriteLine(num++);
}
Елените на Дядо Коледа
Дядо Коледа много обича да пътешества, но за съжаление се случило, така че точно преди да замине на почивка три от елените му се разболяли и трябва да ги остави.Когато заминава, той трябва да съобрази колко храна да остави на всеки един от елените, за да не останат гладни.Напишете програма, която пресмята дали оставената от Дядо Коледа храна ще е достатъчна за времето, в което него няма да го има.Всеки елен изяжда определено количество храна на ден.
10 ТОЧКИ
using System;
class Program { static void Main(string[] args) { int days = int.Parse(Console.ReadLine()); int kgFood = int.Parse(Console.ReadLine()); double dailyFoodFirst = double.Parse(Console.ReadLine()); double dailyFoodSecond = double.Parse(Console.ReadLine()); double dailyFoodThird = double.Parse(Console.ReadLine());
double foodNeeded = days * dailyFoodFirst
+ days * dailyFoodSecond
+ days * dailyFoodThird;
if (kgFood >= foodNeeded)
{
Console.WriteLine($"{Math.Floor(kgFood - foodNeeded)} kilos of food left.");
}
else
{
Console.WriteLine($"{Math.Ceiling(foodNeeded - kgFood)} more kilos of food are needed.");
}
}
}
Дефинирайте понятието метод - Защо е добра практика да използваме методи? Как се декларират методи? Как се извикват методи? Какво са параметри на метод и връщана стойност?
метода е блок от код който извършва определена задача.Правят кода по лесен.Параметрите са данни които метода получава.Извиква се с int s = Sum(3, 5);
Компилаторът има за задача да[преведе изходния код] (най-често написан на език от по-високо ниво) до[машинен код] или друг език от по-ниско ниво, като междувременно[проверява за грешки текста] на програмата.
Резултатът от неговото изпълнение представлява[изпълним файл], специфичен за дадена хардуерна и софтуерна платформа. При компилируемите езици за програмиране компилирането на програмата се извършва задължително[преди] нейното изпълнение и[по време] на компилация се откриват синтактичните грешки(грешно зададени команди).
Дайте пример за конзолна програма, която чете парола(един ред с произволен текст), въведена от потребителя, и проверява дали въведеното съвпада с фразата “s3cr3t!P @ssw0rd”. При съвпадение да се изведе “Welcome”. При несъвпадение да се изведе “Wrong password!”.
Console.WriteLine(Console.ReadLine()==“s3cr3t!P @sww0rd"?"Welcome":"Wrong password!");
Компютърната програма е:
Правилният отговор е: Всичко от изброеното.
Посоченият по-долу фрагмент на C# събира числото 0.00001 общо 100000 пъти. Очакваният резултат от това е 1. При изпълнение се получава резултат 0.999999999998084. Как ще промените програмата, така че да се поправи тази изчислителна грешка?
Правилният отговор е: Чрез използване на тип decimal вместо double и добавянето на суфикс M след изписването на 0 и 0.00001.
Болница
За даден период от време, всеки ден в болницата пристигат пациенти за преглед.Тя разполага първоначално със 7 лекари.Всеки лекар може да преглежда само по един пациент на ден, но понякога има недостиг на лекари, затова останалите пациенти се изпращат в други болници.Всеки трети ден, болницата прави изчисления и ако броят на непрегледаните пациенти е по-голям от броя на прегледаните, се назначава още един лекар.Като назначаването става преди да започне приемът на пациенти за деня.
Напишете програма, която изчислява за дадения период броя на прегледаните и непрегледаните пациенти.
10 ТОЧКИ
using System;
class Program { static void Main(string[] args) { int days = int.Parse(Console.ReadLine());
int doctors = 7;
int treated = 0;
int untreated = 0;
for (int day = 1; day <= days; day++)
{
int patientsCount = int.Parse(Console.ReadLine());
// проверка за всеки 3-ти ден (преди прегледите)
if (day % 3 == 0 && untreated > treated)
{
doctors++;
}
if (patientsCount <= doctors)
{
treated += patientsCount;
}
else
{
treated += doctors;
untreated += (patientsCount - doctors);
}
}
Console.WriteLine($"Treated patients: {treated}.");
Console.WriteLine($"Untreated patients: {untreated}.");
}
}
Формулирайте правилно определението за условни конструкции.
Условните конструкции if и if-else представляват[тип условен контрол], чрез който програмата може да се държи[различно], в зависимост от[някакво условие], което се проверява по време на изпълнение на конструкцията.
- Футболен мач
На един стадион има определен брой сектори, в които има седалки наредени в правоъгълна форма и има X реда и Y седалки на ред.
Има четири вида сектори с билети на различни цени:
Sector A – цена на билета 11.60 лева Sector B – цена на билета 14.50 лева Sector C – цена на билета 16.10 лева Sector D – цена на билета 8.40 лева
10 ТОЧКИ
static void Main(string[] args) { string sector = Console.ReadLine(); int row = int.Parse(Console.ReadLine()); int col = int.Parse(Console.ReadLine()); double totalSum = 0; switch (sector) { case "Sector A": totalSum = GetTotalProfit(row, col, 11.60); break; case "Sector B": totalSum = GetTotalProfit(row, col, 14.50); break; case "Sector C": totalSum = GetTotalProfit(row, col, 16.10); break; case "Sector D": totalSum = GetTotalProfit(row, col, 8.40); break;
Console.WriteLine($"{sector} profit is {totalSum:f2} lv.");
}
static double GetTotalProfit(int row, int col, double price)
{
return row * col * price;
}
}
Даден е следният примерен код на C#. Изчислете какъв ще бъде резултата, ако числото n = 5 , запишете в полето за отговор това, което ще се отпечата на конзолата.
Правилният отговор е: 6
Посочете как се записва в C# кратка форма на условна конструкция?
Правилният отговор е: if(true) { //some code... }
Имате даден следният програмен фрагмент:
Открийте какъв ще бъде резултатът след изпълнението на програмата при подаден вход 120.
Правилният отговор е: Between 100 and 200
Дайте пример(напишете примерен код) за оператор за многовариантен избор(switch-case) като използвате програмния език C#.
int d = int.Parse(Console.ReadLine()); Console.WriteLine(d switch { 1 =>"Monday", 2 => "Tuesday", _=> "Other day"});
Посочете кое твърдение е вярно за променливите?
Правилните отговори са: Променливата е място, на което пазим информация., Всяка една променлива в C# си има тип и име., Не може да има две променливи с едно и също име.
Правилният отговор е: За програмиране на езика Java: → IntelliJ IDEA, За програмиране на езика C#: → Visual Studio, За програмиране на езика Python: → PyCharm
Показан е следния програмен код на C#. Каква е целта на програмата? Посочете верния отговор.
Правилният отговор е: Намира всички числа в интервала [1 … 1000], които завършват на 7 и ги отпечатва на конзолата.Правилният отговор е: Намира всички числа в интервала [1 … 1000], които завършват на 7 и ги отпечатва на конзолата.
Деление без остатък
Дадени са n-на брой цели числа в интервала [1…1000]. От тях някакъв брой се делят без остатък на 2, друг брой се делят без остатък на 3, друг брой се делят без остатък на 5. Да се напише програма, която изчислява и отпечатва броя на числата във всяка група.
Пример: имаме n = 10 числа: 680, 2, 600, 200, 800, 799, 199, 46, 128, 65. Получаваме следното разпределение и визуализация:Деление без остатък
Дадени са n-на брой цели числа в интервала [1…1000]. От тях някакъв брой се делят без остатък на 2, друг брой се делят без остатък на 3, друг брой се делят без остатък на 5. Да се напише програма, която изчислява и отпечатва броя на числата във всяка група.
Пример: имаме n = 10 числа: 680, 2, 600, 200, 800, 799, 199, 46, 128, 65. Получаваме следното разпределение и визуализация:
10 ТОЧКИ
using System;
class Program { static void Main(string[] args) { int n = int.Parse(Console.ReadLine());
int d2 = 0;
int d3 = 0;
int d5 = 0;
for (int i = 0; i < n; i++)
{
int number = int.Parse(Console.ReadLine());
if (number % 2 == 0)
{
d2++;
}
if (number % 3 == 0)
{
d3++;
}
if (number % 5 == 0)
{
d5++;
}
}
Console.WriteLine(d2);
Console.WriteLine(d3);
Console.WriteLine(d5);
}
}
Дайте пример за for - цикъл в C#. За пример може да ползвате код, който отпечатва на конзолата числата от 1 до 100.
for (int i = 1; i ⇐ 100; i++) { Console.WriteLine(i); }
ТЕСТ 2
Опишете как ще преминете от двоична бройна система в десетична.
Преобразувайте числото 11101(2) от двоична в десетична бройна система.
При преминаване от двоична в десетична бройна система, се извършва преобразуване на двоичното число в десетично. Числата записани в двоична бройна система се състоят от двоични цифри, които са подредени по степените на двойката.
Всяка една двоична цифра се умножава по 2 на степен, позицията, на която се намира (в двоичното число). Накрая се извършва събиране на числата, получени за всяка от двоичните цифри, за да се получи десетичната равностойност на двоичното число.
11101(2) = 1х24 + 1х23 + 1х22 + 0х21 + 1х20
= 16(10) + 8(10) + 4(10) + 0(10) + 1(10) = 29
Демонстрирайте как ще достъпите елемент от масива. Напишете код с C#, който да отпечата на конзолата името Alex от масива names.
string[] names = { "John", "Peter", "Stella", "Alex", "Jessie"}
Правилният отговор е: Console.WriteLine(names[3]);
Посочете как се декларира многомерен масив в C#.
int[,] arr == new int[2, 3];
Посочете по кой от начините ще добавите стойност в речник, ако речника има за ключ тип данни низ и за стойност целочислен тип данни?
Правилният отговор е: dict.Add("tomatoes", 2);
В най-популярната система за контрол на версиите GitHub има няколко основни команди, които се използват когато пишете в конзолния клиент GitBash. Обяснете какво прави командата git pull, като поставите липсващите думи в празните полета.
С командата pull автоматично [изтегляте] промените от отдалеченото хранилище.
Баскетболен сезон Треньорът на баскетболен отбор иска да знае накрая на сезона по точки е вкарала всяка една от състезателките му. Помогнете му като напишете програма, която получава име на състезателката и колко точки е вкарала в съответния мач, докато не получите команда "END". След получаване на командата, принтирайте в азбучен ред имената на състезателките и срещу имената на всяка една от тях колко точки е вкарала през сезона.
10 ТОЧКИ
static void Main(string[] args) { SortedDictionary<string, int> dict = new SortedDictionary<string, int>();//2Т
string[] input = Console.ReadLine().Split(" - ", StringSplitOptions.RemoveEmptyEntries); //2Т
while (!input[0].Equals("END"))//1Т
{
if (!dict.ContainsKey(input[0]))//2Т
{
dict.Add(input[0], 0); //1Т
}
dict[input[0]] += int.Parse(input[1]); //1Т
input = Console.ReadLine().Split(" - ", StringSplitOptions.RemoveEmptyEntries);
}
foreach (var kvp in dict)
{
Console.WriteLine($"{kvp.Key} -> {kvp.Value}"); //1Т
}
}
Даден е следния програмен код на C#. След изпълнението на тази програма какво ще се отпечата на конзолата? Решете задачата и в празното поле запишете само това, което ще се отпечата!
Примерен вход: Java C# PHP PHP JAVA C java
Правилният отговор е: java, c#, c
Напишете примерен код, който да отпечата на конзолата следната матрица:
int[,] matrix = { {1, 2, 3, 4}, {5, 6, 7, 8}, };
КОД
for (int row = 0; row < matrix.GetLength(0); row++) { for (int col = 0; col < matrix.GetLength(1); col++) { Console.Write(matrix[row, col]); } Console.WriteLine(); }
Демонстрирайте как ще запишете с код на C# променлива от тип символен низ със стойност: Hello, my name is Niki. Запишете отговора в полето.
Правилният отговор е: string text = "Hello, my name is Niki.";
Посочете кое от изброените е вярно за символните низове?
Правилните отговори са: Символните низове имат свойство Length., Символните низове позволяват достъп по индекс.
Ако имате речник с ключ от тип данни низ и стойност тип данни цяло число, по кой от изброените начини ще премахнете елемент от този речник, който има за ключ стойност "tomatoes"? Посочете верния отговор?
Правилният отговор е: dict.Remove("tomatoes");
Дефинирайте понятието многомерен масив в C#.
структура от данни която съдържа елементи подредени в едно или повече измерения
Великденски яйца Предстои Великден и едно от най-вълнуващите неща е боядисването на яйца. Наличните цветове за боядисване са: • червено(red) • оранжев(orange) • син(blue) • зелен(green) Напишете програма, която изчислява какъв е броят на яйцата от всеки цвят и от кой цвят яйцата са най - много, като знаете общия им брой и цветът на всяко яйце.
10 ТОЧКИ
static void Main(string[] args) { Dictionary<string, int> dict = new Dictionary<string, int>(); int eggs = int.Parse(Console.ReadLine()); //2т for (int i = 0; i < eggs; i++) //1т { string color = Console.ReadLine(); if (!dict.ContainsKey(color)) //2т { dict.Add(color, 0); //1т } dict[color]++;//1т }
Console.WriteLine($"Red eggs: {(dict.ContainsKey("red") ? dict["red"] : 0)}"); //1т
Console.WriteLine($"Orange eggs: {(dict.ContainsKey("orange") ? dict["orange"] : 0)}"); //2т
Console.WriteLine($"Blue eggs: {(dict.ContainsKey("blue") ? dict["blue"] : 0)}");
Console.WriteLine($"Green eggs: {(dict.ContainsKey("green") ? dict["green"] : 0)}");
Console.WriteLine($"Max eggs: {dict.Values.Max()} -> {dict.OrderByDescending(x => x.Value).FirstOrDefault().Key}");
}
Дайте пример за това как бихте декларирали променлива от тип низ със стойност "Hello, World!"?
Правилният отговор е: string message = "Hello, World!"
Дефинирайте понятието сорс-контрол система. Какво представляват? За какво служат? Как се използват?
инструмент който проследява променливите в кода и позволява работа в екип
Видове числа В системата първоначално има въведени числа, които трябва да бъдат разпределени в три групи.
Групите са следните:
Група на четните числа Група на нечетните числа Група на числа, чийто сбор на цифрите завършва на 5
10 ТОЧКИ
static void Main(string[] args)
{ int[] nums = Console.ReadLine().Split(',').Select(int.Parse).ToArray(); //2Т
List<int> evens = new List<int>();
List<int> odds = new List<int>();
List<int> sum5 = new List<int>();
for (int i = 0; i < nums.Length; i++) //1Т
{
if (nums[i] % 2 == 0) //2Т
{
evens.Add(nums[i]);
}
else
{//1Т
odds.Add(nums[i]);
}
if (SumDigits(nums[i]) % 10 == 5)//2Т
{
sum5.Add(nums[i]);
}
}
Console.WriteLine(String.Join(", ", evens));
Console.WriteLine(String.Join(", ", odds));
Console.WriteLine(String.Join(", ", sum5));
} public static int SumDigits(int number) { int sum = 0;
while (number != 0) //2Т
{
sum += number % 10;
number /= 10;
}
return sum;
}
Обяснете какво прави метода ContainsValue(V) реализиран в класа Dictionary<K, V>?
Проверява дали в речникa присъстват една или повече наредени двойки с посочената стойност. Тази операция работи бавно, тъй като проверява всеки елемент на хеш-таблицата.
Магически числа В системата първоначално има въведени числа, които трябва да бъдат разпределени в три групи.
Групите са следните:
Група на четните числа, които завършват на 4 или 8 Група на нечетните числа, които завършват на 5 или 7 Група на числа, чийто сбор на цифрите е 15
10 ТОЧКИ
static void Main(string[] args) { int[] nums = Console.ReadLine().Split(',').Select(int.Parse).ToArray(); //1Т List<int> evens = new List<int>(); List<int> odds = new List<int>(); List<int> sum5 = new List<int>();
for (int i = 0; i < nums.Length; i++)
{
if (nums[i] % 2 == 0 && (nums[i] % 10 == 4 || nums[i] % 10 == 8)) //2T
{
evens.Add(nums[i]);//2Т
}//1Т
else if (nums[i] % 2 != 0 && (nums[i] % 10 == 5 || nums[i] % 10 == 7))
{
odds.Add(nums[i]);
}
if (SumDigits(nums[i]) == 15)//1Т
{
sum5.Add(nums[i]);
}
}
Console.WriteLine(String.Join(", ", evens));
Console.WriteLine(String.Join(", ", odds)); //1T
Console.WriteLine(String.Join(", ", sum5));
} public static int SumDigits(int number) { int sum = 0;
while (number != 0)
{
sum += number % 10;
number /= 10;
}
return sum; //2Т
}
Какво представляват бройните системи? Дефинирайте понятието бройна система, като поставите липсващите думи в изреченията.
Бройните системи са начин за [представяне] на числата, чрез[краен набор] от [графични знаци] наречени цифри. Към тях трябва да се добавят и [правила] за представяне на числата.
Даден е следния код на C#.
Правилният отговор е: Ще възникне изключение.
Посочете кое твърдение е вярно за променливите?
Правилните отговори са: Променливата е място, на което пазим информация., Всяка една променлива в C# си има тип и име., Не може да има две променливи с едно и също име.
Посочете правилната стойност по подразбиране към всеки от типовете данни:
Правилният отговор е: decimal → 0.0m, bool → false, object → null, string → null, float → 0.0f, char → '\u0000', sbyte → 0
Дефинирайте понятието двоична бройна система. Какво представлява? Къде се използва най-често? Как са представени числата в двоичната бройна система?
системата използва само цифрите 0 и 1
Посочете кои от характеристиките се отнасят към централизираните сорс-контрол системи и кои към децентрализираните сорс-контрол системи.
Използват един сървър, съдържащ всички контролирани файлове и множество от клиенти, които издърпват файловете от това централно място. [Централизирани]
Клиентите изтеглят последния snapshot на файловете и изцяло клонират цялото хранилище, включително пълната му история. [Децентрализирани]
Администраторите имат подробен контрол върху това кой какво може да прави и освен това е много по-лесно да се администрира. [Централизирани]
Ако сървърът загине, хранилището на даден проект може да се възстанови от локалното копие на всеки клиент. [Децентрализирани]
Всички данни се пазят на едно място и зависят от надеждността на сървъра, който ги съхранява. [Централизирани]
Ако сървърът по някаква причина не е достъпен за час - тогава през този час никой не може да качва своите промени. [Централизирани]
// // // // // // // // ТЕСТ 3
Имате за задача да създадете училищна система за записване и отписване на ученици. За целта трябва да създадете някои класове, методи и свойства.
За ваше удобство ще ви бъде предоставен скелет на задачата, който обаче е непълен/неработещ/некоректен. Предоставеният скелет трябва да се приведе в работещ вид.
Клас School
Създайте клас School:
· Класът трябва да притежава поле за съхранение на записаните ученици
· Конструктор, който да получава като параметър името на училището
· Свойство Name, което да пази името на училището
· Метод EnrollStudent(Student student) – методът трябва да има функционалност да записва ученици в даденото училище
· Метод UnenrollStudent(int id) – методът трябва да може да премахва ученик от системата по подадено id на ученика. Ако няма записани ученици в системата на училището или ако такова ID не съществува в системата отпечатайте: “No such Id in our database!” 16 ТОЧКИ
using System;
public class Student { private static int counter = 0;
public Student(string firstName, string lastName)
{
counter++;
this.StudentId = counter;
this.FullName = firstName + " " + lastName;
}
public int StudentId { get; set; }
public string FullName { get; private set; }
public override string ToString()
{
return $"Student ID: {StudentId} Name: {FullName}";
}
}
using System; using System.Collections.Generic; using System.Linq; using System.Text;
public class School { private List<Student> students;
public School(string name)
{
this.Name = name;
this.students = new List<Student>();
}
public string Name { get; private set; }
public void EnrollStudent(Student student)
{
students.Add(student);
}
public Student UnenrollStudent(int id)
{
Student student = students.FirstOrDefault(s => s.StudentId == id);
if (student == null)
{
return null;
}
students.Remove(student);
return student;
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($"{this.Name}:");
foreach (var student in students)
{
sb.AppendLine(student.ToString());
}
return sb.ToString().TrimEnd();
}
}
using System;
class Program { static void Main(string[] args) { string schoolName = Console.ReadLine(); School school = new School(schoolName);
string[] command = Console.ReadLine().Split();
while (command[0] != "End")
{
switch (command[0])
{
case "Enroll":
Student student = new Student(command[1], command[2]);
school.EnrollStudent(student);
Console.WriteLine($"{student} was successfully enrolled!");
break;
case "Unenroll":
Student removed = school.UnenrollStudent(int.Parse(command[1]));
if (removed != null)
{
Console.WriteLine($"{removed} was successfully unenrolled!");
}
else
{
Console.WriteLine("No such Id in our database!");
}
break;
case "Print":
Console.WriteLine(school);
break;
}
command = Console.ReadLine().Split();
}
}
}
//
//
//
// Дайте примерен код за метод написан на C#, който да върне най-голямото реално число от даден масив.
// static double MaxNumber(double[] array)
// {
// double max = array[0];
// for (int i = 1; i < array.Length; i++)
// {
// if(array[i]> max)
// {
// max = array[i];
// }
// }
//
// return max;
// }
//
//
// Посочете правилната дефиниция по понятията класове, атрибути и поведение в ООП. Изберете от падащите менюта:
//
// Класът дефинира [характеристиките и поведението на даден обект.].
//
// Атрибутите на класа се [дефинират като собствени променливи в тялото му.].
//
// Поведението на обектите се [моделира чрез дефиниция на методи в класовете].
//
// Атрибутите на класа се наричат още [член променливи].
//
//
// Дефинирайте за кого ще е видимо поле/метод в C#, ако то е с модификатор за достъп private?
// само за класа, в който се намира
//
//
// В C# като статични могат да бъдат декларирани:
// Полета, методи, свойства, конструктори и класове.
//
//
//
//
// Демонстрирайте как бихте използвали статичен член от даден клас в C#.
//
// Имате статичен клас (например Mathematics), който има статичен метод (Add) за събиране на две числа.
//
// Как бихте извикали този статичен метод в класа Program.cs, за да проверите колко е сбора на числата 5 и 6 и да отпечатате стойността на конзолата?
//
// Console.WriteLine(Mathematics.Add(5, 6));
//
//
// Посочете кое от изброените се отнася за конструкторите в C#:
// Конструкторът е специален метод на класа, чрез който инициализираме обекти., Конструкторът се извиква с ключовата дума new., Конструкторът няма тип на връщаната стойност., Конструктор може да бъде с или без параметри.
//
//
//
// Имате следния пример: клас Circle е производен на клас Figure. По кой от следните начини е възможно да се декларират обекти?
// Figure fig = new Figure();,
// Figure fig = new Circle();
// Circle fig = new Circle();
//
// Даден е следния програмен фрагмент. Открийте грешките и запишете правилния код.
// ГРЕШЕН КОД
// public Dog
// {
// private string name;
// private int age;
//
// private Dog(string, int name)
// {
// Name = name;
// Age = age;
// }
//
// public string Name
// {
// get { return Name; }
// private set { name = value; }
// }
// public int age
// {
// get { return age; }
// private set { age = value; }
// }
// }
// ПРАВИЛЕН КОД
// public class Dog
// {
// private string name;
// private int age;
//
// public Dog(string name, int age)//2t
// {
// Name = name;
// Age = age;
// }
//
// public string Name
// {
// get { return name; }//2t
// private set { name = value; }
// }
// public int Age //2t
// {
// get { return age; }
// private set { age = value; }
// }
//
// }
//
// Дайте пример за клас в C#. Нека този клас моделира реалния обект училище(School) и притежава полетата (fields) и свойствата (properties): име (name), адрес (address), информация (information).
//
// public class School
// {
// private string name;
// private string address;
// private string information;
// public string Name
// {
// get { return name; }
// set { name = value; }
// }
// public string Address
// {
// get { return address; }
// set { address = value; }
// }
// public string Information
// {
// get { return information; }
// set { information = value; }
// }
//
// }
//
//
//
//
// Дефиниране на клас BankAccount (банкова сметка)
// Създайте клас BankAccount.
//
// Този клас трябва да има полета за:
//
// · id: int
//
// · balance: decimal
//
// Класът трябва да има свойства за:
//
// · ID: int
//
// · Balance: decimal
//
// Конструктор:
//
// · BankAccount(int id, decimal balance)
//
// Създайте методите:
//
// · Deposit(decimal amount): void – който да вкарва пари в сметката. Ако количество пари, което се подава като параметър на метода е отрицателно число, на конзолата да се изведе съобщение: „Amount must be positive number!“
//
// · Withdraw(decimal amount): void – който да изтегля пари от сметката. Ако количеството пари, което се подава като параметър на метода е повече от наличния баланс, на конзолата да изведе съобщение: „Insufficient Balance!“
//
// Заменете метода ToString()!
//
// using System;
//
// class Program
// {
// static void Main(string[] args)
// {
// BankAccount account = new BankAccount(1, 20);
//
// account.Deposit(100);
// Console.WriteLine(account);
//
// account.Withdraw(200);
// Console.WriteLine(account);
// }
// }
//
//
//
//
//
//
//
// using System;
//
// public class BankAccount
// {
// private int id;
// private decimal balance;
//
// public BankAccount(int id, decimal balance)
// {
// this.Id = id;
// this.Balance = balance;
// }
//
// public int Id
// {
// get { return id; }
// private set { id = value; }
// }
//
// public decimal Balance
// {
// get { return balance; }
// private set { balance = value; }
// }
//
// public void Deposit(decimal amount)
// {
// if (amount < 0)
// {
// Console.WriteLine("Amount must be positive number!");
// return;
// }
//
// this.Balance += amount;
// }
//
// public void Withdraw(decimal amount)
// {
// if (amount > this.Balance)
// {
// Console.WriteLine("Insufficient Balance!");
// return;
// }
//
// this.Balance -= amount;
// }
//
// public override string ToString()
// {
// return $"Account {this.Id}, balance {this.Balance}";
// }
// }
//
//
//
//
//
// Петя е начинаещ програмист и е написала прост клас на C#, но е забравила да спази един много важен принцип в обектно-ориентираното програмиране - а именно спазването на правилната енкапсулация на данните! За да докажете, че различавате модификаторите за достъп до елементите в даден клас, попълнете правилните модификатори в дадения код!
//
//
// [public] class Turtle
// {
// [private] string name;
// [private] int age;
// [public] Turtle(string name, int age)
// {
// Name = name;
// Age = age;
// }
// [public] string Name
// {
// get { return name; }
// [private] set { name = value; }
// }
// [public] int Age
// {
// get { return age; }
// [private] set { age = value; }
// }
//
// [public] void MakeTrick()
// {
// Console.WriteLine("I do a triple somersault!");
// }
// }
//
//
// Обяснете какво правят т.нар getters в C#:
// метод за четене на стойността на едно свойство
//
//
//
// Дайте пример за клас в C#. Нека този клас моделира реалния обект книга и притежава полетата и свойствата: име, автор, брой страници.
// public class Book
// {
// private string name;
// public string Name
// {
// get { return name; }
// set { name = value; }
// }
//
// private string author;
//
// public string Author
// {
// get { return author; }
// set { author = value; }
// }
//
// private int pages;
//
// public int Pages
// {
// get { return pages; }
// set { pages = value; }
// }
// }
//
//
//
//
// Дадени са следните фрагменти от код на C#. От вас се очаква да различавате кое от посочените е конструктор, кое е метод, кое е свойство и кое поле. Срещу всяка снимка има поле, от което трябва да изберете вярното:
// ПОЛЕ
// КОНСТРУКТОР
// СВОЙСТВО
// МЕТОД
//
//
//
//
// Открийте грешката в кода и я поправете, така че програмата да работи правилно:
// ГРЕШЕН КОД
// public class Dog
// {
// private int count;
// public Dog()
// {
// count++;
// }
//
// public int Count { get => count; }
// }
//
// public class Program
// {
// static void Main(string[] args)
// {
// Dog dog = new Dog();
// Console.WriteLine(dog.Count);
// }
// }
//
// ПРАВИЛЕН КОД
// public class Dog
// {
// private static int count;//2т
// public Dog()
// {
// count++;
// }
//
// public static int Count { get => count; }//2т
// }
//
// public class Program
// {
// static void Main(string[] args)
// {
// Dog dog = new Dog();
// Console.WriteLine(Dog.Count);//2т
// }
// }
//
// Дефинирайте за кого ще е видимо поле/метод в C#, ако то е с модификатор за достъп public?
//
// може да бъде достъпен от всеки друг клас, независимо дали е от текущия проект, от текущото пространство от имена или извън тях.
//
//
// Дайте примерен код на C# за метод само за четене на стойността на едно свойство. (Например свойството Age). Спазвайте правилната енкапсулация на данните!
//
// public int Age
// {
// get { return age; }
// }
//
//
//
//
//
//
//
// ТЕСТ 4
//
//
//
// Посочете кое от изброените твърдение е вярно за класовете в C#.
//
// Можем да създаваме инстанции., Описва състоянието и поведението на обектите
//
//
//
// Свържете кои от характеристиките се отнасят за абстракцията, кои за енкапсулацията.
// Енкапсулация
// Абстракция
// Абстракция
// Енкапсулация
//
//
//
//
//
// Създайте следната йерархия от класове и интерфейси.
//
// За ваше удобство ще ви бъде предоставен скелет на задачата, който обаче е непълен/неработещ/некоректен. Предоставеният скелет трябва да се приведе в работещ вид.
//
// Интерфейс IMakeNoise
// · Този интерфейс трябва да съдържа сигнатурата на метод string MakeNoise()
//
// Интерфейс IMakeTrick
// · Този интерфейс трябва да съдържа сигнатурата на метод string MakeTrick()
//
// Интерфейс IAnimal
//
//
//
//
// using System;
// using System.Collections.Generic;
// using System.Linq;
//
// // INTERFACES
// interface IMakeNoise
// {
// string MakeNoise();
// }
//
// interface IMakeTrick
// {
// string MakeTrick();
// }
//
// interface IAnimal : IMakeNoise, IMakeTrick
// {
// string Type { get; }
// string Name { get; }
// void Perform();
// }
//
// // ABSTRACT CLASS
// abstract class Animal : IAnimal
// {
// private string name;
//
// protected Animal(string name)
// {
// this.Name = name;
// }
//
// public string Name
// {
// get { return name; }
// private set
// {
// if (string.IsNullOrWhiteSpace(value))
// {
// throw new ArgumentException("Name can't be null or empty!");
// }
// name = value;
// }
// }
//
// public abstract string Type { get; }
//
// public abstract string MakeNoise();
// public abstract string MakeTrick();
//
// public void Perform()
// {
// Console.WriteLine($">>> {this.MakeNoise()}");
// Console.WriteLine($">>> {this.MakeTrick()}");
// }
//
// public override string ToString()
// {
// return $"{this.Type} {this.Name}";
// }
// }
//
// // CAT
// class Cat : Animal
// {
// public Cat(string name) : base(name) { }
//
// public override string Type => "Cat";
//
// public override string MakeNoise()
// {
// return "Meow!";
// }
//
// public override string MakeTrick()
// {
// return "No trick for you! I'm too lazy!";
// }
// }
//
// // DOG
// class Dog : Animal
// {
// public Dog(string name) : base(name) { }
//
// public override string Type => "Dog";
//
// public override string MakeNoise()
// {
// return "Woof!";
// }
//
// public override string MakeTrick()
// {
// return "Hold my paw, human!";
// }
// }
//
// // TRAINER
// class Trainer
// {
// private IAnimal entity;
// private string name;
//
// public Trainer(string name, IAnimal entity)
// {
// this.Name = name;
// this.Entity = entity;
// }
//
// public string Name
// {
// get { return name; }
// private set
// {
// if (string.IsNullOrWhiteSpace(value))
// {
// throw new ArgumentException("Name can't be null or empty!");
// }
// name = value;
// }
// }
//
// public IAnimal Entity
// {
// get { return entity; }
// private set { entity = value; }
// }
//
// public void Work(IAnimal entity)
// {
// this.Entity = entity;
// Console.WriteLine($"Trainer {this.Name} works with {Entity}!");
// }
//
// public void Make()
// {
// this.Entity.Perform();
// }
// }
//
// // PROGRAM
// class Program
// {
// static void Main(string[] args)
// {
// List<IAnimal> animals = new List<IAnimal>();
//
// int n = int.Parse(Console.ReadLine());
//
// for (int i = 0; i < n; i++)
// {
// string[] line = Console.ReadLine().Split();
// IAnimal animal = CreateAnimal(line);
// animals.Add(animal);
// }
//
// string trainerName = Console.ReadLine();
// Trainer trainer = null;
//
// string name = Console.ReadLine();
//
// while (name != "End")
// {
// IAnimal current = animals.FirstOrDefault(a => a.Name == name);
//
// if (current == null)
// {
// Console.WriteLine("No such name in the Database!");
// }
// else
// {
// if (trainer == null)
// {
// trainer = new Trainer(trainerName, current);
// }
//
// trainer.Work(current);
// trainer.Make();
// }
//
// name = Console.ReadLine();
// }
// }
//
// private static IAnimal CreateAnimal(string[] line)
// {
// switch (line[0])
// {
// case "Cat": return new Cat(line[1]);
// case "Dog": return new Dog(line[1]);
// default: return null;
// }
// }
// }
//
//
//
//
//
//
// Свържете кои от характеристиките се отнасят за абстрактните класове, кои за интерфейсите.
// Абстракция
// Абстракция
// И за двете
// Абстракция
// Интерфейси
// Интерфейси
//
//
//
//
// Дайте пример чрез код на C# за това как и къде бихте използвали презаписване на методи.
//
// Например имате класовете Animal и Dog. Имате и един единствен метод MakeTrick(), който трябва да отпечатва на конзолата за всички животни, че по подразбиране не могат да правят никакъв трик ("No trick!"). Само и единствено кучето умее трика да подава лапа ("Give a paw!").
//
// Реализирайте примера чрез код на C#.
//
// class Animal
// {
// public virtual void MakeTrick()
// {
// Console.WriteLine("No trick...");
// }
// }
// class Dog : Animal
// {
// public override void MakeTrick()
// {
// Console.WriteLine("Give a paw...");
// }
// }
//
//
//
//
// Дайте пример за абстракция. Напишете примерен код, който:
//
// Има класовете BaseEmployee, FullTimeEmployee и ContractEmployee.
//
// Условието на задачата е всички работници да имат име, както и метод CalculateSalary(int workingHours) - който ще изчислява заплатата за работника, като се приема параметър – брой изработени часове.
//
// Заплатата на FullTimeEmployee се изчислява по формулата: 250 + workingHours*10.80.
//
// А заплатата на ContractEmployee по формулата: 250 + workingHours*20.
//
// Спазвайте принципа за абстракция в обектно-ориентираното програмиране.
//
// abstract class BaseEmployee
// {
// public string Name { get; set; }
// public abstract double CalculateSalary(int workingHours);
// }
//
// class FullTimeEmployee : BaseEmployee
// {
// public override double CalculateSalary(int workingHours)
// {
// return 250 + workingHours * 10.80;
// }
// }
//
// class ContractEmployee : BaseEmployee
// {
// public override double CalculateSalary(int workingHours)
// {
// return 250 + workingHours * 20;
// }
// }
//
//
//
//
//
// Посочете по какъв начин бихте декларирали шаблонен клас (с примерно име MyClass) в C#.
// class MyClass<T>
// {
//
// }
//
//
//
//
//
//
// Имате следния код:
//
// public List<int> CreateList(int item, int count)
// {
// List<int> list = new List<int>();
// for (int i = 0; i < count; i++)
// {
// list.Add(item);
// }
// }
//
// Модифицирайте кода,така че методът да работи с всякакъв тип данни.
//
// public List<T> CreateList<T>(T item, int count)//2т
// {
// List<T> list = new List<T>();//2т
// for (int i = 0; i < count; i++)
// {
// list.Add(item);
// }
// return list;//2т
// }
//
//
// Посочете видовете полиморфизъм в .NET.
// Полиморфизъм по време на компилиране., Полиморфизъм по време на изпълнение.
//
//
//
//
// Открийте разликите между клас и интерфейс. Кои от изброените твърдения се отнасят за класовете в C#, кои за интерфейсите?
//
// Има както дефиниция, така и реализация. [Клас]
//
// Има само дефиниция. [Интерфейс]
//
// Не може да бъде инстанциран. [Интерфейс]
//
// Може да бъде инстанциран. [Клас]
//
// Може да съдържа членове, методи, заедно с дефиниция и реализация. [Клас]
//
// Набор от дефиниции, които трябва да се приложат. [Интерфейс]
//
//
//
// Посочете кое от изброените твърдение е вярно за интерфейсите в C#.
//
// Предоставя договор, определящ как да се създаде обект, без да се интересува от спецификата на това как обекта ще прави нещата., Това е референтен тип и включва само абстрактни членове като събития, методи, свойства и т.н. и няма реализации за нито един от своите членове.
//
//
//
//
// Дефинирайте понятието полиморфизъм в обектно-ориентираното програмиране като попълните липсващите думи в текста.
//
// Полиморфизмът в обектно-ориентираното програмиране представлява свойството на обектите от един и същи [тип] да имат един и същи [интерфейс], но с [различна реализация] на този [интерфейс]. „Един [интерфейс], [множество от различни реализации]“. Чрез полиморфизма се постига по-голяма [абстракция ] и по-лесно [повторно използване] на кода.
//
//
//
//
// Открийте липсващите думи в текста:
//
// Възможността референция към [базов клас ] да сочи обект както от базовия, така и обект от някой от производните класове е в основата на реализацията на [полиморфизма ] в езика C#.
//
// Кои от следните примери потвърждават това правило, ако имате следната йерархия class Cat : class Animal ?
//
// Cat cat = new Animal(); [не]
//
// Animal animal = new Animal(); [да]
//
// Animal animal = new Cat(); [да]
//
//
//
//
//
//
// Дайте пример за шаблонен клас, който да се казва Кутия (Box) и тази кутия да може да съхраняват всякакви елементи. В този клас създайте и един метод (Add), който да добавя елемент в края на редицата.
//
// class Box<T>
// {
// private List<T> items;
//
// public Box()
// {
// items = new List<T>();
// }
// public void Add(T item)
// {
// this.items.Add(item);
// }
// }
//
//
//
// Посочете кое от изброените е дефиниция на метод, който може да бъде презаписан в клас наследник.
// Виртуален метод.
//
//
//
//
// Дефинирайте понятието наследяване от обектно-ориентираното програмиране като попълните липсващите думи в текста.
//
// Наследяването е [основен принцип] от обектно-ориентираното програмиране. То позволява на един клас да "наследява" [поведение и характеристики] от друг, по-общ клас.
//
// В .NET и други модерни езици за програмиране един клас може да наследи [само един друг клас].
//
//
// Класът, който [дава ] своите членове на [дъщерния] си клас се нарича [базов] клас. А класът, който [получава] членове от [своя базов клас] - [подклас].
//
//
//
//
//
// Дефинирайте термина полиморфизъм в обектно-ориентираното програмиране, като поставите липсващите думи в текста.
//
// Терминът полиморфизъм в обектно-ориентираното програмиране определя, че [едни и същи (еднотипни)] действия се реализират по [различен начин] в зависимост от обектите, върху които се прилагат. Такива действия се наричат [полиморфични]. За да се реализира [полиморфно действие], класовете на обектите, върху които се прилага това действие, трябва да имат [общ корен] т.е. да бъдат производни на [един и същи клас].
//
//
//
//
//
// Обяснете основните разлики между презареждане и презаписване на методи.
//
// Методи с едно и също име, но различни сигнатури. [Презареждане на методи]
// Може да се случи в същия клас или в негов подклас. [Презареждане на методи]
// Може да се случи в подкласовете. [Презаписване на методи]
// Трябва да има същия тип на връщана стойност. [Презаписване на методи]
// При компилиране, според подадените параметри компилатора определя кой метод точно ще изпълни. [Презареждане на методи]
// Модификатора за достъп не може да бъде по-ограничаващ. [Презаписване на методи]
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 5
//
//
//
// Посочете какво представлява и какво прави Current() от интерфейса IEnumerator:
// Current е свойството, което връща елемента от колекцията, който е на текущата позиция на итератора.
//
//
//
//
// Направете сравнение между IEnumerable и IEnumerator, като поставите липсващите думи в текста:
//
// IEnumerable се използва за [generic интерфейс], но IEnumerator се използва за [non‑generic интерфейс].
// IEnumerable има [само един метод], докато IEnumerator има [само два метода].
// IEnumerable [може да върне IEnumerator]. IEnumerator [не може да върне IEnumerable].
//
//
//
//
//
// Демонстрирайте как ще направите имплементацията на IComparable<T> като ви е предоставен следния фрагмент от код:
//
//
//
// class Point : [IComparable<Point>]
// {
// public int X { get; set; }
// public int Y { get; set; }
// public int [CompareTo(Point otherPoint)]
// {
// if (this.X != otherPoint.X)
// return (this.X - otherPoint.X);
//
// if (this.Y != otherPoint.Y)
// return (this.Y - otherPoint);
// return 0;
// }
// }
//
//
//
//
//
//
// Дефинирайте понятието функция, като попълните липсващите думи в текста.
//
// Функцията е [специално отношение], където на [всички входни данни] има [еднозначен изход].
//
//
//
//
// Имате следното парче код:
// Какво ще се случи след изпълнението на програмата? Ще се изведе ли нещо като резултат и какъв ще бъде той? Запишете вашия отговор в полето.
//
// На конзолата ще се отпечатат всички нечетни числа. 15 1 5 7
//
//
//
//
//
//
// Напишете програма, която въвежда цели числа разделени с ", ". Изведете четните числа в множеството, сортирани в низходящ ред.
//
// Изберете какъв тип на структури от данни ще използвате за решаване на този проблем. Използвайте функционален програмен филтър, сортирайте и отпечатайте на конзолата колекцията от числа на един ред разделени с ", ".
//
// За примерни входни/изходни данни ползвайте следните таблици:
//
// List<int> list = Console.ReadLine()
// .Split(", ", StringSplitOptions.RemoveEmptyEntries)
// .Select(int.Parse)
// .Where(x => x % 2 == 0)
// .OrderByDescending(x => x)
// .ToList();
//
// Console.WriteLine(string.Join(", ", list));
//
//
//
//
//
//
//
// Имате даден следния програмен фрагмент:
//
// int[] nums = { 1, 2, 3, 4, 5, 6 };
// nums = nums[.Where(num => num % 2 == 0)].ToArray();
//
// Коя от следните LINQ заявки и какъв ламбда израз ще използвате, за да филтрирате колекцията, така че тя да съдържа само четни числа?
//
//
//
//
// Имате даден следния програмен фрагмент:
//
// int[] nums = { 11, 99, 33, 55, 77, 44, 66, 22, 88 };
//
// nums = nums[.OrderBy(x => x)].ToArray();
// Коя от следните LINQ заявки ще използвате, за да подредите числата в колекцията във възходящ ред?
//
//
//
//
//
//
//
// Обяснете следния фрагмент от код с думи:
//
// int[] nums = { 1, 2, 3, 4, 5, 6 };
//
// int[] otherNums = { 7, 8, 9, 0 };
//
// nums = nums.Concat(otherNums);
//
//
// Console.WriteLine(string.Join(", ", nums));
//
// В полето запишете ред по ред какво прави кода и какво се очаква да получим като резултат.
//
//
//
// Инициализираме масив от цели числа nums и друг масив от цели числа otherNums.
//
// Конкатенираме (или слепваме) двата масива - масив otherNums се "залепя" след масива nums.
//
// Отпечатваме на конзолата елементите от масива на един ред разделени със ", ".
//
// Очакван резултат:
//
// 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
//
//
//
//
//
//
//
// Обяснете следния фрагмент от код с думи:
//
// List<int> list = new List<int>() { 20, 15, 1, 5, 7, 18, 66 };
//
// list.OrderByDescending(x => x).Take(3);
//
// Console.WriteLine(string.Join(", ", list));
//
// В полето запишете ред по ред какво прави кода и какво се очаква да получим като резултат.
//
//
//
// Инициализираме списък с цели числа.
//
// Сортираме числата от колекцията в низходящ ред и вземаме първите три числа от тях.
//
// Очакван резултат: 20, 15, 1, 5, 7, 18, 66
//
// Списъкът с числа си остава същия, защото OrderByDescending връща нов IOrderedEnumerable списък, а в дадения код не се презаписва новата подредба на числата върху предишния списък с числа.
//
//
//
//
//
//
//
//
// На конзолата ще ви бъдат подадени цели числа записани на един ред и разделени с интервал. Например: 5 7 12 56 24 3 8
//
// Напишете собствена функция на C# за парсване на цели числа. Запишете числата в подходяща структура от данни, след което отпечатайте числата на конзолата на един ред разделени със запетая и интервал.
//
// string input = Console.ReadLine();
// Func<string, int> parser = (x) => int.Parse(x);
// int[] nums = input.Split().Select(parser).ToArray();
// Console.WriteLine(string.Join(", ", nums));
//
//
//
//
//
//
//
// Опишете какво представляват референциите към функции/методи в C#, като поставите липсващите думи в текста:
//
// Ламбда функциите могат да бъдат записани в променливи от тип [делегат]. [Делегатите] представляват специален тип [променливи], които съдържат [функции]. Типовете Func и Action са [generic] и съдържат: на последна позиция [типа на връщаната стойност], а на първите позиции се задават [типовете на параметрите] на функциите. Променливите от тези типове са [референции] към функции.
//
//
//
//
//
//
//
//
//
//
//
//
// Имате следния примерен код:
//
// class Person
// {
// private int age;
//
// public int Age
// {
// get { return age; }
// private set
// {
// if(value < 0)
// {
// [throw new ArgumentOutOfRangeException("Age must be positive number!");]
// }
// age = value;
// }
// }
// }
//
// По какъв начин ще хвърлите изключение, че числото, което е въведено е невалидно?
//
//
//
//
//
//
//
//
// Обяснете какво ще се случи, ако потребителя напише в конзолата 123. Също така какво ще се случи, ако потребителя реши да въведе Hello.
//
// Ако потребителя въведе цяло число, това число ще се отпечата на конзолата и изпълнението на програмата се прекратява.
// Когато потребителя въведе вход на конзолата различен от цяло число, програмата ще прихване изключението FormatException и на конзолата ще се отпечата съобщение за грешка Input string was not in a correct format. Програмата се изпълнява докато потребителя въведе цяло число.
//
//
//
//
//
//
//
// Обяснете какво ще се случи и защо, ако потребителя въведе числото 2147483648:
//
// Ако потребителя въведе числото 2147483648 програмата ще хвърли изключение от типа System.OverflowException със следното съобщение за грешка: Value was either too large or too small for an Int32.
// Това се получава така, защото липсва catch клауза за прихващане на изключение от този тип.
//
//
//
//
//
//
//
//
// Напишете програма на C#, която да дефинира делегат, който може да приема метод, който сумира две реални числа. Накрая резултатът да се отпечата на конзолата.
//
//
// public delegate double SumDelegate(double firstNumber, double secondNumber);
// class Program
// {
// static void Main(string[] args)
// {
// SumDelegate del = new SumDelegate(Sum);
// Console.WriteLine(del(2.5, 3.14));
// }
//
// private static double Sum(double firstNumber, double secondNumber)
// {
// return firstNumber + secondNumber;
// }
// }
//
//
//
//
//
//
//
//
//
// Имате даден следният програмен фрагмент:
//
// Program.cs
//
// try
// {
// string name = Console.ReadLine();
// int age = int.Parse(Console.ReadLine());
// Person person = new Person(name, age);
// }
// catch (ArgumentNullException ex)
// {
// Console.WriteLine(ex.Message);
// }
//
//
//
// Person.cs
//
// private string firstName;
// private int age;
//
// public Person(string firstName, int age)
// {
// FirstName = firstName;
// Age = age
// }
//
// public string FirstName
// {
// get { return firstName; }
// private set
// {
// if (string.IsNullOrEmpty(value) || string.IsNullOrWhiteSpace(value))
// {
// throw new ArgumentNullException("value", "The first name cannot be null or empty");
// }
// firstName = value;
// }
// }
//
// public int Age
// {
// get { return age };
// private set
// {
// if(value < 0 || value > 120)
// {
// throw new ArgumentOutOfRangeException("value", "Age should be in the range [0..120]");
// }
// age = value;
// }
// }
//
//
//
// При подадени входни данни (например: Pepi и -5) изпълнението на кода води до грешки!
//
// Вашата задача е да предотвратите сриването на програмата, така че тя да продължава своето изпълнение, без да спира принудително! Открийте и поправете грешките, така че да реши поставената задача!
//
//
//
//
// try
// {
// string name = Console.ReadLine();
// int age = int.Parse(Console.ReadLine());
//
// Person person = new Person(name, age);
// }
// catch (ArgumentNullException ex)
// {
// Console.WriteLine(ex.Message);
// }
// catch (ArgumentOutOfRangeException ex)
// {
// Console.WriteLine(ex.Message);
// }
// catch (FormatException ex)
// {
// Console.WriteLine("Invalid input for age!");
// }
//
//
//
//
//
//
//
//
//
//
//
// public class Person
// {
// private string firstName;
// private int age;
//
// public Person(string firstName, int age)
// {
// FirstName = firstName;
// Age = age;
// }
//
// public string FirstName
// {
// get { return firstName; }
// private set
// {
// if (string.IsNullOrWhiteSpace(value))
// {
// throw new ArgumentNullException("value", "The first name cannot be null or empty");
// }
// firstName = value;
// }
// }
//
// public int Age
// {
// get { return age; }
// private set
// {
// if (value < 0 || value > 120)
// {
// throw new ArgumentOutOfRangeException("value", "Age should be in the range [0..120]");
// }
// age = value;
// }
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Имате даден клас Book със следните членове на класа. Авторите може да са анонимни, един или повече. Book трябва да има само един конструктор!
//
// Book.cs
//
// private string title;
// private int year;
// public Book(string title, int year)
// {
// this.Title = title;
// this.Year = year;
// this.Authors = authors;
// }
// public string Title
// {
// get { return title; }
// private set { title = value; }
// }
// public int Year
// {
// get { return year; }
// private set { year = value; }
// }
// public IReadOnlyList<string> Authors { get; private set; }
//
// public override string ToString()
// {
// return $"{this.Title} - {this.Year} Authors: {string.Join(", ", this.Authors)}"; }
//
//
//
// Имате даден и клас Library със следните членове на класа. Той трябва да съхранява колекция книги. Library може да е инициализиран без книги или с какъвто и да е брой книги и трябва да има само един конструктор.
//
//
//
// Library.cs
//
// private List<Book> books;
//
// public Library()
// {
// this.books = new List<Book>(books);
// }
//
// public IEnumerator<Book> GetEnumerator()
// {
// foreach (var book in this.books)
// {
//
// }
// }
//
// IEnumerator IEnumerable.GetEnumerator()
// {
// return this.GetEnumerator();
// }
//
//
//
// Имате даден и Program.cs файла:
//
// Program.cs
//
// Book bookOne = new Book("Animal Farm", 2003, "George Orwell");
// Book bookTwo = new Book("The Documents in the Case", 2002, "Dorothy Sayers", "Robert Eustace");
// Book bookThree = new Book("The Documents in the Case", 1930);
//
// Library library = new Library(bookOne, bookTwo, bookThree);
//
// foreach (var book in library)
// {
// Console.WriteLine(book);
// }
//
//
//
// Книгите и библиотеката трябва да могат да се използват по дадения начин. Не променяйте нищо по Program.cs файла!
//
// Кодът е грешен/непълен. Вашата задача е да откриете и поправите грешките в кода, така че той да работи правилно!
//
// При правилно работещ код като изход в конзолата трябва да получите следният резултат:
//
// Изход
//
// Animal Farm - 2003 Authors: George Orwell
//
// The Documents in the Case - 2002 Authors: Dorothy Sayers, Robert Eustace
//
// The Documents in the Case - 1930 Authors:
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// PRAVILNITE
//
//
//
//
//
//
// using System.Collections.Generic;
// using System.Linq;
//
// public class Book
// {
// private string title;
// private int year;
//
// public Book(string title, int year, params string[] authors)
// {
// this.Title = title;
// this.Year = year;
// this.Authors = authors.ToList().AsReadOnly();
// }
//
// public string Title
// {
// get { return title; }
// private set { title = value; }
// }
//
// public int Year
// {
// get { return year; }
// private set { year = value; }
// }
//
// public IReadOnlyList<string> Authors { get; private set; }
//
// public override string ToString()
// {
// return $"{this.Title} - {this.Year} Authors: {string.Join(", ", this.Authors)}";
// }
// }
//
//
//
//
//
//
//
//
//
// using System.Collections;
// using System.Collections.Generic;
//
// public class Library : IEnumerable<Book>
// {
// private List<Book> books;
//
// public Library(params Book[] books)
// {
// this.books = new List<Book>(books);
// }
//
// public IEnumerator<Book> GetEnumerator()
// {
// foreach (var book in this.books)
// {
// yield return book;
// }
// }
//
// IEnumerator IEnumerable.GetEnumerator()
// {
// return this.GetEnumerator();
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
// Напишете програма, която изпълнява някои математически операции върху дадена колекция. На първия ред са дадени списък от числа. На следващите редове се подават различни команди, които трябва да се прилагат за всички числа в списъка:
//
// · "add"-> добави 1 към всяко число;
//
// · "multiply"-> умножава всяко число по 2;
//
// · "subtract"-> изважда 1 от всяко число;
//
// · "print"-> извежда колекцията.
//
// · Входът ще приключи с команда "end".
//
// · Използвайте функции.
//
// Примери:
//
// Вход
//
// Изход
//
// 1 2 3 4 5
//
// add
//
// add
//
// print
//
// end
//
// 3 4 5 6 7
//
// 5 10
//
// multiply
//
// subtract
//
// print
//
// end
//
// 9 19
//
// За ваше улеснение ви е предоставен Program.cs файл. Кодът обаче е грешен/непълен. Вашата задача е да откриете и поправите грешките в кода, така че той да работи правилно!
//
// Program.cs
//
// List<int> numbers = Console.ReadLine()
//
// .Split()
//
// .Select(int.Parse)
//
// .ToList();
//
//
//
// string cmd = Console.ReadLine();
//
//
//
// while (!cmd.Equals("end"))
//
// {
//
// switch (cmd)
//
// {
//
// case "add":
//
// numbers = numbers.Select(addition).ToList();
//
// break;
//
// case "multiply":
//
// numbers = numbers.Select(multiplication).ToList();
//
// break;
//
// case "subtract":
//
// numbers = numbers.Select(subtraction).ToList();
//
// break;
//
// case "print":
//
// foreach (var item in numbers)
//
// {
//
// print(item);
//
// }
//
// Console.WriteLine();
//
// break;
//
// }
//
//
//
// cmd = Console.ReadLine();
//
// }
//
//
//
//
//
//
//
//
//
// PRAVILNITE
//
//
//
//
//
//
//
//
//
// using System;
// using System.Collections.Generic;
// using System.Linq;
//
// class Program
// {
// static void Main()
// {
// List<int> numbers = Console.ReadLine()
// .Split()
// .Select(int.Parse)
// .ToList();
//
// string cmd = Console.ReadLine();
//
// while (!cmd.Equals("end"))
// {
// switch (cmd)
// {
// case "add":
// numbers = numbers.Select(Addition).ToList();
// break;
//
// case "multiply":
// numbers = numbers.Select(Multiplication).ToList();
// break;
//
// case "subtract":
// numbers = numbers.Select(Subtraction).ToList();
// break;
//
// case "print":
// foreach (var item in numbers)
// {
// Print(item);
// }
// Console.WriteLine();
// break;
// }
//
// cmd = Console.ReadLine();
// }
// }
//
// static int Addition(int x)
// {
// return x + 1;
// }
//
// static int Multiplication(int x)
// {
// return x * 2;
// }
//
// static int Subtraction(int x)
// {
// return x - 1;
// }
//
// static void Print(int x)
// {
// Console.Write(x + " ");
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
// Имате даден клас Person:
//
// Person.cs
//
// private string name;
// private int age;
// private string city;
//
// public Person(string name, int age, string city)
// {
// Name = name;
// Age = age;
// City = city;
// }
//
// public string Name
// {
// get { return name; }
// private set { name = value; }
// }
// public int Age
// {
// get { return age; }
// private set { age = value; }
// }
// public string City
// {
// get { return city; }
// private set { city = value; }
// }
//
//
//
//
// И клас Program.cs. Не променяйте нищо по него!
//
// Program.cs
//
// List<Person> people = new List<Person>();
//
// string cmd = Console.ReadLine();
//
// while (!cmd.Equals("END"))
// {
// string[] info = cmd.Split();
// Person person = new Person(info[0], int.Parse(info[1]), info[2]);
// people.Add(person);
//
// cmd = Console.ReadLine();
// }
//
// int n = int.Parse(Console.ReadLine());
//
// Person p = people[n - 1];
// int equalsPeopleCount = 0;
// int notEqualsPeoplesCount = 0;
//
// for(int i = 0; i < people.Count; i++)
// {
// if(i == n - 1)
// {
// continue;
// }
// if(people[i].CompareTo(p) == 0)
// {
// equalsPeopleCount++;
// }
// else
// {
// notEqualsPeoplesCount++;
// }
// }
//
// Console.WriteLine(equalsPeopleCount == 0 ? "No matches!" :
// $"{equalsPeopleCount} {notEqualsPeoplesCount} {people.Count}");
//
//
//
//
// Вашата задача е да сравните хората - първо сравнете имената им, след това – възрастите им, а накрая – градовете им.
//
// На единствения ред от изхода изведете статистики: колко хора са еднакви с него, колко не са и общият брой хора във вашата колекция.
//
// Формат: {брой еднакви хора} {брой нееднакви хора} {общ брой хора}
//
// Вход:
//
// На всеки ред ще получавате човек във формат:
//
// {име} {възраст} {град}
//
// Колекционирайте ги, докато не получите "END"
//
// След това ще получите цяло число N - Nтия човек в колекцията ви. Започвайки от 1.
//
// Примери:
//
// Вход
//
// Изход
//
// Pesho 22 Vraca
//
// Gogo 14 Sofeto
//
// END
//
// 2
//
// No matches
//
// Pesho 22 Vraca
//
// Gogo 22 Vraca
//
// Gogo 22 Vraca
//
// END
//
// 2
//
//
//
//
//
//
//
//
//
// PRAVILNITE
//
//
//
//
//
//
// using System;
//
// public class Person : IComparable<Person>
// {
// private string name;
// private int age;
// private string city;
//
// public Person(string name, int age, string city)
// {
// Name = name;
// Age = age;
// City = city;
// }
//
// public string Name
// {
// get { return name; }
// private set { name = value; }
// }
//
// public int Age
// {
// get { return age; }
// private set { age = value; }
// }
//
// public string City
// {
// get { return city; }
// private set { city = value; }
// }
//
// public int CompareTo(Person other)
// {
// int result = this.Name.CompareTo(other.Name);
//
// if (result != 0)
// return result;
//
// result = this.Age.CompareTo(other.Age);
//
// if (result != 0)
// return result;
//
// return this.City.CompareTo(other.City);
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
// Напишете програма, която филтрира списък с имена по тяхната дължина. На първия ред ще ви бъде дадено цяло число n, представляващо дължина на име. На втория ред ще ви бъде дадени някои имена като символни низове, разделени с интервал.
//
// Напишете функция, която филтрира само имената, чиято дължина е по-малка или равна на n. И функция, която отпечатва имената.
//
// Използвайте ваши собствени функции!
//
// За ваше улеснение ви е предоставен код, който обаче е грешен/непълен. Вашата задача е да откриете и поправите грешките в кода, така че той да работи правилно!
//
// Program.cs
//
// int length = int.Parse(Console.ReadLine());
// List<string> names = Console.ReadLine().Split().ToList();
//
// names.Where()
// .ToList()
// .ForEach();
//
//
//
//
// Примери:
//
// Вход
//
// Изход
//
// 4
// Kurnelia Qnaki Geo Muk Ivan
//
//
// Geo
// Muk
// Ivan
//
// 4
// Karaman Asen Kiril Yordan
//
// Asen
//
//
//
//
//
//
//
//
//
//
//
// PRAVILNITE
//
//
//
//
//
//
//
//
//
//
//
// using System;
// using System.Collections.Generic;
// using System.Linq;
//
// class Program
// {
// static void Main()
// {
// int length = int.Parse(Console.ReadLine());
// List<string> names = Console.ReadLine().Split().ToList();
//
// names
// .Where(name => Filter(name, length))
// .ToList()
// .ForEach(Print);
// }
//
// static bool Filter(string name, int length)
// {
// return name.Length <= length;
// }
//
// static void Print(string name)
// {
// Console.WriteLine(name);
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 6
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Имате имплементация на свързана опашка. При така написания код, посочете верния изход в конзолата и броят на елементите в опашката.
//
// var queue = new LinkedQueue<int>();
//
// queue.Enqueue(112);
//
// queue.Enqueue(911);
//
// queue.Enqueue(166);
//
// queue.Enqueue(160);
//
// queue.Enqueue(150);
//
// queue.Dequeue();
//
//
//
// Console.WriteLine(string.Join(" ", queue));
//
// Console.WriteLine("Count = {0}", queue.Count);
//
//
// Правилният отговор е: 911, 166, 160, 150, Count = 4
//
//
//
//
//
//
//
//
//
// Опишете какво прави методът Pop(), принадлежащ на класа Stack?
// премахва най-горния елемент в стека
//
//
//
//
//
//
//
//
//
// Отговорете кое от следните твърдения е вярно за разтеглив масив?
// структура от данни, която е масив по своята същност, но за разлика от обикновеният масив може да променя размера си
//
//
//
//
//
//
// Опишете какво прави методът Push(), принадлежащ на класа Stack?
// Добавя елемент най-горе в стека
//
//
//
//
//
//
//
// Имате даден следния програмен фрагмент:
// Този фрагмент е част от имплементацията на линейната структура от данни стек - премахване на елемент от стек. В кода има грешка! Вашата задача е да откриете грешката, да обясните каква е тя и по какъв начин ще я поправите!
//
//
//
// public T Pop(int index)
// {
// if (this.Count == 0)
// {
// throw new InvalidOperationException("Empty stack");
// }
//
// T element = this.items[index];
//
// for (int i = index; i < this.Count - 1; i++)
// {
// this.items[i] = this.items[i + 1];
// }
//
// this.items[this.Count - 1] = default(T); // по желание
// this.Count--;
//
// return element;
// }
//
//
//
//
//
//
//
// Опишете какво прави методът Peek() от класа Stack?
// връща най-горния елемент в стека, без да го премахва
//
//
//
//
//
//
// Посочете кой от следните примери показва добавяне на елемент към стек в C#, който е създаден по следния начин: (забележете че се създава нова структура от данни, без да са добавени нови елемнти в нея):
// Stack s = new Stack();
// Правилният отговор е: s.Push(325);
//
//
//
//
//
// За ваше удобство ще ви бъде предоставен скелет на задачата, който обаче е непълен/неработещ/некоректен. Предоставеният скелет трябва да се приведе в работещ вид.
//
// Имплементация на разтеглив масив ArrayList<T>
// Имплементирайте структура от данни ArrayList<T> която съдържа поредица от елементи от шаблонен тип T. Структурата трябва да пази поредица от елементи в масив. Структурата трябва да има капацитет, който расте двойно, когато се препълни, като в началото винаги има 2 елемента. Масивът трябва да поддържа следните операции:
//
// · int Count à дава броя на елементите в структрата
//
// · T this[int index] à индексатор, който служи за достъпване на елементите по техния индекс (в интервал 0 … Count-1)
//
// · void Add(T item) à добавя елемент към поредицата и удвоява капацитета на масива, ако е запълнен
//
// · void RemoveAt(int index) à премахва елемента по неговия индекс (в интервала 0 … Count-1)
//
// · Метод Get(int index) – връща елемента на търсената позиция
//
// · Метод Set(int index) – задава стойност на елемента на подадената позиция
//
// · Имплементиране на функционалност за обхождане на колекцията с foreach цикъл
//
//
//
//
//
//
//
//
// using System;
// using System.Collections;
// using System.Collections.Generic;
//
// class Program
// {
// static void Main(string[] args)
// {
// CustomList<string> list = new CustomList<string>();
//
// list.Add("Pesho");
// list.Add("Gosho");
// list.Add("Tosho");
//
// Console.WriteLine(list.Length);
// Console.WriteLine(list.Capacity);
//
// // Console.WriteLine(list.Get(-2)); // ще хвърли exception
// list.Set(2, "Geri");
// Console.WriteLine(list.Get(2));
//
// // list.RemoveAt(-1); // ще хвърли exception
//
// foreach (var item in list)
// {
// Console.WriteLine(item);
// }
// }
// }
//
// class CustomList<T> : IEnumerable<T>
// {
// private const int INITIAL_CAPACITY = 2;
//
// private T[] items;
//
// public int Length { get; private set; }
// public int Capacity { get; private set; }
//
// public CustomList()
// {
// this.Capacity = INITIAL_CAPACITY;
// this.items = new T[this.Capacity];
// this.Length = 0;
// }
//
// public T this[int index]
// {
// get
// {
// CheckIndexOutsideBounds(index);
// return this.items[index];
// }
// set
// {
// CheckIndexOutsideBounds(index);
// this.items[index] = value;
// }
// }
//
// public void Add(T element)
// {
// if (this.Length == this.Capacity)
// {
// Resize();
// }
//
// this.items[this.Length] = element;
// this.Length++;
// }
//
// private void Resize()
// {
// this.Capacity *= 2;
// T[] temp = new T[this.Capacity];
//
// for (int i = 0; i < this.Length; i++)
// {
// temp[i] = this.items[i];
// }
//
// this.items = temp;
// }
//
// public T Get(int index)
// {
// CheckIndexOutsideBounds(index);
// return this.items[index];
// }
//
// public void Set(int index, T element)
// {
// CheckIndexOutsideBounds(index);
// this.items[index] = element;
// }
//
// public void RemoveAt(int index)
// {
// CheckIndexOutsideBounds(index);
//
// for (int i = index; i < this.Length - 1; i++)
// {
// this.items[i] = this.items[i + 1];
// }
//
// this.items[this.Length - 1] = default(T);
// this.Length--;
// }
//
// private void CheckIndexOutsideBounds(int index)
// {
// if (index < 0 || index >= this.Length)
// {
// throw new IndexOutOfRangeException();
// }
// }
//
// public IEnumerator<T> GetEnumerator()
// {
// for (int i = 0; i < this.Length; i++)
// {
// yield return this.items[i];
// }
// }
//
// IEnumerator IEnumerable.GetEnumerator()
// {
// return this.GetEnumerator();
// }
// }
//
//
//
//
//
//
//
//
//
//
//
// Даден е следния програмен фрагмент:
//
// class CustomList
// {
// private class Node
// {
// private object element;
// private Node next;
// public Node(object element, Node prevNode)
// {
// this.Element = element;
// prevNode.Next = this;
// }
// public Node(object element)
// {
// this.Element = element;
// }
// public object Element
// {
// get { return this.element; }
// set { this.element = value; }
// }
// public Node Next
// {
// get { return this.next; }
// set { this.next = value; }
// }
// }
// //полета
// //глава(начало) на списъка
// private Node head;
// //опашка(край) на списъка
// private Node tail;
// //броят на елементите в свързания списък
// private int count;
// public int Count
// {
// get { return this.count; }
// private set { this.count = value; }
// }
// public void Add(object element)
// {
//
// }
//
// Допишете метода Add(object element) който трябва да добави елемент в списъка. Обърнете внимание на това каква имплементация на списъчната структура е използвана - динамична или статична)!
//
//
//
//
//
//
//
//
// public void Add(object element)
// {
// //ако броя на елементите ни е 0, т.е. ако няма елементи в списъка
// if(count == 0)
// {
// //създаваме си един нов нод с елемента, който ни се подава
// Node newNode = new Node(element);
// //в такъв случай и началото и края ще са равни на този нов нод
// head = newNode;
// tail = newNode;
// //и броя на елементите ни се увеличава
// count++;
// }
// //в противен случай, ако вече имаме елементи в нашия списък
// else
// {
// //вече ще ползваме конструктора на класа Node на който подаваме елемента и опашката(предишния нод), или
// //последния елемент в нашия списък
// Node newNode = new Node(element, tail);
// //казваме на последния елемент, че вече ще бъде равен на този нов нод
// tail = newNode;
// //и увеличаваме броя на елементите в нашия списък
// count++;
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
// Дайте пример с C# код, за метод който да сортира елементите от списъка List<int> list = new List<int>() { 12, 8, 10, 2, 9, 6, 1}; посредством алгоритъма за сортиране чрез метода на мехурчето.
//
//
//
//
// using System;
// using System.Collections.Generic;
//
// class Program
// {
// static void Main()
// {
// List<int> list = new List<int>() { 12, 8, 10, 2, 9, 6, 1 };
//
// BubbleSort(list);
//
// Console.WriteLine(string.Join(" ", list));
// }
//
// static void BubbleSort(List<int> list)
// {
// int n = list.Count;
//
// for (int i = 0; i < n - 1; i++)
// {
// for (int j = 0; j < n - i - 1; j++)
// {
// if (list[j] > list[j + 1])
// {
//
// int temp = list[j];
// list[j] = list[j + 1];
// list[j + 1] = temp;
// }
// }
// }
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
// Имате даден следния код:
//
// List<int> list = Console.ReadLine()
// .Split()
// .Select(int.Parse)
// .ToList();
//
// int currVal = list[0];
// int currCount = 1;
// int maxCount = 1;
// int maxValue = currVal;
//
// for (int i = 1; i < list.Count; i++)
// {
// if(currVal == list[i])
// {
// currCount++;
// if(currCount > maxCount)
// {
// maxCount = currCount;
// maxValue = currVal;
// }
// }
// else
// {
// currCount = 1;
// currVal = list[i];
// }
// }
//
// Console.WriteLine($"{maxValue} -> {maxCount}");
//
// Свържете към намирането на коя от следните подредици съответства:
//
// най‑дълга подредица от равни числа
//
//
//
//
//
//
//
//
//
//
// Посочете вярното за следното твърдение:
//
// Enqueue – добавя елемент в края на опашката
//
//
//
//
//
// Обяснете какво прави методът Enqueue(T) , принадлежащ на класа Queue?
//
// добавя елемент в края на опашката
//
//
//
//
//
//
//
//
// Посочете кои са по-важните свойства на алгоритмите?
// всичко изброено
//
//
//
//
//
//
//
//
//
//
//
// Даден е следния програмен фрагмент:
//
// class CustomStack<T>
// {
// private class Node<T>
// {
// public T Value { get; set; }
// public Node<T> PrevNode { get; private set; }
//
// public Node(T value, Node<T> prev = null)
// {
// this.Value = value;
// this.PrevNode = prev;
// }
// }
//
// private Node<T> firstNode;
// public int Count { get; private set; }
//
// public void Push(T element)
// {
//
// }
// }
//
// Допишете метода Push(T element) който трябва да добави елемент в стека. Обърнете внимание на това каква имплементация на списъчната структура е използвана!
//
//
// public void Push(T element)
// {
// this.firstNode = new Node<T>(element, this.firstNode);
// this.Count++;
// }
//
//
//
//
//
//
//
//
//
//
// Обяснете какво прави методът Dequeue() на класа Queue?
// премахва и връща елемента от началото на опашката
//
//
//
//
//
//
//
// Имате дадени следните твърдения:
//
//
//
// Губим възможността за произволен достъп. Няма начин, по който да индексираме k-тия елемент, без да минем през всички k-1 предходни. [Динамична имплементация]
//
// Реализация на списък чрез масив, който автоматично увеличава размера си при нужда. [Статична имплементация]
//
// Операциите добавяне и премахване от вътрешността на списъка изискват пренареждане на елементите. [Статична имплементация]
//
// Операциите добавяне и премахване от вътрешността на списъка е бърза операция. [Динамична имплементация]
//
// Търсенето на елементите в него е сравнително бърза операция. [Статична имплементация]
//
// При често добавяне и премахване (особено при голям брой елементи) това може да доведе до ниска производителност. [Статична имплементация]
//
// Можем да поддържаме паметта точно колкото ни трябва като сложността на добавяне си остава. [Динамична имплементация]
//
// Елементите съдържат само конкретния обект. [Статична имплементация]
//
// Всеки елемент съдържа променлива и указател, сочещ към следващия елемент. [Динамична имплементация]
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 7
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Обяснете какво прави методът Dequeue()?
//
// премахва и връща елемента от началото на опашката
//
//
//
//
//
//
//
// Имате дадени твърдения. Вие трябва да можете да различавате и сравнявате видовете структури от данни. Срещу всяко едно от тези твърдения трябва да зададете правилната структура от данни за която то се отнася.
//
// За добавяне на елемент в структурата от данни използва операцията Push(T). [Стек]
//
// Можем да обходим елементите в структура от данни тип опашка с помощта на for-цикъл. [Твърдението не е вярно]
//
// За премахване на елемент от структурата от данни използва операцията Dequeue(). [Опашка]
//
// За премахване на елемент от структурата от данни използва операцията Pop(). [Стек]
//
// Структура от данни, която има поведението първи влязъл първи излязъл. [Опашка]
//
// Можем да достъп елемент от структурата от данни стек, като използваме операцията Peek(index) неговия индекс. [Твърдението не е вярно]
//
// Структура от данни, която има поведението последен влязъл първи излязъл. [Стек]
//
// За добавяне на елемент в структурата от данни използва операцията Enqueue(T). [Опашка]
//
//
//
//
//
//
//
//
//
//
//
//
//
// Дадени са следните картинки:
//
//
//
//
//
// Това е визуализация на един от алгоритмите за сортиране. За този алгоритъм важи следното правило:
// Взима първият елемент на масива (29) и го сравнява със следващия (10). В случая следващия елемент е по-малък и стойностите се разменят. След това сравнява вторият елемент, който вече е (29) със следващия (14) и тъй като 14 < 29 отново ги разменя. Алгоритъма разменя стойностите, само ако има нужда от това. Ако следващия елемент (напр. 37) е по-голям от предходния (29) тогава елементите няма да се разменят и сравняването ще продължи вече с новото по-голямо число (37) и следващият елемент (14). Продължава така, докато не подреди елементите в масива.
// Посочете кой от видовете алгоритми е използван:
//
// Сортиране на елементите чрез метода на мехурчето.
//
//
//
//
//
//
//
//
//
//
//
// Имате зададени твърдения за два алгоритъма за търсене - двоично търсене и интерполационно търсене. По зададените твърдения и характеристики трябва да сравните двата алгоритъма и да зададете коя от тях към кой от алгоритмите се отнася:
//
// Стойностите в масива трябва да са сортирани и равномерно разпределени. [Интерполационно търсене]
//
// Работи във времева сложност O(log n). [Двоично търсене]
//
// Ако ключът е по-малък от средния елемент, тогава ключът може да лежи само в левия подмасив. [Отнася се и за двата алгоритъма]
//
// Работи във времева сложност O(log(log n)). [Интерполационно търсене]
//
// Ако ключът е по-голям от средния елемент, тогава ключът може да лежи само в десния подмасив. [Отнася се и за двата алгоритъма]
//
// Може да се оцени позицията на стойността на ключа в масива,като се вземат предвид най-малкият и най-големият елемент в масива и дължината на масива. [Интерполационно търсене]
//
// Оценява средната позиция за масива и сравнява този елемент с желания ключ. [Интерполационно търсене]
//
// Ако ключът съвпада със средния елемент, върнете средното местоположение. [Отнася се и за двата алгоритъма]
//
//
//
//
//
//
//
//
//
//
//
//
//
// Имате следният програмен фрагмент, който трябва да сортира елементите в подаден списък. В кода има грешка и не работи правилно.
// При примерен вход: 36 15 1 7 20 8 24
//
// Програмата извежда като резултат следното: 1 1 1 7 8 8 24
//
// А трябва да изведе сортираните елементи: 1 7 8 15 20 24 36
//
// var list = Console.ReadLine().Split().Select(int.Parse).ToList();
// for (int i = 0; i <= list.Count - 2; i++)
// {
// for (int i = 0; i <= list.Count - 2; i++)
// {
// if (list[i] < list[i + 1])
// {
// list[i] = list[i + 1];
// list[i + 1] = list[i];
// }
// }
// }
// Console.WriteLine(string.Join(" ", list));
//
// Вашата задача е да откриете грешката, да я поправите и да запишете в полето вече правилно работещ код.
//
// PRAVILEN KOD
//
//
//
//
// var list = Console.ReadLine().Split().Select(int.Parse).ToList();
//
// for (int i = 0; i <= list.Count - 2; i++)
// {
// for (int j = 0; j <= list.Count - 2; j++)
// {
// if (list[j] > list[j + 1])
// {
// int temp = list[j];
// list[j] = list[j + 1];
// list[j + 1] = temp;
// }
// }
// }
//
// Console.WriteLine(string.Join(" ", list));
//
//
//
//
//
//
//
//
//
//
//
// Даден е аритметичен израз със скоби (може и вложени).
// Цел: извличане на всички под-изрази в скоби
// Примерен вход:
// 1 + (2 - (2 + 3) * 4 / (3 + 1)) * 5
//
// Изход:
//
// (2 + 3)
//
// (3 + 1)
//
// (2 - (2 + 3) * 4 / (3 + 1))
//
// Имате следният програмен фрагмент.
// В кода има грешка и не работи правилно.
// static void Main(string[] args)
// {
// Queue<int> indexes = new Queue<int>();
// string expression = Console.ReadLine();
// for (int i = 0; i < expression.Length; i++)
// {
// if (expression[i] == '(')
// {
// indexes.Enqueue(i);
// }
// else if (expression[i] == ')')
// {
// int startIndex = indexes.Dequeue();
// int length = i - startIndex + 1;
// string substr = expression.Substring(startIndex, length);
// Console.WriteLine(substr);
// }
// }
// }
//
// Вашата задача е да анализирате този фрагмент от код и да идентифицирате и поправите правилно грешките в написания програмен код, така че да реши поставената задача. Да допълните кода, ако и когато това е необходимо.
//
// В полето за въвеждане записвате:
//
// 1. Вашият анализ на грешката и това как може да бъде поправено.
//
// 2. Редактиран и правилно работещ код.
//
//
//
//
//
//
// Основният проблем в кода е използването на Queue<int> вместо Stack<int>.
// Какво трябва да се промени:
// Queue<int> ➜ Stack<int>
// Enqueue() ➜ Push()
// Dequeue() ➜ Pop()
//
//
//
// using System;
// using System.Collections.Generic;
//
// class Program
// {
// static void Main(string[] args)
// {
// Stack<int> indexes = new Stack<int>();
// string expression = Console.ReadLine();
//
// for (int i = 0; i < expression.Length; i++)
// {
// if (expression[i] == '(')
// {
// indexes.Push(i);
// }
// else if (expression[i] == ')')
// {
// int startIndex = indexes.Pop();
// int length = i - startIndex + 1;
// string substr = expression.Substring(startIndex, length);
// Console.WriteLine(substr);
// }
// }
// }
// }
//
//
//
//
//
//
//
//
//
//
//
// Да кажем, че играем на игра, в която трябва да познаете числото. Имате списък с числа от 1 до 20 включително подредени във възходящ ред. Решете задачата, като намерите кое е търсеното число и използвания алгоритъм за търсене на числото.
//
// Намислям си число и ти предполагаш, че числото е 11. Аз ти казвам, че моето число е по-малко.
//
// Търсиш в числата между 1 и 10. Предполагаш, че моето число е 5. Аз ти казвам, че моето число е по-малко.
//
// Търсиш в числата между 1 и 4. Предполагаш, че моето число е 2. Аз ти казвам, че моето число е по-голямо.
//
// Позна ли кое е моето число? [Търсеното число е 3]
//
// Кой алгоритъм за търсене използва? [Двоично търсене]
//
//
//
//
//
//
//
//
//
// Посочете вярното за следното твърдение:
// [Enqueue] – добавя елемент в края на опашката
//
//
//
//
//
//
//
//
//
// Имате даден програмен фрамент от код написан на C#.
//
//
// using System;
//
// namespace Sequence
// {
// class Program
// {
// static void Main(string[] args)
// {
// List<int> nums = Console.ReadLine().Split().ToList();
//
// int bestStart = 0
// int bestLength = 1;
// int currentLength = 1;
// int index = 0;
// int first = nums[index];
//
// for (int i = 1; i < nums.Count; i++)
// {
// if (first == nums[i])
// {
// currentLength++;
// if (currentLength > bestLength)
// {
// bestLength = currentLength;
// }
// }
// else
// {
// first = nums[i];
// index = i;
// }
// }
//
// for (int i = bestStart; i < bestStart + bestLength; i++)
// {
// Console.Write($"{nums[i]} ");
// }
// }
// }
// }
//
//
//
//
// Съставете програма, която намира най-дългата последователност от равни числа в даден списък от цели числа List<int> и отпечатва като резултат тази най-дълга последователност. Ако няколко поредици имат същата най-дълга дължина, върнете най-лявата от тях.
//
// PRAVILEN KOD
//
//
// using System;
// using System.Collections.Generic;
// using System.Linq;
//
// namespace Sequence
// {
// class Program
// {
// static void Main(string[] args)
// {
// List<int> nums = Console.ReadLine()
// .Split()
// .Select(int.Parse)
// .ToList();
//
// int bestStart = 0;
// int bestLength = 1;
//
// int currentStart = 0;
// int currentLength = 1;
//
// for (int i = 1; i < nums.Count; i++)
// {
// if (nums[i] == nums[i - 1])
// {
// currentLength++;
//
// if (currentLength > bestLength)
// {
// bestLength = currentLength;
// bestStart = currentStart;
// }
// }
// else
// {
// currentStart = i;
// currentLength = 1;
// }
// }
//
// for (int i = bestStart; i < bestStart + bestLength; i++)
// {
// Console.Write(nums[i] + " ");
// }
// }
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Имате следният програмен фрагмент, който трябва да сортира елементите в подаден списък. В кода има грешка и не работи правилно.
// При примерен вход: 36 15 1 7 20 8 24
//
// Програмата извежда като резултат следното: 1 1 1 7 8 8 24
//
// А трябва да изведе сортираните елементи: 1 7 8 15 20 24 36
//
// var collection = Console.Readline().Split().Select(int.Parse).ToList();
// for (int index = 0; index < collection.Count; index++)
// {
// int min = index;
// for (int curr = index + 1; curr < collection.Count; curr++)
// {
// if (collection[curr] > collection[min])
// {
// min = curr;
// }
// }
// collection[index] = collection[min];
// collection[min] = collection[index];
// }
// Console.WriteLine(string.Join(" ", collection));
//
// Вашата задача е да откриете грешката, да я поправите и да запишете в полето вече правилно работещ код.
//
//
//
//
// PRAVILEN KOD
//
//
//
// var collection = Console.ReadLine().Split().Select(int.Parse).ToList();
//
// for (int index = 0; index < collection.Count; index++)
// {
// int min = index;
//
// for (int curr = index + 1; curr < collection.Count; curr++)
// {
// if (collection[curr] < collection[min])
// {
// min = curr;
// }
// }
//
// int temp = collection[index];
// collection[index] = collection[min];
// collection[min] = temp;
// }
//
// Console.WriteLine(string.Join(" ", collection));
//
//
//
//
//
//
//
//
//
//
// На картинката е показана част от имплементацията на линейната структура от данни опашка. Посочете коя имплементация е използвана:
// Правилният отговор е: Динамична имплементация на опашка
//
//
//
//
//
//
//
// Дайте пример с C# код, за метод който да сортира елементите от списъка List<int> list = new List<int>() { 12, 8, 10, 2, 9, 6, 1}; посредством алгоритъма за сортиране чрез метода на мехурчето.
//
//
//
//
// using System;
// using System.Collections.Generic;
//
// class Program
// {
// static void Main()
// {
// List<int> list = new List<int>() { 12, 8, 10, 2, 9, 6, 1 };
//
// BubbleSort(list);
//
// Console.WriteLine(string.Join(" ", list));
// }
//
// static void BubbleSort(List<int> list)
// {
// for (int i = 0; i < list.Count - 1; i++)
// {
// for (int j = 0; j < list.Count - 1 - i; j++)
// {
// if (list[j] > list[j + 1])
// {
// int temp = list[j];
// list[j] = list[j + 1];
// list[j + 1] = temp;
// }
// }
// }
// }
// }
//
//
//
//
//
//
//
// Дефинирайте понятието сложност на алгоритъм, като попълните липсващите думи в текста.
//
// Сложност на алгоритъм е [груба оценка на броя стъпки], които алгоритъмът ще направи в зависимост от [размера на входните данни]. Това е груба оценка, която се интересува от [порядъка на броя стъпки], а не от [точния им брой].
//
//
//
// На картинката е показана част от имплементацията на линейната структура от данни опашка. Посочете коя имплементация е използвана:
// Правилният отговор е: Статична имплементация на опашка
//
//
//
//
//
//
//
// Изчислете какъв ще бъде отговорът на следния пример:
//
// През 2013 ООН има 193 страни членки. Ако имената на тези страни са сортирани по азбучен ред в масив, колко имена трябва да провери двоичното търсене, за да намери конкретно име в масива в най-лошия случай?
//
// [Не повече от 8.]
//
//
//
//
//
//
//
//
//
//
//
//
// Имате зададени твърдения за два алгоритъма за търсене - двоично търсене и линейно търсене. По зададените твърдения и характеристики трябва да сравните двата алгоритъма и да зададете коя от тях към кой от алгоритмите се отнася:
//
// Стойностите в масива трябва да са сортирани. [Двоично търсене]
//
// Работи във времева сложност O(log n). [Двоично търсене]
//
// Ако ключът е по-малък от средния елемент, тогава ключът може да лежи само в левия подмасив. [Двоично търсене]
//
// Работи във времева сложност O(log(log n)). [Линейно търсене]
//
// Ако ключът е по-голям от средния елемент, тогава ключът може да лежи само в десния подмасив. [Двоично търсене]
//
// Стойностите в масива не е задължително да са сортирани. [Линейно търсене]
//
// Започва винаги от началото на масива. [Линейно търсене]
//
// Ако ключът съвпада със средния елемент, върнете средното местоположение. [Двоично търсене]
//
// Започва търсенето от средата на масива. [Двоично търсене]
//
//
//
//
//
//
//
// Обяснете какво прави методът Enqueue(T)?
// добавя елемент в края на опашката
//
//
//
//
//
//
//
//
// Показани са означенията на типовете сложност на алгоритъм, посочете съответстващата му сложност, като изберете от падащия списък срещу всяко от означенията:
//
// O(n3) [кубична]
//
// O(log(N)) [логаритмична]
//
// O(N) [линейна]
//
// O(2n) [експоненциална]
//
// О(n2) [квадратична]
//
// O(1) [константна]
//
// O(N!) [експоненциална]
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Запазете историята на браузъра. Ще получите възможни команди:
// URL – отваря дадената страница
// back – връща към предната страница
// exit – спира програмата
// Примерен вход:
//
// www.softuni.bg
// www.judge.softuni.bg
// www.kids.softuni.bg
// back
// back
// exit
//
// Изход:
// www.judge.softuni.bg
// www.softuni.bg
//
// Имате следният програмен фрагмент.
// В кода има грешка и не работи правилно.
// static void Main(string[] args)
// {
// List<string> pages = new List<string>();
// string command = Console.ReadLine();
// string previous = null;
// while (!"exit".Equals(command))
// {
// if (command.Equals("back"))
// {
// if (pages.Count != 0)
// {
// Console.WriteLine(pages.Remove);
// }
// previous = null;
// }
// else
// {
// if (previous != null)
// {
// pages.Add(command);
// }
// previous = command;
// }
//
// command = Console.ReadLine();
//
// }
// }
//
// Вашата задача е да анализирате този фрагмент от код и да идентифицирате и поправите правилно грешките в написания програмен код, така че да реши поставената задача. Да допълните кода, ако и когато това е необходимо.
//
// В полето за въвеждане записвате:
//
// 1. Вашият анализ на грешката и това как може да бъде поправено.
//
// 2. Редактиран и правилно работещ код.
//
//
//
//
//
// Неправилно използване на List вместо стек
// Историята на браузъра работи на принцип LIFO (Last In, First Out)
// Това означава, че трябва да използваме Stack<string>, а не List<string>
//
// Неправилно извикване на Remove
// Console.WriteLine(pages.Remove);
// Remove е метод и изисква аргумент
// Освен това той връща bool, не самата страница
// Трябва да използваме Pop() при стек
//
// Липсва проверка за празна история
// При back, ако няма страници → трябва да се изведе:
// no previous URLs
//
// if (previous != null)
// {
// pages.Add(command);
// }
// Добавя се грешният елемент
// Трябва да се пази текущата страница и да се добавя в историята
//
// PRAVILEN KOD
//
//
// using System;
// using System.Collections.Generic;
//
// class Program
// {
// static void Main(string[] args)
// {
// Stack<string> history = new Stack<string>();
// string command = Console.ReadLine();
// string currentPage = null;
//
// while (command != "exit")
// {
// if (command == "back")
// {
// if (history.Count > 0)
// {
// currentPage = history.Pop();
// Console.WriteLine(currentPage);
// }
// else
// {
// Console.WriteLine("no previous URLs");
// }
// }
// else
// {
// if (currentPage != null)
// {
// history.Push(currentPage);
// }
//
// currentPage = command;
// }
//
// command = Console.ReadLine();
// }
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Имате следният програмен фрагмент, който трябва да сортира елементите в подаден списък. В кода има грешка и не работи правилно.
// При примерен вход: 36 15 1 7 20 8 24
//
// Програмата извежда като резултат следното: 1 1 1 7 8 8 24
//
// А трябва да изведе сортираните елементи: 1 7 8 15 20 24 36
//
// var list = Console.ReadLine().Split().Select(int.Parse).ToList();
// for (int j = 0 j <= list.Count - 2; j++)
// {
// for (int i = 0; i <= list.Count - 2; i++)
// {
// if (list[i] > list[i + 1])
// {
// list[i] = list[i + 1];
// list[i + 1] = list[i];
// }
// }
// }
// Console.WriteLine(string.Join(" ", list));
//
// Вашата задача е да откриете грешката, да я поправите и да запишете в полето вече правилно работещ код.
//
//
//
//
//
//
//
// PRAVILEN KOD
//
//
//
// var list = Console.ReadLine().Split().Select(int.Parse).ToList();
//
// for (int j = 0; j <= list.Count - 2; j++)
// {
// for (int i = 0; i <= list.Count - 2; i++)
// {
// if (list[i] > list[i + 1])
// {
// int temp = list[i];
// list[i] = list[i + 1];
// list[i + 1] = temp;
// }
// }
// }
//
// Console.WriteLine(string.Join(" ", list));
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 8
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Ограниченията задават правила за данните в дадена таблица. Посочете вярното твърдение за ограничението PRIMARY KEY.
// Правилният отговор е:
// идентифицира уникално всеки запис в таблицата
//
//
//
//
// Правилният отговор е: Връзка много към много → При тази връзка се използва помощна таблица, в която се поставят връзки към отделните таблици., Връзка едно към едно → При тази връзка на един запис от първата таблица съответства точно един запис от втората таблица., Връзка едно към много → При тази връзка един запис от първата таблица съответства на много записи от втората таблица.
//
//
//
//
//
//
// Моля посочете вярното твърдение за дефиниране на понятието бази от данни.
// Правилният отговор е: База от данни се нарича всяка организирана колекция от данни (информация).
//
//
//
//
//
// Имате заявка, която свързва две таблици от база от данни Orders и Persons. От изброените 6 думи, изберете три верни, с които да получите работеща заявка и ги поставете в дадения код.
//
// CREATE TABLE Orders(
//
// OrderID int NOT NULL,
//
// OrderNumber int NOT NULL,
//
// PersonID int,
//
// [PRIMARY KEY] (OrderID),
//
// [FOREIGN KEY] (PersonID) [REFERENCES] Persons(PersonID)
//
// );
//
//
//
//
//
//
//
//
//
// Имате следната заявка за създаване на таблица directors в база от данни Movies:
//
// CREATE TABLE directors(
//
// id INT PRIMARY KEY,
//
// director_name VARCHAR(10),
//
// notes VARCHAR(20)
//
// );
//
// Моля, определете от какъв тип данни и каква дължина са трите колони в таблицата.
//
//
//
// 1. Колона id
// Тип данни: INT
// Дължина: стандартен 4-байтов цяло число (не се задава дължина ръчно)
// Допълнение: PRIMARY KEY → уникална стойност за всеки запис
//
//
// 2. Колона director_name
// Тип данни: VARCHAR
// Дължина: до 10 символа
// Използва се за текст с променлива дължина
//
// 3. Колона notes
// Тип данни: VARCHAR
// Дължина: до 20 символа
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Имате код за създаване на таблици. Посочете вида на връзката, която се получава.
//
// CREATE TABLE employees(
//
// employee_id INT PRIMARY KEY,
// employee_name VARCHAR(50)
//
// );
//
// CREATE TABLE projects(
// project_id INT PRIMARY KEY,
// project_name VARCHAR(50)
//
// );
//
// CREATE TABLE employees_projects(
// employee_id INT,
// project_id INT,
//
// CONSTRAINT pk_employees_projects
//
// PRIMARY KEY(employee_id, project_id),
//
// CONSTRAINT fk_employees_projects_employees
//
// FOREIGN KEY(employee_id)
//
// REFERENCES employees(employee_id),
//
// CONSTRAINT fk_employees_projects_projects
//
// FOREIGN KEY(project_id)
//
// REFERENCES projects(project_id)
//
// );
//
// много към много
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Като използвате дадената ER диаграма, напишете заявките за създаване база данни plants и за създаване на таблиците в нея.
// 40 TOCHKI
//
//
//
//
//
//
// -- Създаване на база данни
// CREATE DATABASE plants;
// USE plants;
//
// -- Таблица users
// CREATE TABLE users (
// user_id INT(11) AUTO_INCREMENT PRIMARY KEY,
// username VARCHAR(255),
// password VARCHAR(255),
// name VARCHAR(255),
// email VARCHAR(255),
// profile_picture VARCHAR(255)
// );
//
// -- Таблица plants
// CREATE TABLE plants (
// plant_id INT(11) AUTO_INCREMENT PRIMARY KEY,
// name VARCHAR(255),
// type VARCHAR(255),
// care_instructions TEXT,
// image VARCHAR(255),
// purchase_date DATE,
// purchase_location VARCHAR(255),
// user_id INT(11),
// FOREIGN KEY (user_id) REFERENCES users(user_id)
// );
//
// -- Таблица categories
// CREATE TABLE categories (
// category_id INT(11) AUTO_INCREMENT PRIMARY KEY,
// name VARCHAR(255)
// );
//
// -- Междинна таблица plants_categories (many-to-many)
// CREATE TABLE plants_categories (
// plant_id INT(11),
// category_id INT(11),
// PRIMARY KEY (plant_id, category_id),
// FOREIGN KEY (plant_id) REFERENCES plants(plant_id),
// FOREIGN KEY (category_id) REFERENCES categories(category_id)
// );
//
// -- Таблица waterings
// CREATE TABLE waterings (
// watering_id INT(11) AUTO_INCREMENT PRIMARY KEY,
// plant_id INT(11),
// date DATE,
// time TIME,
// FOREIGN KEY (plant_id) REFERENCES plants(plant_id)
// );
//
// -- Таблица fertilizings
// CREATE TABLE fertilizings (
// fertilizing_id INT(11) AUTO_INCREMENT PRIMARY KEY,
// plant_id INT(11),
// date DATE,
// time TIME,
// FOREIGN KEY (plant_id) REFERENCES plants(plant_id)
// );
//
// -- Таблица reminders
// CREATE TABLE reminders (
// reminder_id INT(11) AUTO_INCREMENT PRIMARY KEY,
// plant_id INT(11),
// date DATE,
// time TIME,
// FOREIGN KEY (plant_id) REFERENCES plants(plant_id)
// );
//
//
//
//
//
//
//
//
//
//
// Създайте таблица people, която да съдържа следните колони city_id, first_name, last_name, и salary, като прецените типа данни, който да укажете за колоните. Колоната city_id да бъде първичен ключ.
//
// CREATE TABLE people (
// city_id INT PRIMARY KEY,
// first_name VARCHAR(50),
// last_name VARCHAR(50),
// salary DECIMAL(10,2)
// );
//
//
//
//
//
//
//
//
//
//
//
// Имате код за създаване на таблици, които реализират връзка между таблици едно към едно. Открийте липсващите думи и ги поставете в текста чрез влачене, така че да получите коректно работещ код.
//
// CREATE TABLE drivers(
//
// driver_id INT [PRIMARY KEY],
//
// driver_name VARCHAR(50)
//
// );
//
// CREATE TABLE cars(
//
// car_id INT PRIMARY KEY,
//
// driver_id INT UNIQUE,
//
// [CONSTRAINT] fk_cars_drivers [FOREIGN KEY]
// (driver_id) [REFERENCES] drivers(driver_id)
//
// );
//
//
//
//
//
//
//
//
//
//
//
// Напишете заявка за създаване на таблица customers, която да съдържа три колони, които са:
//
// id - от тип цели числа, name - от тип текст с дължина 50 знака и birthday от тип дата.
//
// CREATE TABLE customers (
// id INT,
// name VARCHAR(50),
// birthday DATE
// );
//
//
//
//
//
//
//
//
//
// Имате код за създаване на таблици. Посочете вида на връзката, която се получава.
//
// CREATE TABLE drivers(
//
// driver_id INT PRIMARY KEY,
//
// driver_name VARCHAR(50)
//
// );
//
// CREATE TABLE cars(
//
// car_id INT PRIMARY KEY,
//
// driver_id INT UNIQUE,
//
// CONSTRAINT fk_cars_drivers FOREIGN KEY
// (driver_id) REFERENCES drivers(driver_id)
//
// );
//
// CONSTRAINT fk_cars_drivers
// FOREIGN KEY (driver_id)
// REFERENCES drivers(driver_id)
//
// едно към едно
//
//
//
//
//
//
//
//
// Искате да изведете от таблица Persons хората, които са на 30 години. Допишете заявката, така че да получите като резултат в таблицата първо име, фамилия и години. Използвайте необходимото ограничение.
//
// CREATE TABLE Persons(
//
// PersonID int NOT NULL,
//
// FirstName varchar(255) NOT NULL,
//
// LastName varchar(255) NOT NULL,
//
// );
//
//
//
//
//
// SELECT FirstName, LastName, Age
// FROM Persons
// WHERE Age = 30;
//
//
//
//
//
//
//
//
//
//
// Посочете вярното твърдение за по-долу посочения код:
//
// CREATE TABLE Persons(
//
// ID int NOT NULL,
//
// FirstName varchar(255) NOT NULL,
//
// LastName varchar(255) NOT NULL,
//
// );
//
//
// Правилният отговор е:
// Създава таблица с колони ID от тип цяло число, FirstName от текстов тип и LastName от текстов тип и не позволява в клетките да има празна стойност.
//
//
//
//
//
//
//
// Моля, посочете вярното твърдение за връзка едно към много.
//
// Правилният отговор е: При тази връзка един запис от първата таблица съответства на много записи от втората таблица.
//
//
//
//
//
//
//
// Създайте таблица cities, която да съдържа две колони - id и name, като прецените типа данни, който да укажете за двете колони. Колоната id да бъде първичен ключ.
//
// CREATE TABLE cities (
// id INT PRIMARY KEY,
// name VARCHAR(100)
// );
//
//
//
//
//
//
//
//
//
// Имате заявка, която създава таблица Persons и трябва да се използва ограничение, което да постави стойност по подразбиране за град Burgas. От трите посочени думи, изберете ограничението, което трябва да поставите за да решите коректно примера.
//
//
//
//
// CREATE TABLE Persons(
//
// PersonID int NOT NULL,
//
// FirstName varchar(255) NOT NULL,
//
// LastName varchar(255) NOT NULL,
//
// Age int,
//
// City varchar(255) [DEFAULT] 'Burgas'
//
// );
//
//
//
//
//
//
//
//
//
//
// Имате заявка за създаване на таблица cities с две колони city_id и name. Посочете липсващите думи в кода, така че да получите коректно работеща заявка.
//
// [CREATE] TABLE cities(
//
// city_id [INT] PRIMARY KEY,
//
// name [VARCHAR(50)]
//
// );
//
//
//
//
//
//
//
//
//
// Ограниченията задават правила за данните в дадена таблица. Имате посочени примери за често срещани ограничения. Моля свържете ограничението с неговото вярно описание.
//
//
// Правилният отговор е: FOREIGN KEY → уникално идентифицира запис от друга таблица, UNIQUE → гарантира, че всички данни в колоната са различни, CHECK → гарантира, че всички данни в колоната удовлетворят дадено условие
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// TEST 9
//
//
//
//
//
//
//
//
//
//
//
//
// Дефинирайте понятието псевдоним в базите от данни и посочете за какво се използва.
//
// Псевдонимите преименуват таблица или заглавие на колона. Използват се, за да се осъществи връзка между таблици по свързващото условие.
//
//
//
//
//
//
// Имате представена подзаявка за намиране служителите от отдел финанси и извеждане на всички колони от таблицата. Поставете липсващите думи, за да направите работещ код.
//
// SELECT * FROM employees
// [WHERE] department_id [IN]
//
// (
//
// SELECT department_id
// [FROM] departments
//
// [WHERE] name = 'Finance' );
//
//
//
//
//
//
//
//
//
// Следната заявка извлича от таблица projects колоната с крайна дата на проекти, която е NULL
//
// UPDATE projects
//
// SET end_date = '2017-05-29'
//
// WHERE end_date IS NULL;
//
//
// Правилният отговор е "Неистина"
//
//
//
//
//
//
//
//
//
// Посочете правилния код за създаване на заявка, която извлича всички записи от таблицата departments.
//
// Правилният отговор е: SELECT * FROM departments;
//
//
//
//
//
//
// Посочете резултата от изпълнението на следната заявка:
//
// UPDATE employees
//
// set last_name = 'Dani'
//
// WHERE employee_id = '1';
//
//
//
// Правилният отговор е: Ще промени таблицата и на колоната фамилно име на служител с номер 1 ще присвои име Dani.
//
//
//
//
//
//
//
//
//
// Пояснете какво прави връзката RIGHT OUTER JOIN.
//
// RIGHT OUTER JOIN извежда всички записи от дясната таблица и съвпадащите записи от лявата таблица.
//
//
//
//
//
// Във вашата база от данни Soft_uni имате създадена таблица Employees с 500 записа. Необходимо е да добавите нова колона с име salary. Напишете заявка за добавяне на колоната в таблица employees.
//
// ALTER TABLE employees
// ADD salary DECIMAL(10,2);
//
//
//
//
//
//
//
// Посочете резултата от изпълнението на следната заявка:
//
// SELECT first_name, last_name, salary FROM employees;
//
// Правилният отговор е: Извлича първо име, фамилия и заплата на служителите
//
//
//
//
//
//
//
//
//
// Посочете какво прави клаузата INNER JOIN:
//
// Клауза INNER JOIN връща само записите, които имат съвпадение в двете свързани таблици.
//
//
//
//
//
//
//
// В база от данни People имате таблица persons, състояща се от 4 колони и те са следните:
//
// PersonID int NOT NULL,
//
// FirstName varchar(25) NOT NULL,
//
// email VARCHAR(10),
//
// Age int );
//
// В таблицата имате достатъчен брой записи, които не трябва да загубите. Вашият мениджър ви поставя задача да промените броя на символите на колоната е-мейл, като ги увеличите на 100. Напишете заявка за промяна на колоната и съответно на таблицата persons.
//
//
//
// ALTER TABLE persons
// MODIFY COLUMN email VARCHAR(100);
//
//
//
//
//
//
//
//
//
//
// В дадения код имате обединяване на заявки чрез клаузата UNION. Попълнете чрез влачене липсващите думи в кода, така че да получите работеща заявка, която да извежда данни от база от данни geography и да сортира колона name.
//
// (select river_name as name [FROM] rivers)
// UNION
//
// ([SELECT] mountain_range from mountains)
//
// [ORDER BY] name ASC LIMIT 100
//
//
//
//
//
//
//
//
//
//
// Изберете липсващите думи в следната заявка, така че да получите служителите със заплата по-голяма от 50000.
//
// [SELECT] e.employee_id, e.first_name, e.salary, d.name [FROM ] employees AS e
//
// JOIN departments AS d ON d.department_id = e.department_id
//
// [WHERE] salary > 50000
//
// [ORDER BY] d.department_id desc;
//
//
//
//
//
//
//
//
//
//
//
// Посочете верния отговор за създаване на заявка, която извлича името на отдела от таблицата departments.
//
// Правилният отговор е: SELECT name FROM departments;
//
//
//
//
//
//
//
//
// Посочете верния изход при изпълнение на следната заявка.
//
// SELECT * FROM employees AS e
//
// JOIN departments AS d ON d.department_id = e.department_id
//
//
//
// Правилният отговор е: Таблица employees ще се преименува на е, а таблица departments ще се преименува на d и по този начин ще се осъществи връзката между двете таблици по свързващото условие колона department_id
//
//
//
//
//
//
//
//
//
//
// Посочете резултата от изпълнението на следната заявка:
//
// SELECT employee_id AS id, first_name, last_name
//
// FROM employees;
//
//
// Правилният отговор е: Колоната employee_id ще се преименува на id.
//
//
//
//
//
//
//
//
//
//
//
// Посочете резултата от изпълнението на следната заявка:
//
// UPDATE employees
//
// SET salary = salary*1.10
//
// WHERE department_id = 7;
//
//
//
// Правилният отговор е: Ще промени таблицата, като стойността на заплатата ще бъде променена само на записите, които са с номер на отдел 7.
//
//
//
//
//
//
//
//
//
//
// Следната заявка ще изтрие всички записи от таблицата, както и ще рестартира брояча на стойностите за ID.
//
// TRUNCATE TABLE `employees`;
//
// "Истина"
//
//
//
//
//
//
//
//
//
// Създайте таблица categories, която да съдържа две колони - id и name, като прецените типа данни, който да укажете за двете колони. Колоната id да бъде първичен ключ.
//
// CREATE TABLE categories (
// id INT NOT NULL PRIMARY KEY,
// name VARCHAR(100) NOT NULL
// );
//
//
//
//
//
//
//
//
//
//
// Имате дадена ER диаграма. Информацията в таблиците е въведена предварително. След като анализирате данните в базата от данни colonial_journey, създайте следните заявки. Съобразете се с посочените примери.
//
// 40 TOCHKI
//
//
//
//
//
//
// SELECT *
// FROM travel_cards
// ORDER BY card_number ASC;
//
//
//
//
// SELECT
// CONCAT(first_name, ' ', last_name) AS full_name,
// id
// FROM colonists
// ORDER BY full_name ASC, id ASC;
//
//
//
//
//
//
//
// SELECT
// s.name AS spaceship_name,
// sp.name AS destination_name
// FROM spaceships s
// JOIN journeys j ON j.spaceship_id = s.id
// JOIN spaceports sp ON j.destination_spaceport_id = sp.id
// ORDER BY s.light_speed_rate DESC
// LIMIT 1;
//
//
//
//
//
//
//
//
// Посочете резултата от изпълнение на следната заявка:
//
// SELECT * FROM projects WHERE end_date IS NULL;
//
//
//
// Правилният отговор е: Извежда само тези записи, които са NULL в колоната крайна дата.
//
//
//
//
//
//
// Допишете следната заявка, така че да изведе служителите със заплати между 20000 и 30000.
//
//
//
// SELECT `last_name`, `salary` FROM `employees`
//
// SELECT `last_name`, `salary`FROM `employees`
//
// WHERE `salary` BETWEEN 20000 AND 22000;
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// TEST 10
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Имате пример за създаване на процедура:
//
// CREATE [PROCEDURE] [usp]_withdraw_money (account_id INT, money_amount DECIMAL)
//
// [BEGIN]
//
// -- Transaction logic goes here.
//
// END
//
// Поставете липсващите думи, така че да се получи правилния код.
//
//
//
//
//
//
//
//
//
//
// Имате създадена съхранена процедура с параметър usp_select_employees_by_seniority(min_years_at_work INT). Моля да дефинирате заявка за извикване на процедурата, за да може да бъде използвана.
//
// CALL usp_select_employees_by_seniority(5);
//
//
//
//
//
//
//
//
//
//
// Имплементирайте код на заявка, която извежда колоните first_name, last_name и job_title от таблица employees и извежда само тези записи със заплата между 20000 и 30000.
//
// SELECT first_name, last_name, job_title
// FROM employees
// WHERE salary BETWEEN 20000 AND 30000;
//
//
//
//
//
//
//
// Посочете коя от следните заявки ще изведе фамилия и заплата, като заплатата е в периода 20000 и 22000.
//
// Правилният отговор е:
// SELECT `last_name`, `salary`FROM `employees` WHERE `salary` BETWEEN 20000 AND 22000;
//
//
//
//
//
//
//
//
// Посочете какво прави клаузата FULL JOIN.
//
// FULL JOIN - Тази връзка връща записите, отговарящи на свързващото условие и също така несъвпадащите записи от лявата или от дясната таблица.
//
//
//
//
//
//
//
// Дадена е дефиниция за транзакция. Поставете липсващите думи в дефиницията.
//
// Транзакциите гарантират пълнотата и цялостността на базата данни. Всички промени в транзакцията са [временни]. Промените се съхраняват едва след изпълнението на [COMMIT]. По всяко време всички промени могат да се отменят чрез [ROLLBACK].
//
//
//
//
//
//
//
//
//
//
// Във вашата база от данни Soft_uni имате създадена таблица Employees с 500 записа. Необходимо е да добавите нова колона с име осигуровки (osigurovki). Напишете заявка за добавяне на колоната в таблица employees.
//
// ALTER TABLE employees
// ADD osigurovki DECIMAL(10,2);
//
//
//
//
//
//
//
//
// В посочения пример имате заявка за създаване на таблица persons с колони person_id, first_name, passport_id и salary. Моля избирете липсващите думи за всяка колона от таблицата.
//
// CREATE TABLE persons(
//
// person_id [INT] PRIMARY KEY,
//
// first_name [VARCHAR(50)],
//
// salary [DECIMAL(8,2)],
//
// passport_id INT UNIQUE,
//
// CONSTRAINT fk_persons_passports FOREIGN KEY(passport_id) REFERENCES passports(passport_id)
//
// );
//
//
//
//
//
//
//
//
//
//
//
// Създайте база данни с името online_auction. Ще получите описания, с помощта на които ще създадете следните 5 таблици:
//
// cities
//
// persons
//
// product_types
//
// products
//
// bids
//
// 40 TOCHKI
//
//
//
//
//
//
// CREATE DATABASE online_auction;
// USE online_auction;
//
//
//
//
// CREATE TABLE cities (
// id INT PRIMARY KEY AUTO_INCREMENT,
// name VARCHAR(40),
// country_name VARCHAR(50)
// );
//
// CREATE TABLE persons (
// id INT PRIMARY KEY AUTO_INCREMENT,
// first_name VARCHAR(50),
// middle_name VARCHAR(20),
// last_name VARCHAR(50),
// birth_date DATETIME,
// city_id INT,
// FOREIGN KEY (city_id) REFERENCES cities(id)
// );
//
// CREATE TABLE product_types (
// id INT PRIMARY KEY AUTO_INCREMENT,
// name VARCHAR(30)
// );
//
// CREATE TABLE products (
// id INT PRIMARY KEY AUTO_INCREMENT,
// name VARCHAR(50),
// description VARCHAR(1024),
// start_bid_price DECIMAL(15,2),
// sold_on DATETIME,
// owner_id INT,
// sold_city_id INT,
// product_type_id INT,
// FOREIGN KEY (owner_id) REFERENCES persons(id),
// FOREIGN KEY (sold_city_id) REFERENCES cities(id),
// FOREIGN KEY (product_type_id) REFERENCES product_types(id)
// );
//
// CREATE TABLE bids (
// product_id INT,
// person_id INT,
// amount DECIMAL(15,2),
// date DATETIME,
// FOREIGN KEY (product_id) REFERENCES products(id),
// FOREIGN KEY (person_id) REFERENCES persons(id)
// );
//
//
//
//
//
//
//
//
//
// SELECT
// p.id,
// p.name AS product_name,
// ps.first_name,
// ps.last_name,
// c.name AS city_name,
// c.country_name
// FROM products p
// JOIN persons ps ON p.owner_id = ps.id
// JOIN cities c ON p.sold_city_id = c.id
// WHERE ps.first_name = 'Britni'
// AND c.country_name = 'Germany'
// ORDER BY p.id ASC;
//
//
//
//
//
//
//
//
//
//
//
// SELECT
// ps.id,
// ps.first_name,
// ps.last_name,
// c.name AS city_name,
// COUNT(p.id) AS product_count
// FROM persons ps
// JOIN products p ON p.owner_id = ps.id
// JOIN cities c ON ps.city_id = c.id
// GROUP BY ps.id, ps.first_name, ps.last_name, c.name
// ORDER BY product_count DESC, ps.first_name ASC
// LIMIT 10;
//
//
//
//
//
//
//
//
// SELECT
// p.name AS product_name,
// c.name AS city_name,
// COUNT(b.product_id) AS bid_count,
// MAX(b.amount) AS max_amount,
// MIN(b.amount) AS min_amount
// FROM products p
// JOIN bids b ON p.id = b.product_id
// JOIN cities c ON c.id = p.sold_city_id
// WHERE c.country_name = 'Bulgaria'
// GROUP BY p.id, p.name, c.name
// ORDER BY bid_count DESC
// LIMIT 5;
//
//
//
//
//
//
//
//
//
//
//
//
// Моля посочете вярното твърдение за съхранени процедури в език My SQL.
//
// Правилният отговор е: Могат да приемат входни параметри; Могат да връщат изходни резултати.
//
//
//
//
//
//
// Създайте заявка, която извежда първо име, фамилия и длъжност на служителите, които имат заплата между 20000 и 30000. Използвайте базата данни soft_uni.
//
// SELECT first_name, last_name, job_title
// FROM employees
// WHERE salary BETWEEN 20000 AND 30000;
//
//
//
//
//
//
// Моля посочете вярното твърдение за посочените типове данни:
//
// Правилният отговор е: Float → тип данни за реални числа, DOUBLE → тип данни за реални числа, VARCHAR(M) → текстов тип данни
//
//
//
//
//
// Допишете следната заявка, така че да изведе като резултат служителите със заплата по-голяма от 50000 и да ги сортира в низходящ ред.
//
// SELECT first_name, last_name, salary FROM employees
//
//
//
// SELECT first_name, last_name, salary
// FROM employees
// WHERE salary > 50000
// ORDER BY salary DESC;
//
//
//
//
//
//
//
//
// Имате представена подзаявка за намиране служителите от отдел финанси и извеждане на всички колони от таблицата. Поставете липсващите думи, за да направите работещ код.
//
// SELECT * FROM employees
// [WHERE] department_id [IN]
//
// (
//
// SELECT department_id
// [FROM] departments
//
// [WHERE] name = 'Finance' );
//
//
//
//
//
//
//
//
//
//
// Имате следната заявка. Посочете вярното твърдение за получения резултат от агрегиращата използвана функция след нейното изпълнение.
//
// SELECT e.`department_id`,
//
// AVG(e.`salary`) AS 'AvgSalary'
//
// FROM `employees` AS e
//
// GROUP BY e.`department_id`;
//
//
// Правилният отговор е: Намира средноаритметичната стойност на заплатите на служителите и преименува колоната.
//
//
//
//
//
//
//
//
//
// Имате синтаксис на транзакция в My SQL. Открийте липсващите думи в кода и го модифицирайте, така че да получите коректно работеща заявка.
//
// [START] [TRANSACTION]
//
// [UPDATE] accounts SET balance = balance – withdraw_amount
//
// WHERE id = account
//
// --Transaction logic goes here
//
// IF ROW_COUNT() <> 1 THEN -- Affected rows are different than one.
//
// SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Invalid account';
//
// [ROLLBACK];
//
// ELSE
//
// [COMMIT];
//
// [END IF];
//
//
//
//
//
//
//
//
// Имате пример за създаване на функция:
//
// CREATE [FUNCTION] [udf]_project_weeks (start_date DATETIME, end_date DATETIME)
//
// [RETURNS] INT
//
// BEGIN
//
// // тяло на функцията
//
// END
//
// Поставете липсващите думи, така че да се получи правилния код.
//
//
//
//
//
//
//
//
// Посочете коя от следните заявки ще изтрие записи от таблица projects, които са с начална дата 2006-01-01.
//
// Правилният отговор е: DELETE FROM projects WHERE start_date = '2006-01-01';
//
//
//
//
//
//
//
// Посочете действието на използваната връзка в следната заявка:
//
// SELECT * FROM employees AS e
//
// RIGHT OUTER JOIN departments AS d
//
// ON e.department_id = d.department_id;
//
//
//
// Правилният отговор е:
// Тази връзка връща записите, отговарящи на свързващото условие и също така несъвпадащите записи от таблица departments.
//
//
//
//
//
//
//
//
//
// Посочете коя от следните заявки ще изведе всички записи от таблица departments и извежда първите два реда от таблицата.
//
//
// Правилният отговор е:
// SELECT * FROM departments WHERE department_id <=2
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 11
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Изберете за какво служи стопера (breakpoint) в дебъгването на програми?
//
// Правилният отговор е: точка за умишлено прекъсване на програма с цел дебъгване
//
//
//
//
//
//
//
// Дефинирайте понятието Изглед (View) от MVC концепцията.
//
// Правилният отговор е: Изгледът в MVC служи за контрол на външен вид и взаимодействие с потребителя
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Фрагмент:
//
// using System;
//
// public class Substring_broken
// {
// public static void Main()
// {
// string text = Console.ReadLine();
// int jump = int.Parse(Console.ReadLine());
//
// const char Search = 'р';
// bool hasMatch = false;
//
// for (int i = 0; i < text.Length; i++)
// {
// if (text[i] == Search)
// {
// hasMatch = true;
//
// int endIndex = jump;
//
// if (endIndex > text.Length)
// {
// endIndex = text.Length;
// }
//
// string matchedString = text.Substring(i, endIndex);
// Console.WriteLine(matchedString);
// i += jump;
// }
// }
//
// if (!hasMatch)
// {
// Console.WriteLine("no");
// }
// }
// }
// Забележка: Фрагментът съдържа логически грешки, които водят до неочаквано повдение на програмата. Открийте ги с помомощта на дебъгера и предоставете поправения код
//
//
//
//
// PRAVILEN KOD
//
//
//
//
//
//
//
// using System;
//
// public class Substring_broken
// {
// public static void Main()
// {
// string text = Console.ReadLine();
// int jump = int.Parse(Console.ReadLine());
//
// const char Search = 'p'; // FIX: латинско p
// bool hasMatch = false;
//
// for (int i = 0; i < text.Length; i++)
// {
// if (text[i] == Search)
// {
// hasMatch = true;
//
// int length = jump + 1; // FIX
//
// // FIX: правилна проверка
// if (i + length > text.Length)
// {
// length = text.Length - i;
// }
//
// string matchedString = text.Substring(i, length);
// Console.WriteLine(matchedString);
//
// // FIX: махаме i += jump;
// }
// }
//
// if (!hasMatch)
// {
// Console.WriteLine("no");
// }
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
// Посочете кое от следните действия НЕ е възможно с помощта на дебъгер?
//
// Правилният отговор е: Подчертаване на логически грешки в програма
//
//
//
//
//
//
//
//
//
//
// Дайте пример за коректно именуване на компонентен тест, който проверява дали потребител влиза успешно с валидно потребителско име и парола.
//
// test_UserLogin_Succeeds_WithValidCredentials
//
//
//
//
//
//
//
//
//
//
// Посочете кой от следните идентификатори има нужда от рефакториране.
//
// Правилният отговор е: int numberofpeople;
//
//
//
//
//
//
// Дефинирайте значението на абревиатурата ААА в контекста на компоненто тестване.
//
// Правилният отговор е: Arrange-Act-Assert
//
//
//
//
//
// Посочете кой програмен фрагмент няма нарушения във форматирането си.
//
// Правилният отговор е: Всички примери имат нарушения в правилата за форматиране
//
//
//
//
//
// Демонстрирайте рефакториране на следния фрагмент от код, като зададате подходящо именуване и форматиране, ако и където това е необходимо:
//
// class tdi { //class for todo items
//
// public string _Name { get; set; }
//
// public string description { get; set; }
//
// public int ToDoListId { get; set; }
//
// }
//
//
//
// PRAVILEN KOD
//
//
// public class TodoItem
// {
// public string Name { get; set; }
//
// public string Description { get; set; }
//
// public int TodoListId { get; set; }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Фрагмент:
//
// using System;
//
// class InstructionSet_broken
// {
// static void Main()
// {
//
// string opCode = Console.ReadLine();
//
// while (opCode != "end")
// {
// string[] codeArgs = opCode.Split(' ');
//
// long result = 0;
// switch (codeArgs[0])
// {
// case "INC":
// {
// int operandOne = int.Parse(codeArgs[1]);
// result = operandOne++;
// break;
// }
// case "DEC":
// {
// int operandOne = int.Parse(codeArgs[1]);
// result = operandOne--;
// break;
// }
// case "ADD":
// {
// int operandOne = int.Parse(codeArgs[1]);
// int operandTwo = int.Parse(codeArgs[2]);
// result = operandOne + operandTwo;
// break;
// }
// case "MLA":
// {
// int operandOne = int.Parse(codeArgs[1]);
// int operandTwo = int.Parse(codeArgs[2]);
// result = (long)(operandOne * operandTwo);
// break;
// }
// }
//
// Console.WriteLine(result);
// }
// }
// }
// Забележка: Фрагментът съдържа логически грешки, които водят до неочаквано повдение на програмата. Открийте ги с помомощта на дебъгера и предоставете поправения код
//
//
//
//
//
// PRAVILEN KOD
//
//
//
//
//
// using System;
//
// class InstructionSet_broken
// {
// static void Main()
// {
// string opCode = Console.ReadLine();
//
// while (opCode != "END") // FIX
// {
// string[] codeArgs = opCode.Split(' ');
//
// long result = 0;
//
// switch (codeArgs[0])
// {
// case "INC":
// {
// int operandOne = int.Parse(codeArgs[1]);
// result = operandOne + 1; // FIX
// break;
// }
// case "DEC":
// {
// int operandOne = int.Parse(codeArgs[1]);
// result = operandOne - 1; // FIX
// break;
// }
// case "ADD":
// {
// int operandOne = int.Parse(codeArgs[1]);
// int operandTwo = int.Parse(codeArgs[2]);
// result = operandOne + operandTwo;
// break;
// }
// case "MLA":
// {
// long operandOne = long.Parse(codeArgs[1]); // FIX
// long operandTwo = long.Parse(codeArgs[2]); // FIX
// result = operandOne * operandTwo;
// break;
// }
// }
//
// Console.WriteLine(result);
//
// opCode = Console.ReadLine(); // FIX (обновяване!)
// }
// }
// }
//
//
//
//
//
//
//
//
//
//
//
// Дайте пример за коректно именуване на компонентен тест, който проверява дали потребител получава грешка при опит за влизане с грешно потребителско име и парола
//
//
// Login_WithInvalidUsernameAndPassword_ShouldReturnError
//
//
//
//
//
//
// Посочете значението на абревиатурата MVC.
//
// Правилният отговор е: Model View Controller
//
//
//
//
//
//
// Посочете кое от следните НЕ е част от процеса по рефакториране:
//
// Правилният отговор е: добавяне на нова функционалност
//
//
//
//
//
// Какво действие активира клавиша F10 във Visual Studio?
//
// Правилният отговор е: Step over
//
//
//
//
// Обяснете как си взаимодействат трите слоя на трислойната архитектура.
//
// UI → казва какво иска потребителят
// Business → решава какво да се направи
// Data → осигурява данните
//
//
//
//
//
//
//
//
//
// Дефинирайте понятието Контролер (Controller) от MVC концепцията.
//
// Правилният отговор е: Контролерът в MVC служи за обработка на заявките на потребителя към приложението
//
//
//
//
//
//
//
// Посочете кое действие от компонентния тест се случва в Act фазата.
//
// Правилният отговор е: извървшане на действието за тестване
//
//
//
//
//
//
// Демонстрирайте рефакториране на следния фрагмент от код, като зададате подходящо именуване и форматиране, ако и където това е необходимо:
//
// class tdl { //class for todo list
//
// public string _Name { get; set; }
//
// public string description { get; set; }
//
// public virtual List<ToDoItem> Items { get; set; }
//
// }
//
//
//
//
//
// PRAVILEN KOD
//
//
//
// using System.Collections.Generic;
//
// public class TodoList
// {
// public string Name { get; set; }
//
// public string Description { get; set; }
//
// public virtual List<TodoItem> Items { get; set; }
// }
//
//
//
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Разполагате с код за калкулатор за действия +, -, *, /, ** (степенуване).
//
// Напишете компоненти тестове за него, които тестват подходящи специфични случаи при прилагането на операциите, например:
//
// * събиране на положително и отрицателно число
//
// * изваждане на число от себе си
//
// * деление на нула
//
// и др. За всяка операция предвидете поне по 3 теста.
//
// 40 TOCHKI ZADACHA
//
//
//
//
// using NUnit.Framework;
// using System;
//
// public class Tests
// {
// // ---------------- ADDITION ----------------
//
// [Test]
// [Category("Addition")]
// public void TestAddingTwoPositiveIntegerNumbers()
// {
// double result = Program.Add(5, 9);
// Assert.AreEqual(14, result);
// }
//
// [Test]
// [Category("Addition")]
// public void TestAddingTwoPositiveFloatingPointNumbers()
// {
// double result = Program.Add(5.43, 0.33);
// Assert.AreEqual(5.76, result, 0.0001);
// }
//
// [Test]
// [Category("Addition")]
// public void TestAddingTwoNegativeNumbers()
// {
// double result = Program.Add(-3.431, -3.241);
// Assert.AreEqual(-6.672, result, 0.0001);
// }
//
// [Test]
// [Category("Addition")]
// public void TestAddingZeroAndNumber()
// {
// double result = Program.Add(1, 0);
// Assert.AreEqual(1, result);
// }
//
// // ---------------- SUBTRACTION ----------------
//
// [Test]
// [Category("Subtraction")]
// public void TestSubtractSameNumber()
// {
// double result = Program.Subtract(5, 5);
// Assert.AreEqual(0, result);
// }
//
// [Test]
// [Category("Subtraction")]
// public void TestSubtractNegativeNumbers()
// {
// double result = Program.Subtract(-3, -5);
// Assert.AreEqual(2, result);
// }
//
// [Test]
// [Category("Subtraction")]
// public void TestSubtractZero()
// {
// double result = Program.Subtract(3, 0);
// Assert.AreEqual(3, result);
// }
//
// // ---------------- MULTIPLICATION ----------------
//
// [Test]
// [Category("Multiplication")]
// public void TestMultiplicationTwoPositiveNumbers()
// {
// double result = Program.Multiply(3, 2.5);
// Assert.AreEqual(7.5, result);
// }
//
// [Test]
// [Category("Multiplication")]
// public void TestMultiplicationTwoNegativeNumbers()
// {
// double result = Program.Multiply(-3, -2);
// Assert.AreEqual(6, result);
// }
//
// [Test]
// [Category("Multiplication")]
// public void TestMultiplicationDifferentSigns()
// {
// double result = Program.Multiply(-3, 2);
// Assert.AreEqual(-6, result);
// }
//
// [Test]
// [Category("Multiplication")]
// public void TestMultiplicationWithZero()
// {
// double result = Program.Multiply(0, 3);
// Assert.AreEqual(0, result);
// }
//
// // ---------------- DIVISION ----------------
//
// [Test]
// [Category("Division")]
// public void TestDivisionNormal()
// {
// double result = Program.Division(3, 2);
// Assert.AreEqual(1.5, result);
// }
//
// [Test]
// [Category("Division")]
// public void TestDivisionWithBiggerDivisor()
// {
// double result = Program.Division(3, 5);
// Assert.AreEqual(0.6, result, 0.0001);
// }
//
// [Test]
// [Category("Division")]
// public void TestDivisionZeroByNumber()
// {
// double result = Program.Division(0, 5);
// Assert.AreEqual(0, result);
// }
//
// [Test]
// [Category("Division")]
// public void TestDivisionByZero()
// {
// Assert.Throws<DivideByZeroException>(() => Program.Division(5, 0));
// }
// }
//
//
//
//
//
// Какво стои зад буквата V в абревиатурата на архитектурния шаблон MVC?
//
// Правилният отговор е: View
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 12
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// За какво служи клавишната комбинация Ctrl + K, Ctrl + D?
//
// Правилният отговор е: подреждане на кода
//
//
//
//
//
//
//
//
// Свържете всеки от посочените случаи с решение, в което средата се използва пълноценно.
//
// Кодът не е добре подреден - [използваме автоматично форматиране (подреждане)]
//
// Разполагаме с файл с около 3000 реда, трябва да намерим тялото на метод, чието име знаем - [Навигираме до метода с помощта на F12]
//
// Налага се често да пишем стандартни фрагменти код - [Използваме снипети, където е възможно]
//
//
//
//
//
//
//
// Посочете коя от следните команди е коректна команда за инсталиране на пакета Banichka чрез Package Manager Console във Visual Studo.
//
// Правилният отговор е: Install-Package Banichka
//
//
//
//
//
// За какво служи клавиш F5 във Visual Studio?
//
// Правилният отговор е: стартиране на програмата в дебъг режим
//
//
//
//
//
// Посочете за какво служи клавиша F12 във Visual Studio.
//
// Правилният отговор е: Навигиране в кода /Go to Definition/ до тялото на даден метод
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Демонстрирайте използването на библиотеката System.Text.Json (в .NET 5+) за десериализиране от JSON към обект.
//
// using Answer 1 Въпрос 6
// ;
//
// namespace DeserializeExtra
// {
// public class WeatherForecast
// {
// public DateTimeOffset Date { get; set; }
// public int TemperatureCelsius { get; set; }
// public string? Summary { get; set; }
// public string? SummaryField;
// public IList<DateTimeOffset>? DatesAvailable { get; set; }
// public Dictionary<string, HighLowTemps>? TemperatureRanges { get; set; }
// public string[]? SummaryWords { get; set; }
// }
//
// public class HighLowTemps
// {
// public int High { get; set; }
// public int Low { get; set; }
// }
//
// public class Program
// {
// public static void Main()
// {
// string jsonString =
// @"{
// ""Date"": ""2019-08-01T00:00:00-07:00"",
// ""TemperatureCelsius"": 25,
// ""Summary"": ""Hot"",
// ""DatesAvailable"": [
// ""2019-08-01T00:00:00-07:00"",
// ""2019-08-02T00:00:00-07:00""
// ],
// ""TemperatureRanges"": {
// ""Cold"": {
// ""High"": 20,
// ""Low"": -10
// },
// ""Hot"": {
// ""High"": 60,
// ""Low"": 20
// }
// },
// ""SummaryWords"": [
// ""Cool"",
// ""Windy"",
// ""Humid""
// ]
// }
// ";
//
// WeatherForecast? weatherForecast = Answer 2 Въпрос 6
// ;
//
// Console.WriteLine($"Date: {weatherForecast?.Date}");
// Console.WriteLine($"TemperatureCelsius: {weatherForecast?.TemperatureCelsius}");
// Console.WriteLine($"Summary: {weatherForecast?.Summary}");
// }
// }
// }
//
// namespace SerializeBasic {
// public class WeatherForecast {
// public DateTimeOffset Date { get; set; }
// public int TemperatureCelsius { get; set; }
// public string? Summary { get; set; }
// }
//
// public class Program {
// public static void Main() {
// var weatherForecast = new WeatherForecast {
// Date = DateTime.Parse("2019-08-01"),
// TemperatureCelsius = 25,
// Summary = "Hot"
// };
//
// Console.WriteLine(jsonString);
// }
// }
// }
//
// ОТГОВОРИ
// Answer 1:
// System.Text.Json
//
// Answer 2:
// JsonSerializer.Deserialize<WeatherForecast>(jsonString)
//
//
//
//
//
//
//
//
//
//
//
//
// Посочете за какво служи клавишната комбинация Ctrl + Q във Visual Studio.
//
// Правилният отговор е: Бързо стартиране /Quick Launch/
//
//
//
//
//
//
// Обяснете как се достъпва NuGET Package Manager.
//
// Чрез менюто на проекта, В Solution Explorer,Десен бутон върху проекта,Избери “Manage NuGet Packages…”
//
//
//
//
//
//
//
//
// За всяка от клавишните комбинации задайте нейното действие във Visual Studio
//
// Ctrl-K + Ctrl-C [закоментиране на избраните редове]
//
// Ctrl-K + Ctrl-U [премахване на коментар от избраните редове]
//
// Ctrl-K + Ctrl-D [подреждане (форматиране) на кода]
//
// Ctrl + Shift + N [създаване на нов файл]
//
//
//
//
//
//
//
// Посочете с коя директива се включват в кода допълнителни библиотеки.
//
// Правилният отговор е: using
//
//
//
//
//
//
//
//
//
//
// Демонстрирайте използването на библиотеката System.Text.Json (в .NET 5+) за сериализиране към JSON.
//
// using Answer 1 Въпрос 11
// ;
// namespace SerializeBasic {
// public class WeatherForecast {
// public DateTimeOffset Date { get; set; }
// public int TemperatureCelsius { get; set; }
// public string? Summary { get; set; }
// }
//
// public class Program {
// public static void Main() {
// var weatherForecast = new WeatherForecast {
// Date = DateTime.Parse("2019-08-01"),
// TemperatureCelsius = 25,
// Summary = "Hot"
// };
//
// string jsonString = Answer 2 Въпрос 11
// ;
// Console.WriteLine(jsonString);
// }
// }
// }
//
//
// ОТГОВОРИ
//
// Answer 1: System.Text.Json
// Answer 2: JsonSerializer.Serialize(weatherForecast)
//
//
//
//
//
//
//
//
//
//
// Посочете коя от изброените програми e среда за разработка на софтуер.
//
// Правилният отговор е: Visual Studio
//
//
//
//
//
//
//
// Обяснете предназначението на breakpoint (точки на счупване) в дебъгера на Visual Studio.
//
// Breakpoint-ите служат за умишлено прекъсване на изпълнението на програмата в определена точка, за да може разработчикът да анализира състоянието на програмата, променливите и потока на изпълнение. Това помага за откриване и отстраняване на грешки в кода.
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен
//
// фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
//
//
// Условие:
//
// Да се напише програма, която трябва да обработва информация за филми в JSON вид.
//
// Създайте клас Movie със свойства за:
//
// ● Id (int) – номер на филма
//
// ● Name (string) – име на филма
//
// ● Rating (decimal) – IMDB рейтинг на филма
//
// ● Year (DateTime) – година на премиерата на филма
//
// Подзадачи:
//
// ● Преобразувайте данните от клас Movie към JSON
//
// ● Преобразувайте JSON към Movie
//
// Изберете подходяща библиотека за работа с JSON за реализиране на подзадачите.
//
// Фрагмент:
//
// Movie.cs:
// public class Movie
// {
// public int Id { get; set
// public string Name get; set; }
// public decimal Rating { get; }
// public DateTime Year get; set; }
// }
//
// Program.cs:
// using System;
// using System.Collections.Generic;
//
// namespace JSONMovie
// {
// class Program
// {
// static void Main(string[] args)
// {
// List movies = new List();
// movies.Add(new Movie() {
//
// Id = 1,
// Name = "Movie 1",
// Rating = 3
// Year = DateTime.Parse("1/1/1998")
// })
//
// movies.Add(new ()
// {
// Id = 2,
// Name = "Movie 2",
// Rating = 3,
// Year = DateTime.Parse("1/1/2006")
// });
//
// string jsonString = JsonSerializer.(movies);
//
// Console.WriteLine(jsonString)
// }
// }
// }
//
//
// ПРАВИЛЕН КОД
//
//
//
// using System;
//
// public class Movie
// {
// public int Id { get; set; }
// public string Name { get; set; }
// public decimal Rating { get; set; }
// public DateTime Year { get; set; }
// }
//
//
//
//
//
//
//
//
//
// using System;
// using System.Collections.Generic;
// using System.Text.Json;
//
// namespace JSONMovie
// {
// class Program
// {
// static void Main(string[] args)
// {
// List<Movie> movies = new List<Movie>();
//
// movies.Add(new Movie()
// {
// Id = 1,
// Name = "Movie 1",
// Rating = 3.5m,
// Year = DateTime.Parse("1998-01-01")
// });
//
// movies.Add(new Movie()
// {
// Id = 2,
// Name = "Movie 2",
// Rating = 3.0m,
// Year = DateTime.Parse("2006-01-01")
// });
//
// // Сериализация към JSON
// string jsonString = JsonSerializer.Serialize(movies);
//
// Console.WriteLine("JSON:");
// Console.WriteLine(jsonString);
//
// // Десериализация от JSON към обекти
// List<Movie> deserializedMovies =
// JsonSerializer.Deserialize<List<Movie>>(jsonString);
//
// Console.WriteLine("\nDeserialized data:");
// foreach (var movie in deserializedMovies)
// {
// Console.WriteLine($"{movie.Id} - {movie.Name} - {movie.Rating} - {movie.Year}");
// }
// }
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Обяснете как работят снипетите във Visual Studio.
//
// Снипетите са предварително дефинирани шаблони за код, които могат да се вмъкват бързо във вашия код. Те съдържат често използвани конструкции и могат да включват плейсхолдъри, които ви позволяват да попълните специфична информация след вмъкването. За да използвате снипет, просто напишете неговото име и натиснете клавиша Tab, след което ще се появи шаблонът, който можете да редактирате според нуждите си. Това ускорява процеса на писане на код и намалява вероятността от грешки при ръчното въвеждане на често срещани конструкции.
//
//
//
//
//
//
//
// За какво служи клавишната комбинация Ctrl + F5 във Visual Studio?
//
// Правилният отговор е: стартиране на програмата в стандартен режим
//
//
//
//
//
// Демонстрирайте как бихте инсталирали разширението CodeMaid в средата за разработка Visual Studio. Подредете картинките така, че да спазват правилната последователност от стъпките.
//
// Номерирайте картинките, като използвате цифрите за влачене под таблицата.
//
// ОТГОВОРИТЕ СА следните: 2, 1, 3
//
//
//
//
//
//
//
// Обяснете каква е разликата между Solution (Решение) и Project (Проект) във Visual Studio.
//
// Solution (Решение) е контейнер, който може да съдържа един или повече проекти. Той служи за организиране на свързани проекти, които заедно формират по-голямо приложение или система. Project (Проект) е единична единица в рамките на решение, която съдържа код, ресурси и настройки за компилиране на конкретна част от приложението. Проектите могат да бъдат от различни типове (например, библиотека, конзолно приложение, уеб приложение) и могат да имат зависимости помежду си.
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 13
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Посочете кой от следните примери е нарушение на добрите практики при използването на WindowsForms като графичен потребителски интерфейс за приложение.
//
// Правилният отговор е: имената на контролите от форма са оставени по подразбиране на label1, button1 и т.н.
//
//
//
//
//
//
//
//
//
//
//
//
// Демонстрирайте създаването на таблици по CodeFirst подхода за следния Context клас:
//
// Създайте таблици за следните класове: Author, Book, Category, Order
// Примете, че необходимите using директиви са предварително поставени.
//
// public class ApplicationDbContext : DbContext
//
// {
//
// public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
//
// : base(options)
//
// {
//
// }
//
// // your code goes here
//
// }
//
//
//
// KODOVETE PRAVILNI
//
//
// public class Author
// {
// public int Id { get; set; }
// public string Name { get; set; }
//
// public ICollection<Book> Books { get; set; }
// }
//
// public class Book
// {
// public int Id { get; set; }
// public string Title { get; set; }
//
// public int AuthorId { get; set; }
// public Author Author { get; set; }
//
// public int CategoryId { get; set; }
// public Category Category { get; set; }
// }
//
// public class Category
// {
// public int Id { get; set; }
// public string Name { get; set; }
//
// public ICollection<Book> Books { get; set; }
// }
//
// public class Order
// {
// public int Id { get; set; }
// public DateTime OrderDate { get; set; }
//
// public ICollection<Book> Books { get; set; }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен
//
// фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
//
//
// Условие:
//
// Разполагате със следната схема. Създайте класове, които да ѝ съответстват и да са подходящи
//
// за работа с ORM система. Запишете класовете един под друг в отговора.
//
// 20 TOCHKI ZADACHA
//
//
//
// public class City
// {
// public int CityId { get; set; }
// public string Name { get; set; }
//
// public ICollection<User> Users { get; set; }
// }
//
//
//
// public class User
// {
// public int UserId { get; set; }
// public string Username { get; set; }
// public string Password { get; set; }
// public string FirstName { get; set; }
// public string LastName { get; set; }
// public decimal Balance { get; set; }
// public DateTime RegisterDate { get; set; }
//
// public int CityId { get; set; }
// public City City { get; set; }
//
// public ICollection<Rent> Rents { get; set; }
// }
//
//
//
// public class Scooter
// {
// public int ScooterId { get; set; }
// public string Model { get; set; }
// public string GpsPosition { get; set; }
// public bool IsTaken { get; set; }
//
// public ICollection<Rent> Rents { get; set; }
// }
//
//
//
// public class Rent
// {
// public int RentId { get; set; }
//
// public int UserId { get; set; }
// public User User { get; set; }
//
// public int ScooterId { get; set; }
// public Scooter Scooter { get; set; }
//
// public DateTime StartDate { get; set; }
// public DateTime EndDate { get; set; }
// public bool IsCompleted { get; set; }
// }
//
//
//
//
//
//
//
//
//
// Посочете кое от следните е валиден начин за изпращане на SELECT заявка в C#.
//
//
// Правилният отговор е: SqlCommand command = new SqlCommand( "SELECT COUNT(*) FROM Employees", dbCon);
//
//
//
//
//
//
// Посочете как се нарича типа в EntityFrameworkCore, който съдържа в себе си записите от дадена таблица от база данни.
//
// Правилният отговор е: DbSet
//
//
//
//
// Демонстрирайте създаване на ViewModel за ToDoList със следните полета:
//
// Id
//
// Title (заглавие, максимум 50 знака, задължително)
//
// Description (описание, максимум 255 знака, не е задължително)
//
//
//
// using System.ComponentModel.DataAnnotations;
//
// public class ToDoViewModel
// {
// public int Id { get; set; }
//
// [Required]
// [StringLength(50, ErrorMessage = "Title cannot exceed 50 characters.")]
// public string Title { get; set; }
//
// [StringLength(255, ErrorMessage = "Description cannot exceed 255 characters.")]
// public string Description { get; set; }
// }
//
//
//
//
//
//
//
// Обяснете предназначението на контролера в MVC и ASP.NET Core.
//
// Контролерът в MVC и ASP.NET Core служи за обработка на входящите HTTP заявки от потребителите. Той приема заявките, извлича необходимите данни от моделите, изпълнява бизнес логиката и връща подходящ отговор, който може да бъде изглед (View) или данни в JSON формат. Контролерът действа като посредник между модела и изгледа, като координира взаимодействието между тях и осигурява правилното функциониране на приложението.
//
//
//
//
// Обяснете действието на следния фрагмент:
//
// toDoList.CreatedAt = DateTime.Now;
// _context.Add(toDoList);
// await _context.SaveChangesAsync();
//
// Този фрагмент от код задава текущата дата и час на свойството CreatedAt на обекта toDoList. След това добавя този обект към контекста на базата данни (_context) и извършва асинхронно записване на промените в базата данни чрез метода SaveChangesAsync(). Това означава, че новият ToDoList ще бъде запазен в базата данни с времето на създаване, което е текущото време.
//
//
//
//
//
//
// Какво представлява ViewModel?
//
// Правилният отговор е: Всички изброени са верни.
//
//
//
//
//
// Посочете кое от следните НЕ Е ORM система.
//
// Правилният отговор е: Microsoft SQL Server
//
//
//
//
// Обяснете действието на следния фрагмент:
//
// toDoList.ModifiedAt = DateTime.Now;
// _context.Update(toDoList);
// await _context.SaveChangesAsync();
//
// Този фрагмент от код задава текущата дата и час на свойството ModifiedAt на обекта toDoList. След това обновява този обект в контекста на базата данни (_context) и извършва асинхронно записване на промените в базата данни чрез метода SaveChangesAsync(). Това означава, че съществуващият ToDoList ще бъде актуализиран в базата данни с новото време на последна модификация, което е текущото време.
//
//
//
//
//
//
//
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен
//
// фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
//
//
// Условие:
//
// Разполагате със следната схема. Създайте класове, които да ѝ съответстват и да са подходящи
//
// за работа с ORM система.
//
//
// 20 TOCHKI KOD
//
//
// public class Country
// {
// public short CountryId { get; set; }
// public string CountryName { get; set; }
// public DateTime LastUpdate { get; set; }
//
// public ICollection<City> Cities { get; set; }
// }
//
//
//
// public class City
// {
// public short CityId { get; set; }
// public string CityName { get; set; }
// public DateTime LastUpdate { get; set; }
//
// public short CountryId { get; set; }
// public Country Country { get; set; }
//
// public ICollection<Address> Addresses { get; set; }
// }
//
//
//
// public class Address
// {
// public short AddressId { get; set; }
// public string AddressText { get; set; }
// public string Address2 { get; set; }
// public string District { get; set; }
// public string PostalCode { get; set; }
// public string Phone { get; set; }
// public string Location { get; set; }
// public DateTime LastUpdate { get; set; }
//
// public short CityId { get; set; }
// public City City { get; set; }
// }
//
//
//
//
//
//
//
//
//
// Посочете кое от следните е ORM система.
//
// Правилните отговори са: EntityFrameworkCore, Microsoft SQL Server
//
//
//
//
//
//
//
//
// Демонстрирайте създаване на клас, който съответства на следната таблица в БД:
//
//
// class Book {
//
// [public int Id { get; set; }]
//
// [public string Title { get; set; }]
//
// [public string Author { get; set; }]
//
// [public double Price { get; set; }]
//
// [public int Quantity { get; set; }]
//
// }
//
//
//
//
//
//
// Демонстрирайте създаване на клас, който съответства на следната таблица в БД:
//
// class Person {
//
// [public int Id { get; set; }]
//
// [public string FirstName { get; set; }]
//
// [public string MiddleName { get; set; }]
//
// [public string LastName { get; set; }]
//
// [public DateTime BirthDate { get; set; }]
//
// [public int CityId { get; set; }]
//
// }
//
//
//
//
//
// Посочете какво наричаме „магически стойности" в програмирането.
//
// Правилният отговор е: низове или числени стойности, които са поставени директно в кода
//
//
//
//
//
// Обяснете защо примерния програмен фрагмент няма да доведе до изтриване на данни от базата данни:
//
// public void DeleteList(ToDoList toDoList)
//
// {
//
// _context.ToDoList.Remove(toDoList);
//
// }
//
// Този фрагмент от код няма да доведе до изтриване на данни от базата данни, защото не извършва операцията SaveChanges() след премахването на обекта toDoList от контекста. За да се отразят промените в базата данни, трябва да се извика методът SaveChanges() или SaveChangesAsync() след Remove(), който ще изпълни SQL командата за изтриване на записа от базата данни. Без този метод, промените остават само в паметта и не се записват в базата данни.
//
//
//
//
//
//
// Посочете какво означава абривиатурата ORM:
//
// Правилният отговор е:
// Object Relational Mapping
//
//
//
//
//
// Обяснете предназначението на модела в MVC и ASP.NET Core.
//
// Моделът в MVC и ASP.NET Core представлява данните и бизнес логиката на приложението. Той съдържа класове, които дефинират структурата на данните, както и методи за обработка на тези данни. Моделът е отговорен за взаимодействието с базата данни, извличането и съхранението на информацията, както и за прилагането на бизнес правила. В MVC архитектурата моделът е отделен от контролера и изгледа, което позволява по-добра организация на кода и улеснява поддръжката и разширяването на приложението.
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// TEST 14
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие: Създайте директория my_dir1, която се намира в домашната папка на потребителя. Създайте директория my_dir2, която се намира в my_dir1, а след това създайте файл hello.txt в my_dir2. Приемете, че стартирате от кореновата директория
//
// Фрагмент:
//
// cd ..
//
// mk dir my_dir1
//
// mkdir my_dir2
//
// cd my_dir2
//
// make hello.txt
//
//
// PRAVILEN KOD
//
// cd ~
//
// mkdir my_dir1
//
// cd my_dir1
//
// mkdir my_dir2
//
// cd my_dir2
//
// touch hello.txt
//
//
//
//
//
//
//
// Посочете коя от следните команди служи за създаване на директория в Линукс?
//
// Правилният отговор е: mkdir
//
//
//
//
// Посочете кое от следните спада към хардуера?
//
// Правилните отговори са: дънна платка, процесор, оперативна памет
//
//
//
//
// Кое от следните НЕ е система за инсталация на пакети в Линукс дистрибуция?
//
// Правилният отговор е: npm
//
//
//
// Демонстрирайте употребата на команда, която извежда всички файлове и директории рекурсивно за директория с име di_2024, която се намира в домашната папка на потребителя. Приемете, че изпълнявате командата, намирайки се в домашната папка на потребителя.
//
// Правилният отговор е: ls -l -R ~/di_2024
//
//
//
//
//
//
// Коя от следните команди инсталира пакет чрез apt системата за управление на пакети в Линукс?
//
// Правилният отговор е: apt install package-name
//
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие: Изведете съдържанието на директорията my_dir, ако тя съществува. В противен случай изведете съобщение "The directory does not exist". Приемете, че стартирате от кореновата директория на системата.
//
// Фрагмент:
//
// [ -d dir goes here && ls ~/ my_dir || "The directory does not exist"
//
// PRAVILEN KOD
//
// [ -d "$HOME/my_dir" ] && ls ~/my_dir || echo "The directory does not eixst"
//
//
//
//
//
//
//
//
//
// Демонстрирайте инсталация на пакет build-essentials в Линукс дистрибуция.
//
// Правилният отговор е: sudo apt install build-essential
//
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие: Създайте чрез команди директория my_dir, която да е разположена в домашната папка на потребителя. Приемете, че стартирате от кореновата директория на системата. Ако директорията съществува, изведете съобщение "Already exists".
//
// Фрагмент:
//
// [ -d dir goes here && "Dir exists" || mk dir ~/my_dir
//
// PRAVILEN KOD
//
// [ -d "$HOME/my_dir" ] && echo "Already exists" || mkdir ~/my_dir
//
//
//
//
//
//
//
// Посочете коя от следните команди служи за копиране на файл в Linux?
//
// Правилният отговор е: cp
//
//
//
//
// Посочете с няколко изречения разликата между L1 и L2 кеша на процесора.
//
// L1 кешът е най-бързият и най-малкият по размер кеш, който се намира директно в процесора. Той е предназначен за съхранение на най-често използваните данни и инструкции, които процесорът може да достъпва много бързо. L2 кешът е по-голям и по-бавен от L1 кеша, и обикновено се намира на същия чип като процесора, но не е директно интегриран в него. L2 кешът служи като междинна стъпка между L1 кеша и основната памет (RAM), като съхранява данни и инструкции, които не са толкова често използвани, но все пак трябва да бъдат достъпвани по-бързо от RAM.
//
//
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие: Изтрийте чрез команди файл my_file, който е разположен в домашната папка на потребителя. Приемете, че стартирате от кореновата директория на системата. Ако файлът не съществува, изведете съобщение "Already removed".
//
// Фрагмент:
//
// -f file path goes here ] && echo "Already removed" || rmdir ~/my_file
//
// PRAVILEN KOD
//
// [ -f "$HOME/my_file" ] && echo "Already removed" || rm ~/my_file
//
//
//
//
//
//
//
//
// Демонстрирайте употребата на команда, която създава директория с име di_2024
//
// Правилният отговор е: mkdir di_2024
//
//
//
//
//
//
// За всяко от понятията посочете определение:
//
// хардуер - [апаратната част на компютъра]
//
// софтуер - [операционна система и приложения]
//
// потребител - [човек или машина, които се възползват от работата на компютъра]
//
//
//
//
//
//
//
// Посочете разликата между програма и процес:
//
// Програмата е [набор от инструкции към процесора записани върху носител], а процесът е [абстракция на програма в режим на изпълнение]
//
//
//
//
//
//
//
//
// Кое от следните е система за инсталация на пакети в Линукс дистрибуция?
//
// Правилният отговор е: apt
//
//
//
//
//
//
// Дайте определение за понятието нишка:
//
// Нишката [e част] от [процеса]. Една програма задължително има [главна нишка]. Нишките [споделят общи ресурси]. Нишките позволяват [конкурентното изпълнение на програмни инструкции].
//
//
//
//
//
// Посочете коя от следните команди служи за извеждане на текущата работна директория в Линукс?
//
// Правилният отговор е: pwd
//
//
//
//
// Посочете кое от следните контролира заделянето на памет?
//
// Правилният отговор е: операционната система
//
//
//
//
// Демонстрирайте инсталация на пакет node в Линукс дистрибуция.
//
// Правилният отговор е: sudo apt install nodejs
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// TEST 15
//
//
//
//
//
//
//
//
//
//
// Как се нарича единицата за разпределение на дисковото пространство в NTFS?
//
// Правилният отговор е: клъстер
//
//
//
//
// Изберете правилното наименование за описаната файлова система
//
// [ext4]
//
// Тази файлова система е скалируемо разширение на друга подобна на нея файлова систена. Често е налична по подразбиране в немалко линукс дистрибуции. Тази файлова система поддържа файл с размери 16 терабайта. Системата поддържа неограничен брой поддиректории.
//
// [fat32]
//
// Тази файлова система се използва често върху определени устройства. Нейният максимален размер на файл е 4 гигабайта.
//
//
//
//
//
// Коя от следните услуги е свръзана с протокола Secure Shell?
//
// Правилният отговор е: sshd
//
//
//
//
// Коя от следните услуги е свръзана с протокола File Transfer Protocol?
//
// Правилните отговори са: vsftpd, httpd
//
//
//
//
// Демонстрирайте команда за създаване на файл с име di_2022 в Линукс. Приемете, че се намирате в домашната папка на потребителя.
//
// Правилният отговор е: touch di_2022
//
//
//
//
//
//
// Коя от следните команди рестартира напълно услугата serviced?
//
// Правилният отговор е: sudo systemctl restart serviced
//
//
//
//
//
// Пример: По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен
//
// фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Създайте чрез команди необходимите директории и файлове от следната диаграма:
//
// 40 tocki zadacha
//
//
// cd ~
//
// mkdir mydir
//
// cd mydir
//
// mkdir colors shapes animals
//
// cd animals
// mkdir reptiles mammals
//
// cd ../colors
//
// touch red green blue
//
// echo '#ff0000' > red
// echo '#00ff00' > green
// echo '#0000ff' > blue
//
// cd ..
//
// zip -r mydir.zip mydir
//
//
//
//
// Демонстрирайте команда за изтриване на файл с име di_2022 в Линукс. Приемете, че се намирате в домашната папка на потребителя.
//
// Правилният отговор е: rm di_2022
//
//
//
// Демонстрирайте с помощта на команда монтиране на файлова система от устройство /dev/sdb1 на точка /mnt/media, като зададете за тип на файловата система ntfs
//
// Правилният отговор е: sudo mount -t ntfs /dev/sdb1 /mnt/media
//
//
//
//
// Коя от следните файлови системи не може да бъде разпозната от ОС Windows 10 по подразбиране?
//
// Правилният отговор е: ext4
//
//
//
// Демонстрирайте команда за изтриване на директория с име di_2022 в Линукс. Приемете, че се намирате в домашната папка на потребителя.
//
// Правилният отговор е: rmdir di_2022
//
//
//
//
// Демонстрирайте с помощта на команда монтиране на файлова система от устройство /dev/sdb1 на точка /mnt/media, като зададете за тип на файловата система ext4
//
// Правилният отговор е: sudo mount -t ext4 /dev/sdb1 /mnt/media
//
//
//
//
// Демонстрирайте команда, с помощта на която форматирате като ntfs устройството /dev/sdb1
//
// Правилният отговор е: sudo mkfs.ntfs /dev/sdb1
//
//
//
// За коя файлова система се отнася описанието:
//
// Тя е журнална файлова система. Не се разпознава от Windows 10 по подразбиране, но се използва широко в Линукс.
//
// Правилният отговор е: ext4
//
//
//
//
// Коя от следните услуги е свръзана с мрежови протокол?
//
// Правилният отговор е: dhcpd
//
//
//
//
// Коя от следните команди спира услугата serviced
//
// Правилният отговор е: sudo systemctl stop serviced
//
//
//
// Коя от следните команди стартира услугата serviced
//
// Правилният отговор е: sudo systemctl start serviced
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// TEST 16
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Посочете коя бройна система използва цифрите от 0 до 9 и буквите A, B, C, D, E и F.
//
// Правилният отговор е: шестнадесетична
//
//
//
//
// Преобразувайте двоичното число 10111101 към положително число в десетична бройна система.
//
//
// Правилният отговор е: 189
//
//
//
//
// Посочете коя е основата на шестнадесетичната бройна система.
//
// Правилният отговор е: 16
//
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Решете следната система линейни уравнения, чрез използването на избрана изучавана софтуерна среда:
//
//
//
// Фрагмент:
//
// using MathNet.Numerics.LinearAlgebra;
// using MathNet.Numerics.LinearAlgebra.Double;
// using System;
//
//
// var matrix = DenseMatrix.OfArray(new double[,] { { 1, 2, 5 }, { 1 -1, 2 }, { -9, 3, 25 } };
// Vector<double> solve = new DenseVector(new[] 3.0, -6.0, -1.0 });
// var answer = matrix.Solve(solve);
// Console.WriteLine(string.Join(" ", solve));
//
// //Решение: 2 -3 -1
//
// 10 tochki
//
//
//
// using MathNet.Numerics.LinearAlgebra;
// using MathNet.Numerics.LinearAlgebra.Double;
// using System;
//
// class Program
// {
// static void Main()
// {
// // Матрица на коефициентите
// var matrix = DenseMatrix.OfArray(new double[,]
// {
// { 1, 2, 5 },
// { 1, -1, 2 },
// { 3, -6, -1 }
// });
//
// // Вектор на свободните членове
// Vector<double> solve = new DenseVector(new double[]
// {
// -9.0,
// 3.0,
// 25.0
// });
//
// // Решение
// var answer = matrix.Solve(solve);
//
// Console.WriteLine(string.Join(" ", answer));
// }
// }
//
//
//
//
//
// Посочете правилната дефиниция на понятието медиана в статистиката.
//
// Правилният отговор е: стойността, която се намира по средата на подреден статистически ред
//
//
//
//
//
//
// Посочете правилната дефиниция на понятието средна стойност.
//
// Правилният отговор е: сумата от стойностите на всички елементи в дадена съвкупност, разделено на броя им.
//
//
//
//
// Функцията f(x) = 2x + 5 e:
//
// Правилният отговор е: линейна
//
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
//
// Напишете програма, която въвежда матрица 3х3, въведете от клавиатурата реално число и умножете матрицата по него.
//
// Фрагмент:
// Console.WriteLine("Please enter 3x3 matrix");
// double[,] m = new double[ , ];
//
// for (int i = 0; i < 3; i++)
// {
// var j = 0;
// var numbers = Console.ReadLine().Split(' ').Select(double.Parse).ToList();
// foreach (var n in numbers)
// {
// m[i, j] = n;
// j++;
// }
// }
//
// Console.WriteLine("Please enter a number");
// var num = int.Parse(Console.ReadLine());
// for (int i = 0; i < 3; i++)
// {
// for (int j = 0; j < 3; j++)
// {
// Console.Write(m[i, j] + " ");
// }
// Console.WriteLine();
// }
//
// PRAVILEN KOD
//
//
// using System;
// using System.Linq;
//
// class Program
// {
// static void Main()
// {
// Console.WriteLine("Please enter 3x3 matrix");
//
// double[,] m = new double[3, 3];
//
// // Въвеждане на матрицата
// for (int i = 0; i < 3; i++)
// {
// int j = 0;
//
// var numbers = Console.ReadLine()
// .Split(' ')
// .Select(double.Parse)
// .ToList();
//
// foreach (var n in numbers)
// {
// m[i, j] = n;
// j++;
// }
// }
//
// Console.WriteLine("Please enter a number");
//
// double num = double.Parse(Console.ReadLine());
//
// // Умножение на матрицата по числото
// for (int i = 0; i < 3; i++)
// {
// for (int j = 0; j < 3; j++)
// {
// m[i, j] = m[i, j] * num;
// Console.Write(m[i, j] + " ");
// }
//
// Console.WriteLine();
// }
// }
// }
//
//
//
//
//
//
//
// Кое от следните НЕ е свойство на математическа функция:
//
// Правилният отговор е: комутативност
//
//
//
//
//
// Преобразувайте десетичното число 765 към число в шестнадесетична бройна система. Отговорът изпишете в 4 позиции.
//
// Правилният отговор е: 02FD
//
//
//
//
//
//
// Да се напише конзолно приложение, което преобразува число от шестнайсетичнабройна система в десетична бройна система
//
// using System;
//
// class Program
// {
// static void Main()
// {
// Console.Write("Въведете шестнайсетично число: ");
//
// string hexNumber = Console.ReadLine();
//
// // Преобразуване от 16-ична в 10-ична бройна система
// int decimalNumber = Convert.ToInt32(hexNumber, 16);
//
// Console.WriteLine("Десетично число: " + decimalNumber);
// }
// }
//
//
//
//
//
//
// Приложете софтуерен метод за решаване на следната система линейни уравнения:
//
//
//
// С помощта на блокчета постройте код, който да реши успешно системата.
//
// using System;
// using MathNet.Numerics.LinearAlgebra.Double;
// using MathNet.Numerics.LinearAlgebra;
//
// var matrix = DenseMatrix.OfArray(new double[,] { [{1,2,5}], [{1,‑1,2}], [{3, ‑6, ‑1}] });
// Vector<double> solve = new DenseVector(new[] [{‑9,3,25}]);
// var answer = [matrix ].Solve([solve]);
// Console.WriteLine(string.Join(" ", answer));
//
//
//
//
//
//
// По какъв начин са представени данните на приложеното графично изображение?
//
// Правилният отговор е: кръгова диаграма
//
//
//
//
// Демонстрирайте с помощта на код на програмен език от изучаваните (Python, C#) , по подаден лист от реални числа разделени с интервал как се изчислява, тяхната Мода :
//
// using System;
// using System.Linq;
// using System.Collections.Generic;
//
// class Program
// {
// static void Main()
// {
// Console.WriteLine("Въведете реални числа, разделени с интервал:");
//
// // Въвеждане на числата
// List<double> numbers = Console.ReadLine()
// .Split(' ')
// .Select(double.Parse)
// .ToList();
//
// // Намиране на модата
// var mode = numbers.GroupBy(x => x)
// .OrderByDescending(g => g.Count())
// .First()
// .Key;
//
// Console.WriteLine("Мода: " + mode);
// }
// }
//
//
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Намерете средната дневна температура за следните замервания:
//
// 15, 13, 12, 12, 19, 22, 21, 18
// Фрагмент:
//
// using System;
// using System.Collections.Generic;
// using System.Linq;
//
// var input = new List<int>();
// Console.WriteLine($"Средна дневна температура: {average}" );
//
// 10 TOCHKI PRAVILEN KOD
//
//
//
//
// using System;
// using System.Collections.Generic;
// using System.Linq;
//
// class Program
// {
// static void Main()
// {
// // Списък с температурите
// var input = new List<int> { 15, 13, 12, 12, 19, 22, 21, 18 };
//
// // Изчисляване на средната стойност
// double average = input.Average();
//
// Console.WriteLine($"Средна дневна температура: {average}");
// }
// }
//
//
//
//
//
// Посочете правилната дефиниция на понятието генерална съвкупност.
//
// Правилният отговор е: Множество от стойностите на разглеждания признак за всички изследвани обекти
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Напишете конзолно приложение, което при въведени коефициенти на полином, разделени с интервал намира корените на функцията на полонома, когато е равна на 0.
// Фрагмент:
//
// var coef = Console.ReadLine().Split(' ').Select(s => double.Parse(s)).Reverse().ToList();
// var p = new Polynomial(coef);
// var answ = p;
// Console.WriteLine(string.Join(" ", coef));
//
//
// PRAVILEN KOD
//
//
//
// using System;
// using System.Linq;
//
// class Program
// {
// static void Main()
// {
// Console.WriteLine("Въведете коефициентите a b c:");
//
// // Въвеждане на коефициентите
// var coef = Console.ReadLine()
// .Split(' ')
// .Select(double.Parse)
// .ToList();
//
// double a = coef[0];
// double b = coef[1];
// double c = coef[2];
//
// // Дискриминанта
// double d = b * b - 4 * a * c;
//
// if (d > 0)
// {
// double x1 = (-b + Math.Sqrt(d)) / (2 * a);
// double x2 = (-b - Math.Sqrt(d)) / (2 * a);
//
// Console.WriteLine($"Корени: {x1} {x2}");
// }
// else if (d == 0)
// {
// double x = -b / (2 * a);
//
// Console.WriteLine($"Един корен: {x}");
// }
// else
// {
// Console.WriteLine("Няма реални корени");
// }
// }
// }
//
//
//
//
//
// По какъв начин са представени данните на приложеното графично изображение?
//
// Правилният отговор е: хистограма (колонна диаграма)
//
//
//
// Посочете правилната дефиниция на понятието мода в статистиката.
//
// Правилният отговор е: стойността, която се среща най-често в статистически ред
//
//
//
//
//
//
//
// Приложете софтуерен метод за решаване на следната система линейни уравнения:
//
//
//
// С помощта на блокчета постройте код, който да реши успешно системата.
//
// using System;
// using MathNet.Numerics.LinearAlgebra.Double;
// using MathNet.Numerics.LinearAlgebra;
//
// var matrix = DenseMatrix.OfArray(new double[,] { [{3,2,‑5}], [{2,‑1,3}], [{1, 2, ‑1}] });
// Vector<double> solve = new DenseVector(new[] [{‑1,13,9}]);
// var answer = [matrix ].Solve([solve]);
// Console.WriteLine(string.Join(" ", answer));
//
//
//
//
//
// Функцията f(x) = 3x2 -2x + 5 e:
//
// Правилният отговор е: квадратична
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// TEMA 17
//
//
//
//
//
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Напишете програма, която въвежда координатите на две точки (А и B) в тримерна координатна система и изчислява координатите на вектора BA
//
// Фрагмент:
//
// var input1 = ;
// Vector3 A= ;
// var input2 = Console.ReadLine().Split(' ').Select(s => float.Parse(s)).ToList();
// Vector3 B= new Vector3(input2[0], input2[1] );
//
// Vector3 answer =A B;
// Console.WriteLine( );
//
// 1O TOCHKI PRAVILEN KOD
//
//
//
//
// using System;
// using System.Linq;
// using System.Numerics;
//
// class Program
// {
// static void Main()
// {
// Console.WriteLine("Въведете координатите на точка A:");
//
// var input1 = Console.ReadLine()
// .Split(' ')
// .Select(s => float.Parse(s))
// .ToList();
//
// Vector3 A = new Vector3(input1[0], input1[1], input1[2]);
//
// Console.WriteLine("Въведете координатите на точка B:");
//
// var input2 = Console.ReadLine()
// .Split(' ')
// .Select(s => float.Parse(s))
// .ToList();
//
// Vector3 B = new Vector3(input2[0], input2[1], input2[2]);
//
// // Вектор BA = A - B
// Vector3 answer = A - B;
//
// Console.WriteLine($"Вектор BA: {answer}");
// }
// }
//
//
//
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Напишете програма, която въвежда координатите на два вектора v1 и v2 в тримерна координатна система. Програмата да намира скаларното произведение на двата вектора.
//
// Фрагмент:
//
// var input1 = Console.ReadLine().Split(' ').Select(s => float.Parse(s)).ToList();
// Vector3 v1 = ;
// var input2 =;
// Vector3 v2 = new Vector3(input2[0], input2[1], );
// Vector3 answer = v2 v1;
// Console.WriteLine( );
//
// 10 TOCHKI PRAVILEN KOD
//
//
//
//
// using System;
// using System.Linq;
// using System.Numerics;
//
// class Program
// {
// static void Main()
// {
// Console.WriteLine("Въведете координатите на вектор v1:");
//
// var input1 = Console.ReadLine()
// .Split(' ')
// .Select(s => float.Parse(s))
// .ToList();
//
// Vector3 v1 = new Vector3(input1[0], input1[1], input1[2]);
//
// Console.WriteLine("Въведете координатите на вектор v2:");
//
// var input2 = Console.ReadLine()
// .Split(' ')
// .Select(s => float.Parse(s))
// .ToList();
//
// Vector3 v2 = new Vector3(input2[0], input2[1], input2[2]);
//
// // Скаларно произведение
// float answer = Vector3.Dot(v1, v2);
//
// Console.WriteLine($"Скаларно произведение: {answer}");
// }
// }
//
//
//
//
//
//
//
//
//
// Представени са три комбинаторни конфигурации. Надпишете всяка от тях.
//
// Представени са три комбинаторни конфигурации. Надпишете всяка от тях.
//
//
//
// 1 2 3 4
//
// 1 2 4 3
//
// 1 3 2 4
//
// 1 3 4 2
//
// 1 4 2 3
//
// 1 4 3 2
//
// 2 1 3 4
//
// 2 1 4 3
//
// 2 3 1 4
//
// 2 3 4 1
//
// 2 4 3 1
//
// 2 4 1 3
//
// 3 1 2 4
//
// 3 1 4 2
//
// 3 2 1 4
//
// 3 2 4 1
//
// 3 4 1 2
//
// 3 4 2 1
//
// 4 1 2 3
//
// 4 1 3 2
//
// 4 2 1 3
//
// 4 2 3 1
//
// 4 3 1 2
//
// 4 3 2 1
//
// 1 1
//
// 1 2
//
// 1 3
//
// 2 2
//
// 2 3
//
// 3 3
//
// 1 2
//
// 1 3
//
// 2 3
//
// А. [Пермутации без повторение]
//
// Б. [Комбинации с потворение]
//
// В. [Комбинации без повторение]
//
//
//
//
//
//
//
//
//
// Нека имаме следните множества:
//
// A = {1, 2, 3}
//
// B = {3, 4, 5}
//
// Можем да кажем, че:
//
// A ∪ B = [{1, 2, 3, 4, 5}]
//
// 1 [∈] A
//
//
//
//
//
//
// Изберете правилната дефиниция на понятието комбинация без повторение.
//
// Правилният отговор е: Съвкупност от избрани k елемента от общо n елемента на дадено множество, като редът не е от значение
//
//
//
//
//
//
// Използвайте блоковете, за да опишете алгоритъм за генериране на комбинации без повторение
//
// public static void Generate(int index, int start)
//
// {
//
// if([index >= k]) {
//
// Console.WriteLine(string.Join(" ", combination));
//
// } else {
//
// for(int i = start; i < elements.Length; i++) {
//
// combination[ [index] ] = [elements[i]];
//
// Generate(index + 1, [i + 1]);
//
// }
//
// }
//
// }
//
//
//
//
//
//
//
//
// Посочете кое от следните е правилна дефиниция на понятието вектор:
//
// Правилният отговор е: отсечка, на която единия край е избран за начало, а другият за край
//
//
//
//
//
// Посочете кое от следните НЕ е свойство на векторите:
//
// Правилният отговор е: идемпотентност
//
//
//
//
// Изберете правилната дефиниция на понятието вариация без повторение.
//
// Правилният отговор е: Съвкупност от избрани k елемента от общо n елемента на дадено множество, като редът е от значение
//
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Напишете програма, която въвежда координатите на 3 вектора и намира дължината на най - късият от тях
//
// Фрагмент:
//
// List<double> l = new List<double>();
// for (int i = 0; i < ; i++)
// {
// var input =
// Vector3 v = new Vector3( );
// l.Add ();
// }
//
// Console.WriteLine( );
//
//
//
//
// PRAVILEN KOD
//
//
//
// using System;
// using System.Collections.Generic;
// using System.Linq;
// using System.Numerics;
//
// class Program
// {
// static void Main()
// {
// List<double> l = new List<double>();
//
// for (int i = 0; i < 3; i++)
// {
// Console.WriteLine("Въведете координатите на вектор:");
//
// var input = Console.ReadLine()
// .Split(' ')
// .Select(double.Parse)
// .ToList();
//
// Vector3 v = new Vector3(
// (float)input[0],
// (float)input[1],
// (float)input[2]);
//
// // Добавяне на дължината на вектора
// l.Add(v.Length());
// }
//
// Console.WriteLine("Най-къс вектор: " + l.Min());
// }
// }
//
//
//
//
//
//
//
// Представени са три комбинаторни конфигурации. Надпишете всяка от тях.
//
//
//
// 1 1
//
// 1 2
//
// 1 3
//
// 2 1
//
// 2 2
//
// 2 3
//
// 3 1
//
// 3 2
//
// 3 3
//
// 1 1
//
// 1 2
//
// 1 3
//
// 2 2
//
// 2 3
//
// 3 3
//
//
// 1 2
//
// 1 3
//
// 2 1
//
// 2 3
//
// 3 1
//
// 3 2
//
//
//
// А. [Вариации с повторение]
//
// Б. [Комбинации с потворение]
//
// В. [Вариации без повторение]
//
//
//
//
//
//
//
// Коя операция между множества е показана на изображението:
//
// Правилният отговор е: обединение
//
//
//
//
//
//
//
// Представени са три комбинаторни конфигурации. Надпишете всяка от тях.
//
//
//
// 1 1
//
// 1 2
//
// 1 3
//
// 2 1
//
// 2 2
//
// 2 3
//
// 3 1
//
// 3 2
//
// 3 3
//
// 1 1
//
// 1 2
//
// 1 3
//
// 2 2
//
// 2 3
//
// 3 3
//
// 1 2
//
// 1 3
//
// 2 3
//
// А. [Вариации с повторение]
//
// Б. [Комбинации с потворение]
//
// В. [Комбинации без повторение]
//
//
//
//
//
//
//
// Използвайте блоковете, за да опишете алгоритъм за генериране на пермутации
//
// public static void Generate(int index)
//
// {
//
// if([index >= elements.Length]) {
//
// Console.WriteLine(string.Join(" ", permutation));
//
// } else {
//
// for(int i = 0; i < elements.Length; i++) {
//
// if([!used[i]]) {
//
// [used[i] = true];
//
// permutation[ [index] ] = [elements[i]];
//
// Generate(index + 1);
//
// used[i] = false;
//
// }
//
// }
//
// }
//
// }
//
//
//
//
//
//
//
//
// Изберете правилната дефиниция на понятието пермутация.
//
// Правилният отговор е: Всяка подредена съвкупност от n елемента на дадено множество, като всеки се среща само веднъж
//
//
//
//
//
// Нека имаме следните множества:
//
// A = {1, 2, 3}
//
// B = {3, 4, 5}
//
// Можем да кажем, че:
//
// A \ B = [{1, 2}]
//
// 3 [∈] B
//
//
//
//
//
//
// Коя операция между множества е показана на изображението: CHERVENA DIAGRAMA
//
// Правилният отговор е: сечение
//
//
//
//
//
//
// [Векторите] са съставени от компоненти, които са числа. Те представляват [масив] от числа, а операциите върху тях се разглеждат като операции върху него. В програмните езици те могат да се представят като [масив].
//
//
//
//
// Демонстрирайте пресмятане на средната вероятност за резултати "ези" или "тора" при хвърляне на монета за 10000 хвърляния. Използвайте средствата на изучаван език за програмиране C# .
//
// using System;
//
// class Program
// {
// static void Main()
// {
// Random rnd = new Random();
//
// int heads = 0; // ези
// int tails = 0; // тора
//
// int throwsCount = 10000;
//
// // Симулиране на хвърлянията
// for (int i = 0; i < throwsCount; i++)
// {
// int result = rnd.Next(0, 2);
//
// if (result == 0)
// heads++;
// else
// tails++;
// }
//
// // Вероятности
// double probabilityHeads = (double)heads / throwsCount;
// double probabilityTails = (double)tails / throwsCount;
//
// Console.WriteLine($"Брой ези: {heads}");
// Console.WriteLine($"Брой тора: {tails}");
//
// Console.WriteLine($"Вероятност за ези: {probabilityHeads:F4}");
// Console.WriteLine($"Вероятност за тора: {probabilityTails:F4}");
// }
// }
//
//
//
//
//
//
//
//
//
//
//
// Използвайте блоковете, за да опишете алгоритъм за генериране на вариации с повторение
//
// public static void Generate(int index)
//
// {
//
// if([index >= k]) {
//
// Console.WriteLine(string.Join(" ", variation));
//
// } else {
//
// for(int i = 0; i < elements.Length; i++) {
//
// variation[ [index] ] = [elements[i]];
//
// Generate(index + 1);
//
// }
//
// }
//
// }
//
//
//
//
//
//
// Какъв е сборът на вектор v1(3, 6) с вектор v2(1, 5)?
//
// Правилният отговор е: v3(4, 11)
//
//
//
//
//
//
// Демонстрирайте пресмятане на средната вероятност за резултат от 1 до 6 при хвърляне на зар за 5000 хвърляния. Използвайте средствата на изучаван език за програмиране C# .
//
//
// using System;
//
// class Program
// {
// static void Main()
// {
// int throws = 5000;
// int[] counts = new int[6]; // индекси 0..5 за стойности 1..6
//
// Random random = new Random();
//
// // Симулираме хвърлянията
// for (int i = 0; i < throws; i++)
// {
// int roll = random.Next(1, 7); // 1 до 6 включително
// counts[roll - 1]++;
// }
//
// Console.WriteLine("Резултати от 5000 хвърляния:\n");
//
// double sumProbabilities = 0;
//
// for (int i = 0; i < 6; i++)
// {
// double probability = (double)counts[i] / throws;
// sumProbabilities += probability;
//
// Console.WriteLine($"Число {i + 1}: {counts[i]} пъти -> вероятност {probability:F4}");
// }
//
// double averageProbability = sumProbabilities / 6;
//
// Console.WriteLine("\nСредна вероятност (средно от всички изходи): " +
// $"{averageProbability:F4}");
// }
// }
//
//
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
// Условие:
//
// Напишете програма, която въвежда координатите на две точки (А и B) в тримерна координатна система и изчислява координатите на вектора AB
//
// Фрагмент:
//
// var input1 = Console.ReadLine().Split(' ').Select(s => float.Parse(s)).ToList();
// Vector3 A= new Vector3(input1[0], input1[1] );
// var input2 = ;
// Vector3 B= ;
//
// Vector3 answer = B A;
// Console.WriteLine( );
//
// PRAVILEN KOD
//
//
// using System;
// using System.Linq;
// using System.Numerics;
//
// class Program
// {
// static void Main()
// {
//
// var input1 = Console.ReadLine()
// .Split(' ')
// .Select(float.Parse)
// .ToList();
//
// Vector3 A = new Vector3(input1[0], input1[1], input1[2]);
//
//
// var input2 = Console.ReadLine()
// .Split(' ')
// .Select(float.Parse)
// .ToList();
//
// Vector3 B = new Vector3(input2[0], input2[1], input2[2]);
//
//
// Vector3 answer = B - A;
//
//
// Console.WriteLine($"{answer.X} {answer.Y} {answer.Z}");
// }
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// TEST 18
//
//
//
//
//
//
//
//
//
//
//
//
// Дефинирайте понятието блокираща операция.
//
// Блокираща операция е операция при която процесът или нишката спира изпълнението си и изчаква нейното завършване преди да продължи
//
//
//
//
// Кой е проблемът, който отговаря на посоченото описание?
// Проблемът може да възникне по следния начин:
//
// Нишка 1 заема ресурс А;
//
// Нишка 2 заема ресурс B;
//
// Нишка 1 опитва да заеме ресурс B;
//
// Нишка 2 опитва да заеме ресурс А.
//
// Тъй като ресурсите А и Б вече се използват съответно от нишка 1 и нишка 2, при опит на другата нишка да заеме ресурс, то тя трябва да изчака. Това води до взаимно изчакване и на двете нишки, което може да продължи безкрайно. Проблемът е възможно да възникне и между по-голям брой ресурси.
//
// Правилният отговор е: Мъртва хватка (dead lock)
//
//
//
//
//
//
//
//
//
// Открийте какъв проблем при употреба на нишки се наблюдава в примерния програмен фрагмент и предложете решение.
//
// static void Main()
// {
// Thread t1 = new Thread(PrintBunny);
// t1.Start();
// }
//
//
//
//
//
//
// Демонстрирайте създаването и стартирането на нишка, която изпълнява метода по-долу. Включете целия необходим код в отговора, в това число class Program и Main метод.
//
//
// using System;
// using System.Threading;
//
// class Program
// {
// static void PrintBunny()
// {
// Console.WriteLine(@"|)___(|");
// Console.WriteLine(@"(o . o)");
// Console.WriteLine(@"(_).(_)");
// }
//
// static void Main()
// {
// Thread t1 = new Thread(PrintBunny);
// t1.Start();
//
// t1.Join();
// }
// }
//
//
//
//
//
//
//
// Кое от следните НЕ е състояние на нишка?
//
// Правилният отговор е:
// „в изчакване” (Awaiting)
//
//
//
//
//
// Кое от понятията е дефинирано в текста по-долу?
//
// Изпълнение на набор от операции едновременно.
//
// Правилният отговор е:
// конкурентност
//
//
//
//
//
// Демонстрирайте създаването и стартирането на нишка, която изпълнява метода по-долу. Включете целия необходим код в отговора, в това число class Program и Main метод.
//
//
// static void Count(int n) {
//
// for(int i = n; i >= 0; i--) {
//
// Console.WriteLine(i);
//
// }
//
// }
//
//
// PRAVILEN KOD
//
// using System;
// using System.Threading;
//
// class Program
// {
// static void Count(int n)
// {
// for (int i = n; i >= 0; i--)
// {
// Console.WriteLine(i);
// }
// }
//
// static void Main()
// {
// Thread t1 = new Thread(() => Count(5));
// t1.Start();
//
// t1.Join();
// }
// }
//
//
//
//
//
//
//
//
// Между процесите и нишките съществува връзка. Кое от тези твърдения описва вярно тази връзка?
//
// Правилният отговор е:
// множество нишки на различни програми може да бъдат изпълнявани от даден процес
//
//
//
//
// Дайте пример за поне два вида блокиращи операции.
//
// Четене от файл или мрежова заявка и използване на lock или Monitor Wait когато нишка чака другата да освободи ресурс
//
//
//
//
//
//
//
// По време на теоретичния изпит се предоставя непълен/неработещ/некоректен програмен фрагмент. Предоставеният фрагмент да се приведе в работещ вид.
//
//
// Условие:
//
// Да се напише програма, която получава цяло число n. След това програмата да генерира масива с n на брой елементи от случайни числа в интервала [-100; 100]. Програмата трябва да разполага с две нишки, които намират и отпечатват съответно сумата и броя на нулите от елементите в масива.
//
// 20 TOCHKI
//
// Предоставен фрагмент:
//
// using System;
//
// using System.Collections.Generic;
//
// using System.Linq;
//
// using System.Threading;
//
//
//
// namespace ExampleThread1
//
// {
//
// class Program
//
// [{]
//
//
// [static] void FindSum(int[] arr)
//
// {
//
// [int sum = 0;]
//
// [for (int i = 0; i < arr.Length; i++)]
//
// {
//
// [sum += arr[i];]
//
// }
//
//
//
// Console.WriteLine($"Sum: {sum}");
//
// }
//
// static void FindZero([int[] arr])
//
// {
//
// [int zeroes = 0;]
//
// for (int i = 0; i < arr.Length; i++)
//
// {
//
// if (arr[i] == 0)
//
// {
//
// [max = arr[i];]
//
// }
//
// }
//
// Console.WriteLine($"Zeroes: {zeroes}");
//
// }
//
// static void Main(string[] args)
//
// {
//
// int n = int.Parse(Console.ReadLine());
//
// int[] arr = new int[n];
//
// Random r = new Random();
//
// for (int i = 0; i < n; i++)
//
// {
//
// arr[i] = r.Next(-100, 100);
//
// }
//
//
//
// [Thread t1 = new Thread(() => FindSum(arr));]
//
// Thread t2 = new Thread(() => FindZero(arr));
//
// t1.Start();
//
// t2.Start();
//
// [}]
//
// }
//
// }
//
//
//
//
//
// Изберете дефиницията на понятието нишка.
//
// Правилният отговор е:
// Самостоятелна редица от програмни инструкции, които се изпълняват последователно
//
//
//
//
//
//
// Демонстрирайте създаването и стартирането на нишка, която изпълнява метода по-долу. Включете целия необходим код в отговора, в това число class Program и Main метод.
//
//
// static void PrintTriangle(int n) {
//
// for(int i = 1; i <= n; i++)
// {
// for(int j = 1; j <= i; j++)
// {
// Console.Write($"{j} ");
// }
// Console.WriteLine();
// }
//
// }
//
//
//
// PRAVILEN KOD
//
// using System;
// using System.Threading;
//
// class Program
// {
// static void PrintTriangle(int n)
// {
// for (int i = 1; i <= n; i++)
// {
// for (int j = 1; j <= i; j++)
// {
// Console.Write($"{j} ");
// }
// Console.WriteLine();
// }
// }
//
// static void Main()
// {
// int n = int.Parse(Console.ReadLine());
//
// Thread t1 = new Thread(() => PrintTriangle(n));
// t1.Start();
//
// t1.Join();
// }
// }
//
//
//
//
//
//
//
//
//
// Свойството ThreadState на нишка показва:
//
// Правилният отговор е:
// състоянието на нишката
//
//
//
//
//
//
// Изберете дефиницията на понятието процес
//
// Правилният отговор е:
// Процесът е абстракция на програма в режим на изпълнение
//
//
//
//
// Свойството IsBackgroundThread на нишка показва:
//
// Правилният отговор е:
// дали работи на преден или заден план
//
//
//
//
// Дайте пример за ситуация, в която възниква проблем „гладуване“ (starvation)?
//
// Когато нишки с различен приоритет се състезават за един и същ ресурс ако нишка с висок приоритет непрекъснато заема ресурса нишка с нисък приоритет може да не получи достъп до него за дълго време или никога
//
//
//
//
//
// Открийте какъв проблем при употреба на нишки се наблюдава в примерния програмен фрагмент. DULUG CHEREN KOD
//
// Наблюдаваният проблем е:
//
// Race Condition
// липса на синхронизация при достъп до споделен ресурс
// възможна критична секция
// потенциално изключение при едновременен достъп до Stack<int> от няколко нишки.
//
//
//
// Обобщете чрез попълване на празните места в диаграмата жизнения цикъл на нишката. BQLA DIAGRAMA
//
// Горното състояние: готовност (Ready)
// Средното състояние: изпълнение (Running)
//
//
//
}
}
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net8.0 is compatible. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. net9.0 was computed. net9.0-android was computed. net9.0-browser was computed. net9.0-ios was computed. net9.0-maccatalyst was computed. net9.0-macos was computed. net9.0-tvos was computed. net9.0-windows was computed. net10.0 was computed. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.
-
net8.0
- No dependencies.
NuGet packages
This package is not used by any NuGet packages.
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 1.0.0 | 112 | 5/19/2026 |