public void BisectLeft_MultipleItemsExists_Test()
{
var array = new[] { 0, 1, 1, 1, 2, 3 };
var index = SortingHelper.CalculateSortedInsertIndex(array, 1, SortMethod.BisectLeft);
Assert.Equal(1, index);
}
[HttpPost] // Sorts passed list and saves to file
public ActionResult <string> SortNumbersList([FromBody] DataToSort pDataToSort)
{
try
{
if (pDataToSort.InputData.Length == 0 || pDataToSort.InputData == null)
{
return(BadRequest());
}
SortingHelper vSorter = new SortingHelper();
int[] vSortedArray;
try
{
vSortedArray = vSorter.SortNumbers(pDataToSort.InputData);
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Error during array sorting: +" +
Environment.NewLine + ex.StackTrace));
}
return(Ok(gFilesHelper.SaveSortedData(vSortedArray)));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public static T[] BubbleSort <T>(params T[] source) where T : IComparable
{
bool sorted = false;
for (int iteration = 0; iteration <= source.Length * source.Length; iteration++) //Worst case is n^2
{
bool swapped = false;
for (int i = 0; i < source.Length - 1; i++)
{
if (source[i].CompareTo(source[i + 1]) == 1)
{
SortingHelper.Swap(ref source[i], ref source[i + 1]);
swapped = true;
}
}
if (!swapped)
{
sorted = true;
Debug.Log(iteration);
break;
}
}
if (!sorted)
{
throw new ArgumentException("Too few iterations to sort array.");
}
return(source);
}
public void FilterFlightsByAirportPair_MultipleAirportPairs_ReturnsFilteredFlights()
{
// Arrange
var firstFlight = new Flight
{
DepartureAirportCode = "SEA",
ArrivalAirportCode = "PHX"
};
var secondFlight = new Flight
{
DepartureAirportCode = "SEA",
ArrivalAirportCode = "PHX"
};
var thirdFlight = new Flight
{
DepartureAirportCode = "PHX",
ArrivalAirportCode = "LAX"
};
var initialFlights = new List <Flight> {
firstFlight, secondFlight, thirdFlight
};
var sortingHelper = new SortingHelper();
// Act
var filteredFlights = sortingHelper.FilterFlightsByAirportPair("SEA", "PHX", initialFlights);
// Assert
filteredFlights.Count.ShouldBe(2);
filteredFlights.ShouldNotContain(thirdFlight);
}
public void SortFlightsByDepartureTimeEarlyToLate_ReverseOrderedFlights_ReturnsSortedFlights()
{
// Arrange
var firstFlight = new Flight
{
ScheduledDepartureTime = "6:00 PM"
};
var secondFlight = new Flight
{
ScheduledDepartureTime = "9:00 AM"
};
var initialFlights = new List <Flight> {
firstFlight, secondFlight
};
var sortingHelper = new SortingHelper();
// Act
var sortedFlights = sortingHelper.SortFlightsByDepartureTimeEarlyToLate(initialFlights);
initialFlights.Reverse();
// Assert
sortedFlights.ShouldBe(initialFlights);
}
protected void InitializePager(IEnumerable <Product> entities)
{
ViewModel.Pagging.List = SortingHelper.ToSortedPagedList(entities, (Sort)ViewModel.SortFilter.Sort,
ViewModel.PageSizeFilter.PageSize,
ViewModel.PageFilter.Page);
InitializeRoutes();
}
public void BisectRight_ItemNotExists_Test()
{
var array = new[] { 0, 1, 3 };
var index = SortingHelper.CalculateSortedInsertIndex(array, 2, SortMethod.BisectRight);
Assert.Equal(2, index);
}
public static T[] CombSort <T>(float shrinkFactor, params T[] source) where T : IComparable
{
bool sorted = false;
int gap = source.Length;
for (int iteration = 0; iteration <= source.Length * source.Length; iteration++) //Worst case is n^2
{
bool swapped = false;
for (int i = 0; i + gap < source.Length; i++)
{
if (source[i].CompareTo(source[i + gap]) == 1)
{
SortingHelper.Swap(ref source[i], ref source[i + gap]);
swapped = true;
}
}
gap = Mathf.FloorToInt(gap / shrinkFactor);
gap = Mathf.Clamp(gap, 1, source.Length);
if (!swapped && gap == 1) //Gap must be 1(regular bubble sort) to make sure everything was sorted
{
sorted = true;
break;
}
}
if (!sorted) //MaxIterations were hit
{
throw new ArgumentException("Too few iterations to sort array.");
}
return(source);
}
public void InitHelpers()
{
cartHelper = new CartHelper(driver);
comparingHelper = new ComparingHelper(driver);
discountHelper = new DiscountHelper(driver);
filterHelper = new FilterHelper(driver);
productCatalogHelper = new ProductCatalogHelper(driver);
productListHelper = new ProductListHelper(driver);
searchHelper = new SearchHelper(driver);
sortingHelper = new SortingHelper(driver);
}
public IEnumerable <House> GetFilteredListOfHouses(Properties.SearchCriteria searchCriteria, Properties.SortingCriteria sortingCritera, Houses serviceData)
{
ServiceData = serviceData;
if (ServiceData == null)
{
GetHousingInfo();
}
_sortingHelper = SortingHelper.Create(ServiceData);
return(_sortingHelper.GetSortedHouseList(searchCriteria, sortingCritera));
}
public House GetIdealHouse(Houses serviceData)
{
ServiceData = serviceData;
if (ServiceData == null)
{
GetHousingInfo();
}
_sortingHelper = SortingHelper.Create(ServiceData);
return(_sortingHelper.GetIdealHouse());
}
public async Task <IEnumerable <Order> > GetAllFilteredAsync(PaginationFilter paginationFilter, SortingFilter sortingFilter, GetAllOrdersFilter filter = null)
{
var query = dbContext.Set <Order>()
.Include(x => x.OrderDetails)
.ThenInclude(x => x.Product)
.AsQueryable();
AddFiltersOnQuery(ref query, filter);
SortingHelper.ApplySort(ref query, sortingFilter.OrderBy);
return(await PaginationHelper <Order> .PagedList(query, paginationFilter.Page));
}
private void StartAlgorithm_Execute()
{
try
{
IAlgorithm algorithm;
if (!CheckContainerSize())
{
throw new InvalidContainerSizeException("Container is not big enough to contain biggest object. Enlarge the container.");
}
if (Dimensionality == AlgorithmDimensionality.TwoDimensional)
{
Container2D startingContainer = containerFactory.Create(algorithmProperties, ContainerWidth, ContainerHeight);
algorithm = factory.Create(algorithmProperties, startingContainer);
}
else
{
Container3D startingContainer = containerFactory.Create(algorithmProperties, ContainerWidth, ContainerHeight, ContainerDepth);
algorithm = factory.Create(algorithmProperties, startingContainer);
}
stopwatch.Reset();
var sortedObjects = SortingHelper.Sort(objectsToPack, ObjectOrdering);
stopwatch.Start();
algorithm.Execute(sortedObjects);
stopwatch.Stop();
var endResults = algorithm.CreateResults();
ExecutionTime = stopwatch.ElapsedMilliseconds;
Quality = endResults.Quality;
ContainersUsed = endResults.ContainersUsed;
ObjectAmount = endResults.ObjectCount;
ObjectTotalFullfilment = endResults.ObjectsTotalFulfillment;
ContainerFulfillment = endResults.ContainerFulfillment;
AverageFulfillmentRatio = endResults.AverageFulfillmentRatio;
FulfillmentRatioStandardDeviation = endResults.FulfillmentRatioStandardDeviation;
WorstFulfillment = endResults.WorstFulfillment;
System.Windows.MessageBox.Show("Program successfully packed input object set.", "End of packing.");
}
catch (Exception err)
{
System.Windows.MessageBox.Show("Error during executing algorithm: " + err.Message, "Error");
}
}
public static int DescendingOrder(int inputNumber)
{
int output;
// it was not explained in the task how to handle negative values so only choice I had was to throw an exception
if (inputNumber < MinimalAllowedNumber)
{
throw new Exception($"Input number must be higher than or equal to { MinimalAllowedNumber }.");
}
var inputNumberAsCharArray = ConvertionHelper.IntToCharArray(inputNumber);
SortingHelper.SortCharArrayDescending(inputNumberAsCharArray);
output = ConvertionHelper.CharArrayToInt(inputNumberAsCharArray);
return(output);
}
public SortingFilter(string sortField, bool ascending)
{
var sortFields = SortingHelper.GetSortField();
sortField = sortField.ToLower();
if (sortFields.Select(x => x.Key).Contains(sortField.ToLower()))
{
sortField = sortFields.Where(x => x.Key == sortField).Select(x => x.Value).SingleOrDefault();
}
else
{
sortField = "Id";
}
SortField = sortField;
Ascending = ascending;
}
private static void RunAlgorithm()
{
IFigure startingContainer;
IAlgorithm algorithm;
Stopwatch stopwatch = new Stopwatch();
IContainerFactory containerFactory = new ContainerFactory();
IAlgorithmFactory factory = new AlgorithmFactory();
if (Properties.Dimensionality == AlgorithmDimensionality.TwoDimensional)
{
startingContainer = containerFactory.Create(Properties, ContainerWidth, ContainerHeight);
algorithm = factory.Create(Properties, startingContainer);
}
else
{
startingContainer = containerFactory.Create(Properties, ContainerWidth, ContainerHeight, ContainerDepth);
algorithm = factory.Create(Properties, startingContainer);
}
ObjectSet objectsToPack = LoadObjectSet();
if (!CheckContainerSize(objectsToPack))
{
throw new InvalidContainerSizeException("Container is not big enough to contain biggest object. Enlarge the container.");
}
stopwatch.Reset();
var sortedObjects = SortingHelper.Sort(objectsToPack, Ordering);
stopwatch.Start();
algorithm.Execute(sortedObjects);
stopwatch.Stop();
var endResults = algorithm.CreateResults();
endResults.ExecutionTime = stopwatch.ElapsedMilliseconds;
WriteResiltsToCsv(endResults, startingContainer);
}
public AllRoleProfilesViewModel(
IEnumerable <RoleProfile> roleProfiles,
string?searchString,
string sortBy,
string sortDirection,
int page
) : base(searchString, sortBy, sortDirection, page)
{
var sortedItems = SortingHelper.SortRoleProfileItems(
roleProfiles,
sortBy,
sortDirection
);
var filteredItems = SearchHelper.FilterRoleProfiles(sortedItems, SearchString, 60, false).ToList();
MatchingSearchResults = filteredItems.Count;
SetTotalPages();
var paginatedItems = PaginateItems(filteredItems);
RoleProfiles = paginatedItems.Cast <RoleProfile>();
}
/// <summary>
/// Sorts IQueryable source according to provided sort criteria and sort functor
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">Source IQueryable</param>
/// <param name="sortCriteria">SortCriteria to be used for sorting</param>
/// <param name="sortFunctor">Sort functor to be used for sorting</param>
/// <returns><see cref="IOrderedQueryable<typeparamref name="T"/>"/></returns>
public static IOrderedQueryable <T> DoSorting <T>(this IQueryable <T> source, IEnumerable <SortCriteria> sortCriteria, Func <string, Expression <Func <T, object> > > sortFunctor)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
// Convert to IOrderedQueryable, will leave current order
var ordered = source.OrderBy(x => 0);
if (!ordered.Any() || sortCriteria == null || !sortCriteria.Any())
{
return(ordered);
}
foreach (var sortRule in sortCriteria.OrderBy(x => x.Priority))
{
ordered = SortingHelper.ApplySortRule(ordered, sortRule, sortFunctor);
}
return(ordered);
}
public IActionResult SizeList(SearchPaginationListModel searchModel)
{
try
{
if (searchModel.pageNo <= 0)
{
searchModel.pageNo = 1;
}
var sizeList = iSize.GetSizeList(searchModel.searchString);
if (sizeList != null)
{
List <SizeListModel> sizeResult = new List <SizeListModel>();
sizeResult = SizeHelper.BindSizeListModel(sizeList);
var sizeIds = SizeHelper.GetSizeIds(sizeResult);
var productList = iSize.GetTotalProductSizeCount(sizeIds);
sizeResult = SizeHelper.BindSizeListModel(sizeResult, productList);
#region Sorting
var sizeResult1 = SortingHelper.GetSortedSizes(searchModel.column, searchModel.direction, sizeResult).ToPagedList(searchModel.pageNo, searchModel.limit).ToList();
#endregion
PagedListModel <SizeListModel> pagedListModel = new PagedListModel <SizeListModel>();
pagedListModel.Items = sizeResult1.ToList();
pagedListModel.Total = sizeResult.Select(x => x.SizeId).Distinct().Count();
return(Ok(ResponseHelper.Success(pagedListModel)));
}
else
{
return(Ok(ResponseHelper.Error(MessageConstants.DataNotFound)));
}
}
catch (Exception ex)
{
LogHelper.ExceptionLog(ex.Message + " ::::: " + ex.StackTrace);
return(Ok(ResponseHelper.Error(ex.Message)));
}
}
public void ShowChoiceButtons(DialogueFragment hubFragment)
{
HideChoiceButtons();
if (hubFragment.OutputPins[0].Connections.Count <= 0)
{
Debug.LogError("Hub has no choices!");
}
List <SortingHelper> sorts = new List <SortingHelper>();
for (int i = 0; i < hubFragment.OutputPins[0].Connections.Count; ++i)
{
DialogueFragment frag = hubFragment.OutputPins[0].Connections[i].Target as DialogueFragment;
IObjectWithPosition positionObject = hubFragment.OutputPins[0].Connections[i].Target as IObjectWithPosition;
SortingHelper sort = new SortingHelper();
sort.Fragment = frag;
sort.PositionY = positionObject.Position.y;
sorts.Add(sort);
}
sorts = sorts.OrderBy(f => f.PositionY).ToList();
for (int i = 0; i < sorts.Count; ++i)
{
if (sorts[i].Fragment.InputPins[0].Evaluate())
{
DialogueChoiceButton choiceButton = Instantiate(ButtonChoiceTemplate);
choiceButton.gameObject.SetActive(true);
choiceButton.gameObject.transform.SetParent(PanelChoice, false);
choiceButton.SetChoice(i, sorts[i].Fragment);
ButtonChoiceList.Add(choiceButton);
}
}
}
/// <summary>
/// Orders IOrderedQueryable ThenByDescending
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">Source IQueryable to order ThenByDescending</param>
/// <param name="property">Property for ordering</param>
/// <returns><see cref="IOrderedQueryable<typeparamref name="T"/>"/></returns>
public static IOrderedQueryable <T> ThenByDescending <T>(this IOrderedQueryable <T> source, string property)
{
return(SortingHelper.ApplyOrder <T>(source, property, "ThenByDescending"));
}
/// <summary>
/// Orders IOrderedQueryable Ascending
/// </summary>
/// <typeparam name="T">IOrderedQueryable</typeparam>
/// <param name="source">Source IQueryable to OrderByAscending</param>
/// <param name="property">Property for ordering</param>
/// <returns><see cref="IOrderedQueryable<typeparamref name="T"/>"/></returns>
public static IOrderedQueryable <T> OrderBy <T>(this IQueryable <T> source, string property)
{
return(SortingHelper.ApplyOrder <T>(source, property, "OrderBy"));
}
public IActionResult GetSortFields()
{
return(Ok(SortingHelper.GetSortField().Select(x => x.Key)));
}
public override void InitManager()
{
base.InitManager();
instance = this;
if (MirrorReference.HasReference)
{
MirrorTemplate = MirrorReference.GetObject <template_item>();
}
if (EraserReference.HasReference)
{
EraserTemplate = EraserReference.GetObject <template_item>();
}
if (ShopKeeperAltGreetReference.HasReference)
{
List <SortingHelper> sorts = new List <SortingHelper>();
Dialogue altGreetDialogue = ShopKeeperAltGreetReference.GetObject <Dialogue>();
for (int i = 0; i < altGreetDialogue.Children.Count; ++i)
{
DialogueFragment frag = altGreetDialogue.Children[i] as DialogueFragment;
if (frag != null)
{
IObjectWithPosition positionObject = frag as IObjectWithPosition;
SortingHelper sort = new SortingHelper();
sort.Fragment = frag;
sort.PositionY = positionObject.Position.y;
sorts.Add(sort);
}
}
sorts.OrderBy(f => f.PositionY);
for (int i = 0; i < sorts.Count; ++i)
{
AltGreetFragments.Add(sorts[i].Fragment);
}
}
for (int i = 0; i < 3; ++i)
{
ItemDictionary.Add(i, new List <template_item>());
}
if (StarterBodyReference.HasReference)
{
StarterBody = StarterBodyReference.GetObject <template_item>();
}
if (StarterHeadReference.HasReference)
{
StarterHead = StarterHeadReference.GetObject <template_item>();
}
if (ItemFolderReference.HasReference)
{
UserFolder itemFolder = ItemFolderReference.GetObject <UserFolder>();
if (itemFolder != null)
{
for (int i = 0; i < itemFolder.Children.Count; ++i)
{
UserFolder childFolder = itemFolder.Children[i] as UserFolder;
for (int j = 0; j < childFolder.Children.Count; ++j)
{
template_item item = childFolder.Children[j] as template_item;
UserFolder childSubfolder = childFolder.Children[j] as UserFolder;
if (childSubfolder != null)
{
for (int y = 0; y < childSubfolder.Children.Count; ++y)
{
template_item subfolderItem = childSubfolder.Children[y] as template_item;
if (subfolderItem != null)
{
ReadItemData(subfolderItem);
}
}
}
if (item != null)
{
ReadItemData(item);
}
}
}
}
Debug.Log("Found " + ItemDictionary[0].Count + " Slot 0 items");
Debug.Log("Found " + ItemDictionary[1].Count + " Slot 1 items");
Debug.Log("Found " + ItemDictionary[2].Count + " Slot 2 items");
Debug.Log("Found " + HeadList.Count + " heads");
Debug.Log("Found " + BodyList.Count + " bodies");
}
}
static void Main(string[] args)
{
User user1 = new User("Igor Dzambazov");
user1.SetAge(55);
User user2 = new User("Vaska Vasileva");
user2.SetAge(26);
User user3 = new User("Petko Petkovski");
user3.SetAge(35);
User user4 = new User("Mitre Mitrevski");
user4.SetAge(52);
User user5 = new User("Mia Minovska");
user5.SetAge(20);
User user6 = new User("Daniela Ristevska");
user6.SetAge(33);
User user7 = new User("Darko Trajkov");
user7.SetAge(78);
User user8 = new User("Luka Dimitriev");
user8.SetAge(18);
User user9 = new User("Darijan Andreevski");
user9.SetAge(62);
User user10 = new User("Vojdan Trpkovski");
user10.SetAge(29);
Ticket ticket1 = new Ticket()
{
Combination = new int[] { 11, 23, 5, 34, 3, 16, 7 },
User = user1
};
Session.AddToArrayTickets(ticket1);
Ticket ticket2 = new Ticket()
{
Combination = new int[] { 18, 6, 32, 4, 27, 9, 23 },
User = user2
};
Session.AddToArrayTickets(ticket2);
Ticket ticket3 = new Ticket()
{
Combination = new int[] { 5, 14, 16, 8, 25, 29, 24 },
User = user3
};
Session.AddToArrayTickets(ticket3);
Ticket ticket4 = new Ticket()
{
Combination = new int[] { 4, 28, 17, 19, 25, 6, 3 },
User = user4
};
Session.AddToArrayTickets(ticket4);
Ticket ticket5 = new Ticket()
{
Combination = new int[] { 1, 15, 24, 25, 26, 36, 31 },
User = user5
};
Session.AddToArrayTickets(ticket5);
Ticket ticket6 = new Ticket()
{
Combination = new int[] { 2, 8, 9, 15, 28, 34, 1 },
User = user6
};
Session.AddToArrayTickets(ticket6);
Ticket ticket7 = new Ticket()
{
Combination = new int[] { 5, 4, 19, 18, 6, 32, 2 },
User = user7
};
Session.AddToArrayTickets(ticket7);
Ticket ticket8 = new Ticket()
{
Combination = new int[] { 9, 12, 18, 25, 26, 35, 4 },
User = user8
};
Session.AddToArrayTickets(ticket8);
Ticket ticket9 = new Ticket()
{
Combination = new int[] { 15, 18, 21, 25, 28, 31, 34 },
User = user9
};
Session.AddToArrayTickets(ticket9);
Ticket ticket10 = new Ticket()
{
Combination = new int[] { 3, 19, 35, 2, 7, 14, 6 },
User = user10
};
Session.AddToArrayTickets(ticket10);
int answer = 0;
while (answer != 2)
{
Console.WriteLine("Do you want to add a new user(1) or start the session(2)? ");
var input = Console.ReadLine();
while (true)
{
if (input == "1" || input == "2")
{
break;
}
Console.WriteLine("You need to enter 1(new user) or 2(start session).");
input = Console.ReadLine();
}
int.TryParse(input, out answer);
switch (answer)
{
case 1:
AddUserHelper.AddNewTicket();
break;
case 2:
{
Session firstSession = new Session();
firstSession.StartSession();
firstSession.PrintWinningCombination();
Console.WriteLine("All users participating in the session are: ");
Session.Print();
SortingHelper.SortTickets(firstSession);
WinnersAnnouncement.AnnounceWinners(firstSession);
FirstSession.GetFirstSessionWinner(firstSession);
SecondSession.GetSecondSessionWinner(firstSession);
}
break;
}
}
Console.ReadLine();
}
protected override void Run()
{
var sortingHelper = new SortingHelper();
sortingHelper.QuickSort(values, 0, values.Length - 1);
}
void pnListColor_Paint(object sender, PaintEventArgs e)
{
if (currentDrawing == DRAWING.NONE)
{
}
else if (currentDrawing == DRAWING.LIST_VW_COLORS)
{
#region
pnListColor.AutoScroll = true;
pnListColor.CreateGraphics().SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
Graphics g = e.Graphics;
int x = 0, y = 0;
int widthEachColor = 30;
List <Color> colorVisualWord = ColorHelper.GenerateColorVisualWord_Rgb();
for (int i = 0; i < colorVisualWord.Count; i++)
{
DrawDot(g, new Dot_RGB(new Point(x + widthEachColor / 2, y + widthEachColor / 2), widthEachColor / 2, colorVisualWord[i]));
x += widthEachColor + 10;
// go to new row
if (x + widthEachColor + 10 > pnListColor.Width - widthEachColor / 2)
{
x = 0;
y += widthEachColor + 20;
}
}
#endregion
}
else if (currentDrawing == DRAWING.LIST_VW_COLORS_RGB_SORTED)
{
#region
// Input: rgb color
// Output: draw input color, draw visualize color in distance order des, distance below the color
Color inputColor = Color.FromArgb(int.Parse(txtR.Text.Trim()), int.Parse(txtG.Text.Trim()), int.Parse(txtB.Text.Trim()));
List <Color> listVWColorRgb = ColorHelper.GenerateColorVisualWord_Rgb();
List <double> listDistance = new List <double>();
foreach (Color colorVWRgb in listVWColorRgb)
{
listDistance.Add(DistanceHelper.CalDistance_RGBEuclid(Color.FromArgb((int)inputColor.R, (int)inputColor.G, (int)inputColor.B), colorVWRgb));
}
List <int> listIndexSortAsc = SortingHelper.SortAsc(listDistance);
DrawDot(pnVisualizse.CreateGraphics(), new Dot_RGB(new Point(50, 50), 20, Color.FromArgb(int.Parse(txtR.Text.Trim()), int.Parse(txtG.Text.Trim()), int.Parse(txtB.Text.Trim()))));
int x = 0, y = 0;
int widthEachColor = 30;
List <Color> colorVisualWord = ColorHelper.GenerateColorVisualWord_Rgb();
foreach (int index in listIndexSortAsc)
{
//Console.WriteLine(listDistance[index]);
Graphics g = e.Graphics;
//g.Clear(Color.Green);
DrawDot(g, new Dot_RGB(new Point(x + widthEachColor / 2, y + widthEachColor / 2), widthEachColor / 2, colorVisualWord[index]));
g.DrawString(Math.Round(listDistance[index], 1).ToString(), new Font("Arial", 8), new SolidBrush(Color.Black), x, y + widthEachColor);
x += widthEachColor + 10;
// go to new row
if (x + widthEachColor + 10 > pnListColor.Width - widthEachColor / 2)
{
x = 0;
y += widthEachColor + 20;
}
}
#endregion
}
else if (currentDrawing == DRAWING.LIST_VW_COLORS_LAB_SORTED)
{
#region
// Input: rgb color
// Output: draw input color, draw visualize color in distance order des, distance below the color
Lab inputColor = ColorHelper.RgbToLab(new Rgb {
R = double.Parse(txtR.Text.Trim()), G = double.Parse(txtG.Text.Trim()), B = double.Parse(txtB.Text.Trim())
});
List <Lab> listVWColorLab = ColorHelper.GenerateColorVisualWord_Lab();
List <double> listDistance = new List <double>();
if (currentDeltaE == DELTA_E.CIE76)
{
calDistanceHander = DistanceHelper.CalDistance_CIE76;
}
else if (currentDeltaE == DELTA_E.CMCIC)
{
calDistanceHander = DistanceHelper.CalDistance_CMCIC;
}
else if (currentDeltaE == DELTA_E.CIE94)
{
calDistanceHander = DistanceHelper.CalDistance_CIE94;
}
else if (currentDeltaE == DELTA_E.CIE2000)
{
calDistanceHander = DistanceHelper.CalDistance_CIE2000;
}
foreach (Lab colorVWLab in listVWColorLab)
{
listDistance.Add(calDistanceHander(inputColor, colorVWLab));
}
List <int> listIndexSortAsc = SortingHelper.SortAsc(listDistance);
DrawDot(pnVisualizse.CreateGraphics(), new Dot_RGB(new Point(50, 50), 20, Color.FromArgb(int.Parse(txtR.Text.Trim()), int.Parse(txtG.Text.Trim()), int.Parse(txtB.Text.Trim()))));
int x = 0, y = 0;
int widthEachColor = 30;
List <Color> colorVisualWord = ColorHelper.GenerateColorVisualWord_Rgb();
foreach (int index in listIndexSortAsc)
{
//Console.WriteLine(listDistance[index]);
Graphics g = e.Graphics;
//g.Clear(Color.Green);
DrawDot(g, new Dot_RGB(new Point(x + widthEachColor / 2, y + widthEachColor / 2), widthEachColor / 2, colorVisualWord[index]));
g.DrawString(Math.Round(listDistance[index], 1).ToString(), new Font("Arial", 8), new SolidBrush(Color.Black), x, y + widthEachColor);
x += widthEachColor + 10;
// go to new row
if (x + widthEachColor + 10 > pnListColor.Width - widthEachColor / 2)
{
x = 0;
y += widthEachColor + 20;
}
}
#endregion
}
}
static void Main(string[] args)
{
//Lze upravit výchozí hodnoty pro generování
int min = -500;
int max = 200;
int count = 1000;
string path;
string fileName;
string saveQ;
bool? saveToFile = null;
List <int> lst = null;
Console.WriteLine("Chcete generovat náhodná čísla do souboru? Ano/Ne");
while (!saveToFile.HasValue)
{
saveQ = Console.ReadLine().Trim();
if (saveQ.ToLower() == "ano")
{
//Přepsat soubor
saveToFile = true;
break;
}
else if (saveQ.ToLower() == "ne")
{
//Nepřepsat soubor
saveToFile = false;
break;
}
Console.WriteLine(@"Neplatný vstup. Zadejte Ano/Ne.");
}
if (saveToFile.Value)
{
Console.WriteLine("Zadejte vstupní parametry pro přípravu pole celočíselných čísel.");
Console.Write("Zadejte minimální hodnotu čísla: ");
while (!int.TryParse(Console.ReadLine(), out min))
{
Console.Write("Vstup není platný. Zadejte minimální hodnotu čísla: ");
}
Console.Write("Zadejte maximální hodnotu čísla: ");
while (!int.TryParse(Console.ReadLine(), out max))
{
Console.Write("Vstup není platný. Zadejte maximální hodnotu čísla: ");
}
Console.Write("Zadejte počet generovaných čísel: ");
while (!int.TryParse(Console.ReadLine(), out count))
{
Console.Write("Vstup není platný. Zadejte počet generovaných čísel: ");
}
Console.Write("Zadejte absolutní cestu pro uložení vygenerovaných čísel do souboru(bez názvu souboru): ");
path = Console.ReadLine();
while (!Directory.Exists(path))
{
Console.Write("Vstup není platný. Zadejte absolutní cestu pro uložení vygenerovaných čísel do souboru(bez názvu souboru): ");
path = Console.ReadLine();
}
Console.Write("Zadejte název souboru: ");
fileName = Console.ReadLine();
while (fileName.IndexOfAny(Path.GetInvalidFileNameChars()) != -1)
{
Console.Write("Vstup není platný. Zadejte název souboru: ");
fileName = Console.ReadLine();
}
if (path.Last() != '\\')
{
path += '\\';
}
if (RandomGeneratorHelper.GetRandomNumbers(min, max, count, path + fileName))
{
string data = File.ReadAllLines(path + fileName)[0];
List <string> dataList = data.Split(' ').ToList();
lst = dataList.Select(a => int.Parse(a)).ToList();
}
}
else
{
lst = RandomGeneratorHelper.GetRandomNumbers(min, max, count);
}
//Otestuje vložit všechny hodnoty do stacku + jednu navíc
/*Console.WriteLine("Stack");
* TestStack(count, lst);
*
* //Otestuje vložit všechny hodnoty do queue + jednu navíc
* Console.WriteLine("Queue");
* TestQueue(count, lst);*/
Console.WriteLine();
/*Console.WriteLine("Vygenerované pole");
* Console.WriteLine(String.Join(", ", lst.ToArray()));*/
/*Console.WriteLine("Select sort");
* Console.WriteLine(String.Join(", ", SortingHelper.SelectSort(lst.ToArray())));
* Console.WriteLine("Insert sort");
* Console.WriteLine(String.Join(", ", SortingHelper.InsertSort(lst.ToArray())));
* Console.WriteLine("Bubble sort");
* Console.WriteLine(String.Join(", ", SortingHelper.BubbleSort(lst.ToArray())));*/
//arr = FileReader.ReadToList(path).ToArray();
var arr = lst.ToArray();
SortingHelper.QuickSort(arr);
FileWriter.WriteListToFile(arr.ToList(), @"c:\skola\ADS\Quick.txt");
int val = 0;
Console.Write("Zadejte hledanou hodnotu čísla: ");
while (!int.TryParse(Console.ReadLine(), out val))
{
Console.Write("Vstup není platný. Zadejte hledanou hodnotu čísla: ");
}
var retLst = SearchHelper.BinarySearch(arr, val);
if (retLst.Count == 0)
{
Console.WriteLine("Hledaná hodnota {0} nebyla nalezena", val);
}
else
{
Console.WriteLine("Hledaná hodnota {0} se nachází na pozicích: ", val);
foreach (var pos in retLst)
{
Console.WriteLine(pos);
}
}
Console.ReadKey();
}
