Esempio n. 1
0
        public Dictionary<int, double> CalculateDesPoints(double alpha, double beta)
        {
            Dictionary<int, double> resultDataSet = new Dictionary<int, double>();

            double sPrev = _originalDataset[2];
            double bPrev = _originalDataset[2] - _originalDataset[1];
            resultDataSet[3] = CalculateForeCast(sPrev, bPrev);

            foreach (KeyValuePair<int, double> pair in _originalDataset.Where((x, i) => i > 1))
            {
                double sNew = CalculateS1(alpha, pair.Value, sPrev, bPrev);
                double bNew = CalculateB1(alpha, beta, sNew, sPrev, bPrev);

                resultDataSet.Add(pair.Key + 1, CalculateForeCast(sNew, bNew));

                sPrev = sNew;
                bPrev = bNew;
            }

            int iterator = 2;

            for (int i = resultDataSet.Max(m=>m.Key) + 1; i < _lines; i++)
            {
                resultDataSet.Add(i, sPrev + (iterator * bPrev));
                iterator++;
            }

            return resultDataSet;
        }
Esempio n. 2
0
    private string Calc(List<string> lst)
    {
        var str = "";
        foreach (var item in lst)
        {
            var dict2 = new Dictionary<int, float>();
            for (int i = 0; i < CodeArray.Length; i++)
            {
                var match = new MatchsMaker(item, CodeArray[i]);
                dict2.Add(i, match.Score);
            }

            var idx = dict2.First(p => p.Value == dict2.Max(x => x.Value)).Key;
            switch (idx)
            {
                case 10:
                    idx = 1;
                    break;
                case 11:
                case 12:
                    idx = 0;
                    break;
                default:
                    break;
            }

            str += idx;
        }
        return str;
    }
        public void VisaData(IList<AktivPeriod> perioder)
        {
            panel1.Controls.Clear();

            var lista = new Dictionary<DateTime, double>();

            foreach (var dag in perioder.Select(o => o.Starttid.Date).Distinct())
            {
                var summeradDag = dag;
                lista.Add(dag,
                          perioder.Where(o => o.Starttid.Date.Equals(summeradDag)).Sum(o => o.Tidsmängd.TotalMinutes));
            }

            if (!lista.Any()) return;

            var max = lista.Max(o => o.Value);
            var xposition = 10;
            foreach (var d in lista)
            {
                var stapel = new Dagstapel
                                 {
                                     Height = panel1.Height - 20,
                                     Top = 10,
                                     Left = xposition
                                 };

                stapel.VisaUppgifter(d.Key, d.Value, max);
                xposition += stapel.Width;
                panel1.Controls.Add(stapel);
            }
        }
Esempio n. 4
0
        public Response Speak()
        {
            Dictionary<Rule, int> acceptDict = new Dictionary<Rule, int>();

            foreach (Rule rule in _ruleDb)
            {
                if (!rule.CanMatch())
                    continue;

                bool match = true;
                foreach (Criterion criterion in rule.Criteria)
                {
                    if (!_factDict.ContainsKey(criterion.Lhs) || !criterion.Compare(_factDict[criterion.Lhs] as IComparable))
                    {
                        match = false;
                        break;
                    }
                }
                if (match)
                    acceptDict.Add(rule, rule.Criteria.Count);
            }
            if (acceptDict.Count == 0)
                return new Response("NullResponse", "NO RESPONSE");

            // Of all the matched rules, find the one(s) that match the most criteria
            int maxScore = acceptDict.Max(kvp => kvp.Value);
            List<Rule> acceptList = acceptDict.Where(kvp => kvp.Value == maxScore).Select(kvp => kvp.Key).ToList();

            // Of all the matched rules of maximum criteria, return a random one
            Rule matchedRule = acceptList.RandomItem();
            matchedRule.Match();
            Response response = matchedRule.Response;
            response.Match();
            return response;
        }
 public static void Main()
 {
     Dictionary<int, int> perimeters = new Dictionary<int, int>();
     for (int i = 12; i < 1001; i += 4)
     {
         for (int j = 3; j < 334; j++)
         {
             for (int k = j; k < (i - j) / 2; k++)
             {
                 if ((i - j - k) * (i - j - k) == j * j + k * k)
                 {
                     if (perimeters.ContainsKey(i))
                     {
                         perimeters[i]++;
                     }
                     else
                     {
                         perimeters.Add(i, 1);
                     }
                 }
             }
         }
     }
     var n = perimeters.Max(p => p.Value);
     var answer = perimeters.First(q => q.Value == n).Key;
     Console.WriteLine(answer);
 }
Esempio n. 6
0
    private static void Main(string[] args)
    {
        string[] strings = new string[int.Parse(Console.ReadLine())];
        for (int i = 0; i < strings.Length; i++)
        {
            strings[i] = Console.ReadLine();
        }

        Dictionary<string, int> Areas = new Dictionary<string, int>();

        foreach (var item in strings)
        {
            if (Areas.ContainsKey(item))
            {
                Areas[item]++;
            }
            else
            {
                Areas.Add(item, 1);
            }
        }

        for (int i = 0; i < Areas.Max(x => x.Value); i++)
        {
            Console.WriteLine(Areas.Aggregate((x, y) => y.Value > x.Value ? y : x).Key);
        }
    }
Esempio n. 7
0
        public TimeIntervalsDlg(Dictionary<string, DateTime> intervals)
            : this()
        {
            var nowTime = DateTime.Now;
            var maxValue = Math.Max(MaxValue, intervals.Max(i => (int) Math.Round((nowTime - i.Value).TotalDays)));

            foreach (var inter in intervals)
            {
                var ctrl = new TimeIntervalControl(inter.Key, MinValue, maxValue,
                                                   (int) Math.Round((nowTime - inter.Value).TotalDays))
                               {
                                   Height = LineHeight,
                                   Dock = DockStyle.Top
                               };
                timeControls.Add(inter.Key, ctrl);
                panelContent.Controls.Add(ctrl);
            }

            if (intervals.Count > 1)
            {
                var defaultTotal = timeControls.Values.Mode(i => i.Value);
                // контрол, масштабирующий все остальные контролы
                scaleControl = new TimeIntervalControl(Localizer.GetString("TitleAll"), MinValue, maxValue, defaultTotal)
                    {
                        Height = LineHeight,
                        Dock = DockStyle.Top,
                        fontTitle = new Font(Font, FontStyle.Bold)
                    };
                scaleControl.ValueChangedByDragging += ScaleControlOnValueChangedByDragging;
                panelContent.Controls.Add(scaleControl);
            }
        }
        public static void Main()
        {
            List<int> numbers = new List<int>() { 3, 4, 4, 2, 3, 3, 3, 3, 3, 2, 5, 3, 5, 6, 3, 5, 3 };
            Dictionary<int, int> occures = new Dictionary<int, int>();
            foreach (var item in numbers)
            {
                if (occures.ContainsKey(item))
                {
                    occures[item]++;
                }
                else
                {
                    occures.Add(item, 1);
                }
            }

            int maxOccures = occures.Max(x => x.Value);
            int countAllElements = numbers.Count;
            if (maxOccures >= countAllElements / 2 + 1)
            {
                Console.WriteLine("majorant is: {0}", maxOccures);
            }
            else
            {
                Console.WriteLine("majorant not exist");
            }
        }
        public static string GetBestDays(int suggestionId)
        {
            List<JoinedUser> users = GetJoinedUsers(suggestionId);

            Dictionary<String, int> votesPerDay = new Dictionary<string, int>();

            foreach (var user in users)
            {
                String[] days = user.Weekdays.Split(',');
                foreach (var day in days)
                {
                    int count;
                    if (votesPerDay.TryGetValue(day, out count))
                        votesPerDay[day] = count + 1;
                    else
                        votesPerDay.Add(day, 1);
                }
            }

            int highest = votesPerDay.Max(kvp => kvp.Value);
            var values = "";

            foreach (var kvp in votesPerDay)
            {
                if (kvp.Value == highest)
                    values += kvp.Key + ", ";
            }

            if (values.Length >= 2)
                values = values.Remove(values.Length - 2, 2);

            return values;
        }
        public static IEnumerable <long> GetPrimeNumbersBelow(long n)
        {
            var highestCalculatedNumber = numbers.Any() ? (long)numbers?.Max(kv => kv.Key) : 0;

            if (n >= 2)
            {
                numbers[2] = true;

                for (long i = 3; i < n; i += 2)
                {
                    if (!numbers.ContainsKey(i))
                    {
                        numbers[i] = true;
                        var multiple = i + i;
                        while (multiple <= n)
                        {
                            numbers[multiple] = false;
                            multiple         += i;
                        }
                    }
                    else if (numbers[i])
                    {
                        var multiple = ((highestCalculatedNumber / i) * i) + i;
                        while (multiple <= n)
                        {
                            numbers[multiple] = false;
                            multiple         += i;
                        }
                    }
                }
            }

            return(numbers.Where(kv => kv.Value).Select(kv => kv.Key));
        }
