public void GetCommand()
{
var input = VInput.GetArgs();
if (input.Length == 0)
{
return; //Don't process 0 args
}
var commandName = input[0];
var args = ArraysUtility.SubArray(input, 1);
//FIND ALIASES
var command = CurrentCommands.FirstOrDefault(command => command.Aliases.Any(alias => alias == commandName.ToLower()));
if (command != null)
{
Attempt(command, args);
return;
}
//FIND NAME
var commandList = StringsUtility.Match(commandName, CurrentCommands);
if (commandList.Count == 0)
{
new GameError($"No commands starting with \"{commandName}\" found!").Write();
}
else if (commandList.Count > 1)
{
VConsole.WriteLine($"Commands starting with \"{commandName}\":");
new TextList <Command>(commandList).Write();
}
else
{
Attempt(commandList[0], args);
}
}
public override void ProcessArgs(string[] args)
{
Tag tag = null;
var tagsUsed = new List <Tag>();
var startIndex = 0;
for (int i = 0; i < args.Length; i++)
{
if (Tags.Where(tag => !tagsUsed.Contains(tag)).Any(tag => tag.Name == args[i]))
{
if (tag == null)
{
base.ProcessArgs(ArraysUtility.SubArray(args, startIndex, i - startIndex));
}
else
{
tag.ProcessArgs(ArraysUtility.SubArray(args, startIndex, i - startIndex));
tagsUsed.Add(tag);
}
tag = Tags.FirstOrDefault(tag => tag.Name == args[i]);
startIndex = i + 1;
}
}
if (tag == null)
{
base.ProcessArgs(ArraysUtility.SubArray(args, startIndex, args.Length - startIndex));
}
else
{
tag.ProcessArgs(ArraysUtility.SubArray(args, startIndex, args.Length - startIndex));
tagsUsed.Add(tag);
}
}
/*Реализовать сортировку слиянием.*/
private static void Task3()
{
Console.WriteLine("Cортировка слиянием");
int[] A = ArraysUtility.GenerateIntArray(50);
A.PrintArray();
Console.WriteLine("Сортируем:");
MergeSort.Sort(A);
A.PrintArray();
}
/*Реализовать быструю сортировку.*/
private static void Task2()
{
Console.WriteLine("Быстрая сортировка");
int[] A = ArraysUtility.GenerateIntArray(50);
A.PrintArray();
Console.WriteLine("Сортируем:");
QuickSort.Sort(A);
A.PrintArray();
}
/* Реализовать шейкерную сортировку. */
public static void Task02()
{
Console.WriteLine("Шейкерная сортировка.");
int[] ar = ArraysUtility.GenerateArray(10, 1, 50);
ar.PrintArray();
ShakerSort(ar);
ar.PrintArray();
}
/*Реализовать сортировку подсчетом.*/
private static void Task1()
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Сортировка подсчетом");
int max = 50;
int[] A = ArraysUtility.GenerateArray(10, 0, max);
A.PrintArray();
Console.WriteLine("Сортируем:");
CountingSort(A, max);
A.PrintArray();
}
/* Реализовать бинарный алгоритм поиска в виде функции,
* которой передается отсортированный массив. Функция возвращает
* индекс найденного элемента или -1, если элемент не найден*/
public static void Task03()
{
int[] ar = ArraysUtility.GenerateArray(10, 1, 20);
BubbleSort(ar);
ar.PrintArray();
int findelement = 5;
Console.WriteLine($"find:{findelement} index = [{ BinarySearch(ar, findelement)}]");
findelement = 7;
Console.WriteLine($"find:{findelement} index = [{ BinarySearch(ar, findelement)}]");
findelement = 10;
Console.WriteLine($"find:{findelement} index = [{ BinarySearch(ar, findelement)}]");
}
/* Попробовать оптимизировать пузырьковую сортировку.
* Сравнить количество операций сравнения оптимизированной и
* не оптимизированной программы. Написать функции сортировки, которые
* возвращают количество операций. */
public static void Task01()
{
Console.ForegroundColor = ConsoleColor.Green;
int[] ar1 = ArraysUtility.GenerateArray(10, 1, 50); // тестовый массив
int[] ar2 = ar1.CopyArrray();
ar1.PrintArray();
int c1 = BubbleSort(ar1);
int c2 = BubbleSortOptimize(ar2);
ar1.PrintArray();
Console.WriteLine($"Итераций (обычная сортировка): {c1}");
Console.WriteLine($"Итераций (оптимизированная сортировка): {c2}");
}
/*Время работы сортировок.*/
private static void Task4()
{
#region Генерируем массивы
Console.WriteLine(new string('+', 50));
Console.WriteLine("Генерируем массивы");
int[] I10 = ArraysUtility.GenerateIntArray(10);
int[] I100 = ArraysUtility.GenerateIntArray(100);
int[] I1000 = ArraysUtility.GenerateIntArray(1000);
int[] I10000 = ArraysUtility.GenerateIntArray(10000);
int[] I100000 = ArraysUtility.GenerateIntArray(100000);
int[] I1000000 = ArraysUtility.GenerateIntArray(1000000);
int[] I10000000 = ArraysUtility.GenerateIntArray(10000000);
double[] D10 = ArraysUtility.GenerateArray(10);
double[] D100 = ArraysUtility.GenerateArray(100);
double[] D1000 = ArraysUtility.GenerateArray(1000);
double[] D10000 = ArraysUtility.GenerateArray(10000);
double[] D100000 = ArraysUtility.GenerateArray(100000);
double[] D1000000 = ArraysUtility.GenerateArray(1000000);
double[] D10000000 = ArraysUtility.GenerateArray(10000000);
#endregion
Console.WriteLine(new string('+', 50));
Console.WriteLine("\n------ !!! Пузырьковая сортировка (int) !!! -------");
Testing.TestedSort("I1_000 -", I1000.CopyArrray(), BubbleSort.Sort);
Testing.TestedSort("I10_000 -", I10000.CopyArrray(), BubbleSort.Sort);
Console.WriteLine("I100_000 - долго...");
Console.WriteLine("\n------ !!! Пузырьковая оптимизированная сортировка (int) !!! -------");
Testing.TestedSort("I1_000 -", I1000.CopyArrray(), BubbleSort.SortOptimize);
Testing.TestedSort("I10_000 -", I10000.CopyArrray(), BubbleSort.SortOptimize);
Console.WriteLine("I100_000 - долго...");
Console.WriteLine("\n------ !!! Cортировка вставкой (int) !!! -------");
Testing.TestedSort("I1_000 -", I1000.CopyArrray(), InsertionSort.Sort);
Testing.TestedSort("I10_000 -", I10000.CopyArrray(), InsertionSort.Sort);
Testing.TestedSort("I100_000 -", I100000.CopyArrray(), InsertionSort.Sort);
Console.WriteLine("I1_000_000 - долго...");
Console.WriteLine("\n------ !!! Шейкерная сортировка (int) !!! -------");
Testing.TestedSort("I1_000 -", I1000.CopyArrray(), ShakerSort.Sort);
Testing.TestedSort("I10_000 -", I10000.CopyArrray(), ShakerSort.Sort);
Console.WriteLine("I100_000 - долго...");
Console.WriteLine("\n------ !!! Пирамидальная сортировка (int) !!! -------");
Testing.TestedSort("I1_000 -", I1000.CopyArrray(), HeapSort.Sort);
Testing.TestedSort("I10_000 -", I10000.CopyArrray(), HeapSort.Sort);
Testing.TestedSort("I100_000 -", I100000.CopyArrray(), HeapSort.Sort);
Testing.TestedSort("I1_000_000 -", I1000000.CopyArrray(), HeapSort.Sort);
Console.WriteLine("\n------ !!! Сортировка слиянием (int) !!! -------");
Testing.TestedSort("I1000 -", I1000.CopyArrray(), MergeSort.Sort);
Testing.TestedSort("I10_000 -", I10000.CopyArrray(), MergeSort.Sort);
Testing.TestedSort("I100_000 -", I100000.CopyArrray(), MergeSort.Sort);
Testing.TestedSort("I1_000_000 -", I1000000.CopyArrray(), MergeSort.Sort);
Testing.TestedSort("I10_000_000 -", I10000000.CopyArrray(), MergeSort.Sort);
Console.WriteLine("\n------ !!! Быстрая сортировка (int) !!! -------");
Testing.TestedSort("I1_000 -", I1000.CopyArrray(), QuickSort.Sort);
Testing.TestedSort("I10_000 -", I10000.CopyArrray(), QuickSort.Sort);
Testing.TestedSort("I100_000 -", I100000.CopyArrray(), QuickSort.Sort);
Testing.TestedSort("I1_000_000 -", I1000000.CopyArrray(), QuickSort.Sort);
Console.WriteLine("I10_000_000 - долго...");
Console.WriteLine("\n------ !!! Быстрая сортировка (double) !!! -------");
Testing.TestedSort("D1_000 -", D1000.CopyArrray(), QuickSort.Sort);
Testing.TestedSort("D10_000 -", D10000.CopyArrray(), QuickSort.Sort);
Testing.TestedSort("D100_000 -", D100000.CopyArrray(), QuickSort.Sort);
Testing.TestedSort("D1_000_000 -", D1000000.CopyArrray(), QuickSort.Sort);
Testing.TestedSort("D10_000_000 -", D10000000.CopyArrray(), QuickSort.Sort);
Console.WriteLine("\n Всё!!! Парам пам пам. ");
}
public Command[] GetCurrentCommandList(Game game)
{
return(ArraysUtility.Add(game.IsInMenu ? MenuCommands : GameCommands, GlobalCommands));
}
public virtual void ProcessArgs(string[] args)
{
if (args.Length < Arguments.Count)
{
throw new FormatException($"The {FunctionType} {Name} needs at least {Arguments.Count} arguments!");
}
if (Arguments.Any(arg => arg is UnlimitedStringArgument))
{
for (var i = args.Length - Arguments.Count; i > 0; i--)
{
try
{
var arguments = new List <Argument>();
arguments.AddRange(Arguments);
arguments.AddRange(OptionalArguments.GetRange(0, i));
ProcessUnlimited(args, arguments);
}
catch (Exception e) { continue; }
return;
}
ProcessUnlimited(args, Arguments);
}
else if (OptionalArguments.Any(arg => arg is UnlimitedStringArgument))
{
var optArgs = new string[args.Length - Arguments.Count];
for (var i = 0; i < args.Length; i++)
{
if (i < Arguments.Count)
{
Arguments[i].ProcessArgs(new [] { args[i] });
}
else
{
optArgs[i - Arguments.Count] = args[i];
}
}
var list = ArraysUtility.SubArray(OptionalArguments.ToArray(), 0, optArgs.Length).ToList();
//TRIES TO MAXIMIZE OPTIONAL ARGUMENTS ADDED
for (var i = list.Count; i > 0; i--)
{
try
{
ProcessUnlimited(optArgs, list);
}
catch (Exception e)
{
list.RemoveAt(list.Count - 1); //Remove Last Item
continue;
}
return;
}
}
else
{
if (args.Length > Arguments.Count + OptionalArguments.Count)
{
throw new FormatException($"The {FunctionType} {Name} can only take up to {Arguments.Count + OptionalArguments.Count} arguments!");
}
for (var i = 0; i < args.Length; i++)
{
if (i < Arguments.Count)
{
Arguments[i].ProcessArgs(new [] { args[i] });
}
else
{
OptionalArguments[i - Arguments.Count].ProcessArgs(new [] { args[i] });
}
}
}
}
