kaloyankibarev07d 1.0.0
dotnet add package kaloyankibarev07d --version 1.0.0
NuGet\Install-Package kaloyankibarev07d -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="kaloyankibarev07d" Version="1.0.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="kaloyankibarev07d" Version="1.0.0" />
<PackageReference Include="kaloyankibarev07d" />
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 kaloyankibarev07d --version 1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: kaloyankibarev07d, 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 kaloyankibarev07d@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=kaloyankibarev07d&version=1.0.0
#tool nuget:?package=kaloyankibarev07d&version=1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 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++)
// {
| 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 | 108 | 5/20/2026 |