Esempio n. 11
0
        protected virtual int[] GetMaxValue(Dictionary<int, Card> cards)
        {
            var max = cards.Max(x => x.Value.DenoteValue);

            var indexWithMax = cards.Where(c => c.Value.DenoteValue == max)
                .Select(c => c.Key).ToArray();

            return indexWithMax;
        }
        public int Down(string tableName, string primaryColumn, Int64 primaryValue, string orderColumn, Int64 orderNumber)
        {
            var data = new Dictionary<string, Int64>();
            using (DataCommand cmd = DataCommandManager.GetDataCommand("CommonDown"))
            {
                cmd.CommandText = string.Format(cmd.CommandText, tableName, primaryColumn, primaryValue, orderColumn,orderNumber);
                using (IDataReader dr = cmd.ExecuteDataReader())
                {
                    while (dr.Read())
                    {
                        if (!Convert.IsDBNull(dr[primaryColumn]) && !Convert.IsDBNull(dr[orderColumn]))
                        {
                            data.Add(dr[primaryColumn].ToString(), Convert.ToInt64(dr[orderColumn]));
                        }
                    }
                }

                if (data.Count == 1)
                {
                    return 2;
                }
                else
                {
                    string sql = "update {0} set {1}={2} where {3}={4}";

                    StringBuilder sb = new StringBuilder();
                    foreach (KeyValuePair<string, long> keyValuePair in data)
                    {
                        if (keyValuePair.Key == primaryValue.ToString())
                        {
                            sb.Append(
                                string.Format(
                                    sql,
                                    tableName,
                                    orderColumn,
                                    data.Min(s => s.Value),
                                    primaryColumn,
                                    primaryValue) + ";");

                        }
                        else
                        {
                            sb.Append(
                                string.Format(
                                    sql,
                                    tableName,
                                    orderColumn,
                                    data.Max(s => s.Value),
                                    primaryColumn,
                                    keyValuePair.Key) + ";");
                        }
                    }
                    cmd.CommandText = sb.ToString();
                    return cmd.ExecuteNonQuery();
                }
            }
        }
Esempio n. 13
0
        static void Main(string[] args)
        {
            string[] input = File.ReadAllLines("input.txt");

            foreach (string line in input)
            {
                Reindeers.Add(ParseReindeer(line));
            }

            Dictionary<Reindeer, int> raceDistancesStar1 = new Dictionary<Reindeer, int>();
            raceDistancesStar1 = CalculateRace(2503);

            foreach (KeyValuePair<Reindeer, int> raceDistance in raceDistancesStar1.OrderByDescending(d => d.Value))
            {
                Console.WriteLine($"Reindeer: {raceDistance.Key.Name}, Distance: {raceDistance.Value}");
            }

            Console.WriteLine($"Day 14 - Star 1, Answer: {raceDistancesStar1.OrderByDescending(rd => rd.Value).First().Key.Name} - {raceDistancesStar1.OrderByDescending(rd => rd.Value).First().Value} km");

            Dictionary<Reindeer, int> extraPoints = new Dictionary<Reindeer, int>();

            Dictionary<Reindeer, int> raceDistancesStar2 = new Dictionary<Reindeer, int>();

            for (int i = 1; i <= 2503; i++)
            {
                raceDistancesStar2 = CalculateRace(i);

                // Give current leading reindeer(s) bonus point
                IEnumerable<KeyValuePair<Reindeer, int>> leadingReindeers = raceDistancesStar2.Where(rd => rd.Value == raceDistancesStar2.Max(d => d.Value));

                foreach (KeyValuePair<Reindeer, int> leadingReindeer in leadingReindeers)
                {
                    if (!extraPoints.ContainsKey(leadingReindeer.Key))
                    {
                        extraPoints.Add(leadingReindeer.Key, 0);
                    }

                    extraPoints[leadingReindeer.Key]++;
                }
            }

            foreach (KeyValuePair<Reindeer, int> raceDistance in raceDistancesStar2.OrderByDescending(d => d.Value))
            {
                int points = 0;
                extraPoints.TryGetValue(raceDistance.Key, out points);

                Console.WriteLine($"Reindeer: {raceDistance.Key.Name}, Distance: {raceDistance.Value}, Points: {points}");
            }

            Console.WriteLine($"Day 14 - Star 2, Answer: {extraPoints.OrderByDescending(rd => rd.Value).First().Key.Name} - {extraPoints.OrderByDescending(rd => rd.Value).First().Value} points");

            Console.ReadKey();
        }
Esempio n. 14
0
        public static void SetChart(Dictionary<string, int> rawValues, Chart chart)
        {
            int fmin = 0;
            int fmax = 1;

            if (rawValues.Count > 0)
            {
                fmax = rawValues.Max(x => x.Value);
                fmin = rawValues.Min(x => x.Value);
            }

            //series init
            chart.Series.Clear();
            //   chart.Tag = values;
            var s = new Series();
            s.ChartType = SeriesChartType.Bar;

            foreach (var kvp in rawValues)
            {
                s.Points.AddXY(kvp.Key, kvp.Value);
                var dpc = s.Points[s.Points.Count - 1];
                dpc.Color = ColorExtras.GetRedGreenBlendedColour(kvp.Value, 0, fmax);
                dpc.ToolTip = kvp.Key + ":" + kvp.Value;
            }

            s.YAxisType = AxisType.Primary;
            s.XAxisType = AxisType.Secondary;
            s.IsVisibleInLegend = false;
            chart.Series.Add(s);
            //chartarea init
            chart.ChartAreas.Clear();
            var ca = new ChartArea();

              //  ca.CursorX.IsUserEnabled = true;
               // ca.CursorX.IsUserSelectionEnabled = true;

            ca.AxisX2.ScrollBar.IsPositionedInside = false;
            ca.AxisX2.ScaleView.Size = zoomMax;
            ca.AxisX2.ScaleView.Position=rawValues.Count-ca.AxisX2.ScaleView.Size;

            ca.AxisX2.Interval = 1;
            ca.AxisY.Interval = MathExtras.Ceiling((Math.Abs(fmax) - Math.Abs(fmin)) / 8);
            if (ca.AxisY.Interval<1)
                ca.AxisY.Interval = 1;

            ca.AxisY.Minimum = fmin;
            ca.AxisY.Maximum = fmax;
            if (Math.Abs(ca.AxisY.Minimum - ca.AxisY.Maximum) < 1)
                ca.AxisY.Minimum--;

            s.Sort(PointSortOrder.Ascending);
            chart.ChartAreas.Add(ca);
        }
