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; }
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); } }
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); }
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); } }
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)); }
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(); } } }
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(); }
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); }
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); }
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 }
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; }
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); }
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); }
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); }
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); }
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); }
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; } } }
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); } }
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); }
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? } }
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); }
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); }
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); }
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(); } }
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); }
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]); }
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)); }
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); }
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}"); }
/// <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); }
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); }
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); }
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); }
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)}"); }
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); }
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; }
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); }
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); }
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); }
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); }
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; }
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)); } }
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); } }
// 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; }
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; }
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; }