public long GetHigherSalaryPlayer(long teamId) { ThrowExceptionIfTeamsNotExists(teamId); return(_players.OrderByDescending(player => player.Value.Salary) .FirstOrDefault() .Value.Id); }
/// <summary> /// </summary> /// <returns></returns> public override string ToString() { var result = new StringBuilder(base.ToString() + "\n"); foreach (var item in Stats.OrderByDescending(r => r.Value.Correlation())) { result.Append($"{item.Key}: {item.Value}\n"); } return(result.ToString()); }
public static string GetNearestLevel(IDictionary<string, Resolution> resolutions, double resolution) { if (resolutions.Count == 0) { throw new ArgumentException("No tile resolutions"); } var localResolutions = resolutions.OrderByDescending(r => r.Value.UnitsPerPixel); //smaller than smallest if (localResolutions.Last().Value.UnitsPerPixel > resolution) return localResolutions.Last().Key; //bigger than biggest if (localResolutions.First().Value.UnitsPerPixel < resolution) return localResolutions.First().Key; string result = null; double resultDistance = double.MaxValue; foreach (var current in localResolutions) { double distance = Math.Abs(current.Value.UnitsPerPixel - resolution); if (distance < resultDistance) { result = current.Key; resultDistance = distance; } } if (result == null) throw new Exception("Unexpected error when calculating nearest level"); return result; }
/// <summary> /// /// </summary> /// <param name="analyzer"></param> public FormQ39(MorphologicalAnalyzer analyzer) { InitializeComponent(); IDictionary <string, List <Word> > result = analyzer.GetGroupByWord(); ChartArea chartArea = new ChartArea("base") { AxisX = { Title = "単語頻出順位" }, AxisY = { Title = "頻出回数" } }; chartArea.AxisX.IsLogarithmic = true; chartArea.AxisY.IsLogarithmic = true; Series series = new Series { ChartType = SeriesChartType.Line, Name = "単語の頻出回数", ChartArea = chartArea.Name }; chart.Series.Clear(); chart.ChartAreas.Clear(); chart.ChartAreas.Add(chartArea); foreach (var item in result.OrderByDescending(pair => pair.Value.Count) .Select((value, index) => new { value, index })) { series.Points.AddXY(item.index + 1, item.value.Value.Count); } chart.Series.Add(series); }
/// <summary> /// Distribuição de notas simples pela manior nota /// Atendende casos como : /// Notas Disponíveis [R$ 100; 1], [R$ 50; 2], [R$ 20; 3], [R$ 10; 0] /// Saque R$ 150 /// Distribuição [R$ 100; 1], [R$ 50; 1] /// Não Atendem casos como : /// Notas Disponíveis [R$ 100; 1], [R$ 50; 2], [R$ 20; 3], [R$ 10; 0] /// Saque R$ 110 /// Distribuição [R$ 50; 1], [R$ 20; 3] /// /// Esse será resolvido pela distribuição recursiva /// /// </summary> /// <param name="valorSaqueTotal"></param> /// <param name="Notas"></param> /// <param name="NotasOriginais"></param> /// <returns></returns> private int DistribuirNotas(int valorSaqueTotal, SortedList <int, int> Notas, IDictionary <int, int> NotasOriginais) { int valorSaque = valorSaqueTotal; foreach (KeyValuePair <int, int> nota in NotasOriginais.OrderByDescending(c => c.Key)) { int notaCassete = nota.Key; int quantidadeNotasCassete = nota.Value; int valorTotalCassete = notaCassete * quantidadeNotasCassete; //Nota sendo menor que o valor do saque, e havendo notas no cassete if ((notaCassete <= valorSaque) && quantidadeNotasCassete > 0) { int valorSacar = valorSaque; //Se o saldo do cassete for menor que o valor para sacar -> pega o resto como valor a sacar do cassete; if (valorTotalCassete < valorSacar) { valorSacar = valorTotalCassete % valorSacar; } int quantidadeNotasSacadas = (valorSacar / notaCassete); if (quantidadeNotasSacadas > 0 && quantidadeNotasSacadas <= quantidadeNotasCassete) { valorSaque -= quantidadeNotasSacadas * notaCassete; Notas.Add(notaCassete, quantidadeNotasSacadas); } } } return(valorSaque); }
void Count(String message) { // Key is message, value is number of occurrences // If message is present in dictionary increment the number, otherwise insert with count of 1 // Internet says TryGetValue is faster than ContainsKey/Item and I have no reason to assume otherwise int value = 0; if (dictionary.TryGetValue(message, out value)) { //Debug.Log("Message already in dictionary!"); dictionary[message] = value + 1; } else { //Debug.Log("Message not in dictionary."); dictionary.Add(message, 0); } // Sort dictionary by value, then grab first ten elements var mySortedList = dictionary.OrderByDescending(d => d.Value).ToList(); var topList = mySortedList.Take(10); // Display top results countingText.text = String.Join("\n", topList.Select((x, n) => $"{n + 1}. {x.Key} : {x.Value + 1}")); // This is probably a bad way to display top ten results in real time // If you're smarter than me you could use something like K Heavy Hitters to display live view // Then hit a Finalize button or something, clear Heavy Hitters and run through/display Dictionary }
public IEnumerable <Tuple <int, string> > GetStatistics() { return(stats.OrderByDescending(kv => kv.Value) .ThenBy(kv => kv.Key) .ToDictionary(kv => kv.Key, kv => kv.Value) .Select(kv => Tuple.Create(kv.Value, kv.Key))); }
/// <summary> /// Returns a List of Products sorted by their popularity. /// The popularity is calculated by the number of times (quantity) a product was sold. /// Assumption: Product Names are unique. /// </summary> /// <param name="products"></param> /// <returns></returns> private async Task <IList <Product> > GetRecommendedProductListAsync(IList <Product> products) { IDictionary <string, long> productQuantity = await GetProductTotalQuntityAsync(); // sort the products by quantity (number of times they were sold) var sortedProductByQuantity = productQuantity.OrderByDescending(pq => pq.Value); IList <Product> sortedProductByQuantityList = new List <Product>(); foreach (KeyValuePair <string, long> kvp in sortedProductByQuantity) { sortedProductByQuantityList.Add(products.Where <Product>(p => p.Name == kvp.Key).FirstOrDefault()); } // Add any missing products foreach (Product prod in products) { if (!sortedProductByQuantityList.Any(p => p.Name == prod.Name)) { sortedProductByQuantityList.Add(prod); } } return(sortedProductByQuantityList); }
public IList <ItemInfo> Calculate(int sourceItemLength, IDictionary <int, int> targetItemCountsByLengths) { foreach (var pair in targetItemCountsByLengths) { var targetItemLength = pair.Key; if (targetItemLength > sourceItemLength) { throw new ArgumentException(); } } targetItemCountsByLengths = targetItemCountsByLengths.OrderByDescending(x => x.Key) .ToDictionary(x => x.Key, x => x.Value); List <ItemInfo> itemInfos = new List <ItemInfo>(); while (!IsEmpty(targetItemCountsByLengths)) { IList <int> minimumItemLengths = GetMinimumItemInfo(sourceItemLength, targetItemCountsByLengths); while (CanAddItemInfo(targetItemCountsByLengths, minimumItemLengths)) { itemInfos.Add(new ItemInfo(sourceItemLength, minimumItemLengths)); foreach (var targetItemLenght in minimumItemLengths) { targetItemCountsByLengths[targetItemLenght]--; } } } return(itemInfos); }
/// <summary> /// Prints word-counts to the given TextWriter /// TextWriter parameter means that code is more generic as it will write to any given destination. /// </summary> public static void WriteWordCounts(IDictionary <string, int> counts, TextWriter writer, int listCount) { writer.WriteLine($"The number of counts for top {listCount} words:"); foreach (KeyValuePair <string, int> kvp in counts.OrderByDescending(key => key.Value).Take(listCount)) { writer.WriteLine(kvp.Key.ToLower() + " " + kvp.Value); // print word in lower-case for consistency } }
private void PopulateListView(IDictionary<char, int> characterCollection) { foreach(var item in characterCollection.OrderByDescending(kp => kp.Value)) { ListViewItem lvi = new ListViewItem(item.Key.ToString()); lvi.SubItems.Add(item.Value.ToString()); CharacterUsageListView.Items.Add(lvi); } }
protected string[] SubstituteVariables(IDictionary<string, string> vars, string[] args) { foreach (var item in vars.OrderByDescending(x => x.Key.Length)) { for (int i = 0; i < args.Length; i++) { args[i] = args[i].Replace(item.Key, item.Value); } } return args; }
public ScoreScene( Game game, SpriteFont font, IDictionary<int, string> highScores, Texture2D background, params Tuple<int, IController>[] playerScores) : base(game) { var backgroundComponent = new ImageComponent(game, background, ImageComponent.DrawMode.Center); Components.Add(backgroundComponent); if (highScores.Count < 10 || playerScores.Any(ps => highScores.Keys.Any(k => k < ps.Item1))) { AcceptingInput = true; var highCount = playerScores.Count(ps => highScores.Keys.Any(k => k < ps.Item1)); var remove = _highScores.Keys.OrderBy(k => k).Take(highCount); foreach (var r in remove) { _highScores.Remove(r); } _playerEntries = playerScores.OrderByDescending(ps => ps.Item1) .Take(highCount) .Select(ps => Tuple.Create(ps.Item1, ps.Item2, string.Empty)) .ToList(); foreach (var pe in _playerEntries) { highScores.Add(pe.Item1, pe.Item3); } } var y = 100; foreach (var hs in highScores.OrderByDescending(x => x.Key)) { var component = new TextComponent(game, font, new Vector2(100, y), Color.White) { Visible = true, Enabled = true, Text = hs.Value + " " + hs.Key }; var playerScore = playerScores.LastOrDefault(ps => hs.Key == ps.Item1); var controller = playerScore != null ? playerScore.Item2 : null; Components.Add(component); _highScores.Add(hs.Key, Tuple.Create(string.Empty, component, controller)); y += 100; } }
public LevelOverrideMap( IDictionary<string, LoggingLevelSwitch> overrides, LogEventLevel defaultMinimumLevel, LoggingLevelSwitch defaultLevelSwitch) { if (overrides == null) throw new ArgumentNullException(nameof(overrides)); _defaultLevelSwitch = defaultLevelSwitch; _defaultMinimumLevel = defaultLevelSwitch != null ? LevelAlias.Minimum : defaultMinimumLevel; // Descending order means that if we have a match, we're sure about it being the most specific. _overrides = overrides .OrderByDescending(o => o.Key) .Select(o => new LevelOverride(o.Key, o.Value)) .ToArray(); }
static void GenerateReport(IDictionary<Uri, long> dump, IDictionary<string, long> errors) { var totalCount = dump.Sum(pair => pair.Value); var distinctCount = dump.Count; var errorCount = errors.Sum(pair => pair.Value); var top10 = dump.OrderByDescending(pair => pair.Value).Take(10).ToList(); var top10Errors = errors.OrderByDescending(pair => pair.Value).Take(10).ToList(); Console.Clear(); Console.WriteLine($"Total Count:\t\t{totalCount}"); Console.WriteLine($"Distinct Count:\t\t{distinctCount}"); Console.WriteLine($"Error Count:\t\t{errorCount}"); Console.WriteLine(); Console.WriteLine("Top 10:"); top10.ForEach(pair => Console.WriteLine($" ({pair.Value}) {pair.Key}"));Console.WriteLine(); Console.WriteLine("Top 10 Errors:"); top10Errors.ForEach(pair => Console.WriteLine($" ({pair.Value}) {pair.Key}")); }
public bool DoesReflectedSimplexPass(Func<IVertex, double> getObjectiveMeasure, Func<StandardKernel, int, IVertex> getAverageOfAllButWorstVertices, Func<StandardKernel, IVertex, IVertex, double, IVertex> getAlteredVertex, IDictionary<int, double> objectiveMeasures) { var numParams = CurrentSimplex.Vertices.Count - 1; ISimplex reflectedSimplex = CurrentSimplex.GetAsCopy(); var firstWorstValueAsKey = objectiveMeasures.OrderByDescending(e => e.Value).ToList()[0].Key; IVertex worstVertex = reflectedSimplex.Vertices[firstWorstValueAsKey]; var secondWorstValueAsKey = objectiveMeasures.OrderByDescending(e => e.Value).ToList()[1].Key; var bestValueAsKey = objectiveMeasures.OrderByDescending(e => e.Value).ToList()[numParams].Key; var kernel = NinJectBindings.GetBoundKernel(); IVertex avgVertex = getAverageOfAllButWorstVertices(kernel, firstWorstValueAsKey); var reflectedVertex = getAlteredVertex(kernel, avgVertex, worstVertex, AlphaReflection); var reflectedVertexObjMeasure = getObjectiveMeasure(reflectedVertex); if (reflectedVertexObjMeasure >= objectiveMeasures[secondWorstValueAsKey]) { return false; } if (reflectedVertexObjMeasure >= objectiveMeasures[bestValueAsKey] && reflectedVertexObjMeasure < objectiveMeasures[secondWorstValueAsKey]) { AssignVertexToCurrentSimplex(numParams, reflectedSimplex, firstWorstValueAsKey, reflectedVertex); objectiveMeasures[firstWorstValueAsKey] = reflectedVertexObjMeasure; return true; } var expandedVertex = getAlteredVertex(kernel, avgVertex, worstVertex, GammaReflectionExpansion); var expandedVertexObjMeasure = getObjectiveMeasure(expandedVertex); if (expandedVertexObjMeasure < reflectedVertexObjMeasure) { AssignVertexToCurrentSimplex(numParams, reflectedSimplex, firstWorstValueAsKey, expandedVertex); objectiveMeasures[firstWorstValueAsKey] = expandedVertexObjMeasure; return true; } AssignVertexToCurrentSimplex(numParams, reflectedSimplex, firstWorstValueAsKey, reflectedVertex); objectiveMeasures[firstWorstValueAsKey] = reflectedVertexObjMeasure; return true; }
public bool DoesContractedSimplexPass(Func<IVertex, double> getObjectiveMeasure, Func<StandardKernel, int, IVertex> getAverageOfAllButWorstVertices, Func<StandardKernel, IVertex, IVertex, double, IVertex> getAlteredVertex, IDictionary<int,double> objectiveMeasures ) { var numParams = CurrentSimplex.Vertices.Count - 1; ISimplex contractedSimplex = CurrentSimplex.GetAsCopy(); var firstWorstValueAsKey = objectiveMeasures.OrderByDescending(e => e.Value).ToList()[0].Key; IVertex worstVertex = contractedSimplex.Vertices[firstWorstValueAsKey]; var kernel = NinJectBindings.GetBoundKernel(); IVertex avgVertex = getAverageOfAllButWorstVertices(kernel, firstWorstValueAsKey); var contractedVertex = getAlteredVertex(kernel, avgVertex, worstVertex, RhoContraction); var contractedVertexObjMeasure = getObjectiveMeasure(contractedVertex); if (contractedVertexObjMeasure >= objectiveMeasures[firstWorstValueAsKey]) { return false; } AssignVertexToCurrentSimplex(numParams, contractedSimplex, firstWorstValueAsKey, contractedVertex); objectiveMeasures[firstWorstValueAsKey] = contractedVertexObjMeasure; return true; }
/// <summary> /// Initializes a new instance of <see cref="Balance"/> class /// </summary> /// <param name="money">dictionary with denomination as keys and amount as values</param> public Balance(IDictionary<decimal, int> money) { _money = money.OrderByDescending(pair => pair.Key) .ToDictionary(pair => pair.Key, pair => pair.Value); }
private void GetPagesRecursive(HtmlAgilityPack.HtmlNode document, IDictionary<int, string> pages) { var chapterPages = document.SelectNodes(@"//div[@class=""main-body""]//div[@class=""btn-group""][2]/ul[@class=""dropdown-menu""]/li/a"); if (chapterPages == null) { throw new ParserException("Could not find expected elements on website.", document.InnerHtml); } int addedCount = 0; foreach (var pageLink in chapterPages) { int pageNumber = 0; var url = GetFullUrl(pageLink.Attributes["href"].Value); if (pages.Any(kvp => kvp.Value == url)) // skip duplicate urls continue; if (!Int32.TryParse(Regex.Match(pageLink.InnerText, @"\d+").Value, out pageNumber)) _log.Error("Unable to parse page number '" + pageLink.InnerText + "'"); if (pages.ContainsKey(pageNumber)) // if page is already in dictionary use random number instead pageNumber = Random; pages.Add(pageNumber, url); addedCount++; } if (addedCount > 0) { var pageRecord = pages.OrderByDescending(kvp => kvp.Key).Skip(1).FirstOrDefault(); if (pageRecord.Equals(default(KeyValuePair<int, string>))) return; var nextDocument = WebHelper.GetHtmlDocument(pageRecord.Value); GetPagesRecursive(nextDocument, pages); } }
private static Option<int> GetMostRepresentativeNumberOfTouchPoints(IDictionary<int, int> touchRegistry) { if (touchRegistry.Any()) { var touchesOrderedByAppearance = touchRegistry.OrderByDescending(pair => pair.Value); return Option.Full(touchesOrderedByAppearance.First().Key); } return Option.Empty(); }