Esempio n. 15
0
        public long Solve()
        {
            var primes = new Prime(Limit);

            var numberDivisors = new Dictionary<int, int>();
            for (var number = 1; number <= Limit; number++)
            {
                var decomposition = primes.GetDecomposition(number);

                var sum = 1;
                foreach (var divisor in decomposition)
                {
                    sum *= this.GetSumDivisors(divisor);
                }
                sum -= number;

                if (sum < Limit && sum != 1)
                {
                    numberDivisors.Add(number, sum);
                }
            }

            var lines = new Dictionary<long, long>();
            foreach (var numberDivisor in numberDivisors)
            {
                var minValueStart = numberDivisor.Key;
                var nextValue = numberDivisor.Value;
                var group = new HashSet<int> { minValueStart };
                var currentCount = 1;

                while (minValueStart != nextValue && nextValue > minValueStart && currentCount == group.Count)
                {
                    if (numberDivisors.ContainsKey(nextValue))
                    {
                        group.Add(nextValue);
                        nextValue = numberDivisors[nextValue];
                        currentCount++;
                    }
                    else
                    {
                        nextValue = 0;
                    }
                }

                if (nextValue == minValueStart && group.Count > 1)
                {
                    lines.Add(minValueStart, group.Count);
                }
            }

            return lines.Where(t => t.Value == lines.Max(r => r.Value)).Min(t => t.Key);
        }
Esempio n. 16
0
        void EnsureCanMigrate(long toVersion, Dictionary<long, Type> migrationTypes, Assembly assemblyContainingMigrations)
        {
            if (migrationTypes.Count == 0)
            {
                throw new ArgumentException("No migrations defined in assembly " + assemblyContainingMigrations.FullName + ".");
            }

            if (toVersion > 0 && !migrationTypes.ContainsKey(toVersion))
            {
                var availableMaxVersion = migrationTypes.Max(t => t.Key);
                throw new ArgumentException("Migration not defined for version " + toVersion + ". Omit the ToVersion parameter to migrate to the maximum version. The maximum migration version available is " + availableMaxVersion + ".");
            }
        }
        static void PrintBestSequence(Dictionary<string, int> occurrences)
        {
            int bestCount = occurrences.Max(key => key.Value);
            // Match the best count with the first value it finds
            var bestEntry
                = occurrences.First(key => key.Value == bestCount).Key;

            Console.WriteLine(bestCount);
            for (int i = 0; i < bestCount; i++)
            {
                Console.WriteLine(bestEntry);
            }
        }
        public void FindPermutationsOfCubes()
        {
            const long lowerLimit = 99999999999;
            const long upperLimit = 1000000000000;

            var dict = new Dictionary<string, List<long>>();

            long n = 0;
            long cube = CubeHelper.GetCube(n);
            while (cube < upperLimit)
            {
                if (cube > lowerLimit)
                {
                    var digits = DigitHelper.GetDigits(cube);
                    var key = string.Concat(digits.OrderBy(d => d));
                    if (!dict.ContainsKey(key))
                        dict.Add(key, new List<long>());

                    dict[key].Add(cube);
                }

                n++;
                cube = CubeHelper.GetCube(n);
            }

            if (dict.Values.Any(c => c.Count == 5))
            {
                foreach (var dictEntry in dict.Where(kvp => kvp.Value.Count == 5))
                {
                    Console.WriteLine("Key: {0}", dictEntry.Key);
                    Console.WriteLine(string.Join(",", dictEntry.Value));
                }
            }
            else
            {
                Console.WriteLine("No five cube set");
                Console.WriteLine("Max entries: {0}", dict.Max(de => de.Value.Count));
            }

            if (dict.ContainsKey("01234566"))
            {
                Console.WriteLine(string.Join(",", dict["01234566"]));
            }

            // 41063625
            // 01234566
        }
Esempio n. 19
0
        static int BruteForce(int num, int maxPrime)
        {
            var map = new Dictionary<int, int>();
            var primes = GetPrimesBelow(maxPrime).ToArray();
            var count = primes.Length;
            for (int i = num; i > 100; i = i - 2)
            {
                if(MathUtils.IsPrime(i))
                {
                    if(!map.ContainsKey(i))
                    {
                        map.Add(i, 0);
                    }

                    int max = 0;
                    int j = 0;

                    while (max + j < count)
                    {
                        var temp = primes[j];
                        for (int k = j + 1; k < count; k++)
                        {
                            temp += primes[k];
                            if(temp == i)
                            {
                                var max1 = k - j + 1;
                                max = max > max1 ? max : max1;
                                break;
                            }
                            else if(temp > i)
                            {
                                break;
                            }
                        }

                        j ++;
                    }

                    map[i] = max;

                }
            }

            var times = map.Max(x => x.Value);
            return map.First(x => x.Value == times).Key;
        }
Esempio n. 20
0
        static void Main(string[] args)
        {
            var items = File.ReadAllLines("input.txt")
                        .Select(l => l.Trim())
                        .Where(l => !string.IsNullOrWhiteSpace(l))
                        .Select(l => ParseLogEntry(l))
                        .OrderBy(l => l.Time)
                        .ToList();

            AssignGuardIds(items);
            Dictionary <int, List <GuardSleep> > sleepEntries = new Dictionary <int, List <GuardSleep> >();

            LoadSleepEntries(items, sleepEntries);
            var bestMinute = Enumerable.Range(0, 60)
                             .OrderByDescending(i => sleepEntries.Max(e => e.Value.Count(s => s.Contains(i)))).First();
            var bestGuard = sleepEntries.OrderByDescending(e => e.Value.Count(s => s.Contains(bestMinute))).First().Key;

            Console.WriteLine(bestMinute * bestGuard);
        }
Esempio n. 21
0
        public string Encode(string input)
        {
            _frequencies      = new Dictionary <char, decimal>();
            _compressionRatio = -1;
            input            += 'ソ';

            foreach (char ch in input)
            {
                if (_frequencies.ContainsKey(ch))
                {
                    continue;
                }
                decimal frequency = (decimal)input.Count(x => x == ch) / input.Length;
                if (_frequencies.Count > 0)
                {
                    frequency += _frequencies.Max(x => x.Value);
                }
                _frequencies.Add(ch, frequency);
            }

            decimal low  = 0.0m;
            decimal high = 1.0m;

            for (int i = 0; i < input.Length; i++)
            {
                decimal range = high - low;
                high = low + range * _frequencies[input[i]];
                if (_frequencies[input[i]] != _frequencies.Min(x => x.Value))
                {
                    low = low + range * _frequencies
                          .Where(x => x.Value < _frequencies[input[i]])
                          .Max(x => x.Value);
                }
            }

            string encodedString = low.ToString(CultureInfo.CurrentCulture);

            encodedString = encodedString.Substring(2, encodedString.Length - 2);

            _compressionRatio = (double)(encodedString.Length * 4) / (input.Length * 8);

            return(encodedString);
        }
Esempio n. 22
0
    public static double CalcDiscount(ShoppingCart sCart, double totPrice)
    {
      //Calc Harry Potter series discount
      Dictionary<IList<int>, double> combinations = new Dictionary<IList<int>, double>();

      //Search for all combination between 2-5 (the one's you got discount for)
      for (int i = 5; i >= 2; i--)
      {
        double discount = 0;
        var uniqueTitles = sCart.Items.Select(x => x.Title).Distinct();
        HashSet<Guid> handled = new HashSet<Guid>(); //To know calculated
        IList<int> uniqueSets = new List<int>();

        while (sCart.Items.Any(x => !handled.Contains(x.Id)))
        {
          HashSet<string> tmpTitles = new HashSet<string>();
          var uniques = sCart.Items.Where(x => !handled.Contains(x.Id));
          foreach (var sItem in uniques)
          {
            if (tmpTitles.Count <= i && !tmpTitles.Contains(sItem.Title))
            {
              tmpTitles.Add(sItem.Title);
              handled.Add(sItem.Id);
            }
          }

          uniqueSets.Add(tmpTitles.Count);
        }

        //Calculate discount for each set
        foreach (int uni in uniqueSets)
        {
          double price = sCart.Items.First().Price;
          discount += CalcSetDiscount(uni, price);
        }

        //Save the total discount for this combination
        combinations.Add(uniqueSets, discount);
      }     

      //Pick the comination with highest possible discount
      return combinations.Max(x => x.Value);
    }
