Example #1
0
        public long GetHigherSalaryPlayer(long teamId)
        {
            ThrowExceptionIfTeamsNotExists(teamId);

            return(_players.OrderByDescending(player => player.Value.Salary)
                   .FirstOrDefault()
                   .Value.Id);
        }
Example #2
0
        /// <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());
        }
Example #3
0
        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;
        }
Example #4
0
        /// <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);
        }
Example #6
0
    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
    }
Example #7
0
 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)));
 }
Example #8
0
        /// <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);
        }
Example #10
0
 /// <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;
            }
        }
Example #14
0
        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();
        }
Example #15
0
        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);
 }
Example #19
0
        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();
 }