kaloyankibarev07e 1.0.0

    //                 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)