Esempio n. 23
0
        static int migratoryBirds(int n, int[] ar)
        {
            // Complete this function
            Dictionary <int, int> types = new Dictionary <int, int>();

            types.Add(1, 0);
            types.Add(2, 0);
            types.Add(3, 0);
            types.Add(4, 0);
            types.Add(5, 0);
            for (var i = 0; i < n; i++)
            {
                var value = types[ar[i]] + 1;
                types[ar[i]] = value;
            }
            var max = types.Max(x => x.Value);

            return(types.Where(x => x.Value == max).First().Key);
        }
Esempio n. 24
0
        private static double HistogramDistance(Dictionary <int, double> runsHistogram, Dictionary <int, double> totalHistogram)
        {
            var minLabelX = Math.Min(runsHistogram.Min(x => x.Key), totalHistogram.Min(x => x.Key));
            var maxLabelX = Math.Max(runsHistogram.Max(x => x.Key), totalHistogram.Max(x => x.Key));

            double distSquared = 0;

            for (int i = minLabelX; i < maxLabelX + 1; i++)
            {
                runsHistogram.TryGetValue(i, out var runVal);
                totalHistogram.TryGetValue(i, out var totalVal);

                distSquared += (runVal - totalVal) * (runVal - totalVal);
            }

            var distance = Math.Sqrt(distSquared);

            return(distance);
        }
        private int GetAssemblyGroup(string assemblyName)
        {
            if (!_assemblyGroups.Any())
            {
                _assemblyGroups.Add(assemblyName, 1);
                return(1);
            }

            if (_assemblyGroups.ContainsKey(assemblyName))
            {
                return(_assemblyGroups[assemblyName]);
            }

            var max = _assemblyGroups.Max(_ => _.Value);

            _assemblyGroups.Add(assemblyName, max + 1);

            return(max);
        }
Esempio n. 26
0
        static void Winner()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            Dictionary <string, long> dict = new Dictionary <string, long>();

            long[]   score = new long[n];
            string[] name  = new string[n];
            for (int i = 0; i < n; i++)
            {
                var temp = Console.ReadLine().Split(' ');
                name[i]  = temp[0];
                score[i] = Convert.ToInt64(temp[1]);

                if (dict.Keys.Contains(name[i]))
                {
                    dict[name[i]] += score[i];
                }
                else
                {
                    dict.Add(name[i], score[i]);
                }
            }

            var max     = dict.Max(a => a.Value);
            var current = new Dictionary <string, long>();

            for (int i = 0; i < n; i++)
            {
                if (current.Keys.Contains(name[i]))
                {
                    current[name[i]] += score[i];
                }
                else
                {
                    current.Add(name[i], score[i]);
                }
                if (current[name[i]] >= max && dict[name[i]] == max)
                {
                    Console.WriteLine(name[i]);
                    break;
                }
            }
        }
Esempio n. 27
0
        static void WriteHelp(object options)
        {
            var flags = new Dictionary <string, string>();

            foreach (var field in options.GetType().GetFields())
            {
                foreach (OptionAttribute option in field.GetCustomAttributes(typeof(OptionAttribute), true))
                {
                    flags.Add("-" + option.ShortName + " --" + option.LongName,
                              (option.Required ? "" : "(optional) ") + option.HelpText);
                }
            }
            var pad = flags.Max(x => x.Key.Length);

            foreach (var flag in flags)
            {
                Console.Out.WriteLine("{0,-" + pad + "} {1}", flag.Key, flag.Value);
            }
        }
        public void AddTableRow(Dictionary <string, string> data, Dictionary <string, string> newRow)
        {
            // clear data if ALL lines are empty
            if (data.All(x => string.IsNullOrWhiteSpace(x.Value)))
            {
                data.Clear();
            }

            var maxRow = data.Count == 0
                ? 0
                : data.Max(x => int.Parse(x.Key.Split(new[] { "__" }, StringSplitOptions.RemoveEmptyEntries)[1]));

            maxRow++;

            foreach (var cell in newRow)
            {
                data.Add(cell.Key + "__" + maxRow, cell.Value);
            }
        }
Esempio n. 29
0
        public string BuildReply(IList <string> intents)
        {
            if (intents.Count <= 0)
            {
                return(Response.Default);
            }
            intents = intents.Distinct().ToList();
            var fromDb     = /*_responseRepository.GetAll(); */ Responses.LoadResponses();
            var equityList = new Dictionary <Response, double>();

            foreach (var response in fromDb)
            {
                var equalElements = intents.Distinct().Intersect(response.Intents.Select(x => x.Content)).Count();
                var equivalence   = (double)equalElements / Math.Max(response.Intents.Count, intents.Count);
                equityList.Add(response, equivalence);
            }

            return(equityList.Max(x => x.Value) > .7 ? equityList.MaxBy(x => x.Value).Key?.Content : Response.Default);
        }
Esempio n. 30
0
        public string Classify(double[] obj)
        {
            Dictionary<string, double> score = new Dictionary<string, double>();

            var results = (from myRow in dataSet.Tables[0].AsEnumerable()
                           group myRow by myRow.Field<string>(dataSet.Tables[0].Columns[0].ColumnName) into g
                           select new { Name = g.Key, Count = g.Count() }).ToList();

            for (int i = 0; i < results.Count; i++)
            {
                List<double> subScoreList = new List<double>();
                int a = 1, b = 1;
                for (int k = 1; k < dataSet.Tables["Gaussian"].Columns.Count; k = k + 2)
                {
                    double mean = Convert.ToDouble(dataSet.Tables["Gaussian"].Rows[i][a]);
                    double variance = Convert.ToDouble(dataSet.Tables["Gaussian"].Rows[i][++a]);
                    double result = Helper.NormalDist(obj[b - 1], mean, Helper.SquareRoot(variance));
                    subScoreList.Add(result);
                    a++; b++;
                }

                double finalScore = 0;
                for (int z = 0; z < subScoreList.Count; z++)
                {
                    if (finalScore == 0)
                    {
                        finalScore = subScoreList[z];
                        continue;
                    }

                    finalScore = finalScore * subScoreList[z];
                }

                score.Add(results[i].Name, finalScore * 0.5);
            }

            double maxOne = score.Max(c => c.Value);
            var name = (from c in score
                        where c.Value == maxOne
                        select c.Key).First();

            return name;
        }
        public string GetBestMatchingTitle( string searchInput, IEnumerable<string> titles )
        {
            var titleToSimilarityMap = new Dictionary<string, float>();
            foreach ( var title in titles )
            {
                titleToSimilarityMap.Add( title, this._titleSimilarity.Similarity( searchInput, title ) );
            }

            var maxSimilarity = titleToSimilarityMap.Max( kvp => kvp.Value );
            if ( maxSimilarity > THRESHOLD )
            {
                var firstEntryWithMaxSimilairty = titleToSimilarityMap.First( kvp => kvp.Value == maxSimilarity );
                return firstEntryWithMaxSimilairty.Key;
            }
            else
            {
                throw new Exception();  // TODO: Should I throw this TYPE of exception?
            }
        }
Esempio n. 32
0
        public StatisticsViewModel(ApplicationDbContext _context)
        {
            DoneTasks      = new Dictionary <int, int>();
            DoneTasksNames = new Dictionary <int, string>();
            listDoneTasks  = new List <int>();
            listDoneDay    = new List <int>();

            for (int i = 0; i < DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month); i++)
            {
                DateTime date = new DateTime(DateTime.Now.Year, DateTime.Now.Month, i + 1);
                listDoneTasks.Add(Done.GetDoneByDate(date, _context).Count);
                listDoneDay.Add(i + 1);
                DoneTasks.Add(i + 1, Done.GetDoneByDate(date, _context).Count);
            }

            BestDay    = DoneTasks.Max(x => x.Value);
            WorstDay   = DoneTasks.Min(x => x.Value);
            MonthCount = DoneTasks.Sum(x => x.Value);
        }
