public string Correct(string word) { if (string.IsNullOrEmpty(word)) return word; word = word.ToLower(); // known() if (_dictionary.ContainsKey(word)) return word; List<String> list = Edits(word); Dictionary<string, int> candidates = new Dictionary<string, int>(); foreach (string wordVariation in list) { if (_dictionary.ContainsKey(wordVariation) && !candidates.ContainsKey(wordVariation)) candidates.Add(wordVariation, _dictionary[wordVariation]); } if (candidates.Count > 0) return candidates.OrderByDescending(x => x.Value).First().Key; // known_edits2() foreach (string item in list) { foreach (string wordVariation in Edits(item)) { if (_dictionary.ContainsKey(wordVariation) && !candidates.ContainsKey(wordVariation)) candidates.Add(wordVariation, _dictionary[wordVariation]); } } return (candidates.Count > 0) ? candidates.OrderByDescending(x => x.Value).First().Key : word; }
public static string Correct(string word) { if (string.IsNullOrEmpty(word)) return word; word = word.ToLower(); if (_dictionary.ContainsKey(word)) return word; List<String> list = Edits(word); Dictionary<string, int> candidates = new Dictionary<string, int>(); FindCandidates(list, ref candidates); if (candidates.Count > 0) return candidates.OrderByDescending(x => x.Value).First().Key; foreach (string item in list) { FindCandidates(Edits(item), ref candidates); } return (candidates.Count > 0) ? candidates.OrderByDescending(x => x.Value).First().Key : word; }
/// <summary> /// Sort the collection in the proper manner. /// </summary> internal static Dictionary<string, ListDictionary> SortCollection(Dictionary<string, ListDictionary> collection, string treeLevel, string sortLevel) { switch (sortLevel) { case "Alphabet": return collection .OrderBy(kvp => kvp.Key) .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); case "Effort": return collection .OrderByDescending(kvp => kvp.Value["effort"]) .ThenBy(kvp => kvp.Key) // Sort alphabetically if there is a tie. .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); case "Priority": return collection .OrderByDescending(kvp => kvp.Value["priority"]) .ThenBy(kvp => kvp.Key) // Sort alphabetically if there is a tie. .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); case "Product": var missingTeamString = SimpleWorkItem.GetMissingString("Team"); var missingTeamCollection = collection.Where(kvp => kvp.Key == missingTeamString); // Reference the 'NO TEAM' grouping. return collection .Where(kvp => kvp.Key != missingTeamString) // Exclude 'NO TEAM' from sorting. .OrderBy(kvp => kvp.Key != "Atlas") .ThenBy(kvp => kvp.Key != "Anubis") .ThenBy(kvp => kvp.Key != "Proteus") .ThenBy(kvp => kvp.Key != "Shiva") .ThenBy(kvp => kvp.Key != "Janus") .ThenBy(kvp => kvp.Key != "Phoenix") .ThenBy(kvp => kvp.Key != "Brahma") .ThenBy(kvp => kvp.Key != "Loki") .ThenBy(kvp => kvp.Key != "Heimdall") .ThenBy(kvp => kvp.Key != "Vulcan") .ThenBy(kvp => kvp.Key != "Athena") .ThenBy(kvp => kvp.Key != "Ra") .ThenBy(kvp => kvp.Key) // Any unmentioned teams above will be sorted alphabetically. .Concat(missingTeamCollection) // Attach 'NO TEAM' back on. .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); case "Date": const string futureString = "Future"; var missingString = SimpleWorkItem.GetMissingString(treeLevel); var futureCollection = collection.Where(kvp => kvp.Key == futureString); // Reference the Future grouping. var missingCollection = collection.Where(kvp => kvp.Key == missingString); // Reference the missing grouping. return collection .Where(kvp => kvp.Key != futureString && kvp.Key != missingString) // Exclude Future and missing from sorting. .OrderBy(kvp => kvp.Key.Split('\\').ElementAtOrDefault(0, "Z")) // Sort by Year, using "Z" to place it last if it's missing. .ThenBy(kvp => kvp.Key.Split('\\').ElementAtOrDefault(1, "Z")) // Sort by Quarter, using "Z" to place it last if it's missing. .ThenBy(kvp => kvp.Key.Split('\\').ElementAtOrDefault(2, "Z")) // Sort by Sprint, using "Z" to place it last if it's missing. .Concat(futureCollection) // Attach Future back on. .Concat(missingCollection) // Attach missing back on. .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); default: throw new Exception("Sorting type: " + sortLevel + ", is not supported."); } }
internal static void WriteStats(List<ChangeList> allChangelists) { var commentForTesterIsNull = 0; var commentForTesterIsEmpty = 0; var commentForTesterIsNc = 0; var commentForTesterIsNullByAuthor = new Dictionary<string, int>(); var commentForTesterIsEmptyByAuthor = new Dictionary<string, int>(); var commentForTesterIsNcByAuthor = new Dictionary<string, int>(); foreach (var changelist in allChangelists) { var description = changelist.ParsedDescription; if (description.CommentForTestersTrimmed == null) { commentForTesterIsNull++; if (commentForTesterIsNullByAuthor.ContainsKey(changelist.Author)) commentForTesterIsNullByAuthor[changelist.Author]++; else commentForTesterIsNullByAuthor[changelist.Author] = 1; } else if (description.CommentForTestersTrimmed == "") { commentForTesterIsEmpty++; if (commentForTesterIsEmptyByAuthor.ContainsKey(changelist.Author)) commentForTesterIsEmptyByAuthor[changelist.Author]++; else commentForTesterIsEmptyByAuthor[changelist.Author] = 1; } else if (string.Equals(description.CommentForTestersTrimmed, "nc", StringComparison.OrdinalIgnoreCase)) { commentForTesterIsNc++; if (commentForTesterIsNcByAuthor.ContainsKey(changelist.Author)) commentForTesterIsNcByAuthor[changelist.Author]++; else commentForTesterIsNcByAuthor[changelist.Author] = 1; } } Console.WriteLine("Comment for tester is null: {0}, authors: {1}, top: {2}-{3}", commentForTesterIsNull, commentForTesterIsNullByAuthor.Count, commentForTesterIsNullByAuthor.OrderByDescending(a => a.Value).First().Key, commentForTesterIsNullByAuthor.OrderByDescending(a => a.Value).First().Value); Console.WriteLine("Comment for tester is empty: {0}, authors: {1}, top: {2}-{3}", commentForTesterIsEmpty, commentForTesterIsEmptyByAuthor.Count, commentForTesterIsEmptyByAuthor.OrderByDescending(a => a.Value).First().Key, commentForTesterIsEmptyByAuthor.OrderByDescending(a => a.Value).First().Value); Console.WriteLine("Comment for tester is nc: {0}, authors: {1}, top: {2}-{3}", commentForTesterIsNc, commentForTesterIsNcByAuthor.Count, commentForTesterIsNcByAuthor.OrderByDescending(a => a.Value).First().Key, commentForTesterIsNcByAuthor.OrderByDescending(a => a.Value).First().Value); Console.WriteLine("Comment for tester is null"); foreach (var author in commentForTesterIsNullByAuthor.OrderByDescending(a => a.Value)) { Console.WriteLine("{0}: {1}", author.Key, author.Value); } Console.WriteLine("Comment for tester is empty"); foreach (var author in commentForTesterIsEmptyByAuthor.OrderByDescending(a => a.Value)) { Console.WriteLine("{0}: {1}", author.Key, author.Value); } Console.WriteLine("Comment for tester is nc"); foreach (var author in commentForTesterIsNcByAuthor.OrderByDescending(a => a.Value)) { Console.WriteLine("{0}: {1}", author.Key, author.Value); } }
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(); }
// POST api/values public async Task <IHttpActionResult> Post() { if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } var url = ""; var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider); Dictionary <string, float> emo = null; Dictionary <string, float> labels = null; foreach (var file in provider.Contents) { var filename = Guid.NewGuid().ToString() + ".png"; var stream = await file.ReadAsStreamAsync(); var mem = new MemoryStream(await file.ReadAsByteArrayAsync()); emo = getemotion(mem); string memetext; if (emo.Any()) { memetext = GetMemeText(emo); } else { labels = GetLabels(mem); if (labels.Any()) { memetext = GetMemeTextByLabel(labels); } else { return(NotFound()); } } var newstream = GenerateImage(stream, memetext); url = saveToSThree(newstream, filename); } var q = emo?.OrderByDescending(x => x.Value).FirstOrDefault().Key ?? ""; var o = labels?.OrderByDescending(x => x.Value).FirstOrDefault().Key ?? ""; return(Ok(new { URL = url, Emotion = emo?.OrderByDescending(x => x.Value).FirstOrDefault().Key ?? "", Tag = labels?.OrderByDescending(x => x.Value).FirstOrDefault().Key ?? "" })); }
static void Main(string[] args) { string s = "заданная,по,умолчанию,строка,на,входе,в,которой,производится,поиск,триплетов"; Dictionary<string,int> triplet = new Dictionary<string,int>(); //список триплетов с количеством повторений каждого Console.Write("Введите строку: "); s=Console.ReadLine(); int err = Check(ref s); //проверка строки if (err == 0) //строка соответствует условию, в строке больше одного триплета { int i = 3; string trip = s.Substring(0, 3).ToLower(); //выделение подстроки с приведением к строчным буквам (считаем триплеты «Три» и «три» одинаковыми) triplet.Add(trip, 1); //первый триплет автоматически попадает в список while (i < s.Length) { if (Char.IsLetter(s[i])) //продолжается ли слово { trip = trip.Substring(1) + Char.ToLower(s[i]); //изменение триплета if (triplet.ContainsKey(trip)) //есть ли уже такой триплет { triplet[trip]++; //увеличение количества вхождений для найденного триплета } else { triplet.Add(trip, 1); //добавление нового триплета } i++; } else { trip = s.Substring(i, 3); // натолкнулись на запятую, создаём триплет, содержащий её и две следующие буквы. Так как из строки удалены слова из двух букв, триплет гарантировано будет i += 3; } } Console.WriteLine(String.Concat(triplet.OrderByDescending(x => x.Value).FirstOrDefault().Key, " ", triplet.OrderByDescending(x => x.Value).FirstOrDefault().Value.ToString())); //выводим наиболее частый триплет и число его вхождений } else if (err == 1) //в строке только три символа или только одно слово из трёх символов { Console.WriteLine(String.Concat(s, " 1")); } else if (err == 2) //в строке нет триплетов { Console.WriteLine("В строке нет ни одного триплета"); } else //в строке присутствуют отличные от букв и запятой символы { Console.WriteLine("Строка не соответствует условию задачи"); } Console.ReadKey(); }
static void Main(string[] args) { Datavase = new Dictionary<string, Country>(); while (true) { string inRaw = Console.ReadLine(); if (inRaw == "report") break; string[] input = inRaw.Split('|'); string country = input[1]; string city = input[0]; int population = int.Parse(input[2]); if (Datavase.ContainsKey(country)) { Datavase[country].Cities.Add(city,population); Datavase[country].TotalPopulation += population; } else { Datavase.Add(country,new Country()); Datavase[country].Cities.Add(city,population); Datavase[country].TotalPopulation += population; } } var sortedCountries = Datavase.OrderByDescending(x => x.Value.TotalPopulation); foreach (var country in sortedCountries) { Console.WriteLine("{0} (total population: {1})",country.Key,country.Value.TotalPopulation); country.Value.Print(); } }
static void Main() { string text = @"Write a program that reads a string from the console and prints all different letters in the string along with information how many times each letter is found."; Dictionary<string, int> words = new Dictionary<string, int>(); string[] wordsInText = text.Split(new char[] { '.', ',', ' ', '!', '?', '-', ':', ';' }, StringSplitOptions.RemoveEmptyEntries); foreach (var word in wordsInText) { if (words.ContainsKey(word)) { words[word]++; } else { words.Add(word, 1); } } var sortedWords = words.OrderByDescending(w => w.Value); foreach (var word in sortedWords) { Console.WriteLine("Word \"{0}\" is found {1} time(s)", word.Key, words[word.Key]); } }
public override Dictionary<string, string> GetPlaybackOptions(string url) { Dictionary<string, string> playbackOptions = new Dictionary<string, string>(); CookieContainer cc = new CookieContainer(); string data = GetWebData(url, cookies: cc, cache: false); Regex rgx = new Regex(@"""metadataUrl"":""(?<url>[^""]*)"); Match m = rgx.Match(data); if (m.Success) { JObject json = GetWebData<JObject>(m.Groups["url"].Value, cookies: cc, cache: false); JToken videos = json["videos"]; if (videos != null) { foreach(JToken video in videos) { string key = video["key"].Value<string>(); string videoUrl = video["url"].Value<string>(); MPUrlSourceFilter.HttpUrl httpUrl = new MPUrlSourceFilter.HttpUrl(videoUrl); CookieCollection cookies = cc.GetCookies(new Uri("http://my.mail.ru")); httpUrl.Cookies.Add(cookies); playbackOptions.Add(key, httpUrl.ToString()); } } } playbackOptions = playbackOptions.OrderByDescending((p) => { string resKey = p.Key.Replace("p",""); int parsedRes = 0; int.TryParse(resKey, out parsedRes); return parsedRes; }).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); return playbackOptions; }
/// <summary> /// Matches song titles, only matches if the titles are exactly the same, needs extending /// </summary> /// <returns></returns> public void MatchTheSelectedSongToTheAvailableSongs() { if (SongDetails == null) return; if (string.IsNullOrEmpty(SongDetails.TrackTitle)) return; if (AvailableZuneTracks.Count() == 0) return; //this matches album songs to zune website songs in the details view //Hold Your Colour ---- hold your colour (Album) = MATCH //Hold your colour ---- hold your face = NO MATCH this.SelectedSong = AvailableZuneTracks.Where(song => song.TrackTitle.ToLower() .Contains(SongDetails.TrackTitle.ToLower())) .FirstOrDefault(); //fallback to word matching if we can't match the title exactly var results = new Dictionary<TrackWithTrackNum, int>(); foreach (var song in AvailableZuneTracks) { int weightedMatches = MatchWordsWeightedByPosition(song.TrackTitle.ToLower(), SongDetails.TrackTitle.ToLower()); results.Add(song, weightedMatches); } //select the song with the most words matching var mostMatches = results.OrderByDescending(val => val.Value); if (mostMatches.First().Value != 0) { this.SelectedSong = mostMatches.First().Key; } }
private static void CountMatchesWords() { try { List<string> sb1 = ReadFromFile("Test1.txt"); List<string> wordList = ReadFromFile("WordList.txt"); var content = string.Join(Environment.NewLine, sb1); var match = @"\b(" + string.Join("|", wordList) + ")\\b"; var result = Regex.Matches(content, match, RegexOptions.IgnoreCase | RegexOptions.Multiline); Dictionary<string, int> matches = new Dictionary<string, int>(); foreach (var item in result) { if (matches.ContainsKey(item.ToString())) matches[item.ToString()] += 1; else matches.Add(item.ToString(), 1); } matches = matches.OrderByDescending(o => o.Value).ToDictionary(k => k.Key, v => v.Value); using (StreamWriter sw = new StreamWriter("result.txt")) { foreach (var key in matches.Keys) sw.WriteLine(key); } } catch (Exception ex) { } }
static void Main(string[] args) { int[] array = ArrayHelpers<int>.Build(20, -10, 5); Console.WriteLine("Original array"); ArrayHelpers<int>.Print(array); // sort the array ArrayHelpers<int>.Quicksort(array, 0, array.Length - 1, true); Console.WriteLine("Sorted array"); ArrayHelpers<int>.Print(array); Dictionary<int, int> counters = new Dictionary<int, int>(); // go through every element and increment the counter in the dictionary for that element for (int i = 0; i < array.Length; i++) { if (counters.ContainsKey(array[i])) { counters[array[i]] += 1; } else { counters[array[i]] = 1; } } // sort the dictionary by occurence counters = counters.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value); Console.WriteLine("Element with the highest occurence is " + counters.First().Key); }
/// <summary> /// Populate asynchronously. /// </summary> /// <param name="done">The callback.</param> public void Populate(Action<ISeries> done) { _series.Populate(() => { _children = _series.Children.Select(x => new Chapter(x) as IChapter).ToArray(); foreach (var source in _children.OfType<Chapter>()) { if (source.Number != -1) continue; var differential = new Dictionary<double, int>(); var origin = null as Chapter; foreach (var candidate in _children.OfType<Chapter>()) { if (candidate != source && candidate.Number != -1 && candidate.Volume == source.Volume) { if (origin != null) { var difference = Math.Round(candidate.Number - origin.Number, 4); if (differential.ContainsKey(difference)) { differential[difference]++; } else { differential[difference] = 1; } } origin = candidate; } } if (differential.Count == 0) { source.Number = origin == null ? 0.5 : origin.Number + origin.Number / 2; } else { var shift = differential.OrderByDescending(x => x.Value).FirstOrDefault().Key; source.Number = Math.Round(origin.Number + (shift <= 0 || shift >= 1 ? 1 : shift) / 2, 4); } } done(this); }); }
static void Main() { StreamReader wordsReader = new StreamReader("../../words.txt"); StreamReader textReader = new StreamReader("../../text.txt"); StreamWriter resultWriter = new StreamWriter("../../result.txt"); using (wordsReader) { using (textReader) { using (resultWriter) { List<string> words = new List<string>(); string line = wordsReader.ReadLine(); while (line != null) { words.Add(line); line = wordsReader.ReadLine(); } List<int> wordsCount = new List<int>(); List<string> text = new List<string>(); line = textReader.ReadLine(); while (line != null) { text.Add(line); line = textReader.ReadLine(); } for (int i = 0; i < words.Count; i++) { wordsCount.Add(0); for (int j = 0; j < text.Count; j++) { if (text[j].ToLower().Contains(words[i].ToLower())) { wordsCount[i]++; } } } Dictionary<string, int> dict = new Dictionary<string, int>(); for (int i = 0; i < words.Count; i++) { dict[words[i]] = wordsCount[i]; } var ordered = dict.OrderByDescending(x => x.Value); foreach (var item in ordered) { resultWriter.WriteLine("{0} - {1}", item.Key, item.Value); } } } } }
private static void PrintResult(Dictionary<string, int> materials, SortedDictionary<string, int> junks, string material) { string name = string.Empty; switch (material) { case "shards": name = "Shadowmourne"; break; case "motes": name = "Dragonwrath"; break; case "fragments": name = "Valanyr"; break; } Console.WriteLine($"{name} obtained!"); var orderedMaterials = materials.OrderByDescending(m => m.Value).ThenBy(m => m.Key); foreach (var m in orderedMaterials) { Console.WriteLine($"{m.Key}: {m.Value}"); } foreach (var junk in junks) { Console.WriteLine($"{junk.Key}: {junk.Value}"); } }
static void Main() { Console.WriteLine("Enter some text with repeated words: "); string text = Console.ReadLine(); string regex = @"\b\w+\b"; Dictionary<string, int> dictionary = new Dictionary<string, int>(); MatchCollection words = Regex.Matches(text, regex); foreach (Match word in words) { if (dictionary.ContainsKey(word.ToString())) { dictionary[word.ToString()] += 1; } else { dictionary.Add(word.ToString(), 1); } } foreach (var word in dictionary.OrderByDescending(m => m.Value)) { Console.WriteLine("{0} - {1}", word.Key, word.Value); } }
static void Main(string[] args) { const string SplitPattern = @"\s*\|\s*"; Regex regex = new Regex(SplitPattern); var countryData = new Dictionary<string, List<string>>(); string input = Console.ReadLine(); while (input != "report") { string[] tokens = regex.Split(input.Trim()); string athlete = Regex.Replace(tokens[0].Trim(), @"\s+", " "); string country = Regex.Replace(tokens[1].Trim(), @"\s+", " "); if (!countryData.ContainsKey(country)) { countryData.Add(country, new List<string>()); } countryData[country].Add(athlete); input = Console.ReadLine(); } var orderedCountryData = countryData .OrderByDescending(x => x.Value.Count); foreach (var country in orderedCountryData) { Console.WriteLine( "{0} ({1} participants): {2} wins", country.Key, country.Value.Distinct().Count(), country.Value.Count); } }
/// <summary> /// Converts the hashed (MD5) Battlefield Heroes Beta file to the common text format. /// </summary> private static void ProcessBattlefieldHeroesFile() { Dictionary<string, PasswordInfo> passwords = new Dictionary<string, PasswordInfo>(); using (TextReader reader = new StreamReader(@"../../../passwords/battlefield_heroes.csv")) { string line = null; while ((line = reader.ReadLine()) != null) { if (line == "") continue; var tokens = line.Split(';'); string pw = tokens.Last().Trim('"'); PasswordInfo val; if (!passwords.TryGetValue(pw, out val)) passwords.Add(pw, new PasswordInfo(0,0)); passwords[pw].Accounts++; passwords[pw].Reward++; } } using (TextWriter writer = new StreamWriter(@"../../../passwords/battlefield_heroes.txt")) foreach (var kv in passwords.OrderByDescending(s => s.Value)) writer.WriteLine(kv.Value + " " + kv.Key); }
static void Main() { StreamReader wordsReader = new StreamReader("../../words.txt"); StreamReader textReader = new StreamReader("../../text.txt"); StreamWriter resultWriter = new StreamWriter("../../result.txt"); List<string> wordsToMacth = FillWordsInList(wordsReader); var resultList = new Dictionary<string, int>(); using (textReader) { string text = textReader.ReadToEnd(); for (int i = 0; i < wordsToMacth.Count; i++) { string patternToMatch = string.Format(@"\b{0}\b", wordsToMacth[i]); Regex findWords = new Regex(patternToMatch); MatchCollection matchedWords = findWords.Matches(text); resultList.Add(wordsToMacth[i], matchedWords.Count); } } using (resultWriter) { foreach (var result in resultList .OrderByDescending(result=> result.Value)) { Console.WriteLine("{0} - {1}", result.Key, result.Value); } } }
/// <summary> /// The uninstall database schema. /// </summary> /// <param name="database"> /// The database. /// </param> /// <param name="orderedTables"> /// The ordered tables. /// </param> /// <param name="version"> /// The version. /// </param> internal static void UninstallDatabaseSchema(Database database, Dictionary<int, Type> orderedTables, string version) { LogHelper.Info<DatabaseSchemaHelper>(string.Format("Start UninstallDataSchema {0}", version)); foreach (var item in orderedTables.OrderByDescending(x => x.Key)) { var tableNameAttribute = item.Value.FirstAttribute<TableNameAttribute>(); string tableName = tableNameAttribute == null ? item.Value.Name : tableNameAttribute.Value; LogHelper.Info<DatabaseSchemaHelper>("Uninstall" + tableName); try { if (database.TableExist(tableName)) { database.DropTable(tableName); } } catch (Exception ex) { //swallow this for now, not sure how best to handle this with diff databases... though this is internal // and only used for unit tests. If this fails its because the table doesn't exist... generally! LogHelper.Error<DatabaseSchemaHelper>("Could not drop table " + tableName, ex); } } }
private static List<StockMarket.Company> GetCurrentQuotes() { Dictionary<string, DateTime> files = new Dictionary<string, DateTime>(); string dir = ConfigurationManager.AppSettings["QuoteDirectory"]; if (!string.IsNullOrEmpty(dir)) { foreach (System.IO.FileInfo fi in new System.IO.DirectoryInfo(dir).GetFiles("AllQuotes_*")) { string[] nameParts = fi.FullName.Split('_'); if (nameParts != null && nameParts.Length > 1) { DateTime d = DateTime.Parse(nameParts[1]); if (d != null) { files.Add(fi.FullName, d); } } } string filename = files.OrderByDescending(f => f.Value).Select(f => f.Key).FirstOrDefault(); return filename.DeSerialze_Binary <List<StockMarket.Company>>().ToList(); } return new List<StockMarket.Company>(); }
static void Main() { string line = Console.ReadLine(); Dictionary<string, Dictionary<string, long>> countryData = new Dictionary<string, Dictionary<string, long>>(); while (line != "report") { string[] lineArgs = line.Split('|'); string city = lineArgs[0]; string country = lineArgs[1]; long population = long.Parse(lineArgs[2]); if (!countryData.ContainsKey(country)) { countryData.Add(country, new Dictionary<string, long>()); } countryData[country][city] = population; line = Console.ReadLine(); } var sorted = countryData.OrderByDescending(c => c.Value.Sum(s => s.Value)); foreach (var pair in sorted) { Console.WriteLine("{0} (total population: {1})", pair.Key, pair.Value.Sum(s => s.Value)); foreach (var innerPair in pair.Value.OrderByDescending(c => c.Value)) { Console.WriteLine("=>{0}: {1}", innerPair.Key, innerPair.Value); } } }
static void Main() { string[] words = File.ReadAllLines("../../words.txt"); Dictionary<string, int> dictionary = new Dictionary<string, int>(); using (StreamReader reader = new StreamReader("../../fileForScaning.txt")) { string line; while ((line = reader.ReadLine()) != null) { for (int i = 0; i < words.Length; i++) { string regex = @"\b" + words[i] + @"\b"; MatchCollection matches = Regex.Matches(line, regex,RegexOptions.IgnoreCase); if (dictionary.ContainsKey(words[i])) { dictionary[words[i]] += matches.Count; } else { dictionary.Add(words[i], matches.Count); } } } } using (StreamWriter writer = new StreamWriter("../../result.txt")) { foreach (var wordCount in dictionary.OrderByDescending(key => key.Value)) { writer.WriteLine("{0} - {1}", wordCount.Key, wordCount.Value); } Console.WriteLine("Count Complete - Please Check result.txt file!"); } }
public static Bitmap PopularityQuantization(Bitmap bmp, int colorsNr) { Dictionary<Color, int> colorDictionary = new Dictionary<Color, int>(); Color color; Bitmap result = new Bitmap(bmp.Width, bmp.Height); for(int i = 0; i < bmp.Width; ++i) for (int j = 0; j < bmp.Height; ++j) { color = bmp.GetPixel(i, j); if (!colorDictionary.ContainsKey(color)) colorDictionary.Add(color, 0); ++colorDictionary[color]; } KeyValuePair<Color, int>[] sortedColorsByFrequency = colorDictionary.OrderByDescending(f => f.Value).Take(colorsNr).ToArray(); Color[] availableColors = new Color[colorsNr]; int k = -1; foreach(var pair in sortedColorsByFrequency) availableColors[++k] = pair.Key; for (int i = 0; i < bmp.Width; ++i) for (int j = 0; j < bmp.Height; ++j) { color = FindClosestColor(availableColors, bmp.GetPixel(i, j)); result.SetPixel(i, j, color); } return result; }
public override IEnumerable<IEffectChoice> GetChoices() { var subtypes = new Dictionary<string, int>(); var cards = Controller.Opponent.Library.Concat(Controller.Opponent.Battlefield).Where(x => x.Is().Creature); foreach (var card in cards) { foreach (var subType in card.Subtypes) { if (!subtypes.ContainsKey(subType)) subtypes.Add(subType, 1); else { subtypes[subType]++; } } } if (subtypes.Count == 0) { subtypes["elf"] = 1; } _mostCommonType = subtypes.OrderByDescending(x => x.Value).First().Key; yield return new DiscreteEffectChoice(subtypes.Keys.ToArray()); }
private static void Main() { const string sentence = "This is some sentence."; var wordCounts = new Dictionary<char, int>(); foreach (char c in sentence) { if (!char.IsLetter(c)) { continue; } if (!wordCounts.ContainsKey(c)) { wordCounts.Add(c, 1); } else { wordCounts[c]++; } } IOrderedEnumerable<KeyValuePair<char, int>> orderedWordCounts = wordCounts.OrderByDescending(x => x.Value); foreach (var word in orderedWordCounts) { string timesString = word.Value > 0 ? "times" : "time"; Console.WriteLine("{0}: {1} {2}", word.Key, word.Value, timesString); } }
public static int FindMajorant(List<int> input) { int majorantMargin = input.Count / 2 + 1; Dictionary<int, int> valueCount = new Dictionary<int, int>(); for (int i = 0; i < input.Count; i++) { if (!valueCount.ContainsKey(input[i])) { valueCount[input[i]] = 1; } else { valueCount[input[i]]++; } if (valueCount[input[i]] > majorantMargin) { return input[i]; } } //handle case when there is no clear winner int majorant = valueCount.OrderByDescending(x => x.Value).Select(x => x.Key).First(); return majorant; }
static void Main() { Dictionary<string, Dictionary<string, int>> stats = new Dictionary<string, Dictionary<string, int>>(); string input; string pattern1 = @"^([A-Za-z]+\s*[A-Za-z]*)\s*\|\s*([A-Za-z]+[\s.'A-Za-z0-9-]*)"; while ((input = Console.ReadLine()) != "report") { Match playerData = Regex.Match(input, pattern1); string name = playerData.Groups[1].Value.Trim(); string country = playerData.Groups[2].Value.Trim(); name = Regex.Replace(name, @"\s+", " "); country = Regex.Replace(country, @"\s+", " "); if(!stats.ContainsKey(country)) stats.Add(country, new Dictionary<string, int>()); if (!stats[country].ContainsKey(name)) stats[country].Add(name, 1); else stats[country][name]++; } var sortedOutput = stats.OrderByDescending(x => x.Value.Skip(0).Sum(y => y.Value)); foreach (var country in sortedOutput) { Console.WriteLine("{0} ({1} participants): {2} wins", country.Key, country.Value.Count, country.Value.Skip(0).Sum(x => x.Value)); } }
static void Main(string[] args) { try { string fileSourcePath = "text.txt"; string fileResultPath = "result.txt"; string fileDictionaryPath = "words.txt"; Dictionary<string, int> dictionary = new Dictionary<string, int>(); using (StreamReader reader = new StreamReader(fileDictionaryPath, Encoding.GetEncoding("windows-1251"))) { while (!reader.EndOfStream) { string word = reader.ReadLine(); dictionary.Add(word, 0); } } using (StreamReader reader = new StreamReader(fileSourcePath, Encoding.GetEncoding("windows-1251"))) { while (!reader.EndOfStream) { string line = reader.ReadLine(); List<string> wordList = new List<string>(dictionary.Keys); foreach (string word in wordList) { string regex = String.Format("\\b{0}\\b", word); MatchCollection matches = Regex.Matches(line, regex); dictionary[word] += matches.Count; } } } using (StreamWriter writer = new StreamWriter(fileResultPath, false, Encoding.GetEncoding("windows-1251"))) { foreach (var wordCounter in dictionary.OrderByDescending(key => key.Value)) { writer.Write(wordCounter.Key); writer.Write("-"); writer.WriteLine(wordCounter.Value); } } } catch (ArgumentNullException) { Console.WriteLine("Path is null"); } catch (FileNotFoundException) { Console.WriteLine("File not found"); } catch (DirectoryNotFoundException) { Console.WriteLine("Directory not found"); } catch (IOException) { Console.WriteLine("IO exception"); } }
/// <summary> /// Given an input feature, a feature space and its associated labels, and a positive integer 'k', /// Determines the 'k' nearest neighbor label for the input feature. The 'k' value corresponds /// to the number of nearest neighbors to use in the voting process. /// /// <remarks> /// "When I have this grid of data points, and I provide one additional example row, find the 'k' number /// of rows that are most similar, count up the number of occurrences of each label for each row (1 to 'k'), /// and choose the label with the highest occurrence." /// </remarks> /// <see href="http://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm" /> /// </summary> /// <param name="distanceType">The type of equation to use when measuring the distance between each data point</param> /// <param name="input">The matrix row to input; must have the same number of columns as the feature space</param> /// <param name="featureSpace">The feature space matrix; everything we know</param> /// <param name="labels">The results for each feature space row; what we call each collection of data points</param> /// <param name="k">The number of nearest neighbors to include in the voting; the label with the most occurrences in 'k' neighbors wins</param> /// <returns></returns> public static string Classify(DistanceType distanceType, Number[] input, Matrix featureSpace, IList<string> labels, int k) { if (labels.Count() != featureSpace.Rows) { throw new ArgumentException("The number of labels must match the number of rows of data in the feature space", "labels"); } var distances = CalculateDistances(distanceType, featureSpace, input); var nearestNeighbors = distances.OrderByDescending(d => d.Value).Take(k); var votes = new Dictionary<string, int>(k); foreach (var label in nearestNeighbors.Select(neighbor => labels[neighbor.Key])) { if (votes.ContainsKey(label)) { votes[label]++; } else { votes.Add(label, 1); } } var nearest = votes.OrderByDescending(v => v.Value).First().Key; return nearest; }
private static Dictionary <string, int> GetWordRankList(List <string> words, ref Dictionary <string, int> globalRankList) { var dict = new Dictionary <string, int>(); int i; foreach (var w in words) { if (globalRankList != null) { globalRankList.TryGetValue(w, out i); globalRankList[w] = i + 1; } dict.TryGetValue(w, out i); dict[w] = i + 1; } globalRankList = globalRankList?.OrderByDescending(s => s.Value).ToDictionary(s => s.Key, s => s.Value); return(dict.OrderByDescending(s => s.Value).ToDictionary(s => s.Key, s => s.Value)); }
/// <summary> /// Inspect the array and return the most repeated /// </summary> /// <param name="pizzaChoice">The array to inspect</param> /// <param name="count">count to return</param> /// <returns>The most repeated Purchased objects</returns> public static List <string> GetMostPopular(PizzaChoice[] pizzaChoice, int count) { //creat a dictionary container Dictionary <PizzaChoice, int> purchCount = new Dictionary <PizzaChoice, int>(); foreach (PizzaChoice purch in pizzaChoice) { // add the count of each topping combination if (!purchCount.ContainsKey(purch)) { purchCount.Add(purch, 1); } else { purchCount[purch]++; } } // compile the results return(purchCount?.OrderByDescending(pc => pc.Value).Select(v => $"Toppings:{v.Key} ordered {v.Value} number of times").Take(count).ToList()); }
public string GetRandom(int seed = 0) { var temp = csv?.OrderByDescending(x => x.Key).ToList(); var adjustedGroups = new List <KeyValuePair <string, DateTime?> >(); var counter = 0; foreach (var item in temp) { counter++; for (var i = 0; i < counter; i++) { adjustedGroups.Add(item); } } var rand = new Random(seed); var num = rand.Next(0, adjustedGroups.Count - 1); var winner = adjustedGroups[num]; if (string.IsNullOrWhiteSpace(winner.Key)) { throw new Exception(); } return(winner.Key); }
// This decompiler is a test bed for our library, // don't expect to see any quality code in here public static void Main(string[] args) { Options = new Options(); CommandLine.Parser.Default.ParseArgumentsStrict(args, Options); Options.InputFile = Path.GetFullPath(Options.InputFile); if (Options.OutputFile != null) { Options.OutputFile = Path.GetFullPath(Options.OutputFile); Options.OutputFile = FixPathSlahes(Options.OutputFile); } var paths = new List <string>(); if (Directory.Exists(Options.InputFile)) { if (Options.OutputFile != null && File.Exists(Options.OutputFile)) { Console.Error.WriteLine("Output path is an existing file, but input is a folder."); return; } paths.AddRange(Directory.GetFiles(Options.InputFile, "*.*_c", Options.RecursiveSearch ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)); } else if (File.Exists(Options.InputFile)) { Options.RecursiveSearch = false; paths.Add(Options.InputFile); } if (paths.Count == 0) { Console.Error.WriteLine("No such file \"{0}\" or directory is empty. Did you mean to include --recursive parameter?", Options.InputFile); return; } CurrentFile = 0; TotalFiles = paths.Count; if (Options.MaxParallelismThreads > 1) { Console.WriteLine("Will use {0} threads concurrently.", Options.MaxParallelismThreads); Parallel.ForEach(paths, new ParallelOptions { MaxDegreeOfParallelism = Options.MaxParallelismThreads }, (path, state) => { ProcessFile(path); }); } else { foreach (var path in paths) { ProcessFile(path); } } if (Options.CollectStats) { Console.WriteLine(); Console.WriteLine("Processed resource stats:"); foreach (var stat in stats.OrderByDescending(x => x.Value.Count).ThenBy(x => x.Key)) { Console.WriteLine("{0,5} resources of version {2} and type {1}{3}", stat.Value.Count, stat.Value.Type, stat.Value.Version, stat.Value.Info != "" ? string.Format(" ({0})", stat.Value.Info) : "" ); } Console.WriteLine(); Console.WriteLine("Unique special dependancies:"); foreach (var stat in uniqueSpecialDependancies) { Console.WriteLine("{0} in {1}", stat.Key, stat.Value); } } }
static void Main(string[] args) { var participants = new Dictionary <string, int>(); var submissions = new Dictionary <string, int>(); var line = Console.ReadLine() .Split("-", StringSplitOptions.RemoveEmptyEntries); while (line[0] != "exam finished") { var name = line[0]; if (line[1] == "banned") { participants.Remove(name); } else { var language = line[1]; var points = int.Parse(line[2]); if (participants.ContainsKey(name) == false) { participants[name] = points; if (submissions.ContainsKey(language) == false) { submissions[language] = 1; } else { submissions[language]++; } } else { if (participants[name] < points) { participants[name] = points; submissions[language]++; } else { if (submissions.ContainsKey(language) == false) { submissions[language] = 1; } else { submissions[language]++; } } } } line = Console.ReadLine() .Split("-", StringSplitOptions.RemoveEmptyEntries); } Console.WriteLine("Results:"); foreach (var name in participants.OrderByDescending(n => n.Value).ThenBy(v => v.Key)) { Console.WriteLine($"{name.Key} | {name.Value}"); } Console.WriteLine("Submissions:"); foreach (var sub in submissions.OrderByDescending(s => s.Value).ThenBy(l => l.Key)) { Console.WriteLine($"{sub.Key} - {sub.Value}"); } }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> protected virtual void PopulateMigrations( IEnumerable <string> appliedMigrationEntries, string targetMigration, out IReadOnlyList <Migration> migrationsToApply, out IReadOnlyList <Migration> migrationsToRevert, out Migration actualTargetMigration) { var appliedMigrations = new Dictionary <string, TypeInfo>(); var unappliedMigrations = new Dictionary <string, TypeInfo>(); var appliedMigrationEntrySet = new HashSet <string>(appliedMigrationEntries, StringComparer.OrdinalIgnoreCase); if (_migrationsAssembly.Migrations.Count == 0) { _logger.MigrationsNotFound(this, _migrationsAssembly); } foreach (var migration in _migrationsAssembly.Migrations) { if (appliedMigrationEntrySet.Contains(migration.Key)) { appliedMigrations.Add(migration.Key, migration.Value); } else { unappliedMigrations.Add(migration.Key, migration.Value); } } if (string.IsNullOrEmpty(targetMigration)) { migrationsToApply = unappliedMigrations .OrderBy(m => m.Key) .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider)) .ToList(); migrationsToRevert = Array.Empty <Migration>(); actualTargetMigration = null; } else if (targetMigration == Migration.InitialDatabase) { migrationsToApply = Array.Empty <Migration>(); migrationsToRevert = appliedMigrations .OrderByDescending(m => m.Key) .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider)) .ToList(); actualTargetMigration = null; } else { targetMigration = _migrationsAssembly.GetMigrationId(targetMigration); migrationsToApply = unappliedMigrations .Where(m => string.Compare(m.Key, targetMigration, StringComparison.OrdinalIgnoreCase) <= 0) .OrderBy(m => m.Key) .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider)) .ToList(); migrationsToRevert = appliedMigrations .Where(m => string.Compare(m.Key, targetMigration, StringComparison.OrdinalIgnoreCase) > 0) .OrderByDescending(m => m.Key) .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider)) .ToList(); actualTargetMigration = appliedMigrations .Where(m => string.Compare(m.Key, targetMigration, StringComparison.OrdinalIgnoreCase) == 0) .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider)) .SingleOrDefault(); } }
static void Main(string[] args) { string input = Console.ReadLine(); string sidePatern = " | "; string userPatern = " -> "; var result = new Dictionary <string, List <string> >(); var saveAllUsers = new List <string>(); while (input != "Lumpawaroo") { if (input.Contains(sidePatern)) { string[] tokens = input .Split(new string[] { " | " }, StringSplitOptions.RemoveEmptyEntries) .ToArray(); string forseSide = tokens[0]; if (!result.ContainsKey(forseSide)) { result.Add(forseSide, new List <string>()); } string forseUser = tokens[1]; if (!saveAllUsers.Contains(forseUser)) { result[forseSide].Add(forseUser); saveAllUsers.Add(forseUser); } } else if (input.Contains(userPatern)) { string[] tokens = input .Split(new string[] { " -> " }, StringSplitOptions.RemoveEmptyEntries) .ToArray(); string forseSide = tokens[1]; string forseUser = tokens[0]; if (!result.ContainsKey(forseSide)) { result.Add(forseSide, new List <string>()); } if (saveAllUsers.Contains(forseUser)) { string getKey = GetKey(result, forseUser); result[getKey].Remove(forseUser); } result[forseSide].Add(forseUser); Console.WriteLine($"{forseUser} joins the {forseSide} side!"); } input = Console.ReadLine(); } result = result.Where(x => x.Value.Count > 0).ToDictionary(k => k.Key, v => v.Value); foreach (var datas in result.OrderByDescending(x => x.Value.Count).ThenBy(x => x.Key)) { string side = datas.Key; var users = datas.Value; Console.WriteLine($" Side: {side}, Members: {users.Count}"); foreach (var user in users.OrderBy(x => x)) { Console.WriteLine($"! {user}"); } } }
// Driver public void Go() { // Input keys (use only 'a' // through 'z' and lower case) string rline; // Read the file and display it line by line. System.IO.StreamReader file = new System.IO.StreamReader("words.txt"); List <String> keys = new List <string>(); while ((rline = file.ReadLine()) != null) { keys.Add(rline); } //using (System.IO.StreamWriter file2 = new System.IO.StreamWriter(@"C:\Users\Brett\Desktop\dict.txt")) //{ // while ((rline = file.ReadLine()) != null) // { // keys.Add(rline); // if (!rline.Contains("&")) // { // file2.WriteLine(rline.ToLower()); // } // } //} root = new TrieNode(); // Construct trie int i; for (i = 0; i < keys.Count; i++) { insert(keys[i]); } //keys = null; string line = ""; found = new Dictionary <string, int>(); do { //read a complete line char c = Console.ReadKey().KeyChar; found.Clear(); //check if line is empty or not if (c == '\r') { addWeight(line); Console.Clear(); Console.WriteLine("Searching: "); line = ""; } else if (Char.IsLetter(c)) { line += c.ToString(); searchAll(line); var test = found; Console.Clear(); Console.WriteLine("Searching: " + line); Console.WriteLine(found.Count + " found"); int count = 0; foreach (var item in found.OrderByDescending(x => x.Value)) { if (count == 20) { break; } string ln = item.Key; if (item.Value > 0) { ln += " (suggested)"; } Console.WriteLine(ln); count++; } //Console.Write("Line was = " + line); } } while (line != null); }
public static object Answer(string[] inputs) { List <(DateTime TimeStamp, string Information)> guards_records = new List <(DateTime TimeStamp, string Information)>(); foreach (var timestamp in inputs) { string ts_str = timestamp.Substring(1, 16); string infos = timestamp.Substring(19, timestamp.Length - 19); DateTime ts = DateTime.ParseExact(ts_str, "yyyy-MM-dd HH:mm", System.Globalization.CultureInfo.InvariantCulture); guards_records.Add((ts, infos)); } guards_records = guards_records.OrderBy(x => x.TimeStamp).ToList(); int guard = 0; DateTime asleepStart = new DateTime(); Dictionary <int, List <DateTime> > SleepyGuards = new Dictionary <int, List <DateTime> >(); foreach (var(TimeStamp, Information) in guards_records) { if (IsWakingUp(Information)) { TimeSpan span = TimeStamp.Subtract(asleepStart); for (int i = 0; i < span.TotalMinutes; i++) { if (SleepyGuards.ContainsKey(guard)) { SleepyGuards[guard].Add(asleepStart.AddMinutes(i)); } else { SleepyGuards.Add(guard, new List <DateTime>() { asleepStart.AddMinutes(i) }); } } continue; } if (IsFallingAsleep(Information)) { asleepStart = TimeStamp; continue; } if (IsBeginningShift(Information)) { guard = GetGuardID(Information); continue; } } var sleepiestGuard = SleepyGuards.OrderByDescending(i => i.Value.Count()).FirstOrDefault(); var sleepiestGuardGrouped = sleepiestGuard.Value.GroupBy(x => x.Minute).ToList() .OrderByDescending(x => x.Count()) .FirstOrDefault(); var partTwoAnswer = PartTwo(SleepyGuards); return($"Part 1 : Guard #{sleepiestGuard.Key} likes to sleep at {sleepiestGuardGrouped.Key} min " + $": {sleepiestGuard.Key} x {sleepiestGuardGrouped.Key} = {sleepiestGuard.Key * sleepiestGuardGrouped.Key} \n{partTwoAnswer}"); }
static void Main(string[] args) { string[] participants = Console.ReadLine() .Split(',') .Select(n => n.Trim()) .ToArray(); string[] songs = Console.ReadLine() .Split(',') .Select(n => n.Trim()) .ToArray(); var participantAwardsDict = new Dictionary <string, HashSet <string> >(); string inputLine = Console.ReadLine(); while (inputLine != "dawn") { string[] inputParameters = inputLine .Split(',') .Select(n => n.Trim()) .ToArray(); string participant = inputParameters[0]; string song = inputParameters[1]; string award = inputParameters[2]; if (songs.Contains(song) && participants.Contains(participant)) { if (!participantAwardsDict.ContainsKey(participant)) { participantAwardsDict[participant] = new HashSet <string>(); } participantAwardsDict[participant].Add(award); } inputLine = Console.ReadLine(); } if (!participantAwardsDict.Any()) { Console.WriteLine("No awards"); } else { participantAwardsDict = participantAwardsDict .OrderByDescending(n => n.Value.Count) .ThenBy(n => n.Key) .ToDictionary(n => n.Key, n => n.Value); foreach (var participantAwardPair in participantAwardsDict) { string participant = participantAwardPair.Key; HashSet <string> awards = participantAwardPair.Value; Console.WriteLine($"{participant}: {awards.Count} awards"); foreach (var award in awards.OrderBy(a => a)) { Console.WriteLine($"--{award}"); } } } }
static void Main(string[] args) { string comand = Console.ReadLine(); Dictionary <string, Dictionary <string, int> > trains = new Dictionary <string, Dictionary <string, int> >(); while (comand != "It's Training Men!") { string[] info = comand.Split(' '); if (info.Length == 5) { string name = info[0]; string wagon = info[2]; int power = int.Parse(info[4]); if (!trains.ContainsKey(name)) { Dictionary <string, int> current = new Dictionary <string, int>(); current.Add(wagon, power); trains.Add(name, current); } else { if (!trains[name].ContainsKey(wagon)) { trains[name].Add(wagon, power); } } } else if (info[1] == "->") { string firs = info[0]; string other = info[2]; if (!trains.ContainsKey(firs)) { Dictionary <string, int> current = new Dictionary <string, int>(); trains.Add(firs, current); } foreach (var pair in trains[other]) { trains[firs].Add(pair.Key, pair.Value); } trains.Remove(other); } else { string firs = info[0]; string other = info[2]; if (!trains.ContainsKey(firs)) { Dictionary <string, int> current = new Dictionary <string, int>(); trains.Add(firs, current); } trains[firs].Clear(); foreach (var pair in trains[other]) { trains[firs].Add(pair.Key, pair.Value); } } comand = Console.ReadLine(); } foreach (var train in trains.OrderByDescending(x => x.Value.Values.Sum()).ThenBy(x => x.Value.Values.Count)) { Console.WriteLine($"Train: {train.Key}"); foreach (var item in train.Value.OrderByDescending(x => x.Value)) { Console.WriteLine($"###{item.Key} - {item.Value}"); } } }
public List <string> GetAnchorWords(int N) { StringBuilder sbAllWords = new StringBuilder(); foreach (children child in children) { sbAllWords.Append(child.SubtreeText); sbAllWords.Append(" "); } string[] allWords = GetAllWords(sbAllWords.ToString()); Dictionary <string, string> stemParentDictionary = GetStemParentDictionary(allWords); List <string> anchorWords = new List <string>(); children rootNode = new children(); List <HashSet <int> > rootChildIDs = new List <HashSet <int> >(); foreach (children child in children) { GetChildIDHashSetList(child); HashSet <int> currChildIDs = new HashSet <int>(); currChildIDs.Add(child.id); foreach (var item in child.ChildIDList) { currChildIDs.UnionWith(item); } rootChildIDs.Add(currChildIDs); } rootNode.ChildIDList = rootChildIDs; NodeList = new List <children>(); NodeList.Add(rootNode); foreach (children child in children) { PopulateNodeList(child); } Dictionary <string, HashSet <int> > wordIDMapping = GetWordIDMapping(); //Dictionary<string, double> WordTreeScore = new Dictionary<string, double>(); Dictionary <string, List <children> > WordLCAList = new Dictionary <string, List <children> >(); foreach (var kvp in wordIDMapping) { List <children> currLCAList = new List <children>(); int numLCAs = 0; foreach (children node in NodeList) { int numBranchesWithWord = 0; foreach (var childIDBranch in node.ChildIDList) { if (childIDBranch.Intersect(kvp.Value).Count() > 0) { numBranchesWithWord += 1; } } if ((numBranchesWithWord == 1 && node.ChildIDList.Count == 1) || numBranchesWithWord > 1) { currLCAList.Add(node); } } WordLCAList[stemParentDictionary.ContainsKey(kvp.Key)? stemParentDictionary[kvp.Key]:kvp.Key] = currLCAList; } anchorWords = WordLCAList .OrderByDescending(x => x.Value.Count) .Select(x => x.Key) .Where(y => CommonWords.GetFrequency(y) < 20) .Where(z => !(z.EndsWith("n't") || z.EndsWith("'m") || (z.EndsWith("'ll")) || (z.EndsWith("'d")) || z.EndsWith("'ve") || z.EndsWith("'re") || z.EndsWith("'s"))) .Take(N) .ToList(); return(anchorWords); }
public static void Main() { int boardSize = int.Parse(Console.ReadLine()); char[,] chessBoard = new char[boardSize, boardSize]; FillInTheBoard(chessBoard, boardSize); List <int[]> possibleMoves = new List <int[]> { new[] { -1, -2 }, new[] { -1, 2 }, new[] { 1, -2 }, new[] { 1, 2 }, new[] { -2, -1 }, new[] { -2, 1 }, new[] { 2, -1 }, new[] { 2, 1 } }; Dictionary <string, int> attackingKinghts = CollectAttackingKnights(chessBoard, possibleMoves); int removedKnights = 0; while (attackingKinghts.Count > 0) { KeyValuePair <string, int> mostDangerousKnight = attackingKinghts.OrderByDescending(x => x.Value).First(); int[] coordinates = mostDangerousKnight.Key .Split('|') .Select(int.Parse) .ToArray(); chessBoard[coordinates[0], coordinates[1]] = '0'; RemoveAttackingKnight(attackingKinghts, possibleMoves, coordinates); removedKnights++; } Console.WriteLine(removedKnights); }
public static void Main() { long bagCapacity = long.Parse(Console.ReadLine()); var input = Console.ReadLine().Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries); var sequence = new Queue <string>(input); var bagQuantites = new Dictionary <string, int>(); var bagItems = new Dictionary <string, Dictionary <string, int> >(); bagQuantites["Gold"] = 0; bagItems["Gold"] = new Dictionary <string, int>(); bagQuantites["Gem"] = 0; bagItems["Gem"] = new Dictionary <string, int>(); bagQuantites["Cash"] = 0; bagItems["Cash"] = new Dictionary <string, int>(); while (sequence.Count > 0) { var item = sequence.Dequeue(); var quantity = int.Parse(sequence.Dequeue()); if (bagQuantites.Sum(i => i.Value) + quantity > bagCapacity) { break; } if (item.Equals("gold", StringComparison.InvariantCultureIgnoreCase)) { bagQuantites["Gold"] += quantity; if (!bagItems["Gold"].ContainsKey("Gold")) { bagItems["Gold"]["Gold"] = 0; } bagItems["Gold"]["Gold"] += quantity; } else if (item.Length == 3) { if (bagQuantites["Cash"] + quantity <= bagQuantites["Gem"]) { bagQuantites["Cash"] += quantity; bagItems["Cash"].Add(item, quantity); } } else if (item.ToLower().Contains("gem")) { if (bagQuantites["Gem"] + quantity <= bagQuantites["Gold"]) { bagQuantites["Gem"] += quantity; bagItems["Gem"].Add(item, quantity); } } } foreach (var kvp in bagQuantites.OrderByDescending(i => i.Value)) { if (kvp.Value > 0) { Console.WriteLine($"<{kvp.Key}> ${kvp.Value}"); foreach (var item in bagItems[kvp.Key].OrderByDescending(i => i.Key).ThenBy(i => i.Value)) { var itemName = kvp.Key.Equals("gold", StringComparison.InvariantCultureIgnoreCase) ? "Gold" : item.Key; Console.WriteLine($"##{itemName} - {item.Value}"); } } } }
static void Main(string[] args) { Dictionary <string, Dictionary <string, int> > boys = new Dictionary <string, Dictionary <string, int> >(); string command = Console.ReadLine(); while (command != "Make a decision already!") { string[] info = command.Split(' '); if (command.EndsWith("does Gyubek!")) { string name = command.Substring(0, command.IndexOf(' ')); if (boys.ContainsKey(name)) { if (boys[name].Values.Any(x => x > 0)) { boys[name].Clear(); } } } else { string name = info[0]; string trait = info[1]; int value = int.Parse(info[2]); if (!boys.ContainsKey(name)) { Dictionary <string, int> current = new Dictionary <string, int>(); int newValue = GetChange(trait, value); current.Add(trait, newValue); boys.Add(name, current); } else { if (!boys[name].ContainsKey(trait)) { int newValue = GetChange(trait, value); boys[name].Add(trait, newValue); } else { if (boys[name][trait] < value) { boys[name][trait] = GetChange(trait, value); } } } } command = Console.ReadLine(); } foreach (var pair in boys.OrderByDescending(x => x.Value.Values.Sum()).ThenBy(x => x.Key)) { Console.WriteLine("# {0}: {1}", pair.Key, pair.Value.Values.Sum()); foreach (var item in pair.Value.OrderByDescending(x => x.Value)) { Console.WriteLine("!!! {0} -> {1}", item.Key, item.Value); } } Console.WriteLine(); }
private void btnRandomNumberRatios_Click(object sender, RoutedEventArgs e) { //here we are initilizating the variable. until here it is null dicNumbers = new Dictionary <int, int>(); Random myrandGenerator = new Random(); for (int i = 0; i < 1000000; i++) { //this will generate a random number between 1 and 101 [1,2,3,4...100] int irMyRandNumber = myrandGenerator.Next(1, 101); if (dicNumbers.ContainsKey(irMyRandNumber)) { dicNumbers[irMyRandNumber]++; // equals to dicNumbers[irMyRandNumber] = dicNumbers[irMyRandNumber]+1; // equals to dicNumbers[irMyRandNumber]+=1; } else { dicNumbers.Add(irMyRandNumber, 1); } } dicNumbers = dicNumbers.OrderBy(pr => pr.Key).ToDictionary(pr => pr.Key, pr => pr.Value); Dictionary <int, int> dicBigToSmall = dicNumbers.OrderByDescending(pr => pr.Key).ToDictionary(pr => pr.Key, pr => pr.Value); File.WriteAllLines("ordered by ascending.txt", dicNumbers.Select(pr => pr.Key + "\t" + pr.Value)); using (StreamWriter swWrite = new StreamWriter("ordered by ascending 2.txt")) { foreach (var vrKeyAndValue in dicNumbers) { swWrite.WriteLine(vrKeyAndValue.Key + "\t" + vrKeyAndValue.Value); } } File.Delete("ordered by ascending 3.txt"); var vrNumbersList = dicNumbers.ToList(); for (int i = 0; i < dicNumbers.Count; i++) { File.AppendAllText("ordered by ascending 3.txt", vrNumbersList[i].Key + "\t" + vrNumbersList[i].Value + Environment.NewLine); } Dictionary <int, int> ReaderDict = new Dictionary <int, int>(); using (StreamReader swRead = new StreamReader("ordered by ascending.txt")) { while (true) { var vrLine = swRead.ReadLine(); if (vrLine == null) { break; } string srKeyLine = vrLine.Split('\t').First(); //string srKeyLine = vrLine.Split('\t')[0]; string srValueLine = vrLine.Split('\t').Last(); //string srValueLine = vrLine.Split('\t')[1]; int irKey = Convert.ToInt32(srKeyLine); //int irKey = Int32.Parse(srKeyLine); int irVal = Convert.ToInt32(srValueLine); ReaderDict.Add(irKey, irVal); } } ReaderDict = new Dictionary <int, int>(); foreach (var vrLine in File.ReadLines("ordered by ascending.txt")) { string srKeyLine = vrLine.Split('\t').First(); string srValueLine = vrLine.Split('\t').Last(); int irKey = Convert.ToInt32(srKeyLine); int irVal = Convert.ToInt32(srValueLine); ReaderDict.Add(irKey, irVal); } }
static void Main(string[] args) { string[] keyMaterialsNames = new string[] { "shards", "fragments", "motes" }; string itemObtained = string.Empty; bool obtained = false; Dictionary <string, long> keyMaterials = new Dictionary <string, long>(); Dictionary <string, long> junk = new Dictionary <string, long>(); keyMaterials["shards"] = 0; keyMaterials["fragments"] = 0; keyMaterials["motes"] = 0; while (!obtained) { string[] inputArgs = Console.ReadLine() .Split(' ', StringSplitOptions.RemoveEmptyEntries) .ToArray(); for (int i = 0; i < inputArgs.Length; i += 2) { long qty = long.Parse(inputArgs[i]); string material = inputArgs[i + 1].ToLower(); if (keyMaterialsNames.Contains(material)) { keyMaterials[material] += qty; if (keyMaterials.Any(m => m.Value >= 250)) { if (material == "shards") { itemObtained = "Shadowmourne"; } else if (material == "fragments") { itemObtained = "Valanyr"; } else { itemObtained = "Dragonwrath"; } keyMaterials[material] -= 250; obtained = true; break; } } else { AddJunk(junk, qty, material); } } } Console.WriteLine($"{itemObtained} obtained!"); keyMaterials = keyMaterials .OrderByDescending(kvp => kvp.Value) .ThenBy(kvp => kvp.Key) .ToDictionary(a => a.Key, b => b.Value); foreach (var kvp in keyMaterials) { Console.WriteLine($"{kvp.Key}: {kvp.Value}"); } junk = junk .OrderBy(kvp => kvp.Key) .ToDictionary(a => a.Key, b => b.Value); foreach (var kvp in junk) { Console.WriteLine($"{kvp.Key}: {kvp.Value}"); } }
static void Main(string[] args) { Dictionary <string, int> materials = new Dictionary <string, int>(); materials["shards"] = 0; materials["fragments"] = 0; materials["motes"] = 0; Dictionary <string, int> junk = new Dictionary <string, int>(); string input = Console.ReadLine().ToLower(); Regex patter = new Regex(@"(([0-9]+)(?:\s)([\w-]+))"); string legendary = string.Empty; while (true) { MatchCollection matches = patter.Matches(input); bool found = false; foreach (Match match in matches) { int quantity = int.Parse(match.Groups[2].Value); string material = match.Groups[3].Value; if (materials.ContainsKey(material)) { materials[material] += quantity; } else if (!junk.ContainsKey(material)) { junk.Add(material, quantity); } else { junk[material] += quantity; } if (materials["shards"] >= 250 || materials["fragments"] >= 250 || materials["motes"] >= 250) { legendary = material.Equals("shards") ? "Shadowmourne" : material.Equals("fragments") ? "Valanyr" : "Dragonwrath"; materials[material] -= 250; found = true; break; } } if (found) { break; } input = Console.ReadLine().ToLower(); } Console.WriteLine("{0} obtained!", legendary); foreach (KeyValuePair <string, int> item in materials.OrderByDescending(x => x.Value) .ThenBy(x => x.Key)) { Console.WriteLine("{0}: {1}" , item.Key , item.Value); } foreach (KeyValuePair <string, int> item in junk.OrderBy(x => x.Key)) { Console.WriteLine("{0}: {1}" , item.Key , item.Value); } }
static void Main(string[] args) { var dict = new Dictionary <string, Dictionary <string, int> >(); var name = ""; var otherName = ""; var role = ""; var stats = 0; var statsToRemember = 0; var allRoles = ""; while (true) { string[] input = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); if (input[0] == "Ave") { break; } if (input.Length == 5) { name = input[0]; role = input[2]; allRoles += role + " "; stats = int.Parse(input[4]); statsToRemember = stats; if (!dict.ContainsKey(name)) { dict.Add(name, new Dictionary <string, int>()); } dict[name].Add(role, stats); if (dict[name].ContainsKey(role)) { if (stats > statsToRemember) { dict[name][role] = stats; } } } else { name = input[0]; otherName = input[2]; if (dict.ContainsKey(name) && dict.ContainsKey(otherName)) { if (dict.Keys.Contains(otherName)) { var nameOneBool = false; var roleToFight = ""; var splittedRoles = allRoles.Split(); for (int i = 0; i < splittedRoles.Length; i++) { if (dict[name].ContainsKey(splittedRoles[i]) && dict[otherName].ContainsKey(splittedRoles[i])) { nameOneBool = true; roleToFight = splittedRoles[i]; } } if (nameOneBool && dict[name][roleToFight] > dict[otherName][roleToFight]) { dict.Remove(otherName); } else if (nameOneBool && dict[name][roleToFight] < dict[otherName][roleToFight]) { dict.Remove(name); } } } } } foreach (var item in dict.OrderByDescending(x => x.Value.Values.Sum()).ThenBy(x => x.Key)) { Console.WriteLine($"{item.Key}: {item.Value.Values.Sum()} skill"); foreach (var kvp in item.Value.OrderByDescending(x => x.Value).ThenBy(x => x.Key)) { Console.WriteLine($"- {kvp.Key} <!> {kvp.Value}"); } } }
static void Main(string[] args) { int n = int.Parse(Console.ReadLine()); Dictionary <string, List <int> > heroes = new Dictionary <string, List <int> >(); for (int i = 0; i < n; i++) { string[] insertHeroes = Console.ReadLine().Split(); heroes.Add(insertHeroes[0], new List <int>()); heroes[insertHeroes[0]].Add(int.Parse(insertHeroes[1])); heroes[insertHeroes[0]].Add(int.Parse(insertHeroes[2])); } string[] cmdArgs = Console.ReadLine().Split(" - "); while (cmdArgs[0] != "End") { string command = cmdArgs[0]; string heroName = cmdArgs[1]; int heroHP = heroes[heroName][0]; int heroMP = heroes[heroName][1]; if (command == "CastSpell") { int mpNeeded = int.Parse(cmdArgs[2]); string spellName = cmdArgs[3]; if (heroes.ContainsKey(heroName)) { if (heroMP >= mpNeeded) { heroes[heroName][1] -= mpNeeded; Console.WriteLine($"{heroName} has successfully cast {spellName} and now has {heroes[heroName][1]} MP!"); } else { Console.WriteLine($"{heroName} does not have enough MP to cast {spellName}!"); } } } else if (command == "TakeDamage") { int damage = int.Parse(cmdArgs[2]); string attacker = cmdArgs[3]; heroes[heroName][0] -= damage; if (heroes[heroName][0] > 0) { Console.WriteLine($"{heroName} was hit for {damage} HP by {attacker} and now has {heroes[heroName][0]} HP left!"); } else { heroes.Remove(heroName); Console.WriteLine($"{heroName} has been killed by {attacker}!"); } } else if (command == "Recharge") { int amount = int.Parse(cmdArgs[2]); heroes[heroName][1] += amount; if (heroes[heroName][1] > 200) { int rechargedFor = amount - (heroes[heroName][1] - 200); Console.WriteLine($"{heroName} recharged for {rechargedFor} MP!"); heroes[heroName][1] = 200; } else { Console.WriteLine($"{heroName} recharged for {amount} MP!"); } } else if (command == "Heal") { int amount = int.Parse(cmdArgs[2]); heroes[heroName][0] += amount; if (heroes[heroName][0] > 100) { int healedFor = amount - (heroes[heroName][0] - 100); Console.WriteLine($"{heroName} healed for {healedFor} HP!"); heroes[heroName][0] = 100; } else { Console.WriteLine($"{heroName} healed for {amount} HP!"); } } cmdArgs = Console.ReadLine().Split(" - "); } foreach (var item in heroes.OrderByDescending(h => h.Value[0]).ThenBy(h => h.Key)) { Console.WriteLine($"{item.Key}"); Console.WriteLine($" HP: {item.Value[0]}"); Console.WriteLine($" MP: {item.Value[1]}"); } }
static void Main(string[] args) { var teams = new Dictionary <string, List <long> >(); string key = Console.ReadLine(); string command = Console.ReadLine(); while (command != "final") { string[] tokens = command .Split(' '); string teamA = tokens[0]; int startIndex = teamA.IndexOf(key); int endIndex = teamA.LastIndexOf(key); string homeTeam = teamA .Substring(startIndex + key.Length, endIndex - startIndex - key.Length); char[] homeTeamArray = homeTeam.ToUpper().ToCharArray(); Array.Reverse(homeTeamArray); homeTeam = new string(homeTeamArray); string teamB = tokens[1]; startIndex = teamB.IndexOf(key); endIndex = teamB.LastIndexOf(key); string awayTeam = teamB .Substring(startIndex + key.Length, endIndex - startIndex - key.Length); char[] awayTeamArray = awayTeam.ToUpper().ToCharArray(); Array.Reverse(awayTeamArray); awayTeam = new string(awayTeamArray); long[] goals = tokens[2] .Split(':') .Select(long.Parse) .ToArray(); long homeTeamGoals = goals[0]; long awayTeamGoals = goals[1]; long pointsForHomeTeam; long pointsForAwayTeam; if (homeTeamGoals > awayTeamGoals) { pointsForHomeTeam = 3; pointsForAwayTeam = 0; } else if (homeTeamGoals < awayTeamGoals) { pointsForHomeTeam = 0; pointsForAwayTeam = 3; } else { pointsForHomeTeam = 1; pointsForAwayTeam = 1; } if (teams.ContainsKey(homeTeam)) { teams[homeTeam][0] += pointsForHomeTeam; teams[homeTeam][1] += homeTeamGoals; } else { teams[homeTeam] = new List <long>(); teams[homeTeam].Add(pointsForHomeTeam); teams[homeTeam].Add(homeTeamGoals); } if (teams.ContainsKey(awayTeam)) { teams[awayTeam][0] += pointsForAwayTeam; teams[awayTeam][1] += awayTeamGoals; } else { teams[awayTeam] = new List <long>(); teams[awayTeam].Add(pointsForAwayTeam); teams[awayTeam].Add(awayTeamGoals); } command = Console.ReadLine(); } Console.WriteLine("League standings:"); int count = 1; foreach (var pair in teams .OrderByDescending(x => x.Value[0]) .ThenBy(t => t.Key)) { string name = pair.Key; long points = pair.Value[0]; Console.WriteLine($"{count}. {name} {points}"); count++; } Console.WriteLine("Top 3 scored goals:"); foreach (var pair in teams .OrderByDescending(x => x.Value[1]) .ThenBy(x => x.Key) .Take(3)) { string name = pair.Key; long goals = pair.Value[1]; Console.WriteLine($"- {name} -> {goals}"); } }
static void Main(string[] args) { string legendaryItem = String.Empty; Dictionary <string, int> materials = new Dictionary <string, int>(); materials.Add("motes", 0); materials.Add("shards", 0); materials.Add("fragments", 0); Dictionary <string, int> junk = new Dictionary <string, int>(); while (materials["motes"] < 250 && materials["fragments"] < 250 && materials["shards"] < 250) { string input = Console.ReadLine().ToLower(); string[] inputTokens = input.Split(" "); for (int i = 0; i < inputTokens.Length; i += 2) { int quantity = int.Parse(inputTokens[i]); string material = inputTokens[i + 1]; switch (material) { case "shards": case "fragments": case "motes": materials[material] += quantity; break; default: if (!junk.ContainsKey(material)) { junk.Add(material, 0); } junk[material] += quantity; break; } if (materials["shards"] >= 250 || materials["fragments"] >= 250 || materials["motes"] >= 250) { break; } } } if (materials["shards"] >= 250) { legendaryItem = "Shadowmourne"; materials["shards"] -= 250; } else if (materials["fragments"] >= 250) { legendaryItem = "Valanyr"; materials["fragments"] -= 250; } else { legendaryItem = "Dragonwrath"; materials["motes"] -= 250; } Console.WriteLine($"{legendaryItem} obtained!"); foreach (var item in materials.OrderByDescending(entry => entry.Value).ThenBy(entry => entry.Key)) { Console.WriteLine($"{item.Key}: {item.Value}"); } foreach (var item in junk.OrderBy(entry => entry.Key)) { Console.WriteLine($"{item.Key}: {item.Value}"); } }
/// <remarks> /// This has just been copied with slight modification from PagesController and /// needs to be refactored. /// </remarks> public IEnumerable <PageSearchResult> Execute(SearchPagesQuery query, IExecutionContext executionContext) { if (string.IsNullOrWhiteSpace(query.Text)) { yield break; } var isAuthenticated = executionContext.UserContext.UserId.HasValue; // TODO: Search results should look at page titles as well as module content // Find any page versions that match by title // TODO: Ignore small words like 'of' and 'the' var titleMatchesPageVersions = _dbContext .Pages .Where(p => !p.IsDeleted && p.PageVersions.Any(pv => !pv.IsDeleted && isAuthenticated ? true : pv.WorkFlowStatusId == (int)WorkFlowStatus.Published) && !query.LocaleId.HasValue || p.LocaleId == query.LocaleId && p.PageTypeId == (int)PageType.Generic ) .Select(p => p.PageVersions .OrderByDescending(v => v.CreateDate) .First(pv => !pv.IsDeleted && isAuthenticated ? true : pv.WorkFlowStatusId == (int)WorkFlowStatus.Published) ) .ToList() .Where(v => v.Title.Contains(query.Text) || v.Title.ToLower().Split(new char[] { ' ' }).Intersect(query.Text.ToLower().Split(new char[] { ' ' })).Any() ) ; // TODO: Search should split the search term and lookup individual words as well (and rank them less strongly) // Get a list of ALL the page modules for live pages - we'll search through these for any matches var pageModules = _dbContext .PageVersionModules .Include(m => m.PageModuleType) .Where(m => !m.PageVersion.IsDeleted) .Where(m => !m.PageVersion.Page.IsDeleted) .Where(m => isAuthenticated ? true : m.PageVersion.WorkFlowStatusId == (int)WorkFlowStatus.Published) .Where(m => !query.LocaleId.HasValue || m.PageVersion.Page.LocaleId == query.LocaleId) .Where(m => m.PageVersion.Page.PageTypeId == (int)PageType.Generic) .ToList(); // This will store a list of matches for each module var matches = new Dictionary <PageVersionModule, List <string> >(); foreach (var pageModule in pageModules.Where(p => !string.IsNullOrEmpty(query.Text))) { var dataProvider = _moduleDisplayDataFactory.MapDisplayModel(pageModule.PageModuleType.FileName, pageModule, WorkFlowStatusQuery.Published); Type dataProviderType = dataProvider.GetType(); // If this module is searchable - ie there is content to search // TODO: Module Searching //if (dataProvider is ISearchable) //{ var props = dataProviderType.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(SearchableAttribute))); foreach (var prop in props) { string str = _htmlSanitizer.StripHtml(((string)prop.GetValue(dataProvider, null))); if (str.IndexOf(query.Text ?? "", StringComparison.InvariantCultureIgnoreCase) > -1) { if (!matches.ContainsKey(pageModule)) { matches[pageModule] = new List <string>(); } int index = str.ToLower().IndexOf(query.Text.ToLower()); int startIndex = index - 100; while (startIndex < 0) { startIndex++; } int length = (index - startIndex) + query.Text.Length + 100; while ((startIndex + length) > str.Length) { length--; } var matchStr = str.Substring(startIndex, length); // Stop the string at the last space if ((startIndex + length) < str.Length - 1 && matchStr.LastIndexOf(" ") > -1) { matchStr = matchStr.Substring(0, matchStr.LastIndexOf(" ")) + " …"; } // Stop the string at the first space if (startIndex > 0 && matchStr.IndexOf(" ") > -1) { matchStr = "… " + matchStr.Substring(matchStr.IndexOf(" ") + 1); } // Highlight the search term matchStr = Regex.Replace(matchStr, query.Text, @"<b>$0</b>", RegexOptions.IgnoreCase); matches[pageModule].Add(matchStr); } } //} } // This is a list of pageversions matches to the number of matches var pageVersionMatches = matches .OrderByDescending(m => m.Value.Count) .GroupBy(m => m.Key.PageVersion.PageVersionId) .ToDictionary( g => g.First().Key.PageVersion, g => g.First().Value.Select(m => (IHtmlString) new HtmlString(m)) ); // Add any pages matched by title to the list of matches foreach (var pageVersion in titleMatchesPageVersions) { if (!pageVersionMatches.ContainsKey(pageVersion)) { pageVersionMatches.Add(pageVersion, null); } } var searchResults = new List <PageSearchResult>(); var pageroutes = _queryExecutor.GetAll <PageRoute>(); foreach (var pageVersionMatch in pageVersionMatches .OrderByDescending(m => titleMatchesPageVersions.Contains(m.Key)) .ThenByDescending(m => m.Value == null ? 0 : m.Value.Count())) { var version = pageVersionMatch.Key; var route = pageroutes.SingleOrDefault(r => r.PageId == version.PageId); if (route != null) { var result = new PageSearchResult(); result.FoundText = pageVersionMatch.Value == null ? new HtmlString(version.MetaDescription) : pageVersionMatch.Value.First(); result.Title = version.Title; result.Url = route.FullPath; yield return(result); } } }
public void update(long counter) { var timeWarpFixedDeltaTime = TimeWarpFixedDeltaTime; IsUpdatedAtLeastOnce = true; Counter = counter; stored_supply = currentPowerSupply; stored_stable_supply = stable_supply; stored_resource_demand = current_resource_demand; stored_current_demand = current_resource_demand; stored_current_hp_demand = high_priority_resource_demand; stored_current_charge_demand = charge_resource_demand; stored_charge_demand = charge_resource_demand; stored_total_power_supplied = total_power_distributed; current_resource_demand = 0; high_priority_resource_demand = 0; charge_resource_demand = 0; total_power_distributed = 0; double availableResourceAmount; double maxResouceAmount; my_part.GetConnectedResourceTotals(resourceDefinition.id, out availableResourceAmount, out maxResouceAmount); //if (maxResouceAmount > 0 && !double.IsNaN(maxResouceAmount) && !double.IsNaN(availableResourceAmount)) // resource_bar_ratio = availableResourceAmount / maxResouceAmount; //else // resource_bar_ratio = 0.0001; double missingResourceAmount = maxResouceAmount - availableResourceAmount; currentPowerSupply += availableResourceAmount; double high_priority_demand_supply_ratio = high_priority_resource_demand > 0 ? Math.Min((currentPowerSupply - stored_current_charge_demand) / stored_current_hp_demand, 1.0) : 1.0; double demand_supply_ratio = stored_current_demand > 0 ? Math.Min((currentPowerSupply - stored_current_charge_demand - stored_current_hp_demand) / stored_current_demand, 1.0) : 1.0; //Prioritise supplying stock ElectricCharge resource if (resourceDefinition.id == megajouleResourceDefinition.id && stored_stable_supply > 0) { double amount; double maxAmount; my_part.GetConnectedResourceTotals(electricResourceDefinition.id, out amount, out maxAmount); double stock_electric_charge_needed = maxAmount - amount; double power_supplied = Math.Min(currentPowerSupply * 1000 * timeWarpFixedDeltaTime, stock_electric_charge_needed); if (stock_electric_charge_needed > 0) { var deltaResourceDemand = stock_electric_charge_needed / 1000 / timeWarpFixedDeltaTime; current_resource_demand += deltaResourceDemand; charge_resource_demand += deltaResourceDemand; } if (power_supplied > 0) { double fixed_provided_electric_charge_in_MW = my_part.RequestResource(ResourceManager.STOCK_RESOURCE_ELECTRICCHARGE, -power_supplied) / 1000; var provided_electric_charge_per_second = fixed_provided_electric_charge_in_MW / timeWarpFixedDeltaTime; total_power_distributed += -provided_electric_charge_per_second; currentPowerSupply += provided_electric_charge_per_second; } } power_supply_list_archive = power_produced.OrderByDescending(m => m.Value.maximumSupply).ToList(); // store current supply and update average power_supply_list_archive.ForEach(m => { Queue <double> queue; if (!power_produced_history.TryGetValue(m.Key, out queue)) { queue = new Queue <double>(10); power_produced_history.Add(m.Key, queue); } if (queue.Count > 10) { queue.Dequeue(); } queue.Enqueue(m.Value.currentSupply); m.Value.averageSupply = queue.Average(); }); List <KeyValuePair <IResourceSuppliable, PowerConsumption> > power_draw_items = power_consumption.OrderBy(m => m.Value.Power_draw).ToList(); power_draw_list_archive = power_draw_items.ToList(); power_draw_list_archive.Reverse(); // check priority 1 parts like reactors foreach (KeyValuePair <IResourceSuppliable, PowerConsumption> power_kvp in power_draw_items) { IResourceSuppliable resourceSuppliable = power_kvp.Key; if (resourceSuppliable.getPowerPriority() == 1) { double power = power_kvp.Value.Power_draw; current_resource_demand += power; high_priority_resource_demand += power; if (flow_type == FNRESOURCE_FLOWTYPE_EVEN) { power = power * high_priority_demand_supply_ratio; } double power_supplied = Math.Max(Math.Min(currentPowerSupply, power), 0.0); currentPowerSupply -= power_supplied; total_power_distributed += power_supplied; //notify of supply resourceSuppliable.receiveFNResource(power_supplied, this.resource_name); } } // check priority 2 parts like reactors foreach (KeyValuePair <IResourceSuppliable, PowerConsumption> power_kvp in power_draw_items) { IResourceSuppliable resourceSuppliable = power_kvp.Key; if (resourceSuppliable.getPowerPriority() == 2) { double power = power_kvp.Value.Power_draw; current_resource_demand += power; if (flow_type == FNRESOURCE_FLOWTYPE_EVEN) { power = power * demand_supply_ratio; } double power_supplied = Math.Max(Math.Min(currentPowerSupply, power), 0.0); currentPowerSupply -= power_supplied; total_power_distributed += power_supplied; //notify of supply resourceSuppliable.receiveFNResource(power_supplied, this.resource_name); } } // check priority 3 parts like engines and nuclear reactors foreach (KeyValuePair <IResourceSuppliable, PowerConsumption> power_kvp in power_draw_items) { IResourceSuppliable resourceSuppliable = power_kvp.Key; if (resourceSuppliable.getPowerPriority() == 3) { double power = power_kvp.Value.Power_draw; current_resource_demand += power; if (flow_type == FNRESOURCE_FLOWTYPE_EVEN) { power = power * demand_supply_ratio; } double power_supplied = Math.Max(Math.Min(currentPowerSupply, power), 0.0); currentPowerSupply -= power_supplied; total_power_distributed += power_supplied; //notify of supply resourceSuppliable.receiveFNResource(power_supplied, this.resource_name); } } // check priority 4 parts like antimatter reactors, engines and transmitters foreach (KeyValuePair <IResourceSuppliable, PowerConsumption> power_kvp in power_draw_items) { IResourceSuppliable resourceSuppliable = power_kvp.Key; if (resourceSuppliable.getPowerPriority() == 4) { double power = power_kvp.Value.Power_draw; current_resource_demand += power; if (flow_type == FNRESOURCE_FLOWTYPE_EVEN) { power = power * demand_supply_ratio; } double power_supplied = Math.Max(Math.Min(currentPowerSupply, power), 0.0); currentPowerSupply -= power_supplied; total_power_distributed += power_supplied; //notify of supply resourceSuppliable.receiveFNResource(power_supplied, this.resource_name); } } // check priority 5 parts and higher foreach (KeyValuePair <IResourceSuppliable, PowerConsumption> power_kvp in power_draw_items) { IResourceSuppliable resourceSuppliable = power_kvp.Key; if (resourceSuppliable.getPowerPriority() >= 5) { double power = power_kvp.Value.Power_draw; current_resource_demand += power; if (flow_type == FNRESOURCE_FLOWTYPE_EVEN) { power = power * demand_supply_ratio; } double power_supplied = Math.Max(Math.Min(currentPowerSupply, power), 0.0); currentPowerSupply -= power_supplied; total_power_distributed += power_supplied; //notify of supply resourceSuppliable.receiveFNResource(power_supplied, this.resource_name); } } // substract avaialble resource amount to get delta resource change currentPowerSupply -= Math.Max(availableResourceAmount, 0.0); internl_power_extract_fixed = -currentPowerSupply * timeWarpFixedDeltaTime; pluginSpecificImpl(); if (internl_power_extract_fixed > 0) { internl_power_extract_fixed = Math.Min(internl_power_extract_fixed, availableResourceAmount); } else { internl_power_extract_fixed = Math.Max(internl_power_extract_fixed, -missingResourceAmount); } my_part.RequestResource(resourceDefinition.id, internl_power_extract_fixed); my_part.GetConnectedResourceTotals(resourceDefinition.id, out availableResourceAmount, out maxResouceAmount); if (maxResouceAmount > 0 && !double.IsNaN(maxResouceAmount) && !double.IsNaN(availableResourceAmount)) { resource_bar_ratio = availableResourceAmount / maxResouceAmount; } else { resource_bar_ratio = 0.0001; } //calculate total input and output //var total_current_supplied = power_produced.Sum(m => m.Value.currentSupply); //var total_current_provided = power_produced.Sum(m => m.Value.currentProvided); //var total_power_consumed = power_consumption.Sum(m => m.Value.Power_consume); //var total_power_min_supplied = power_produced.Sum(m => m.Value.minimumSupply); ////generate wasteheat from used thermal power + thermal store //if (!CheatOptions.IgnoreMaxTemperature && total_current_produced > 0 && // (resourceDefinition.id == thermalpowerResourceDefinition.id || resourceDefinition.id == chargedpowerResourceDefinition.id)) //{ // var min_supplied_fixed = TimeWarp.fixedDeltaTime * total_power_min_supplied; // var used_or_stored_power_fixed = TimeWarp.fixedDeltaTime * Math.Min(total_power_consumed, total_current_produced) + Math.Max(-actual_stored_power, 0); // var wasteheat_produced_fixed = Math.Max(min_supplied_fixed, used_or_stored_power_fixed); // var effective_wasteheat_ratio = Math.Max(wasteheat_produced_fixed / (total_current_produced * TimeWarp.fixedDeltaTime), 1); // ORSResourceManager manager = ORSResourceOvermanager.getResourceOvermanagerForResource(ResourceManager.FNRESOURCE_WASTEHEAT).getManagerForVessel(my_vessel); // foreach (var supplier_key_value in power_produced) // { // if (supplier_key_value.Value.currentSupply > 0) // { // manager.powerSupplyPerSecondWithMax(supplier_key_value.Key, supplier_key_value.Value.currentSupply * effective_wasteheat_ratio, supplier_key_value.Value.maximumSupply * effective_wasteheat_ratio); // } // } //} currentPowerSupply = 0; stable_supply = 0; power_produced.Clear(); power_consumption.Clear(); }
static async Task Main() { // for (int x = 0; x < 16; x++) // { // for (int y = 0; y < 16; y++) // { // var code = x * 16 + y; // Console.Write($"{Color(code)}{code:000}"); // } // Console.WriteLine(); // } // Console.ReadLine(); Console.OutputEncoding = Encoding.UTF8; Console.InputEncoding = Encoding.UTF8; Device = FindDevice(); try { await MonitoringMode(true); Console.WriteLine($"-- Listening on { Device.Name}, hit 'Enter' to stop..."); var sb = new StringBuilder(); var probes = new Dictionary <CacheEntry, string>(); var aps = new List <CacheEntry>(); Console.Clear(); while (true) { //Console.Clear(); sb.Clear(); aps.Clear(); probes.Clear(); foreach (var kvp in BeaconCache.Cache) { foreach (var entry in kvp.Value) { if (DateTime.Now - entry.LastSeen < TimeSpan.FromMinutes(5)) { aps.Add(entry); } } } foreach (var kvp in ProbeCache.Cache) { var first = kvp.Value.FirstOrDefault(); if (DateTime.Now - first.LastSeen > TimeSpan.FromMinutes(5)) { continue; } var ssids = ""; foreach (var entry in kvp.Value) { ssids += entry.SSID + ", "; } probes.TryAdd(first, ssids); } sb.AppendLine("############################# PROBES #########################################"); sb.AppendLine($"| Last seen | Count | Signal | MAC |"); foreach (var kvp in probes.OrderByDescending(p => p.Key.SignalStrength)) { var a = kvp.Key.LastSeen.ToString("HH:mm:ss"); var b = $"{kvp.Key.SeenTimes:000}"; var c = $"{kvp.Key.SignalStrength:000}"; var d = kvp.Key.MAC; var e = kvp.Value; var colorCode = 40; if (DateTime.Now - kvp.Key.LastSeen > TimeSpan.FromSeconds(5)) { colorCode = 41; } if (DateTime.Now - kvp.Key.LastSeen > TimeSpan.FromSeconds(15)) { colorCode = 42; } if (DateTime.Now - kvp.Key.LastSeen > TimeSpan.FromSeconds(30)) { colorCode = 43; } if (DateTime.Now - kvp.Key.LastSeen > TimeSpan.FromSeconds(45)) { colorCode = 44; } if (DateTime.Now - kvp.Key.LastSeen > TimeSpan.FromMinutes(1)) { colorCode = 62; } if (DateTime.Now - kvp.Key.LastSeen > TimeSpan.FromMinutes(2)) { colorCode = 56; } if (DateTime.Now - kvp.Key.LastSeen > TimeSpan.FromMinutes(3)) { colorCode = 54; } if (DateTime.Now - kvp.Key.LastSeen > TimeSpan.FromMinutes(4)) { colorCode = 90; } a = Color(colorCode) + a + Color(7); if (kvp.Key.LastSignalStrength - kvp.Key.SignalStrength < -2) { c = Color(40) + c + '+' + Color(7); } else if (kvp.Key.LastSignalStrength - kvp.Key.SignalStrength > 2) { c = Color(1) + c + '-' + Color(7); } else { c = Color(7) + c + ' ' + Color(7); } if (e.EndsWith(", ")) { e = e.Remove(e.Length - 2); } sb.AppendLine($"| {a} | {b} | {c} | {d} | {e} |"); } sb.AppendLine(" "); sb.AppendLine("############################# BEACONS ########################################"); sb.AppendLine($"| Last seen | Count | Signal | MAC | SSID |"); var newest = aps.OrderByDescending(p => p.SignalStrength).Take(25).OrderByDescending(p => p.SignalStrength); foreach (var entry in newest) { var a = entry.LastSeen.ToString("HH:mm:ss"); var b = $"{entry.SeenTimes:000}"; var c = $"{entry.SignalStrength:000}"; var d = entry.MAC; var e = entry.SSID.Trim().Trim(' ').PadRight(30); var colorCode = 40; if (DateTime.Now - entry.LastSeen > TimeSpan.FromSeconds(5)) { colorCode = 41; } if (DateTime.Now - entry.LastSeen > TimeSpan.FromSeconds(15)) { colorCode = 42; } if (DateTime.Now - entry.LastSeen > TimeSpan.FromSeconds(30)) { colorCode = 43; } if (DateTime.Now - entry.LastSeen > TimeSpan.FromSeconds(45)) { colorCode = 44; } if (DateTime.Now - entry.LastSeen > TimeSpan.FromMinutes(1)) { colorCode = 62; } if (DateTime.Now - entry.LastSeen > TimeSpan.FromMinutes(2)) { colorCode = 56; } if (DateTime.Now - entry.LastSeen > TimeSpan.FromMinutes(3)) { colorCode = 54; } if (DateTime.Now - entry.LastSeen > TimeSpan.FromMinutes(4)) { colorCode = 90; } a = Color(colorCode) + a + Color(7); if (entry.LastSignalStrength - entry.SignalStrength < -2) { c = Color(40) + c + '+' + Color(7); } else if (entry.LastSignalStrength - entry.SignalStrength > 2) { c = Color(1) + c + '-' + Color(7); } else { c = Color(7) + c + ' ' + Color(7); } sb.AppendLine($"| {a} | {b} | {c} | {d} | {e} |"); } Console.SetCursorPosition(0, 0); Console.WriteLine(sb); Thread.Sleep(1000); } } catch (Exception e) { Console.WriteLine(e); } finally { await MonitoringMode(false); } }
/* * This method sentence-tokenizes all top level comments * The best sentences are those where the words in the sentence * occur in the most number of subtree items within the current * top level comment */ public List <SentenceObj> GetTopSentences(int N) { List <SentenceObj> topSentenceObjs = new List <SentenceObj>(); List <string> topSentences = new List <string>(); Dictionary <string, double> sentenceScores = new Dictionary <string, double>(); Dictionary <string, string> sentenceAuthors = new Dictionary <string, string>(); Dictionary <string, string> sentenceCommentTrees = new Dictionary <string, string>(); Dictionary <string, int> sentenceIds = new Dictionary <string, int>(); foreach (children child in children) { try { Dictionary <string, HashSet <int> > wordIDMapping = GetWordIDMapping(child); string text = child.text; List <string> currSentences = SentenceTokenizer.Tokenize(Util.StripTagsCharArray(text)); string bestSentence = currSentences[0]; double currMax = double.MinValue; foreach (string sentence in currSentences) { string[] allWords = GetAllWords(sentence); bool goodSentence = (allWords.Length > 2) && (stopWords.Where(x => !allWords.Contains(x.ToLower())).Count() > 2); if (goodSentence) { double weightedScore = 0; int totalIDCount = 0; foreach (string word in allWords) { if (!stopWords.Contains(word.ToLower())) { string stemmedWord = Stemmer.GetStem(word); if (wordIDMapping.ContainsKey(stemmedWord)) { HashSet <int> idsContainingWord = wordIDMapping[stemmedWord]; totalIDCount += idsContainingWord.Count; weightedScore += idsContainingWord.Count * 1.0 / (CommonWords.GetFrequency(word) + 1); } } } //add some weighting so that longer sentences have more weight weightedScore = weightedScore * (1 - (1 / (Math.Pow(1.25, allWords.Length)))); double avgScore = weightedScore / allWords.Length; if (avgScore > currMax) { currMax = avgScore; bestSentence = sentence; } } } sentenceScores[bestSentence] = currMax; sentenceAuthors[bestSentence] = child.author; sentenceCommentTrees[bestSentence] = JsonConvert.SerializeObject(GetCommentTreeString(child)); sentenceIds[bestSentence] = child.id; } catch (Exception ex) { } } topSentences = sentenceScores.OrderByDescending(x => x.Value).Take(N).Where(y => !string.IsNullOrWhiteSpace(y.Key)).Select(x => x.Key).ToList(); foreach (var sent in topSentences) { SentenceObj sentenceObj = new SentenceObj() { Author = sentenceAuthors[sent], Sentence = sent, SentenceCommentTree = sentenceCommentTrees[sent], Id = sentenceIds[sent], StoryId = this.id }; topSentenceObjs.Add(sentenceObj); } topSentenceObjs = topSentenceObjs.OrderByDescending(x => GetChildCount(GetNodeById(x.Id))).ToList(); return(topSentenceObjs); }
private void skill_SelectedIndexChanged(object sender, EventArgs e) { var ID = skill.SelectedIndex + 1; var q = db.Competitions.Where(x => x.skillIdFK == ID).ToList(); total.Text = q.Count().ToString(); var count = 0; #region populating Data grid View //Go through each session foreach (var item in q) { //Get the results for that session (for those that are there) var q2 = db.Results.Where(x => x.competitionIdFK == item.competitionId).ToList(); foreach (var i in q2) { if (i.q1Marks == 0) { count = 0; continue; } else if (i.q2Marks == 0) { count = 0; continue; } else if (i.q3Marks == 0) { count = 0; continue; } else if (i.q4Marks == 0) { count = 0; continue; } count += 1; } var q3 = db.Competitors.Where(x => x.skillIdFK == ID).ToList(); foreach (var i in q3) { var q4 = db.Results.Where(x => x.recordsIdFK == i.recordsId).FirstOrDefault(); if (q4 == null) { count = 0; continue; } } } completed.Text = count.ToString(); var qq = db.Competitors.Where(x => x.skillIdFK == ID).ToList(); dataGridView1.DataSource = cdt(qq); dataGridView1.Columns["MM"].Visible = false; #endregion #region Getting the Gold, Silver and Bronze People //Lists that contain all the G,S and B people! Dictionary <string, double> vsG = new Dictionary <string, double>(); Dictionary <string, double> vsS = new Dictionary <string, double>(); Dictionary <string, double> vsB = new Dictionary <string, double>(); foreach (DataGridViewRow dr in dataGridView1.Rows) { var total = double.Parse(dr.Cells["Total Marks"].Value.ToString()); var max = double.Parse(dr.Cells["MM"].Value.ToString()); if (total > max * 0.8) { vsG.Add(dr.Cells["Competitor"].Value.ToString(), total); } else if (total > max * 0.75) { vsS.Add(dr.Cells["Competitor"].Value.ToString(), total); } else if (total > max * 0.71) { vsB.Add(dr.Cells["Competitor"].Value.ToString(), total); } } if (vsG.Count > 1) { var vsG2 = vsG.OrderByDescending(x => x.Value).ToList(); var maxN = vsG2[0].Value; vsG.Clear(); for (int i = 0; i < vsG2.Count(); i++) { if (vsG2[i].Value == maxN || vsG2[i].Value >= maxN - 2.0) { vsG.Add(vsG2[i].Key, vsG2[i].Value); } else { vsS.Add(vsG2[i].Key, vsG2[i].Value); } } } if (vsS.Count > 1) { var vsS2 = vsS.OrderByDescending(x => x.Value).ToList(); var maxN = vsS2[0].Value; vsS.Clear(); for (int i = 0; i < vsS2.Count(); i++) { if (vsS2[i].Value == maxN || vsS2[i].Value >= maxN - 2.0) { vsS.Add(vsS2[i].Key, vsS2[i].Value); } else { vsB.Add(vsS2[i].Key, vsS2[i].Value); } } } if (vsB.Count > 1) { var vsB2 = vsB.OrderByDescending(x => x.Value).ToList(); var maxN = vsB2[0].Value; vsB.Clear(); for (int i = 0; i < vsB2.Count(); i++) { if (vsB2[i].Value == maxN || vsB2[i].Value >= maxN - 2.0) { vsB.Add(vsB2[i].Key, vsB2[i].Value); } } } dataGridView2.Columns.Clear(); dataGridView3.Columns.Clear(); dataGridView4.Columns.Clear(); dataGridView2.DataSource = cdt1(vsG); DataGridViewImageColumn dataGridViewImageColumn = new DataGridViewImageColumn(); dataGridViewImageColumn.HeaderText = "Image"; dataGridView2.Columns.Add(dataGridViewImageColumn); dataGridView2.Columns[0].Visible = false; DataGridViewImageColumn dataGridViewImageColumn1 = new DataGridViewImageColumn(); dataGridViewImageColumn1.HeaderText = "Image"; dataGridView3.DataSource = cdt1(vsS); dataGridView3.Columns.Add(dataGridViewImageColumn1); dataGridView3.Columns[0].Visible = false; DataGridViewImageColumn dataGridViewImageColumn2 = new DataGridViewImageColumn(); dataGridViewImageColumn2.HeaderText = "Image"; dataGridView4.DataSource = cdt1(vsB); dataGridView4.Columns.Add(dataGridViewImageColumn2); dataGridView4.Columns[0].Visible = false; //Testing Code! foreach (DataGridViewRow dr in dataGridView2.Rows) { var key = dr.Cells[0].Value.ToString(); dr.Cells[1].Style.BackColor = Color.Transparent; if (key.Equals("Singapore")) { dr.Cells[1].Value = imageList1.Images[6]; } else if (key.Equals("Malaysia")) { dr.Cells[1].Value = imageList1.Images[2]; } else if (key.Equals("Indonesia")) { dr.Cells[1].Value = imageList1.Images[5]; } else if (key.Equals("Philippines")) { dr.Cells[1].Value = imageList1.Images[3]; } else if (key.Equals("Thailand")) { dr.Cells[1].Value = imageList1.Images[4]; } else if (key.Equals("Brunei")) { dr.Cells[1].Value = imageList1.Images[0]; } else if (key.Equals("Cambodia")) { dr.Cells[1].Value = imageList1.Images[1]; } } foreach (DataGridViewRow dr in dataGridView3.Rows) { var key = dr.Cells[0].Value.ToString(); dr.Cells[1].Style.BackColor = Color.Transparent; if (key.Equals("Singapore")) { dr.Cells[1].Value = imageList1.Images[6]; } else if (key.Equals("Malaysia")) { dr.Cells[1].Value = imageList1.Images[2]; } else if (key.Equals("Indonesia")) { dr.Cells[1].Value = imageList1.Images[5]; } else if (key.Equals("Philippines")) { dr.Cells[1].Value = imageList1.Images[3]; } else if (key.Equals("Thailand")) { dr.Cells[1].Value = imageList1.Images[4]; } else if (key.Equals("Brunei")) { dr.Cells[1].Value = imageList1.Images[0]; } else if (key.Equals("Cambodia")) { dr.Cells[1].Value = imageList1.Images[1]; } } foreach (DataGridViewRow dr in dataGridView4.Rows) { var key = dr.Cells[0].Value.ToString(); dr.Cells[1].Style.BackColor = Color.Transparent; if (key.Equals("Singapore")) { dr.Cells[1].Value = imageList1.Images[6]; } else if (key.Equals("Malaysia")) { dr.Cells[1].Value = imageList1.Images[2]; } else if (key.Equals("Indonesia")) { dr.Cells[1].Value = imageList1.Images[5]; } else if (key.Equals("Philippines")) { dr.Cells[1].Value = imageList1.Images[3]; } else if (key.Equals("Thailand")) { dr.Cells[1].Value = imageList1.Images[4]; } else if (key.Equals("Brunei")) { dr.Cells[1].Value = imageList1.Images[0]; } else if (key.Equals("Cambodia")) { dr.Cells[1].Value = imageList1.Images[1]; } } #endregion }
public static void Main() { var keyMaterialesNames = new Dictionary <string, string>(); keyMaterialesNames.Add("shards", "Shadowmourne"); keyMaterialesNames.Add("fragments", "Valanyr"); keyMaterialesNames.Add("motes", "Dragonwrath"); string[] lineArgs = Console.ReadLine().ToLower().Split().ToArray(); var junkMateriales = new SortedDictionary <string, int>(); var keyMateriales = new Dictionary <string, int>(); keyMateriales.Add("shards", 0); keyMateriales.Add("fragments", 0); keyMateriales.Add("motes", 0); while (true) { string[] currentMaterials = lineArgs.Where((x, i) => i % 2 == 1).ToArray(); int[] quantity = lineArgs.Where((x, i) => i % 2 == 0).Select(int.Parse).ToArray(); bool hasObtained = false; for (int i = 0; i < currentMaterials.Length; i++) { string currentMaterial = currentMaterials[i]; if (keyMaterialesNames.Keys.Contains(currentMaterial)) { keyMateriales[currentMaterial] += quantity[i]; if (keyMateriales.Values.Any(x => x >= 250)) { hasObtained = true; break; } } else { if (!junkMateriales.ContainsKey(currentMaterial)) { junkMateriales.Add(currentMaterial, 0); } junkMateriales[currentMaterial] += quantity[i]; } if (hasObtained) { break; } } if (hasObtained) { break; } lineArgs = Console.ReadLine().ToLower().Split().ToArray(); } var obtainedElementName = keyMateriales .Where(x => x.Value >= 250) .First() .Key .ToString(); keyMateriales[obtainedElementName] -= 250; keyMateriales = keyMateriales .OrderByDescending(x => x.Value) .ThenBy(x => x.Key) .ToDictionary(x => x.Key, x => x.Value); Console.WriteLine($"{keyMaterialesNames[obtainedElementName]} obtained!"); var result = keyMateriales.Concat(junkMateriales).ToDictionary(x => x.Key, x => x.Value); foreach (var material in result) { Console.WriteLine($"{material.Key}: {material.Value}"); } }
public Dictionary <string, List <CommentObj> > GetNamedObjects(int N) { StringBuilder sbAllWords = new StringBuilder(); foreach (children child in children) { sbAllWords.Append(child.SubtreeText); sbAllWords.Append(" "); } string[] allWords = GetAllWords(sbAllWords.ToString()); Dictionary <string, string> stemParentDictionary = GetStemParentDictionary(allWords); List <string> namedObjects = new List <string>(); children rootNode = new children(); List <HashSet <int> > rootChildIDs = new List <HashSet <int> >(); foreach (children child in children) { GetChildIDHashSetList(child); HashSet <int> currChildIDs = new HashSet <int>(); currChildIDs.Add(child.id); foreach (var item in child.ChildIDList) { currChildIDs.UnionWith(item); } rootChildIDs.Add(currChildIDs); } rootNode.ChildIDList = rootChildIDs; NodeList = new List <children>(); NodeList.Add(rootNode); foreach (children child in children) { PopulateNodeList(child); } Dictionary <string, HashSet <int> > wordIDMapping = GetWordIDMapping(); //Dictionary<string, double> WordTreeScore = new Dictionary<string, double>(); Dictionary <string, List <children> > WordLCAList = new Dictionary <string, List <children> >(); foreach (var kvp in wordIDMapping) { List <children> currLCAList = new List <children>(); int numLCAs = 0; foreach (children node in NodeList) { int numBranchesWithWord = 0; foreach (var childIDBranch in node.ChildIDList) { if (childIDBranch.Intersect(kvp.Value).Count() > 0) { numBranchesWithWord += 1; } } if ((numBranchesWithWord == 1 && node.ChildIDList.Count == 1) || numBranchesWithWord > 1) { currLCAList.Add(node); } } WordLCAList[stemParentDictionary.ContainsKey(kvp.Key) ? stemParentDictionary[kvp.Key] : kvp.Key] = currLCAList; } namedObjects = WordLCAList .OrderByDescending(x => x.Value.Count) .Select(x => x.Key) .Where(y => CommonWords.GetFrequency(y) < 1) .Where(a => char.IsUpper(a[0])) .Where(b => b.Length > 1) .Where(z => !(z.EndsWith("n't") || z.EndsWith("'m") || (z.EndsWith("'ll")) || (z.EndsWith("'d")) || z.EndsWith("'ve") || z.EndsWith("'re") || z.EndsWith("'s"))) .Take(N) .ToList(); //namedObjects.Sort(); Dictionary <string, List <CommentObj> > namedObjectDictionary = new Dictionary <string, List <CommentObj> >(); foreach (string namedObject in namedObjects) { List <CommentObj> commentObjsForWord = new List <CommentObj>(); string stem = Stemmer.GetStem(namedObject); HashSet <int> idsWithWord = wordIDMapping[stem]; foreach (int id in idsWithWord) { children child = GetNodeById(id); CommentObj commentObj = new CommentObj() { Id = id, Text = child.text }; commentObjsForWord.Add(commentObj); } namedObjectDictionary[namedObject] = commentObjsForWord; } var ordered = namedObjectDictionary.Keys.OrderByDescending(x => namedObjectDictionary[x].Count).ToList().ToDictionary(x => x, x => namedObjectDictionary[x]); return(ordered); }