kaloyankibarev07j 1.0.0
dotnet add package kaloyankibarev07j --version 1.0.0
NuGet\Install-Package kaloyankibarev07j -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="kaloyankibarev07j" Version="1.0.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="kaloyankibarev07j" Version="1.0.0" />
<PackageReference Include="kaloyankibarev07j" />
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 kaloyankibarev07j --version 1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: kaloyankibarev07j, 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 kaloyankibarev07j@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=kaloyankibarev07j&version=1.0.0
#tool nuget:?package=kaloyankibarev07j&version=1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
//
//
// Използвайте блоковете, за да опишете алгоритъм за генериране на комбинации без повторение
//
// 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 | 110 | 5/20/2026 |