Esempio n. 33
0
        public string Classify(double[] obj)
        {
            var score = new Dictionary <string, double>();

            var results = (dataSet.Tables[0].AsEnumerable()
                           .GroupBy(myRow => myRow.Field <string>(dataSet.Tables[0].Columns[0].ColumnName))
                           .Select(g => new { Name = g.Key, Count = g.Count() })).ToList();

            for (int i = 0; i < results.Count; i++)
            {
                var subScoreList = new List <double>();
                int a = 1, b = 1;
                for (int k = 1; k < dataSet.Tables[normalDistributionTableName].Columns.Count; k = k + 2)
                {
                    var mean     = Convert.ToDouble(dataSet.Tables[normalDistributionTableName].Rows[i][a]);
                    var variance = Convert.ToDouble(dataSet.Tables[normalDistributionTableName].Rows[i][++a]);
                    var result   = Helper.NormalDist(obj[b - 1], mean, Helper.SquareRoot(variance));
                    subScoreList.Add(result);
                    a++;
                    b++;
                }

                double finalScore = 0;
                for (int z = 0; z < subScoreList.Count; z++)
                {
                    if (finalScore == 0)
                    {
                        finalScore = subScoreList[z];
                        continue;
                    }

                    finalScore = finalScore * subScoreList[z];
                }

                score.Add(results[i].Name, finalScore * 0.5);
            }

            double maxOne = score.Max(c => c.Value);
            var    name   = (score.Where(c => c.Value == maxOne).Select(c => c.Key)).First();

            return(name);
        }
Esempio n. 34
0
        static int FindShortestSubArray2(int[] nums)
        {
            var dict = new Dictionary <int, int>();

            for (int i = 0; i < nums.Length; i++)
            {
                if (!dict.ContainsKey(nums[i]))
                {
                    dict[nums[i]] = 1;
                }
                else
                {
                    dict[nums[i]]++;
                }
            }
            int degree = dict.Max(r => r.Value);

            List <int>[] record = new List <int> [50001];
            int          res    = int.MaxValue;

            for (int i = 0; i < nums.Length; i++)
            {
                if (record[nums[i]] == null)
                {
                    record[nums[i]] = new List <int>()
                    {
                        i
                    }
                }
                ;
                else
                {
                    record[nums[i]].Add(i);
                }
                if (record[nums[i]].Count == degree)
                {
                    int len = record[nums[i]].Count;
                    res = Math.Min(res, record[nums[i]][len - 1] - record[nums[i]][0] + 1);
                }
            }
            return(res);
        }
Esempio n. 35
0
        private void ResetCurrentDataSource()
        {
            string newStr = m_dt.ToString("yyyy-MM-dd");

            m_lstHourSource.Clear();
            m_lstRects.Clear();
            maxSplit = 1;
            if (_dataSource != null)
            {
                _currentDataSource = _dataSource.FindAll(p => p.BeginTimeStr == newStr || p.EndTimeStr == newStr || (CurrentTime >= p.BeginTime && CurrentTime <= p.EndTime));
                foreach (var item in _currentDataSource)
                {
                    DateTime dt2       = DateTime.Parse(item.EndTime.Value.ToString("yyyy-MM-dd") + " " + item.EndTime.Value.Hour + ":00:00");
                    int      beginHour = 0;
                    if (item.BeginTime.Day == CurrentTime.Day)
                    {
                        beginHour = item.BeginTime.Hour;
                    }
                    for (int i = beginHour; i < 24; i++)
                    {
                        DateTime dt1 = DateTime.Parse(item.BeginTime.ToString("yyyy-MM-dd") + " " + i + ":00:00");
                        if (dt1 <= dt2)
                        {
                            if (!m_lstHourSource.ContainsKey(i))
                            {
                                m_lstHourSource[i] = new List <NoteEntity>();
                            }
                            m_lstHourSource[i].Add(item);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
                if (m_lstHourSource.Count > 0)
                {
                    maxSplit = m_lstHourSource.Max(p => p.Value.Count);
                }
                CheckCom();
            }
        }
Esempio n. 36
0
        public T Map(IReadOnlyList <string> source, T target)
        {
            var maxIndex = _mappers.Max(m => m.Key);

            for (var i = 0; i < source.Count && i <= maxIndex; i++)
            {
                if (!_mappers.ContainsKey(i))
                {
                    continue;
                }

                var propertyMapper = _mappers[i];

                // account for value types (unary)
                var unary          = propertyMapper.Body as UnaryExpression;
                var memberSelector = unary == null
                    ? propertyMapper.Body as MemberExpression
                    : unary.Operand as MemberExpression;

                var propertyInfo = memberSelector?.Member as PropertyInfo;
                if (propertyInfo == null)
                {
                    continue;
                }

                var value = GetValue(i, source);

                if (_valueCallbacks.ContainsKey(i))
                {
                    // the client provided a callback so don't mess with the type
                    var callback = _valueCallbacks[i];
                    propertyInfo.SetValue(target, callback(value), null);
                }
                else
                {
                    var convertedValue = SafeConvert(value, propertyInfo.PropertyType);
                    propertyInfo.SetValue(target, convertedValue, null);
                }
            }

            return(target);
        }
Esempio n. 37
0
        private Color CBP(Point point)
        {
            var Q = new Dictionary <Color, int>();

            for (var y = point.Y - SR; y <= point.Y + SR; y++)
            {
                if (!(0 <= y && y < image.Width))
                {
                    continue;
                }
                for (var x = point.X - SR; x <= point.X + SR; x++)
                {
                    if (!(0 <= x && x < image.Height))
                    {
                        continue;
                    }
                    if (x == point.X && y == point.Y)
                    {
                        continue;
                    }
                    var currentPoint = new Point {
                        X = x, Y = y
                    };
                    if (SAD(point, currentPoint) < T && !SaltAndPepper(currentPoint))
                    {
                        var color = image.GetPixel(currentPoint);
                        if (Q.ContainsKey(color))
                        {
                            Q[color]++;
                        }
                        else
                        {
                            Q.Add(color, 1);
                        }
                    }
                }
            }

            var max = Q.Max(pair => pair.Value);

            return(Q.Where(pair => pair.Value == max).Select(pair => pair.Key).ToList()[0]);
        }
Esempio n. 38
0
        static int LargestOverlap(int[][] A, int[][] B)
        {
            List <int> oneInA = new List <int>();
            List <int> oneInB = new List <int>();

            for (int r = 0; r < A.Length; r++)
            {
                for (int c = 0; c < A[0].Length; c++)
                {
                    if (A[r][c] == 1)
                    {
                        oneInA.Add(r * 100 + c);
                    }
                    if (B[r][c] == 1)
                    {
                        oneInB.Add(r * 100 + c);
                    }
                }
            }
            var dict = new Dictionary <int, int>();

            for (int i = 0; i < oneInA.Count; i++)
            {
                for (int j = 0; j < oneInB.Count; j++)
                {
                    int tem = oneInA[i] - oneInB[j];
                    if (!dict.ContainsKey(tem))
                    {
                        dict[tem] = 1;
                    }
                    else
                    {
                        dict[tem]++;
                    }
                }
            }
            if (dict.Count == 0)
            {
                return(0);
            }
            return(dict.Max(r => r.Value));
        }
Esempio n. 39
0
        private LegalMove GetMostSurvivableMove(GameState.BoardData board, int indexOfMyself)
        {
            var boardArray = new int[board.Width, board.Height];

            foreach (var snake in board.Snakes)
            {
                for (int i = 0; i < snake.Body.Count - 1; i++)
                {
                    boardArray[snake.Body[i].X, snake.Body[i].Y] = 1;
                }
            }

            var snakeBodies = board.Snakes.Select(x => x.Body.ToArray()).ToArray();
            var healths     = board.Snakes.Select(x => x.Health).ToArray();

            var permutations = this.precalc.GetPossibleMovesPermutations(board.Snakes.Count);

            var survivableFutures = new Dictionary <LegalMove, int>
            {
                { LegalMove.Up, 0 },
                { LegalMove.Down, 0 },
                { LegalMove.Left, 0 },
                { LegalMove.Right, 0 }
            };

            for (int i = 0; i < permutations.Length; i++)
            {
                (var futureSnakes, var futureHealths) = gameEngine.ProcessMoves(snakeBodies, healths, boardArray, permutations[i]);

                if (futureHealths[indexOfMyself] > 0)
                {
                    survivableFutures[permutations[i][indexOfMyself]]++;
                }
            }

            foreach (var survivableFuture in survivableFutures)
            {
                Console.WriteLine($"{survivableFuture.Key}: {survivableFuture.Value}");
            }

            return(survivableFutures.First(x => x.Value == survivableFutures.Max(y => y.Value)).Key);
        }
Esempio n. 40
0
        public static void PartOne()
        {
            long[] data = InputHelper.GetIntcodeFromFile("7");

            List <int> phases = new List <int> {
                0, 1, 2, 3, 4
            };

            var allPhases = Permute(phases);
            Dictionary <long, List <int> > outputPerPhase = new Dictionary <long, List <int> >();

            foreach (IEnumerable <int> p in allPhases)
            {
                var             phase = p.ToList();
                IntcodeComputer a     = new IntcodeComputer(data);
                a.InputQueue.Enqueue(phase[0]);
                a.InputQueue.Enqueue(0);
                a.Run();
                IntcodeComputer b = new IntcodeComputer(data);
                b.InputQueue.Enqueue(phase[1]);
                b.InputQueue.Enqueue(a.OutputQueue.Dequeue());
                b.Run();
                IntcodeComputer c = new IntcodeComputer(data);
                c.InputQueue.Enqueue(phase[2]);
                c.InputQueue.Enqueue(b.OutputQueue.Dequeue());
                c.Run();
                IntcodeComputer d = new IntcodeComputer(data);
                d.InputQueue.Enqueue(phase[3]);
                d.InputQueue.Enqueue(c.OutputQueue.Dequeue());
                d.Run();
                IntcodeComputer e = new IntcodeComputer(data);
                e.InputQueue.Enqueue(phase[4]);
                e.InputQueue.Enqueue(d.OutputQueue.Dequeue());
                e.Run();
                long output = e.OutputQueue.Dequeue();
                outputPerPhase.Add(output, phase);
                Console.WriteLine($"Phase {String.Join(',', phase)} produces output {output}");
            }
            var maxPhase = outputPerPhase.First(o => o.Key == outputPerPhase.Max(k => k.Key));

            Console.WriteLine($"Phase with biggest output {String.Join(',', maxPhase.Value)} produces output {maxPhase.Key}");
        }
Esempio n. 41
0
        /// <summary>
        ///     Determines whether the invocation parameters match the set up parameters.
        /// </summary>
        /// <param name="setUpParameters">The set up parameters.</param>
        /// <param name="invocationParameters">The invocation parameters.</param>
        /// <returns>true the invocation parameters are a partial or full match of the set up parameters.</returns>
        /// <remarks>
        ///     If the parameters are DbParameters, parameter name and value are compared.
        ///     Parameter name matching is case insensitive.
        ///     If the value is a string, the matching is case insensitive.
        ///     For everything else an exact match is required.
        /// </remarks>
        public static bool DoInvocationParametersMatchSetUpParameters(IEnumerable <object> setUpParameters, IEnumerable <object> invocationParameters)
        {
            var setUpParametersAsList      = setUpParameters.ToList();
            var invocationParametersAsList = invocationParameters.ToList();

            var matches = new Dictionary <int, int>();

            for (var i = 0; i < invocationParametersAsList.Count; i++)
            {
                var invocationParameter = invocationParametersAsList[i];
                Logger.LogDebug("Checking invocationParameter '{invocationParameter}'", invocationParameter);
                matches.Add(i, -1);

                //What was the last set up parameter matched?
                var startAt = matches.Any() ? matches.Max(x => x.Value) + 1 : 0;
                Logger.LogDebug("startAt: {startAt}", startAt);

                for (var j = 0; j < setUpParametersAsList.Count; j++)
                {
                    var setUpParameter = setUpParametersAsList[j];
                    Logger.LogDebug("Checking setUpParameter '{setUpParameter}'", setUpParameter);

                    if (invocationParameter is DbParameter dbInvocationParameter &&
                        setUpParameter is DbParameter dbSetUpParameter &&
                        DoesInvocationParameterMatchSetUpParameter(dbSetUpParameter, dbInvocationParameter))
                    {
                        matches[i] = j;
                        break;
                    }

                    if (DoesInvocationParameterValueMatchSetUpParameterValue(setUpParameter, invocationParameter))
                    {
                        matches[i] = j;
                        break;
                    }
                }
            }

            Logger.LogDebug("Match summary '{summary}'", string.Join(Environment.NewLine, matches.Select(x => $"{x.Key}: {x.Value}")));

            return(matches.Count(x => x.Value > -1) >= setUpParametersAsList.Count);
        }
Esempio n. 42
0
        public void PartitionKeyTest()
        {
            // Let's emulate the partitioned database.
            var db = new Dictionary <string, List <UnifiedId> >();

            // We will use 100K records, just to execute it fast.
            var all = 100000;

            for (var i = 0; i <= all; i++)
            {
                // Generate random Id.
                var id = UnifiedId.NewId();

                // Get it's partition key. Number of partitions could be customized, default 16K.
                var partition = id.PartitionKey(1);

                // Initialize partitions in your DB.
                if (!db.ContainsKey(partition))
                {
                    db.Add(partition, new List <UnifiedId>());
                }

                // Add values to partitions.
                db[partition].Add(id);
            }

            var partitions = 16U;

            float max = db.Max(x => x.Value.Count);
            float min = db.Min(x => x.Value.Count);

            var diff = max - min;

            var maxp  = (max / (all / partitions)) * 100;
            var minp  = (min / (all / partitions)) * 100;
            var diffp = (diff / (all / partitions)) * 100;

            output.WriteLine($"Elements tested: {all} partition size: {all / partitions}");
            output.WriteLine($"MAX: {max:N1}({maxp:N1}%) MIN: {min:N1}({minp:N1}%) DIFF: {diff:N1}({diffp:N1}%)");

            Assert.True(diffp < 10);
        }
        public static IEnumerable <StatPriority> GetWorkTypeStatPrioritiesForPawn([NotNull] Pawn pawn)
        {
            if (pawn == null)
            {
                throw new ArgumentNullException(nameof(pawn));
            }
            var workTypes          = DefDatabase <WorkTypeDef> .AllDefsListForReading;
            var workTypePriorities = new Dictionary <WorkTypeDef, int>();
            var workTypeWeights    = new Dictionary <WorkTypeDef, IEnumerable <StatPriority> >();

            foreach (var workType in workTypes)
            {
                var priority = pawn.workSettings?.GetPriority(workType) ?? 0;
                if (priority <= 0)
                {
                    continue;
                }
                workTypePriorities.Add(workType, priority);
                workTypeWeights.Add(workType, GetWorkTypeStatPriorities(workType));
            }
            if (!workTypePriorities.Any())
            {
                return(new List <StatPriority>());
            }
            var priorityRange =
                new IntRange(workTypePriorities.Min(s => s.Value), workTypePriorities.Max(s => s.Value));
            var weightedPriorities = new List <StatPriority>();

            foreach (var workTypePriority in workTypePriorities)
            {
                var normalizedWorkPriority = priorityRange.min == priorityRange.max
                    ? 1f
                    : 1f - (float)(workTypePriority.Value - priorityRange.min) /
                                             (priorityRange.max + 1 - priorityRange.min);
                weightedPriorities.AddRange(workTypeWeights[workTypePriority.Key].Select(statPriority =>
                                                                                         new StatPriority(statPriority.Stat, statPriority.Weight * normalizedWorkPriority)));
            }
            var statPriorities = weightedPriorities.Select(o => o.Stat).Distinct().Select(stat =>
                                                                                          new StatPriority(stat, weightedPriorities.Where(o => o.Stat == stat).Average(o => o.Weight))).ToList();

            return(statPriorities);
        }
Esempio n. 44
0
        static void Main(string[] args)
        {
            var n = long.Parse(Console.ReadLine());
            var a = Console.ReadLine().Split().Select(i => long.Parse(i)).ToArray();

            var d = new Dictionary <long, long>();

            for (var i = 0; i < n; i++)
            {
                var x = a[i];
                if (d.ContainsKey(x))
                {
                    d[x] += 1;
                }
                else
                {
                    d.Add(x, 1);
                }

                if (d.ContainsKey(x + 1))
                {
                    d[x + 1] += 1;
                }
                else
                {
                    d.Add(x + 1, 1);
                }

                if (d.ContainsKey(x - 1))
                {
                    d[x - 1] += 1;
                }
                else
                {
                    d.Add(x - 1, 1);
                }
            }

            var max = d.Max(t => t.Value);

            Console.WriteLine(max);
        }
Esempio n. 45
0
        protected void FindScore(int playerCount, int pointCount)
        {
            var current = new Node(0);

            current.Next = current;
            current.Prev = current;
            var players = new Dictionary <int, long>();

            for (int i = 1; i <= pointCount; i++)
            {
                if (i % 23 == 0)
                {
                    var player = i % playerCount;
                    if (!players.ContainsKey(player))
                    {
                        players[player] = 0;
                    }
                    players[player] += i;
                    for (int j = 0; j < 7; j++)
                    {
                        current = current.Prev;
                    }

                    players[player]  += current.Value;
                    current.Prev.Next = current.Next;
                    current           = current.Next;
                }
                else
                {
                    var node = new Node(i);
                    node.Next         = current.Next.Next;
                    current.Next.Next = node;
                    node.Prev         = current.Next;
                    node.Next.Prev    = node;
                    current           = node;
                }
            }

            var winning = players.Max(t => t.Value);

            Console.WriteLine(winning);
        }
Esempio n. 46
0
        internal static void CalculatePart1()
        {
            StreamReader reader = new StreamReader("input08.txt");

            Dictionary <string, int> register = new Dictionary <string, int>();

            while (!reader.EndOfStream)
            {
                //Read instructions
                string   line      = reader.ReadLine();
                string[] lineparts = line.Split(' ');

                string registername   = lineparts[0];
                string operation      = (lineparts[1].Equals("inc"))? "+" : "-";
                int    operationValue = int.Parse(lineparts[2]);

                string conditionRegistername = lineparts[4];
                string conditionOperation    = lineparts[5];
                int    conditionValue        = int.Parse(lineparts[6]);

                //Prepare register
                if (!register.ContainsKey(registername))
                {
                    register.Add(registername, 0);
                }
                if (!register.ContainsKey(conditionRegistername))
                {
                    register.Add(conditionRegistername, 0);
                }

                //Excecute instruction
                DataTable dt = new DataTable();
                //splitting and putting back, could be done with string.replace...
                string condition = $"{register[conditionRegistername]} {conditionOperation.Replace("==", "=").Replace("!=", "<>")} {conditionValue}";
                if ((bool)dt.Compute(condition, ""))
                {
                    register[registername] = (int)dt.Compute($"{register[registername]} {operation} {operationValue}", "");
                }
            }

            Console.WriteLine($"Largest number in register: {register.Max(r => r.Value)}");
        }
Esempio n. 47
0
        private void Print(IVehicle vehicle)
        {
            Console.Clear();
            const int percentWidth = 30;
            var       dict         = new Dictionary <string, string>
            {
                { nameof(Vehicle.Link), vehicle.Link.Value.ToString() },
                { nameof(Vehicle.PacketRateHz), vehicle.PacketRateHz.Value.ToString("0 Hz") },
                { nameof(HeartbeatPayload.SystemStatus), vehicle.RawHeartbeat.Value?.SystemStatus.ToString() ?? string.Empty },
                { nameof(HeartbeatPayload.Type), vehicle.RawHeartbeat.Value?.Type.ToString() ?? string.Empty },
                { nameof(HeartbeatPayload.Autopilot), vehicle.RawHeartbeat.Value?.Autopilot.ToString() ?? string.Empty },
                { nameof(HeartbeatPayload.BaseMode), vehicle.RawHeartbeat.Value?.BaseMode.ToString("F") ?? string.Empty },
                { nameof(HeartbeatPayload.CustomMode), vehicle.RawHeartbeat.Value?.CustomMode.ToString() ?? string.Empty },
                { nameof(HeartbeatPayload.MavlinkVersion), vehicle.RawHeartbeat.Value?.MavlinkVersion.ToString() ?? string.Empty },
                { nameof(SysStatusPayload.BatteryRemaining), vehicle.RawSysStatus.Value?.BatteryRemaining.ToString() ?? string.Empty },
                { nameof(SysStatusPayload.CurrentBattery), vehicle.RawSysStatus.Value?.CurrentBattery.ToString() ?? string.Empty },
                { nameof(SysStatusPayload.DropRateComm), TextRender.Progress(((vehicle.RawSysStatus.Value?.DropRateComm) ?? 0) / 10000.0, percentWidth) },
                { nameof(SysStatusPayload.ErrorsComm), vehicle.RawSysStatus.Value?.ErrorsComm.ToString() ?? string.Empty },
                { nameof(SysStatusPayload.Load), TextRender.Progress((vehicle.RawSysStatus.Value?.Load ?? 0) / 1000.0, percentWidth) },
                { nameof(SysStatusPayload.VoltageBattery), vehicle.RawSysStatus.Value?.VoltageBattery.ToString() ?? string.Empty },
                { nameof(Vehicle.GlobGps), vehicle.GlobGps.Value.ToString() },
                { nameof(Vehicle.Home), vehicle.Home.Value.ToString() },
                { nameof(GpsRawIntPayload.Alt), ((vehicle.RawGpsRawInt.Value?.Alt ?? double.NaN) / 1000.0).ToString("F1") },
                { "LastCommand", _lastCommand }
            };

            GetAddidtionslParams(vehicle, dict);

            TextTable.PrintKeyValue(Console.WriteLine, new DoubleTextTableBorder(), dict.Max(_ => _.Key.Length), dict.Max(_ => _.Value.Length), "Vehicle", dict);

            var help = new Dictionary <string, string>
            {
                { "Arrows", "Move XY" },
                { "U and D", "Up/down altitude" },
                { "PageUp and PageDown", "Up / Down max speed (MPC_XY_VEL_MAX)" },
                { "A", "Arm" },
                { "T", "Take off" },
                { "Q", "Exit" },
            };

            TextTable.PrintKeyValue(Console.WriteLine, new DoubleTextTableBorder(), help.Max(_ => _.Key.Length), help.Max(_ => _.Value.Length), "Commands", help);
        }
Esempio n. 48
0
 private void ProcessingMetadataUsage()
 {
     metadataUsageDic = new Dictionary <uint, SortedDictionary <uint, uint> >();
     for (uint i = 1; i <= 6u; i++)
     {
         metadataUsageDic[i] = new SortedDictionary <uint, uint>();
     }
     foreach (var metadataUsageList in metadataUsageLists)
     {
         for (int i = 0; i < metadataUsageList.count; i++)
         {
             var offset            = metadataUsageList.start + i;
             var metadataUsagePair = metadataUsagePairs[offset];
             var usage             = GetEncodedIndexType(metadataUsagePair.encodedSourceIndex);
             var decodedIndex      = GetDecodedMethodIndex(metadataUsagePair.encodedSourceIndex);
             metadataUsageDic[usage][metadataUsagePair.destinationIndex] = decodedIndex;
         }
     }
     maxMetadataUsages = metadataUsageDic.Max(x => x.Value.Max(y => y.Key)) + 1;
 }
Esempio n. 49
0
        private Dictionary <int, string> GetLabelsClasses(Dictionary <int, double> p_seuilsBas)
        {
            Dictionary <int, string> v_classes = new Dictionary <int, string>();

            try
            {
                string v_label;
                for (int v_index = 1; v_index < p_seuilsBas.Max(c => c.Key); v_index++)
                {
                    v_label = p_seuilsBas[v_index] + "_" + p_seuilsBas[v_index + 1];
                    v_classes.Add(v_index, v_label);
                }
                v_label = "Plus_de_" + p_seuilsBas.Last().Value;
            }
            catch (Exception)
            {
                throw;
            }
            return(v_classes);
        }
Esempio n. 50
0
        public long AddObject(AppObject obj)
        {
            lock (ObjectCache)
            {
                long id = 1;

                if (ObjectCache.Count > 0)
                {
                    id = ObjectCache.Max(x => x.Key) + 1;
                }

                obj.Id = id;
                obj.OnConnectionAdd    += AddConnectionObject;
                obj.OnConnectionRemove += RemoveConnectionObject;

                ObjectCache.Add(id, obj);

                return(id);
            }
        }
        public static string GetMostFrequent(this string[] values)
        {
            var dicc = new Dictionary <string, int>();

            foreach (var v in values)
            {
                if (!dicc.ContainsKey(v))
                {
                    dicc.Add(v, 1);
                }
                else
                {
                    dicc[v] += 1;
                }
            }

            var maxVal = dicc.Max(e => e.Value);

            return(dicc.First(p => p.Value == maxVal).Key);
        }
Esempio n. 52
0
        public void Process(IList<short[]> data)
        {
            var length = data.First().Length;
            var median = new short[length];
            var rates = new Dictionary<int, int>();

            for (int i = 0; i < length; i++)
            {
                rates.Clear();
                for (var j = 0; j < data.Count; j++)
                    if (!rates.ContainsKey(data[j][i]))
                        rates.Add(data[j][i], 1);
                    else
                        ++rates[data[j][i]];
                var popularValue = rates.Max(x => x.Value);
                median[i] = Convert.ToInt16(rates.Where(x => x.Value == popularValue).Select(y => y.Key).Average());
            }

            data.Clear();
            data.Add(median);
        }
Esempio n. 53
0
    static void Main()
    {
        int[] array = { 4, 1, 1, 4, 2, 3, 4, 4, 1, 2, 4, 9, 3 };

        Dictionary<int, int> elementsInArray = new Dictionary<int, int>();

        for (int i = 0; i < array.Length; i++)
        {
            if (elementsInArray.ContainsKey(array[i]))
            {
                elementsInArray[array[i]] += 1;
            }
            else
            {
                elementsInArray.Add(array[i], 1);
            }
        }
        int number = elementsInArray.Aggregate((x, y) => x.Value > y.Value ? x : y).Key;
        int count = elementsInArray.Max(x => x.Value);
        Console.WriteLine("{0} ({1} times)", number, count);
    }
Esempio n. 54
0
        public void WriteHelp()
        {
            _output.WriteInfoLine("CSBuild", true);
            _output.WriteInfoLine("Version: " + _buildEnvironment.Version, true);
            _output.WriteInfoLine();
            var arguments = new Dictionary<string, string>
            {
                {"-help", "Shows this help message."},
                {"-target=<task>", "Specifies which task to run."},
                {"-tasklist", "Displays a list of all available tasks."},
                {"-dryrun", "Displays a list of all tasks that will be executed. Can be combined with -target=<task>."}
            };

            var maxParamNameWidth = arguments.Max(x => x.Key.Length);
            foreach (var p in arguments)
            {
                _output.WriteInfo(p.Key + new string(' ', maxParamNameWidth - p.Key.Length), true);
                _output.WriteInfo("  :  ");
                _output.WriteInfoLine(p.Value);
            }
        }
        public int FindWinner(int[] inputArray)
        {
            Dictionary<int, int> winnersD = new Dictionary<int, int>();
            //winnersD.OrderBy(x => x.Key);

            int result = 0;
            foreach (var winner in inputArray)
            {
                if (winnersD.ContainsKey(winner))
                    winnersD[winner] = winnersD[winner] + 1;
                else
                    winnersD.Add(winner, 1);

                var numWins = winnersD.Max(x => x.Value);
                //var numWins = winnersD.Aggregate((l, r) => l.Value > r.Value ? l : r).Value;

                result = winnersD.First(x => x.Value == numWins).Key;
            }

            return result;

        }
Esempio n. 56
0
        public void Save(Dictionary<string, List<News>> news)
        {
            decimal min = news.Min(n => n.Value.Min(m => m.RawScore));
            decimal max = news.Max(n => n.Value.Max(m => m.RawScore));

            using (var dbContext = new DistrictsInTownModelContainer())
            {
                foreach (var district in news)
                    AddArticlesToDB(dbContext, district, min, max);

                try
                {
                    dbContext.SaveChanges();
                }
                catch (Exception error)
                {
                    Console.WriteLine(error.StackTrace);
                }

                Console.WriteLine("Total results: {0}", news.Sum(n => n.Value.Count));
            }
        }
Esempio n. 57
0
        internal void Fold(Dictionary<Int32,FoldRegion> regions)
        {
            if (regions.Count == 0)
                return;

            var start = regions.Min(rv => rv.Key);
            var end = regions.Max(rv => rv.Value.EndLine);
            var lc =  @ref.Send(Sci.SCI_GETLINECOUNT);

            for (var i = start; i < end + 2; i++)
            {
                FoldRegion reg;

                if (regions.TryGetValue(i, out reg))
                {
                    //System.Diagnostics.Debug.WriteLine("sl=" + i + ";el=" + reg.EndLine + ";level=" + reg.Level);
                    ProcessRegion(ref i, 0, regions, reg);
                    i--;
                }
                else if (i < lc)
                    @ref.Send(Sci.SCI_SETFOLDLEVEL, i, 0 | Sci.SC_FOLDLEVELBASE);
            }
        }
Esempio n. 58
0
        // a < b < c
        // a + b > c
        // a2 + b2 = c2
        // a + b + c <= 1000

        static int BruteForce()
        {
            var map = new Dictionary<int, int>();
            for (int a = 0; a < 1000 /3; a++)
            {
                for (int b = a + 1; b < 1000/2; b++)
                {
                    for (int c = b + 1; c < 1000/2; c++)
                    {
                        if(IsTriangle(a, b, c))
                        {
                            var sum = a + b + c;
                            if(!map.ContainsKey(sum))
                            {
                                map.Add(sum, 0);
                            }
                            map[sum] ++;
                        }
                    }
                }
            }
            var max = map.Max(obj => obj.Value);
            return map.First(v => v.Value == max).Key;
        }
Esempio n. 59
0
        public string Classify(double[] testedData)
        {
            var distanceList = new List<DigitData>();

              //Calculating the distance
              foreach(var trainingData in _trainingSet)
              {
            trainingData.Distance = EuclideanDistance(trainingData.Feature, testedData);

            distanceList.Add(trainingData);
              }

              //Sort based on distance
              distanceList.Sort();

              var majoritySubset = new Dictionary<string, int>();

              for(var i=0;i<K;i++)
              {
            var resultClass = distanceList[i];

            if(majoritySubset.ContainsKey(resultClass.Label))
            {
              majoritySubset[resultClass.Label] += 1;
            }else
            {
              majoritySubset.Add(resultClass.Label, 1);
            }

              }

              //Find the majority class in the K subset
              var label = majoritySubset.Max(c => c.Key);

              return label;
        }
Esempio n. 60
0
        public Dictionary<int, int> GetParts(Dictionary<int, int> results)
        {
            Dictionary<int, int> newResults = new Dictionary<int, int>();

            int allAnswers = results.Sum(r => r.Value);
            int sumParts = 0;

            foreach (var result in results)
            {
                double part = allAnswers != 0 ? (double)result.Value / (double)allAnswers : 0;
                int percents = int.Parse(Math.Round(part * 100, 0).ToString());
                newResults.Add(result.Key, percents);
                sumParts += percents;
            }

            if (sumParts != 100 && sumParts != 0)
            {
                var correlation = 100-sumParts;
                var maxPart = newResults.FirstOrDefault(d=>d.Value.Equals(newResults.Max(t=>t.Value)));
                newResults[maxPart.Key] = maxPart.Value + correlation;
            }

            return newResults;
        }